]> 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
[aarch64] Check region OK for HW watchpoint in GDBserver
[thirdparty/binutils-gdb.git] / binutils / readelf.c
CommitLineData
252b5132 1/* readelf.c -- display contents of an ELF format file
b90efa5b 2 Copyright (C) 1998-2015 Free Software Foundation, Inc.
252b5132
RH		 3
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
12ab83a9 5 Modifications by Nick Clifton <nickc@redhat.com>
252b5132
RH		 6
7 This file is part of GNU Binutils.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
32866df7 11 the Free Software Foundation; either version 3 of the License, or
252b5132
RH		 12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
b43b5d5f
NC		 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 02110-1301, USA. */
252b5132 23\f
9eb20dd8 24/* The difference between readelf and objdump:
252b5132 25
74013231 26 Both programs are capable of displaying the contents of ELF format files,
9eb20dd8 27 so why does the binutils project have two file dumpers ?
0de14b54 28
9eb20dd8
NC		 29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
35
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
38
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
42\f
3db64b00 43#include "sysdep.h"
252b5132 44#include <assert.h>
252b5132 45#include <time.h>
1b315056 46#include <zlib.h>
3bfcb652 47#ifdef HAVE_WCHAR_H
7bfd842d 48#include <wchar.h>
3bfcb652 49#endif
252b5132 50
a952a375 51#if __GNUC__ >= 2
19936277 52/* Define BFD64 here, even if our default architecture is 32 bit ELF
a952a375 53 as this will allow us to read in and parse 64bit and 32bit ELF files.
b34976b6 54 Only do this if we believe that the compiler can support a 64 bit
a952a375 55 data type. For now we only rely on GCC being able to do this. */
19936277 56#define BFD64
a952a375
NC		 57#endif
58
3db64b00
AM		 59#include "bfd.h"
60#include "bucomm.h"
3284fe0c 61#include "elfcomm.h"
19e6b90e 62#include "dwarf.h"
252b5132
RH		 63
64#include "elf/common.h"
65#include "elf/external.h"
66#include "elf/internal.h"
252b5132 67
4b78141a
NC		 68
69/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
73
74#include "elf/h8.h"
75#undef _ELF_H8_H
76
77/* Undo the effects of #including reloc-macros.h. */
78
79#undef START_RELOC_NUMBERS
80#undef RELOC_NUMBER
81#undef FAKE_RELOC
82#undef EMPTY_RELOC
83#undef END_RELOC_NUMBERS
84#undef _RELOC_MACROS_H
85
252b5132
RH		 86/* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
89
90#define RELOC_MACROS_GEN_FUNC
91
a06ea964 92#include "elf/aarch64.h"
252b5132 93#include "elf/alpha.h"
3b16e843 94#include "elf/arc.h"
252b5132 95#include "elf/arm.h"
3b16e843 96#include "elf/avr.h"
1d65ded4 97#include "elf/bfin.h"
60bca95a 98#include "elf/cr16.h"
3b16e843 99#include "elf/cris.h"
1c0d3aa6 100#include "elf/crx.h"
252b5132
RH		 101#include "elf/d10v.h"
102#include "elf/d30v.h"
d172d4ba 103#include "elf/dlx.h"
cfb8c092 104#include "elf/epiphany.h"
252b5132 105#include "elf/fr30.h"
5c70f934 106#include "elf/frv.h"
3f8107ab 107#include "elf/ft32.h"
3b16e843
NC		 108#include "elf/h8.h"
109#include "elf/hppa.h"
110#include "elf/i386.h"
35b1837e 111#include "elf/i370.h"
3b16e843
NC		 112#include "elf/i860.h"
113#include "elf/i960.h"
114#include "elf/ia64.h"
1e4cf259 115#include "elf/ip2k.h"
84e94c90 116#include "elf/lm32.h"
1c0d3aa6 117#include "elf/iq2000.h"
49f58d10 118#include "elf/m32c.h"
3b16e843
NC		 119#include "elf/m32r.h"
120#include "elf/m68k.h"
75751cd9 121#include "elf/m68hc11.h"
252b5132 122#include "elf/mcore.h"
15ab5209 123#include "elf/mep.h"
a3c62988 124#include "elf/metag.h"
7ba29e2a 125#include "elf/microblaze.h"
3b16e843 126#include "elf/mips.h"
3c3bdf30 127#include "elf/mmix.h"
3b16e843
NC		 128#include "elf/mn10200.h"
129#include "elf/mn10300.h"
5506d11a 130#include "elf/moxie.h"
4970f871 131#include "elf/mt.h"
2469cfa2 132#include "elf/msp430.h"
35c08157 133#include "elf/nds32.h"
13761a11 134#include "elf/nios2.h"
73589c9d 135#include "elf/or1k.h"
7d466069 136#include "elf/pj.h"
3b16e843 137#include "elf/ppc.h"
c833c019 138#include "elf/ppc64.h"
99c513f6 139#include "elf/rl78.h"
c7927a3c 140#include "elf/rx.h"
a85d7ed0 141#include "elf/s390.h"
1c0d3aa6 142#include "elf/score.h"
3b16e843
NC		 143#include "elf/sh.h"
144#include "elf/sparc.h"
e9f53129 145#include "elf/spu.h"
40b36596 146#include "elf/tic6x.h"
aa137e4d
NC		 147#include "elf/tilegx.h"
148#include "elf/tilepro.h"
3b16e843 149#include "elf/v850.h"
179d3252 150#include "elf/vax.h"
619ed720 151#include "elf/visium.h"
3b16e843 152#include "elf/x86-64.h"
c29aca4a 153#include "elf/xc16x.h"
f6c1a2d5 154#include "elf/xgate.h"
93fbbb04 155#include "elf/xstormy16.h"
88da6820 156#include "elf/xtensa.h"
252b5132 157
252b5132 158#include "getopt.h"
566b0d53 159#include "libiberty.h"
09c11c86 160#include "safe-ctype.h"
2cf0635d 161#include "filenames.h"
252b5132 162
15b42fb0
AM		 163#ifndef offsetof
164#define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
165#endif
166
2cf0635d 167char * program_name = "readelf";
c9c1d674 168static unsigned long archive_file_offset;
85b1c36d 169static unsigned long archive_file_size;
f54498b4 170static bfd_size_type current_file_size;
85b1c36d
BE		 171static unsigned long dynamic_addr;
172static bfd_size_type dynamic_size;
8b73c356 173static size_t dynamic_nent;
2cf0635d 174static char * dynamic_strings;
85b1c36d 175static unsigned long dynamic_strings_length;
2cf0635d 176static char * string_table;
85b1c36d
BE		 177static unsigned long string_table_length;
178static unsigned long num_dynamic_syms;
2cf0635d
NC		 179static Elf_Internal_Sym * dynamic_symbols;
180static Elf_Internal_Syminfo * dynamic_syminfo;
85b1c36d
BE		 181static unsigned long dynamic_syminfo_offset;
182static unsigned int dynamic_syminfo_nent;
f8eae8b2 183static char program_interpreter[PATH_MAX];
bb8a0291 184static bfd_vma dynamic_info[DT_ENCODING];
fdc90cb4 185static bfd_vma dynamic_info_DT_GNU_HASH;
85b1c36d
BE		 186static bfd_vma version_info[16];
187static Elf_Internal_Ehdr elf_header;
2cf0635d
NC		 188static Elf_Internal_Shdr * section_headers;
189static Elf_Internal_Phdr * program_headers;
190static Elf_Internal_Dyn * dynamic_section;
191static Elf_Internal_Shdr * symtab_shndx_hdr;
85b1c36d
BE		 192static int show_name;
193static int do_dynamic;
194static int do_syms;
2c610e4b 195static int do_dyn_syms;
85b1c36d
BE		 196static int do_reloc;
197static int do_sections;
198static int do_section_groups;
5477e8a0 199static int do_section_details;
85b1c36d
BE		 200static int do_segments;
201static int do_unwind;
202static int do_using_dynamic;
203static int do_header;
204static int do_dump;
205static int do_version;
85b1c36d
BE		 206static int do_histogram;
207static int do_debugging;
85b1c36d
BE		 208static int do_arch;
209static int do_notes;
4145f1d5 210static int do_archive_index;
85b1c36d 211static int is_32bit_elf;
0e602686 212static int decompress_dumps;
252b5132 213
e4b17d5c
L		 214struct group_list
215{
2cf0635d 216 struct group_list * next;
e4b17d5c
L		 217 unsigned int section_index;
218};
219
220struct group
221{
2cf0635d 222 struct group_list * root;
e4b17d5c
L		 223 unsigned int group_index;
224};
225
85b1c36d 226static size_t group_count;
2cf0635d
NC		 227static struct group * section_groups;
228static struct group ** section_headers_groups;
e4b17d5c 229
09c11c86
NC		 230
231/* Flag bits indicating particular types of dump. */
232#define HEX_DUMP (1 << 0) /* The -x command line switch. */
233#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
234#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
235#define STRING_DUMP (1 << 3) /* The -p command line switch. */
cf13d699 236#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
09c11c86
NC		 237
238typedef unsigned char dump_type;
239
240/* A linked list of the section names for which dumps were requested. */
aef1f6d0
DJ		 241struct dump_list_entry
242{
2cf0635d 243 char * name;
09c11c86 244 dump_type type;
2cf0635d 245 struct dump_list_entry * next;
aef1f6d0 246};
2cf0635d 247static struct dump_list_entry * dump_sects_byname;
aef1f6d0 248
09c11c86
NC		 249/* A dynamic array of flags indicating for which sections a dump
250 has been requested via command line switches. */
251static dump_type * cmdline_dump_sects = NULL;
252static unsigned int num_cmdline_dump_sects = 0;
18bd398b
NC		 253
254/* A dynamic array of flags indicating for which sections a dump of
255 some kind has been requested. It is reset on a per-object file
aef1f6d0
DJ		 256 basis and then initialised from the cmdline_dump_sects array,
257 the results of interpreting the -w switch, and the
258 dump_sects_byname list. */
09c11c86
NC		 259static dump_type * dump_sects = NULL;
260static unsigned int num_dump_sects = 0;
252b5132 261
252b5132 262
c256ffe7 263/* How to print a vma value. */
843dd992
NC		 264typedef enum print_mode
265{
266 HEX,
267 DEC,
268 DEC_5,
269 UNSIGNED,
270 PREFIX_HEX,
271 FULL_HEX,
272 LONG_HEX
273}
274print_mode;
275
bb4d2ac2
L		 276/* Versioned symbol info. */
277enum versioned_symbol_info
278{
279 symbol_undefined,
280 symbol_hidden,
281 symbol_public
282};
283
284static const char *get_symbol_version_string
285 (FILE *file, int is_dynsym, const char *strtab,
286 unsigned long int strtab_size, unsigned int si,
287 Elf_Internal_Sym *psym, enum versioned_symbol_info *sym_info,
288 unsigned short *vna_other);
289
9c19a809
NC		 290#define UNKNOWN -1
291
2b692964
NC		 292#define SECTION_NAME(X) \
293 ((X) == NULL ? _("<none>") \
294 : string_table == NULL ? _("<no-name>") \
295 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
0b49d371 296 : string_table + (X)->sh_name))
252b5132 297
ee42cf8c 298#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
252b5132 299
ba5cdace
NC		 300#define GET_ELF_SYMBOLS(file, section, sym_count) \
301 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
302 : get_64bit_elf_symbols (file, section, sym_count))
9ea033b2 303
d79b3d50
NC		 304#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
305/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
306 already been called and verified that the string exists. */
307#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
18bd398b 308
61865e30
NC		 309#define REMOVE_ARCH_BITS(ADDR) \
310 do \
311 { \
312 if (elf_header.e_machine == EM_ARM) \
313 (ADDR) &= ~1; \
314 } \
315 while (0)
d79b3d50 316\f
c9c1d674
EG		 317/* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
318 the offset of the current archive member, if we are examining an archive.
59245841
NC		 319 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
320 using malloc and fill that. In either case return the pointer to the start of
321 the retrieved data or NULL if something went wrong. If something does go wrong
c9c1d674
EG		 322 and REASON is not NULL then emit an error message using REASON as part of the
323 context. */
59245841 324
c256ffe7 325static void *
57028622
NC		 326get_data (void * var, FILE * file, unsigned long offset, bfd_size_type size,
327 bfd_size_type nmemb, const char * reason)
a6e9f9df 328{
2cf0635d 329 void * mvar;
57028622 330 bfd_size_type amt = size * nmemb;
a6e9f9df 331
c256ffe7 332 if (size == 0 || nmemb == 0)
a6e9f9df
AM		 333 return NULL;
334
57028622
NC		 335 /* If the size_t type is smaller than the bfd_size_type, eg because
336 you are building a 32-bit tool on a 64-bit host, then make sure
337 that when the sizes are cast to (size_t) no information is lost. */
338 if (sizeof (size_t) < sizeof (bfd_size_type)
339 && ( (bfd_size_type) ((size_t) size) != size
340 || (bfd_size_type) ((size_t) nmemb) != nmemb))
341 {
342 if (reason)
343 error (_("Size truncation prevents reading 0x%llx elements of size 0x%llx for %s\n"),
344 (unsigned long long) nmemb, (unsigned long long) size, reason);
345 return NULL;
346 }
347
348 /* Check for size overflow. */
349 if (amt < nmemb)
350 {
351 if (reason)
352 error (_("Size overflow prevents reading 0x%llx elements of size 0x%llx for %s\n"),
353 (unsigned long long) nmemb, (unsigned long long) size, reason);
354 return NULL;
355 }
356
c9c1d674
EG		 357 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
358 attempting to allocate memory when the read is bound to fail. */
359 if (amt > current_file_size
360 || offset + archive_file_offset + amt > current_file_size)
a6e9f9df 361 {
049b0c3a 362 if (reason)
57028622
NC		 363 error (_("Reading 0x%llx bytes extends past end of file for %s\n"),
364 (unsigned long long) amt, reason);
a6e9f9df
AM		 365 return NULL;
366 }
367
c9c1d674 368 if (fseek (file, archive_file_offset + offset, SEEK_SET))
071436c6
NC		 369 {
370 if (reason)
c9c1d674
EG		 371 error (_("Unable to seek to 0x%lx for %s\n"),
372 (unsigned long) archive_file_offset + offset, reason);
071436c6
NC		 373 return NULL;
374 }
375
a6e9f9df
AM		 376 mvar = var;
377 if (mvar == NULL)
378 {
c256ffe7 379 /* Check for overflow. */
57028622 380 if (nmemb < (~(bfd_size_type) 0 - 1) / size)
c256ffe7 381 /* + 1 so that we can '\0' terminate invalid string table sections. */
57028622 382 mvar = malloc ((size_t) amt + 1);
a6e9f9df
AM		 383
384 if (mvar == NULL)
385 {
049b0c3a 386 if (reason)
57028622
NC		 387 error (_("Out of memory allocating 0x%llx bytes for %s\n"),
388 (unsigned long long) amt, reason);
a6e9f9df
AM		 389 return NULL;
390 }
c256ffe7 391
c9c1d674 392 ((char *) mvar)[amt] = '\0';
a6e9f9df
AM		 393 }
394
57028622 395 if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
a6e9f9df 396 {
049b0c3a 397 if (reason)
57028622
NC		 398 error (_("Unable to read in 0x%llx bytes of %s\n"),
399 (unsigned long long) amt, reason);
a6e9f9df
AM		 400 if (mvar != var)
401 free (mvar);
402 return NULL;
403 }
404
405 return mvar;
406}
407
14a91970 408/* Print a VMA value. */
cb8f3167 409
66543521 410static int
14a91970 411print_vma (bfd_vma vma, print_mode mode)
66543521 412{
66543521
AM		 413 int nc = 0;
414
14a91970 415 switch (mode)
66543521 416 {
14a91970
AM		 417 case FULL_HEX:
418 nc = printf ("0x");
419 /* Drop through. */
66543521 420
14a91970 421 case LONG_HEX:
f7a99963 422#ifdef BFD64
14a91970 423 if (is_32bit_elf)
437c2fb7 424 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
f7a99963 425#endif
14a91970
AM		 426 printf_vma (vma);
427 return nc + 16;
b19aac67 428
14a91970
AM		 429 case DEC_5:
430 if (vma <= 99999)
431 return printf ("%5" BFD_VMA_FMT "d", vma);
432 /* Drop through. */
66543521 433
14a91970
AM		 434 case PREFIX_HEX:
435 nc = printf ("0x");
436 /* Drop through. */
66543521 437
14a91970
AM		 438 case HEX:
439 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 440
14a91970
AM		 441 case DEC:
442 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 443
14a91970
AM		 444 case UNSIGNED:
445 return printf ("%" BFD_VMA_FMT "u", vma);
f7a99963 446 }
66543521 447 return 0;
f7a99963
NC		 448}
449
7bfd842d 450/* Display a symbol on stdout. Handles the display of control characters and
3bfcb652 451 multibye characters (assuming the host environment supports them).
31104126 452
7bfd842d
NC		 453 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
454
455 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
456 padding as necessary.
171191ba
NC		 457
458 Returns the number of emitted characters. */
459
460static unsigned int
7a88bc9c 461print_symbol (int width, const char *symbol)
31104126 462{
171191ba 463 bfd_boolean extra_padding = FALSE;
7bfd842d 464 int num_printed = 0;
3bfcb652 465#ifdef HAVE_MBSTATE_T
7bfd842d 466 mbstate_t state;
3bfcb652 467#endif
7bfd842d 468 int width_remaining;
961c521f 469
7bfd842d 470 if (width < 0)
961c521f 471 {
961c521f
NC		 472 /* Keep the width positive. This also helps. */
473 width = - width;
171191ba 474 extra_padding = TRUE;
0b4362b0 475 }
74e1a04b 476 assert (width != 0);
961c521f 477
7bfd842d
NC		 478 if (do_wide)
479 /* Set the remaining width to a very large value.
480 This simplifies the code below. */
481 width_remaining = INT_MAX;
482 else
483 width_remaining = width;
cb8f3167 484
3bfcb652 485#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 486 /* Initialise the multibyte conversion state. */
487 memset (& state, 0, sizeof (state));
3bfcb652 488#endif
961c521f 489
7bfd842d
NC		 490 while (width_remaining)
491 {
492 size_t n;
7bfd842d 493 const char c = *symbol++;
961c521f 494
7bfd842d 495 if (c == 0)
961c521f
NC		 496 break;
497
7bfd842d
NC		 498 /* Do not print control characters directly as they can affect terminal
499 settings. Such characters usually appear in the names generated
500 by the assembler for local labels. */
501 if (ISCNTRL (c))
961c521f 502 {
7bfd842d 503 if (width_remaining < 2)
961c521f
NC		 504 break;
505
7bfd842d
NC		 506 printf ("^%c", c + 0x40);
507 width_remaining -= 2;
171191ba 508 num_printed += 2;
961c521f 509 }
7bfd842d
NC		 510 else if (ISPRINT (c))
511 {
512 putchar (c);
513 width_remaining --;
514 num_printed ++;
515 }
961c521f
NC		 516 else
517 {
3bfcb652
NC		 518#ifdef HAVE_MBSTATE_T
519 wchar_t w;
520#endif
7bfd842d
NC		 521 /* Let printf do the hard work of displaying multibyte characters. */
522 printf ("%.1s", symbol - 1);
523 width_remaining --;
524 num_printed ++;
525
3bfcb652 526#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 527 /* Try to find out how many bytes made up the character that was
528 just printed. Advance the symbol pointer past the bytes that
529 were displayed. */
530 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
3bfcb652
NC		 531#else
532 n = 1;
533#endif
7bfd842d
NC		 534 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
535 symbol += (n - 1);
961c521f 536 }
961c521f 537 }
171191ba 538
7bfd842d 539 if (extra_padding && num_printed < width)
171191ba
NC		 540 {
541 /* Fill in the remaining spaces. */
7bfd842d
NC		 542 printf ("%-*s", width - num_printed, " ");
543 num_printed = width;
171191ba
NC		 544 }
545
546 return num_printed;
31104126
NC		 547}
548
74e1a04b
NC		 549/* Returns a pointer to a static buffer containing a printable version of
550 the given section's name. Like print_symbol, except that it does not try
551 to print multibyte characters, it just interprets them as hex values. */
552
553static const char *
0d2a7a93 554printable_section_name (const Elf_Internal_Shdr * sec)
74e1a04b
NC		 555{
556#define MAX_PRINT_SEC_NAME_LEN 128
557 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
558 const char * name = SECTION_NAME (sec);
559 char * buf = sec_name_buf;
560 char c;
561 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
562
563 while ((c = * name ++) != 0)
564 {
565 if (ISCNTRL (c))
566 {
567 if (remaining < 2)
568 break;
948f632f 569
74e1a04b
NC		 570 * buf ++ = '^';
571 * buf ++ = c + 0x40;
572 remaining -= 2;
573 }
574 else if (ISPRINT (c))
575 {
576 * buf ++ = c;
577 remaining -= 1;
578 }
579 else
580 {
581 static char hex[17] = "0123456789ABCDEF";
582
583 if (remaining < 4)
584 break;
585 * buf ++ = '<';
586 * buf ++ = hex[(c & 0xf0) >> 4];
587 * buf ++ = hex[c & 0x0f];
588 * buf ++ = '>';
589 remaining -= 4;
590 }
591
592 if (remaining == 0)
593 break;
594 }
595
596 * buf = 0;
597 return sec_name_buf;
598}
599
600static const char *
601printable_section_name_from_index (unsigned long ndx)
602{
603 if (ndx >= elf_header.e_shnum)
604 return _("<corrupt>");
605
606 return printable_section_name (section_headers + ndx);
607}
608
89fac5e3
RS		 609/* Return a pointer to section NAME, or NULL if no such section exists. */
610
611static Elf_Internal_Shdr *
2cf0635d 612find_section (const char * name)
89fac5e3
RS		 613{
614 unsigned int i;
615
616 for (i = 0; i < elf_header.e_shnum; i++)
617 if (streq (SECTION_NAME (section_headers + i), name))
618 return section_headers + i;
619
620 return NULL;
621}
622
0b6ae522
DJ		 623/* Return a pointer to a section containing ADDR, or NULL if no such
624 section exists. */
625
626static Elf_Internal_Shdr *
627find_section_by_address (bfd_vma addr)
628{
629 unsigned int i;
630
631 for (i = 0; i < elf_header.e_shnum; i++)
632 {
633 Elf_Internal_Shdr *sec = section_headers + i;
634 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
635 return sec;
636 }
637
638 return NULL;
639}
640
071436c6
NC		 641static Elf_Internal_Shdr *
642find_section_by_type (unsigned int type)
643{
644 unsigned int i;
645
646 for (i = 0; i < elf_header.e_shnum; i++)
647 {
648 Elf_Internal_Shdr *sec = section_headers + i;
649 if (sec->sh_type == type)
650 return sec;
651 }
652
653 return NULL;
654}
655
657d0d47
CC		 656/* Return a pointer to section NAME, or NULL if no such section exists,
657 restricted to the list of sections given in SET. */
658
659static Elf_Internal_Shdr *
660find_section_in_set (const char * name, unsigned int * set)
661{
662 unsigned int i;
663
664 if (set != NULL)
665 {
666 while ((i = *set++) > 0)
667 if (streq (SECTION_NAME (section_headers + i), name))
668 return section_headers + i;
669 }
670
671 return find_section (name);
672}
673
0b6ae522
DJ		 674/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
675 bytes read. */
676
f6f0e17b
NC		 677static inline unsigned long
678read_uleb128 (unsigned char *data,
679 unsigned int *length_return,
680 const unsigned char * const end)
0b6ae522 681{
f6f0e17b 682 return read_leb128 (data, length_return, FALSE, end);
0b6ae522
DJ		 683}
684
28f997cf
TG		 685/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
686 This OS has so many departures from the ELF standard that we test it at
687 many places. */
688
689static inline int
690is_ia64_vms (void)
691{
692 return elf_header.e_machine == EM_IA_64
693 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
694}
695
bcedfee6 696/* Guess the relocation size commonly used by the specific machines. */
252b5132 697
252b5132 698static int
2dc4cec1 699guess_is_rela (unsigned int e_machine)
252b5132 700{
9c19a809 701 switch (e_machine)
252b5132
RH		 702 {
703 /* Targets that use REL relocations. */
252b5132 704 case EM_386:
22abe556 705 case EM_IAMCU:
63fcb9e9 706 case EM_960:
e9f53129 707 case EM_ARM:
2b0337b0 708 case EM_D10V:
252b5132 709 case EM_CYGNUS_D10V:
e9f53129 710 case EM_DLX:
252b5132 711 case EM_MIPS:
4fe85591 712 case EM_MIPS_RS3_LE:
e9f53129 713 case EM_CYGNUS_M32R:
1c0d3aa6 714 case EM_SCORE:
f6c1a2d5 715 case EM_XGATE:
9c19a809 716 return FALSE;
103f02d3 717
252b5132
RH		 718 /* Targets that use RELA relocations. */
719 case EM_68K:
e9f53129 720 case EM_860:
a06ea964 721 case EM_AARCH64:
cfb8c092 722 case EM_ADAPTEVA_EPIPHANY:
e9f53129
AM		 723 case EM_ALPHA:
724 case EM_ALTERA_NIOS2:
725 case EM_AVR:
726 case EM_AVR_OLD:
727 case EM_BLACKFIN:
60bca95a 728 case EM_CR16:
e9f53129
AM		 729 case EM_CRIS:
730 case EM_CRX:
2b0337b0 731 case EM_D30V:
252b5132 732 case EM_CYGNUS_D30V:
2b0337b0 733 case EM_FR30:
3f8107ab 734 case EM_FT32:
252b5132 735 case EM_CYGNUS_FR30:
5c70f934 736 case EM_CYGNUS_FRV:
e9f53129
AM		 737 case EM_H8S:
738 case EM_H8_300:
739 case EM_H8_300H:
800eeca4 740 case EM_IA_64:
1e4cf259
NC		 741 case EM_IP2K:
742 case EM_IP2K_OLD:
3b36097d 743 case EM_IQ2000:
84e94c90 744 case EM_LATTICEMICO32:
ff7eeb89 745 case EM_M32C_OLD:
49f58d10 746 case EM_M32C:
e9f53129
AM		 747 case EM_M32R:
748 case EM_MCORE:
15ab5209 749 case EM_CYGNUS_MEP:
a3c62988 750 case EM_METAG:
e9f53129
AM		 751 case EM_MMIX:
752 case EM_MN10200:
753 case EM_CYGNUS_MN10200:
754 case EM_MN10300:
755 case EM_CYGNUS_MN10300:
5506d11a 756 case EM_MOXIE:
e9f53129
AM		 757 case EM_MSP430:
758 case EM_MSP430_OLD:
d031aafb 759 case EM_MT:
35c08157 760 case EM_NDS32:
64fd6348 761 case EM_NIOS32:
73589c9d 762 case EM_OR1K:
e9f53129
AM		 763 case EM_PPC64:
764 case EM_PPC:
99c513f6 765 case EM_RL78:
c7927a3c 766 case EM_RX:
e9f53129
AM		 767 case EM_S390:
768 case EM_S390_OLD:
769 case EM_SH:
770 case EM_SPARC:
771 case EM_SPARC32PLUS:
772 case EM_SPARCV9:
773 case EM_SPU:
40b36596 774 case EM_TI_C6000:
aa137e4d
NC		 775 case EM_TILEGX:
776 case EM_TILEPRO:
708e2187 777 case EM_V800:
e9f53129
AM		 778 case EM_V850:
779 case EM_CYGNUS_V850:
780 case EM_VAX:
619ed720 781 case EM_VISIUM:
e9f53129 782 case EM_X86_64:
8a9036a4 783 case EM_L1OM:
7a9068fe 784 case EM_K1OM:
e9f53129
AM		 785 case EM_XSTORMY16:
786 case EM_XTENSA:
787 case EM_XTENSA_OLD:
7ba29e2a
NC		 788 case EM_MICROBLAZE:
789 case EM_MICROBLAZE_OLD:
9c19a809 790 return TRUE;
103f02d3 791
e9f53129
AM		 792 case EM_68HC05:
793 case EM_68HC08:
794 case EM_68HC11:
795 case EM_68HC16:
796 case EM_FX66:
797 case EM_ME16:
d1133906 798 case EM_MMA:
d1133906
NC		 799 case EM_NCPU:
800 case EM_NDR1:
e9f53129 801 case EM_PCP:
d1133906 802 case EM_ST100:
e9f53129 803 case EM_ST19:
d1133906 804 case EM_ST7:
e9f53129
AM		 805 case EM_ST9PLUS:
806 case EM_STARCORE:
d1133906 807 case EM_SVX:
e9f53129 808 case EM_TINYJ:
9c19a809
NC		 809 default:
810 warn (_("Don't know about relocations on this machine architecture\n"));
811 return FALSE;
812 }
813}
252b5132 814
9c19a809 815static int
2cf0635d 816slurp_rela_relocs (FILE * file,
d3ba0551
AM		 817 unsigned long rel_offset,
818 unsigned long rel_size,
2cf0635d
NC		 819 Elf_Internal_Rela ** relasp,
820 unsigned long * nrelasp)
9c19a809 821{
2cf0635d 822 Elf_Internal_Rela * relas;
8b73c356 823 size_t nrelas;
4d6ed7c8 824 unsigned int i;
252b5132 825
4d6ed7c8
NC		 826 if (is_32bit_elf)
827 {
2cf0635d 828 Elf32_External_Rela * erelas;
103f02d3 829
3f5e193b 830 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 831 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 832 if (!erelas)
833 return 0;
252b5132 834
4d6ed7c8 835 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 836
3f5e193b
NC		 837 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
838 sizeof (Elf_Internal_Rela));
103f02d3 839
4d6ed7c8
NC		 840 if (relas == NULL)
841 {
c256ffe7 842 free (erelas);
591a748a 843 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 844 return 0;
845 }
103f02d3 846
4d6ed7c8
NC		 847 for (i = 0; i < nrelas; i++)
848 {
849 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
850 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 851 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 852 }
103f02d3 853
4d6ed7c8
NC		 854 free (erelas);
855 }
856 else
857 {
2cf0635d 858 Elf64_External_Rela * erelas;
103f02d3 859
3f5e193b 860 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 861 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 862 if (!erelas)
863 return 0;
4d6ed7c8
NC		 864
865 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 866
3f5e193b
NC		 867 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
868 sizeof (Elf_Internal_Rela));
103f02d3 869
4d6ed7c8
NC		 870 if (relas == NULL)
871 {
c256ffe7 872 free (erelas);
591a748a 873 error (_("out of memory parsing relocs\n"));
4d6ed7c8 874 return 0;
9c19a809 875 }
4d6ed7c8
NC		 876
877 for (i = 0; i < nrelas; i++)
9c19a809 878 {
66543521
AM		 879 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
880 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 881 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 882
883 /* The #ifdef BFD64 below is to prevent a compile time
884 warning. We know that if we do not have a 64 bit data
885 type that we will never execute this code anyway. */
886#ifdef BFD64
887 if (elf_header.e_machine == EM_MIPS
888 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
889 {
890 /* In little-endian objects, r_info isn't really a
891 64-bit little-endian value: it has a 32-bit
892 little-endian symbol index followed by four
893 individual byte fields. Reorder INFO
894 accordingly. */
91d6fa6a
NC		 895 bfd_vma inf = relas[i].r_info;
896 inf = (((inf & 0xffffffff) << 32)
897 | ((inf >> 56) & 0xff)
898 | ((inf >> 40) & 0xff00)
899 | ((inf >> 24) & 0xff0000)
900 | ((inf >> 8) & 0xff000000));
901 relas[i].r_info = inf;
861fb55a
DJ		 902 }
903#endif /* BFD64 */
4d6ed7c8 904 }
103f02d3 905
4d6ed7c8
NC		 906 free (erelas);
907 }
908 *relasp = relas;
909 *nrelasp = nrelas;
910 return 1;
911}
103f02d3 912
4d6ed7c8 913static int
2cf0635d 914slurp_rel_relocs (FILE * file,
d3ba0551
AM		 915 unsigned long rel_offset,
916 unsigned long rel_size,
2cf0635d
NC		 917 Elf_Internal_Rela ** relsp,
918 unsigned long * nrelsp)
4d6ed7c8 919{
2cf0635d 920 Elf_Internal_Rela * rels;
8b73c356 921 size_t nrels;
4d6ed7c8 922 unsigned int i;
103f02d3 923
4d6ed7c8
NC		 924 if (is_32bit_elf)
925 {
2cf0635d 926 Elf32_External_Rel * erels;
103f02d3 927
3f5e193b 928 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 929 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 930 if (!erels)
931 return 0;
103f02d3 932
4d6ed7c8 933 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 934
3f5e193b 935 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 936
4d6ed7c8
NC		 937 if (rels == NULL)
938 {
c256ffe7 939 free (erels);
591a748a 940 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 941 return 0;
942 }
943
944 for (i = 0; i < nrels; i++)
945 {
946 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
947 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 948 rels[i].r_addend = 0;
9ea033b2 949 }
4d6ed7c8
NC		 950
951 free (erels);
9c19a809
NC		 952 }
953 else
954 {
2cf0635d 955 Elf64_External_Rel * erels;
9ea033b2 956
3f5e193b 957 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 958 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 959 if (!erels)
960 return 0;
103f02d3 961
4d6ed7c8 962 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 963
3f5e193b 964 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 965
4d6ed7c8 966 if (rels == NULL)
9c19a809 967 {
c256ffe7 968 free (erels);
591a748a 969 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 970 return 0;
971 }
103f02d3 972
4d6ed7c8
NC		 973 for (i = 0; i < nrels; i++)
974 {
66543521
AM		 975 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
976 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 977 rels[i].r_addend = 0;
861fb55a
DJ		 978
979 /* The #ifdef BFD64 below is to prevent a compile time
980 warning. We know that if we do not have a 64 bit data
981 type that we will never execute this code anyway. */
982#ifdef BFD64
983 if (elf_header.e_machine == EM_MIPS
984 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
985 {
986 /* In little-endian objects, r_info isn't really a
987 64-bit little-endian value: it has a 32-bit
988 little-endian symbol index followed by four
989 individual byte fields. Reorder INFO
990 accordingly. */
91d6fa6a
NC		 991 bfd_vma inf = rels[i].r_info;
992 inf = (((inf & 0xffffffff) << 32)
993 | ((inf >> 56) & 0xff)
994 | ((inf >> 40) & 0xff00)
995 | ((inf >> 24) & 0xff0000)
996 | ((inf >> 8) & 0xff000000));
997 rels[i].r_info = inf;
861fb55a
DJ		 998 }
999#endif /* BFD64 */
4d6ed7c8 1000 }
103f02d3 1001
4d6ed7c8
NC		 1002 free (erels);
1003 }
1004 *relsp = rels;
1005 *nrelsp = nrels;
1006 return 1;
1007}
103f02d3 1008
aca88567
NC		 1009/* Returns the reloc type extracted from the reloc info field. */
1010
1011static unsigned int
1012get_reloc_type (bfd_vma reloc_info)
1013{
1014 if (is_32bit_elf)
1015 return ELF32_R_TYPE (reloc_info);
1016
1017 switch (elf_header.e_machine)
1018 {
1019 case EM_MIPS:
1020 /* Note: We assume that reloc_info has already been adjusted for us. */
1021 return ELF64_MIPS_R_TYPE (reloc_info);
1022
1023 case EM_SPARCV9:
1024 return ELF64_R_TYPE_ID (reloc_info);
1025
1026 default:
1027 return ELF64_R_TYPE (reloc_info);
1028 }
1029}
1030
1031/* Return the symbol index extracted from the reloc info field. */
1032
1033static bfd_vma
1034get_reloc_symindex (bfd_vma reloc_info)
1035{
1036 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1037}
1038
13761a11
NC		 1039static inline bfd_boolean
1040uses_msp430x_relocs (void)
1041{
1042 return
1043 elf_header.e_machine == EM_MSP430 /* Paranoia. */
1044 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1045 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1046 /* TI compiler uses ELFOSABI_NONE. */
1047 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1048}
1049
d3ba0551
AM		 1050/* Display the contents of the relocation data found at the specified
1051 offset. */
ee42cf8c 1052
41e92641 1053static void
2cf0635d 1054dump_relocations (FILE * file,
d3ba0551
AM		 1055 unsigned long rel_offset,
1056 unsigned long rel_size,
2cf0635d 1057 Elf_Internal_Sym * symtab,
d3ba0551 1058 unsigned long nsyms,
2cf0635d 1059 char * strtab,
d79b3d50 1060 unsigned long strtablen,
bb4d2ac2
L		 1061 int is_rela,
1062 int is_dynsym)
4d6ed7c8 1063{
b34976b6 1064 unsigned int i;
2cf0635d 1065 Elf_Internal_Rela * rels;
103f02d3 1066
4d6ed7c8
NC		 1067 if (is_rela == UNKNOWN)
1068 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 1069
4d6ed7c8
NC		 1070 if (is_rela)
1071 {
c8286bd1 1072 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1073 return;
4d6ed7c8
NC		 1074 }
1075 else
1076 {
1077 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1078 return;
252b5132
RH		 1079 }
1080
410f7a12
L		 1081 if (is_32bit_elf)
1082 {
1083 if (is_rela)
2c71103e
NC		 1084 {
1085 if (do_wide)
1086 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1087 else
1088 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1089 }
410f7a12 1090 else
2c71103e
NC		 1091 {
1092 if (do_wide)
1093 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1094 else
1095 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1096 }
410f7a12 1097 }
252b5132 1098 else
410f7a12
L		 1099 {
1100 if (is_rela)
2c71103e
NC		 1101 {
1102 if (do_wide)
8beeaeb7 1103 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 1104 else
1105 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1106 }
410f7a12 1107 else
2c71103e
NC		 1108 {
1109 if (do_wide)
8beeaeb7 1110 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 1111 else
1112 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1113 }
410f7a12 1114 }
252b5132
RH		 1115
1116 for (i = 0; i < rel_size; i++)
1117 {
2cf0635d 1118 const char * rtype;
b34976b6 1119 bfd_vma offset;
91d6fa6a 1120 bfd_vma inf;
b34976b6
AM		 1121 bfd_vma symtab_index;
1122 bfd_vma type;
103f02d3 1123
b34976b6 1124 offset = rels[i].r_offset;
91d6fa6a 1125 inf = rels[i].r_info;
103f02d3 1126
91d6fa6a
NC		 1127 type = get_reloc_type (inf);
1128 symtab_index = get_reloc_symindex (inf);
252b5132 1129
410f7a12
L		 1130 if (is_32bit_elf)
1131 {
39dbeff8
AM		 1132 printf ("%8.8lx %8.8lx ",
1133 (unsigned long) offset & 0xffffffff,
91d6fa6a 1134 (unsigned long) inf & 0xffffffff);
410f7a12
L		 1135 }
1136 else
1137 {
39dbeff8
AM		 1138#if BFD_HOST_64BIT_LONG
1139 printf (do_wide
1140 ? "%16.16lx %16.16lx "
1141 : "%12.12lx %12.12lx ",
91d6fa6a 1142 offset, inf);
39dbeff8 1143#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 1144#ifndef __MSVCRT__
39dbeff8
AM		 1145 printf (do_wide
1146 ? "%16.16llx %16.16llx "
1147 : "%12.12llx %12.12llx ",
91d6fa6a 1148 offset, inf);
6e3d6dc1
NC		 1149#else
1150 printf (do_wide
1151 ? "%16.16I64x %16.16I64x "
1152 : "%12.12I64x %12.12I64x ",
91d6fa6a 1153 offset, inf);
6e3d6dc1 1154#endif
39dbeff8 1155#else
2c71103e
NC		 1156 printf (do_wide
1157 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1158 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 1159 _bfd_int64_high (offset),
1160 _bfd_int64_low (offset),
91d6fa6a
NC		 1161 _bfd_int64_high (inf),
1162 _bfd_int64_low (inf));
9ea033b2 1163#endif
410f7a12 1164 }
103f02d3 1165
252b5132
RH		 1166 switch (elf_header.e_machine)
1167 {
1168 default:
1169 rtype = NULL;
1170 break;
1171
a06ea964
NC		 1172 case EM_AARCH64:
1173 rtype = elf_aarch64_reloc_type (type);
1174 break;
1175
2b0337b0 1176 case EM_M32R:
252b5132 1177 case EM_CYGNUS_M32R:
9ea033b2 1178 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 1179 break;
1180
1181 case EM_386:
22abe556 1182 case EM_IAMCU:
9ea033b2 1183 rtype = elf_i386_reloc_type (type);
252b5132
RH		 1184 break;
1185
ba2685cc
AM		 1186 case EM_68HC11:
1187 case EM_68HC12:
1188 rtype = elf_m68hc11_reloc_type (type);
1189 break;
75751cd9 1190
252b5132 1191 case EM_68K:
9ea033b2 1192 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1193 break;
1194
63fcb9e9 1195 case EM_960:
9ea033b2 1196 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1197 break;
1198
adde6300 1199 case EM_AVR:
2b0337b0 1200 case EM_AVR_OLD:
adde6300
AM		 1201 rtype = elf_avr_reloc_type (type);
1202 break;
1203
9ea033b2
NC		 1204 case EM_OLD_SPARCV9:
1205 case EM_SPARC32PLUS:
1206 case EM_SPARCV9:
252b5132 1207 case EM_SPARC:
9ea033b2 1208 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1209 break;
1210
e9f53129
AM		 1211 case EM_SPU:
1212 rtype = elf_spu_reloc_type (type);
1213 break;
1214
708e2187
NC		 1215 case EM_V800:
1216 rtype = v800_reloc_type (type);
1217 break;
2b0337b0 1218 case EM_V850:
252b5132 1219 case EM_CYGNUS_V850:
9ea033b2 1220 rtype = v850_reloc_type (type);
252b5132
RH		 1221 break;
1222
2b0337b0 1223 case EM_D10V:
252b5132 1224 case EM_CYGNUS_D10V:
9ea033b2 1225 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1226 break;
1227
2b0337b0 1228 case EM_D30V:
252b5132 1229 case EM_CYGNUS_D30V:
9ea033b2 1230 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1231 break;
1232
d172d4ba
NC		 1233 case EM_DLX:
1234 rtype = elf_dlx_reloc_type (type);
1235 break;
1236
252b5132 1237 case EM_SH:
9ea033b2 1238 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1239 break;
1240
2b0337b0 1241 case EM_MN10300:
252b5132 1242 case EM_CYGNUS_MN10300:
9ea033b2 1243 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1244 break;
1245
2b0337b0 1246 case EM_MN10200:
252b5132 1247 case EM_CYGNUS_MN10200:
9ea033b2 1248 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1249 break;
1250
2b0337b0 1251 case EM_FR30:
252b5132 1252 case EM_CYGNUS_FR30:
9ea033b2 1253 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1254 break;
1255
ba2685cc
AM		 1256 case EM_CYGNUS_FRV:
1257 rtype = elf_frv_reloc_type (type);
1258 break;
5c70f934 1259
3f8107ab
AM		 1260 case EM_FT32:
1261 rtype = elf_ft32_reloc_type (type);
1262 break;
1263
252b5132 1264 case EM_MCORE:
9ea033b2 1265 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1266 break;
1267
3c3bdf30
NC		 1268 case EM_MMIX:
1269 rtype = elf_mmix_reloc_type (type);
1270 break;
1271
5506d11a
AM		 1272 case EM_MOXIE:
1273 rtype = elf_moxie_reloc_type (type);
1274 break;
1275
2469cfa2 1276 case EM_MSP430:
13761a11
NC		 1277 if (uses_msp430x_relocs ())
1278 {
1279 rtype = elf_msp430x_reloc_type (type);
1280 break;
1281 }
2469cfa2
NC		 1282 case EM_MSP430_OLD:
1283 rtype = elf_msp430_reloc_type (type);
1284 break;
1285
35c08157
KLC		 1286 case EM_NDS32:
1287 rtype = elf_nds32_reloc_type (type);
1288 break;
1289
252b5132 1290 case EM_PPC:
9ea033b2 1291 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1292 break;
1293
c833c019
AM		 1294 case EM_PPC64:
1295 rtype = elf_ppc64_reloc_type (type);
1296 break;
1297
252b5132 1298 case EM_MIPS:
4fe85591 1299 case EM_MIPS_RS3_LE:
9ea033b2 1300 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1301 break;
1302
1303 case EM_ALPHA:
9ea033b2 1304 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1305 break;
1306
1307 case EM_ARM:
9ea033b2 1308 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1309 break;
1310
584da044 1311 case EM_ARC:
9ea033b2 1312 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1313 break;
1314
1315 case EM_PARISC:
69e617ca 1316 rtype = elf_hppa_reloc_type (type);
252b5132 1317 break;
7d466069 1318
b8720f9d
JL		 1319 case EM_H8_300:
1320 case EM_H8_300H:
1321 case EM_H8S:
1322 rtype = elf_h8_reloc_type (type);
1323 break;
1324
73589c9d
CS		 1325 case EM_OR1K:
1326 rtype = elf_or1k_reloc_type (type);
3b16e843
NC		 1327 break;
1328
7d466069 1329 case EM_PJ:
2b0337b0 1330 case EM_PJ_OLD:
7d466069
ILT		 1331 rtype = elf_pj_reloc_type (type);
1332 break;
800eeca4
JW		 1333 case EM_IA_64:
1334 rtype = elf_ia64_reloc_type (type);
1335 break;
1b61cf92
HPN		 1336
1337 case EM_CRIS:
1338 rtype = elf_cris_reloc_type (type);
1339 break;
535c37ff
JE		 1340
1341 case EM_860:
1342 rtype = elf_i860_reloc_type (type);
1343 break;
bcedfee6
NC		 1344
1345 case EM_X86_64:
8a9036a4 1346 case EM_L1OM:
7a9068fe 1347 case EM_K1OM:
bcedfee6
NC		 1348 rtype = elf_x86_64_reloc_type (type);
1349 break;
a85d7ed0 1350
35b1837e
AM		 1351 case EM_S370:
1352 rtype = i370_reloc_type (type);
1353 break;
1354
53c7db4b
KH		 1355 case EM_S390_OLD:
1356 case EM_S390:
1357 rtype = elf_s390_reloc_type (type);
1358 break;
93fbbb04 1359
1c0d3aa6
NC		 1360 case EM_SCORE:
1361 rtype = elf_score_reloc_type (type);
1362 break;
1363
93fbbb04
GK		 1364 case EM_XSTORMY16:
1365 rtype = elf_xstormy16_reloc_type (type);
1366 break;
179d3252 1367
1fe1f39c
NC		 1368 case EM_CRX:
1369 rtype = elf_crx_reloc_type (type);
1370 break;
1371
179d3252
JT		 1372 case EM_VAX:
1373 rtype = elf_vax_reloc_type (type);
1374 break;
1e4cf259 1375
619ed720
EB		 1376 case EM_VISIUM:
1377 rtype = elf_visium_reloc_type (type);
1378 break;
1379
cfb8c092
NC		 1380 case EM_ADAPTEVA_EPIPHANY:
1381 rtype = elf_epiphany_reloc_type (type);
1382 break;
1383
1e4cf259
NC		 1384 case EM_IP2K:
1385 case EM_IP2K_OLD:
1386 rtype = elf_ip2k_reloc_type (type);
1387 break;
3b36097d
SC		 1388
1389 case EM_IQ2000:
1390 rtype = elf_iq2000_reloc_type (type);
1391 break;
88da6820
NC		 1392
1393 case EM_XTENSA_OLD:
1394 case EM_XTENSA:
1395 rtype = elf_xtensa_reloc_type (type);
1396 break;
a34e3ecb 1397
84e94c90
NC		 1398 case EM_LATTICEMICO32:
1399 rtype = elf_lm32_reloc_type (type);
1400 break;
1401
ff7eeb89 1402 case EM_M32C_OLD:
49f58d10
JB		 1403 case EM_M32C:
1404 rtype = elf_m32c_reloc_type (type);
1405 break;
1406
d031aafb
NS		 1407 case EM_MT:
1408 rtype = elf_mt_reloc_type (type);
a34e3ecb 1409 break;
1d65ded4
CM		 1410
1411 case EM_BLACKFIN:
1412 rtype = elf_bfin_reloc_type (type);
1413 break;
15ab5209
DB		 1414
1415 case EM_CYGNUS_MEP:
1416 rtype = elf_mep_reloc_type (type);
1417 break;
60bca95a
NC		 1418
1419 case EM_CR16:
1420 rtype = elf_cr16_reloc_type (type);
1421 break;
dd24e3da 1422
7ba29e2a
NC		 1423 case EM_MICROBLAZE:
1424 case EM_MICROBLAZE_OLD:
1425 rtype = elf_microblaze_reloc_type (type);
1426 break;
c7927a3c 1427
99c513f6
DD		 1428 case EM_RL78:
1429 rtype = elf_rl78_reloc_type (type);
1430 break;
1431
c7927a3c
NC		 1432 case EM_RX:
1433 rtype = elf_rx_reloc_type (type);
1434 break;
c29aca4a 1435
a3c62988
NC		 1436 case EM_METAG:
1437 rtype = elf_metag_reloc_type (type);
1438 break;
1439
c29aca4a
NC		 1440 case EM_XC16X:
1441 case EM_C166:
1442 rtype = elf_xc16x_reloc_type (type);
1443 break;
40b36596
JM		 1444
1445 case EM_TI_C6000:
1446 rtype = elf_tic6x_reloc_type (type);
1447 break;
aa137e4d
NC		 1448
1449 case EM_TILEGX:
1450 rtype = elf_tilegx_reloc_type (type);
1451 break;
1452
1453 case EM_TILEPRO:
1454 rtype = elf_tilepro_reloc_type (type);
1455 break;
f6c1a2d5
NC		 1456
1457 case EM_XGATE:
1458 rtype = elf_xgate_reloc_type (type);
1459 break;
36591ba1
SL		 1460
1461 case EM_ALTERA_NIOS2:
1462 rtype = elf_nios2_reloc_type (type);
1463 break;
252b5132
RH		 1464 }
1465
1466 if (rtype == NULL)
39dbeff8 1467 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1468 else
8beeaeb7 1469 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1470
7ace3541 1471 if (elf_header.e_machine == EM_ALPHA
157c2599 1472 && rtype != NULL
7ace3541
RH		 1473 && streq (rtype, "R_ALPHA_LITUSE")
1474 && is_rela)
1475 {
1476 switch (rels[i].r_addend)
1477 {
1478 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1479 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1480 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1481 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1482 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1483 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1484 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1485 default: rtype = NULL;
1486 }
1487 if (rtype)
1488 printf (" (%s)", rtype);
1489 else
1490 {
1491 putchar (' ');
1492 printf (_("<unknown addend: %lx>"),
1493 (unsigned long) rels[i].r_addend);
1494 }
1495 }
1496 else if (symtab_index)
252b5132 1497 {
af3fc3bc 1498 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1499 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1500 else
19936277 1501 {
2cf0635d 1502 Elf_Internal_Sym * psym;
bb4d2ac2
L		 1503 const char * version_string;
1504 enum versioned_symbol_info sym_info;
1505 unsigned short vna_other;
19936277 1506
af3fc3bc 1507 psym = symtab + symtab_index;
103f02d3 1508
bb4d2ac2
L		 1509 version_string
1510 = get_symbol_version_string (file, is_dynsym,
1511 strtab, strtablen,
1512 symtab_index,
1513 psym,
1514 &sym_info,
1515 &vna_other);
1516
af3fc3bc 1517 printf (" ");
171191ba 1518
d8045f23
NC		 1519 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1520 {
1521 const char * name;
1522 unsigned int len;
1523 unsigned int width = is_32bit_elf ? 8 : 14;
1524
1525 /* Relocations against GNU_IFUNC symbols do not use the value
1526 of the symbol as the address to relocate against. Instead
1527 they invoke the function named by the symbol and use its
1528 result as the address for relocation.
1529
1530 To indicate this to the user, do not display the value of
1531 the symbol in the "Symbols's Value" field. Instead show
1532 its name followed by () as a hint that the symbol is
1533 invoked. */
1534
1535 if (strtab == NULL
1536 || psym->st_name == 0
1537 || psym->st_name >= strtablen)
1538 name = "??";
1539 else
1540 name = strtab + psym->st_name;
1541
1542 len = print_symbol (width, name);
bb4d2ac2
L		 1543 if (version_string)
1544 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1545 version_string);
d8045f23
NC		 1546 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1547 }
1548 else
1549 {
1550 print_vma (psym->st_value, LONG_HEX);
171191ba 1551
d8045f23
NC		 1552 printf (is_32bit_elf ? " " : " ");
1553 }
103f02d3 1554
af3fc3bc 1555 if (psym->st_name == 0)
f1ef08cb 1556 {
2cf0635d 1557 const char * sec_name = "<null>";
f1ef08cb
AM		 1558 char name_buf[40];
1559
1560 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1561 {
4fbb74a6 1562 if (psym->st_shndx < elf_header.e_shnum)
74e1a04b 1563 sec_name = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1564 else if (psym->st_shndx == SHN_ABS)
1565 sec_name = "ABS";
1566 else if (psym->st_shndx == SHN_COMMON)
1567 sec_name = "COMMON";
ac145307
BS		 1568 else if ((elf_header.e_machine == EM_MIPS
1569 && psym->st_shndx == SHN_MIPS_SCOMMON)
1570 || (elf_header.e_machine == EM_TI_C6000
1571 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1572 sec_name = "SCOMMON";
1573 else if (elf_header.e_machine == EM_MIPS
1574 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1575 sec_name = "SUNDEF";
8a9036a4 1576 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1577 || elf_header.e_machine == EM_L1OM
1578 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1579 && psym->st_shndx == SHN_X86_64_LCOMMON)
1580 sec_name = "LARGE_COMMON";
9ce701e2
L		 1581 else if (elf_header.e_machine == EM_IA_64
1582 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1583 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1584 sec_name = "ANSI_COM";
28f997cf 1585 else if (is_ia64_vms ()
148b93f2
NC		 1586 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1587 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1588 else
1589 {
1590 sprintf (name_buf, "<section 0x%x>",
1591 (unsigned int) psym->st_shndx);
1592 sec_name = name_buf;
1593 }
1594 }
1595 print_symbol (22, sec_name);
1596 }
af3fc3bc 1597 else if (strtab == NULL)
d79b3d50 1598 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1599 else if (psym->st_name >= strtablen)
d79b3d50 1600 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1601 else
bb4d2ac2
L		 1602 {
1603 print_symbol (22, strtab + psym->st_name);
1604 if (version_string)
1605 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1606 version_string);
1607 }
103f02d3 1608
af3fc3bc 1609 if (is_rela)
171191ba 1610 {
7360e63f 1611 bfd_vma off = rels[i].r_addend;
171191ba 1612
7360e63f 1613 if ((bfd_signed_vma) off < 0)
598aaa76 1614 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1615 else
598aaa76 1616 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1617 }
19936277 1618 }
252b5132 1619 }
1b228002 1620 else if (is_rela)
f7a99963 1621 {
7360e63f 1622 bfd_vma off = rels[i].r_addend;
e04d7088
L		 1623
1624 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
7360e63f 1625 if ((bfd_signed_vma) off < 0)
e04d7088
L		 1626 printf ("-%" BFD_VMA_FMT "x", - off);
1627 else
1628 printf ("%" BFD_VMA_FMT "x", off);
f7a99963 1629 }
252b5132 1630
157c2599
NC		 1631 if (elf_header.e_machine == EM_SPARCV9
1632 && rtype != NULL
1633 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1634 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1635
252b5132 1636 putchar ('\n');
2c71103e 1637
aca88567 1638#ifdef BFD64
53c7db4b 1639 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1640 {
91d6fa6a
NC		 1641 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1642 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1643 const char * rtype2 = elf_mips_reloc_type (type2);
1644 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1645
2c71103e
NC		 1646 printf (" Type2: ");
1647
1648 if (rtype2 == NULL)
39dbeff8
AM		 1649 printf (_("unrecognized: %-7lx"),
1650 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1651 else
1652 printf ("%-17.17s", rtype2);
1653
18bd398b 1654 printf ("\n Type3: ");
2c71103e
NC		 1655
1656 if (rtype3 == NULL)
39dbeff8
AM		 1657 printf (_("unrecognized: %-7lx"),
1658 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1659 else
1660 printf ("%-17.17s", rtype3);
1661
53c7db4b 1662 putchar ('\n');
2c71103e 1663 }
aca88567 1664#endif /* BFD64 */
252b5132
RH		 1665 }
1666
c8286bd1 1667 free (rels);
252b5132
RH		 1668}
1669
1670static const char *
d3ba0551 1671get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1672{
1673 switch (type)
1674 {
1675 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1676 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1677 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1678 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1679 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1680 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1681 case DT_MIPS_MSYM: return "MIPS_MSYM";
1682 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1683 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1684 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1685 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1686 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1687 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1688 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1689 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1690 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1691 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
a5499fa4 1692 case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
252b5132
RH		 1693 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1694 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1695 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1696 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1697 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1698 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1699 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1700 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1701 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1702 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1703 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1704 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1705 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1706 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1707 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1708 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1709 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1710 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1711 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1712 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1713 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1714 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1715 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1716 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1717 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1718 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1719 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1720 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1721 default:
1722 return NULL;
1723 }
1724}
1725
9a097730 1726static const char *
d3ba0551 1727get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1728{
1729 switch (type)
1730 {
1731 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1732 default:
1733 return NULL;
1734 }
103f02d3
UD		 1735}
1736
7490d522
AM		 1737static const char *
1738get_ppc_dynamic_type (unsigned long type)
1739{
1740 switch (type)
1741 {
a7f2871e 1742 case DT_PPC_GOT: return "PPC_GOT";
e8910a83 1743 case DT_PPC_OPT: return "PPC_OPT";
7490d522
AM		 1744 default:
1745 return NULL;
1746 }
1747}
1748
f1cb7e17 1749static const char *
d3ba0551 1750get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1751{
1752 switch (type)
1753 {
a7f2871e
AM		 1754 case DT_PPC64_GLINK: return "PPC64_GLINK";
1755 case DT_PPC64_OPD: return "PPC64_OPD";
1756 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
e8910a83 1757 case DT_PPC64_OPT: return "PPC64_OPT";
f1cb7e17
AM		 1758 default:
1759 return NULL;
1760 }
1761}
1762
103f02d3 1763static const char *
d3ba0551 1764get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1765{
1766 switch (type)
1767 {
1768 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1769 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1770 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1771 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1772 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1773 case DT_HP_PREINIT: return "HP_PREINIT";
1774 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1775 case DT_HP_NEEDED: return "HP_NEEDED";
1776 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1777 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1778 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1779 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1780 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1781 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1782 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1783 case DT_HP_FILTERED: return "HP_FILTERED";
1784 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1785 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1786 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1787 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1788 case DT_PLT: return "PLT";
1789 case DT_PLT_SIZE: return "PLT_SIZE";
1790 case DT_DLT: return "DLT";
1791 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1792 default:
1793 return NULL;
1794 }
1795}
9a097730 1796
ecc51f48 1797static const char *
d3ba0551 1798get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1799{
1800 switch (type)
1801 {
148b93f2
NC		 1802 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1803 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1804 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1805 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1806 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1807 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1808 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1809 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1810 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1811 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1812 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1813 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1814 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1815 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1816 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1817 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1818 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1819 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1820 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1821 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1822 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1823 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1824 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1825 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1826 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1827 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1828 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1829 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1830 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1831 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1832 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1833 default:
1834 return NULL;
1835 }
1836}
1837
fabcb361
RH		 1838static const char *
1839get_alpha_dynamic_type (unsigned long type)
1840{
1841 switch (type)
1842 {
1843 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1844 default:
1845 return NULL;
1846 }
1847}
1848
1c0d3aa6
NC		 1849static const char *
1850get_score_dynamic_type (unsigned long type)
1851{
1852 switch (type)
1853 {
1854 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1855 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1856 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1857 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1858 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1859 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1860 default:
1861 return NULL;
1862 }
1863}
1864
40b36596
JM		 1865static const char *
1866get_tic6x_dynamic_type (unsigned long type)
1867{
1868 switch (type)
1869 {
1870 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1871 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1872 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1873 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1874 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1875 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1876 default:
1877 return NULL;
1878 }
1879}
1c0d3aa6 1880
36591ba1
SL		 1881static const char *
1882get_nios2_dynamic_type (unsigned long type)
1883{
1884 switch (type)
1885 {
1886 case DT_NIOS2_GP: return "NIOS2_GP";
1887 default:
1888 return NULL;
1889 }
1890}
1891
252b5132 1892static const char *
d3ba0551 1893get_dynamic_type (unsigned long type)
252b5132 1894{
e9e44622 1895 static char buff[64];
252b5132
RH		 1896
1897 switch (type)
1898 {
1899 case DT_NULL: return "NULL";
1900 case DT_NEEDED: return "NEEDED";
1901 case DT_PLTRELSZ: return "PLTRELSZ";
1902 case DT_PLTGOT: return "PLTGOT";
1903 case DT_HASH: return "HASH";
1904 case DT_STRTAB: return "STRTAB";
1905 case DT_SYMTAB: return "SYMTAB";
1906 case DT_RELA: return "RELA";
1907 case DT_RELASZ: return "RELASZ";
1908 case DT_RELAENT: return "RELAENT";
1909 case DT_STRSZ: return "STRSZ";
1910 case DT_SYMENT: return "SYMENT";
1911 case DT_INIT: return "INIT";
1912 case DT_FINI: return "FINI";
1913 case DT_SONAME: return "SONAME";
1914 case DT_RPATH: return "RPATH";
1915 case DT_SYMBOLIC: return "SYMBOLIC";
1916 case DT_REL: return "REL";
1917 case DT_RELSZ: return "RELSZ";
1918 case DT_RELENT: return "RELENT";
1919 case DT_PLTREL: return "PLTREL";
1920 case DT_DEBUG: return "DEBUG";
1921 case DT_TEXTREL: return "TEXTREL";
1922 case DT_JMPREL: return "JMPREL";
1923 case DT_BIND_NOW: return "BIND_NOW";
1924 case DT_INIT_ARRAY: return "INIT_ARRAY";
1925 case DT_FINI_ARRAY: return "FINI_ARRAY";
1926 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1927 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1928 case DT_RUNPATH: return "RUNPATH";
1929 case DT_FLAGS: return "FLAGS";
2d0e6f43 1930
d1133906
NC		 1931 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1932 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1933
05107a46 1934 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1935 case DT_PLTPADSZ: return "PLTPADSZ";
1936 case DT_MOVEENT: return "MOVEENT";
1937 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1938 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1939 case DT_POSFLAG_1: return "POSFLAG_1";
1940 case DT_SYMINSZ: return "SYMINSZ";
1941 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1942
252b5132 1943 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1944 case DT_CONFIG: return "CONFIG";
1945 case DT_DEPAUDIT: return "DEPAUDIT";
1946 case DT_AUDIT: return "AUDIT";
1947 case DT_PLTPAD: return "PLTPAD";
1948 case DT_MOVETAB: return "MOVETAB";
252b5132 1949 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1950
252b5132 1951 case DT_VERSYM: return "VERSYM";
103f02d3 1952
67a4f2b7
AO		 1953 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1954 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1955 case DT_RELACOUNT: return "RELACOUNT";
1956 case DT_RELCOUNT: return "RELCOUNT";
1957 case DT_FLAGS_1: return "FLAGS_1";
1958 case DT_VERDEF: return "VERDEF";
1959 case DT_VERDEFNUM: return "VERDEFNUM";
1960 case DT_VERNEED: return "VERNEED";
1961 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1962
019148e4 1963 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1964 case DT_USED: return "USED";
1965 case DT_FILTER: return "FILTER";
103f02d3 1966
047b2264
JJ		 1967 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1968 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1969 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1970 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1971 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1972 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1973
252b5132
RH		 1974 default:
1975 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1976 {
2cf0635d 1977 const char * result;
103f02d3 1978
252b5132
RH		 1979 switch (elf_header.e_machine)
1980 {
1981 case EM_MIPS:
4fe85591 1982 case EM_MIPS_RS3_LE:
252b5132
RH		 1983 result = get_mips_dynamic_type (type);
1984 break;
9a097730
RH		 1985 case EM_SPARCV9:
1986 result = get_sparc64_dynamic_type (type);
1987 break;
7490d522
AM		 1988 case EM_PPC:
1989 result = get_ppc_dynamic_type (type);
1990 break;
f1cb7e17
AM		 1991 case EM_PPC64:
1992 result = get_ppc64_dynamic_type (type);
1993 break;
ecc51f48
NC		 1994 case EM_IA_64:
1995 result = get_ia64_dynamic_type (type);
1996 break;
fabcb361
RH		 1997 case EM_ALPHA:
1998 result = get_alpha_dynamic_type (type);
1999 break;
1c0d3aa6
NC		 2000 case EM_SCORE:
2001 result = get_score_dynamic_type (type);
2002 break;
40b36596
JM		 2003 case EM_TI_C6000:
2004 result = get_tic6x_dynamic_type (type);
2005 break;
36591ba1
SL		 2006 case EM_ALTERA_NIOS2:
2007 result = get_nios2_dynamic_type (type);
2008 break;
252b5132
RH		 2009 default:
2010 result = NULL;
2011 break;
2012 }
2013
2014 if (result != NULL)
2015 return result;
2016
e9e44622 2017 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 2018 }
eec8f817
DA		 2019 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2020 || (elf_header.e_machine == EM_PARISC
2021 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 2022 {
2cf0635d 2023 const char * result;
103f02d3
UD		 2024
2025 switch (elf_header.e_machine)
2026 {
2027 case EM_PARISC:
2028 result = get_parisc_dynamic_type (type);
2029 break;
148b93f2
NC		 2030 case EM_IA_64:
2031 result = get_ia64_dynamic_type (type);
2032 break;
103f02d3
UD		 2033 default:
2034 result = NULL;
2035 break;
2036 }
2037
2038 if (result != NULL)
2039 return result;
2040
e9e44622
JJ		 2041 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2042 type);
103f02d3 2043 }
252b5132 2044 else
e9e44622 2045 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 2046
252b5132
RH		 2047 return buff;
2048 }
2049}
2050
2051static char *
d3ba0551 2052get_file_type (unsigned e_type)
252b5132 2053{
b34976b6 2054 static char buff[32];
252b5132
RH		 2055
2056 switch (e_type)
2057 {
2058 case ET_NONE: return _("NONE (None)");
2059 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 2060 case ET_EXEC: return _("EXEC (Executable file)");
2061 case ET_DYN: return _("DYN (Shared object file)");
2062 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 2063
2064 default:
2065 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 2066 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 2067 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 2068 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 2069 else
e9e44622 2070 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 2071 return buff;
2072 }
2073}
2074
2075static char *
d3ba0551 2076get_machine_name (unsigned e_machine)
252b5132 2077{
b34976b6 2078 static char buff[64]; /* XXX */
252b5132
RH		 2079
2080 switch (e_machine)
2081 {
c45021f2 2082 case EM_NONE: return _("None");
a06ea964 2083 case EM_AARCH64: return "AArch64";
c45021f2
NC		 2084 case EM_M32: return "WE32100";
2085 case EM_SPARC: return "Sparc";
e9f53129 2086 case EM_SPU: return "SPU";
c45021f2
NC		 2087 case EM_386: return "Intel 80386";
2088 case EM_68K: return "MC68000";
2089 case EM_88K: return "MC88000";
22abe556 2090 case EM_IAMCU: return "Intel MCU";
c45021f2
NC		 2091 case EM_860: return "Intel 80860";
2092 case EM_MIPS: return "MIPS R3000";
2093 case EM_S370: return "IBM System/370";
7036c0e1 2094 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 2095 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 2096 case EM_PARISC: return "HPPA";
252b5132 2097 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 2098 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 2099 case EM_960: return "Intel 90860";
2100 case EM_PPC: return "PowerPC";
285d1771 2101 case EM_PPC64: return "PowerPC64";
c45021f2 2102 case EM_FR20: return "Fujitsu FR20";
3f8107ab 2103 case EM_FT32: return "FTDI FT32";
c45021f2 2104 case EM_RH32: return "TRW RH32";
b34976b6 2105 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 2106 case EM_ARM: return "ARM";
2107 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 2108 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 2109 case EM_SPARCV9: return "Sparc v9";
2110 case EM_TRICORE: return "Siemens Tricore";
584da044 2111 case EM_ARC: return "ARC";
c2dcd04e
NC		 2112 case EM_H8_300: return "Renesas H8/300";
2113 case EM_H8_300H: return "Renesas H8/300H";
2114 case EM_H8S: return "Renesas H8S";
2115 case EM_H8_500: return "Renesas H8/500";
30800947 2116 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 2117 case EM_MIPS_X: return "Stanford MIPS-X";
2118 case EM_COLDFIRE: return "Motorola Coldfire";
c45021f2 2119 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 2120 case EM_CYGNUS_D10V:
2121 case EM_D10V: return "d10v";
2122 case EM_CYGNUS_D30V:
b34976b6 2123 case EM_D30V: return "d30v";
2b0337b0 2124 case EM_CYGNUS_M32R:
26597c86 2125 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 2126 case EM_CYGNUS_V850:
708e2187 2127 case EM_V800: return "Renesas V850 (using RH850 ABI)";
f6c1a2d5 2128 case EM_V850: return "Renesas V850";
2b0337b0
AO		 2129 case EM_CYGNUS_MN10300:
2130 case EM_MN10300: return "mn10300";
2131 case EM_CYGNUS_MN10200:
2132 case EM_MN10200: return "mn10200";
5506d11a 2133 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 2134 case EM_CYGNUS_FR30:
2135 case EM_FR30: return "Fujitsu FR30";
b34976b6 2136 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 2137 case EM_PJ_OLD:
b34976b6 2138 case EM_PJ: return "picoJava";
7036c0e1
AJ		 2139 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2140 case EM_PCP: return "Siemens PCP";
2141 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2142 case EM_NDR1: return "Denso NDR1 microprocesspr";
2143 case EM_STARCORE: return "Motorola Star*Core processor";
2144 case EM_ME16: return "Toyota ME16 processor";
2145 case EM_ST100: return "STMicroelectronics ST100 processor";
2146 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 2147 case EM_PDSP: return "Sony DSP processor";
2148 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2149 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 2150 case EM_FX66: return "Siemens FX66 microcontroller";
2151 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2152 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2153 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
6927f982 2154 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ		 2155 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2156 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2157 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2158 case EM_SVX: return "Silicon Graphics SVx";
2159 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2160 case EM_VAX: return "Digital VAX";
619ed720 2161 case EM_VISIUM: return "CDS VISIUMcore processor";
2b0337b0 2162 case EM_AVR_OLD:
b34976b6 2163 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 2164 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 2165 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2166 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2167 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 2168 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 2169 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 2170 case EM_PRISM: return "Vitesse Prism";
bcedfee6 2171 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 2172 case EM_L1OM: return "Intel L1OM";
7a9068fe 2173 case EM_K1OM: return "Intel K1OM";
b7498e0e 2174 case EM_S390_OLD:
b34976b6 2175 case EM_S390: return "IBM S/390";
1c0d3aa6 2176 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 2177 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
73589c9d 2178 case EM_OR1K: return "OpenRISC 1000";
11636f9e 2179 case EM_ARC_A5: return "ARC International ARCompact processor";
1fe1f39c 2180 case EM_CRX: return "National Semiconductor CRX microprocessor";
cfb8c092 2181 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
d172d4ba 2182 case EM_DLX: return "OpenDLX";
1e4cf259 2183 case EM_IP2K_OLD:
b34976b6 2184 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 2185 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 2186 case EM_XTENSA_OLD:
2187 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 2188 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2189 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2190 case EM_NS32K: return "National Semiconductor 32000 series";
2191 case EM_TPC: return "Tenor Network TPC processor";
2192 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2193 case EM_MAX: return "MAX Processor";
2194 case EM_CR: return "National Semiconductor CompactRISC";
2195 case EM_F2MC16: return "Fujitsu F2MC16";
2196 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 2197 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 2198 case EM_M32C_OLD:
49f58d10 2199 case EM_M32C: return "Renesas M32c";
d031aafb 2200 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 2201 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 2202 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2203 case EM_SEP: return "Sharp embedded microprocessor";
2204 case EM_ARCA: return "Arca RISC microprocessor";
2205 case EM_UNICORE: return "Unicore";
2206 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2207 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 2208 case EM_NIOS32: return "Altera Nios";
2209 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 2210 case EM_C166:
d70c5fc7 2211 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 2212 case EM_M16C: return "Renesas M16C series microprocessors";
2213 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2214 case EM_CE: return "Freescale Communication Engine RISC core";
2215 case EM_TSK3000: return "Altium TSK3000 core";
2216 case EM_RS08: return "Freescale RS08 embedded processor";
2217 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2218 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2219 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2220 case EM_SE_C17: return "Seiko Epson C17 family";
2221 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2222 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2223 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2224 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2225 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2226 case EM_R32C: return "Renesas R32C series microprocessors";
2227 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2228 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2229 case EM_8051: return "Intel 8051 and variants";
2230 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2231 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2232 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2233 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2234 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2235 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2236 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 2237 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 2238 case EM_CR16:
f6c1a2d5 2239 case EM_MICROBLAZE:
7ba29e2a 2240 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
99c513f6 2241 case EM_RL78: return "Renesas RL78";
c7927a3c 2242 case EM_RX: return "Renesas RX";
a3c62988 2243 case EM_METAG: return "Imagination Technologies Meta processor architecture";
11636f9e
JM		 2244 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2245 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2246 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2247 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2248 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2249 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2250 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2251 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 2252 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 2253 case EM_CUDA: return "NVIDIA CUDA architecture";
f6c1a2d5 2254 case EM_XGATE: return "Motorola XGATE embedded processor";
252b5132 2255 default:
35d9dd2f 2256 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2257 return buff;
2258 }
2259}
2260
f3485b74 2261static void
d3ba0551 2262decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2263{
2264 unsigned eabi;
2265 int unknown = 0;
2266
2267 eabi = EF_ARM_EABI_VERSION (e_flags);
2268 e_flags &= ~ EF_ARM_EABIMASK;
2269
2270 /* Handle "generic" ARM flags. */
2271 if (e_flags & EF_ARM_RELEXEC)
2272 {
2273 strcat (buf, ", relocatable executable");
2274 e_flags &= ~ EF_ARM_RELEXEC;
2275 }
76da6bbe 2276
f3485b74
NC		 2277 /* Now handle EABI specific flags. */
2278 switch (eabi)
2279 {
2280 default:
2c71103e 2281 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2282 if (e_flags)
2283 unknown = 1;
2284 break;
2285
2286 case EF_ARM_EABI_VER1:
a5bcd848 2287 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2288 while (e_flags)
2289 {
2290 unsigned flag;
76da6bbe 2291
f3485b74
NC		 2292 /* Process flags one bit at a time. */
2293 flag = e_flags & - e_flags;
2294 e_flags &= ~ flag;
76da6bbe 2295
f3485b74
NC		 2296 switch (flag)
2297 {
a5bcd848 2298 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2299 strcat (buf, ", sorted symbol tables");
2300 break;
76da6bbe 2301
f3485b74
NC		 2302 default:
2303 unknown = 1;
2304 break;
2305 }
2306 }
2307 break;
76da6bbe 2308
a5bcd848
PB		 2309 case EF_ARM_EABI_VER2:
2310 strcat (buf, ", Version2 EABI");
2311 while (e_flags)
2312 {
2313 unsigned flag;
2314
2315 /* Process flags one bit at a time. */
2316 flag = e_flags & - e_flags;
2317 e_flags &= ~ flag;
2318
2319 switch (flag)
2320 {
2321 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2322 strcat (buf, ", sorted symbol tables");
2323 break;
2324
2325 case EF_ARM_DYNSYMSUSESEGIDX:
2326 strcat (buf, ", dynamic symbols use segment index");
2327 break;
2328
2329 case EF_ARM_MAPSYMSFIRST:
2330 strcat (buf, ", mapping symbols precede others");
2331 break;
2332
2333 default:
2334 unknown = 1;
2335 break;
2336 }
2337 }
2338 break;
2339
d507cf36
PB		 2340 case EF_ARM_EABI_VER3:
2341 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2342 break;
2343
2344 case EF_ARM_EABI_VER4:
2345 strcat (buf, ", Version4 EABI");
3bfcb652
NC		 2346 while (e_flags)
2347 {
2348 unsigned flag;
2349
2350 /* Process flags one bit at a time. */
2351 flag = e_flags & - e_flags;
2352 e_flags &= ~ flag;
2353
2354 switch (flag)
2355 {
2356 case EF_ARM_BE8:
2357 strcat (buf, ", BE8");
2358 break;
2359
2360 case EF_ARM_LE8:
2361 strcat (buf, ", LE8");
2362 break;
2363
2364 default:
2365 unknown = 1;
2366 break;
2367 }
2368 break;
2369 }
2370 break;
3a4a14e9
PB		 2371
2372 case EF_ARM_EABI_VER5:
2373 strcat (buf, ", Version5 EABI");
d507cf36
PB		 2374 while (e_flags)
2375 {
2376 unsigned flag;
2377
2378 /* Process flags one bit at a time. */
2379 flag = e_flags & - e_flags;
2380 e_flags &= ~ flag;
2381
2382 switch (flag)
2383 {
2384 case EF_ARM_BE8:
2385 strcat (buf, ", BE8");
2386 break;
2387
2388 case EF_ARM_LE8:
2389 strcat (buf, ", LE8");
2390 break;
2391
3bfcb652
NC		 2392 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2393 strcat (buf, ", soft-float ABI");
2394 break;
2395
2396 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2397 strcat (buf, ", hard-float ABI");
2398 break;
2399
d507cf36
PB		 2400 default:
2401 unknown = 1;
2402 break;
2403 }
2404 }
2405 break;
2406
f3485b74 2407 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2408 strcat (buf, ", GNU EABI");
f3485b74
NC		 2409 while (e_flags)
2410 {
2411 unsigned flag;
76da6bbe 2412
f3485b74
NC		 2413 /* Process flags one bit at a time. */
2414 flag = e_flags & - e_flags;
2415 e_flags &= ~ flag;
76da6bbe 2416
f3485b74
NC		 2417 switch (flag)
2418 {
a5bcd848 2419 case EF_ARM_INTERWORK:
f3485b74
NC		 2420 strcat (buf, ", interworking enabled");
2421 break;
76da6bbe 2422
a5bcd848 2423 case EF_ARM_APCS_26:
f3485b74
NC		 2424 strcat (buf, ", uses APCS/26");
2425 break;
76da6bbe 2426
a5bcd848 2427 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2428 strcat (buf, ", uses APCS/float");
2429 break;
76da6bbe 2430
a5bcd848 2431 case EF_ARM_PIC:
f3485b74
NC		 2432 strcat (buf, ", position independent");
2433 break;
76da6bbe 2434
a5bcd848 2435 case EF_ARM_ALIGN8:
f3485b74
NC		 2436 strcat (buf, ", 8 bit structure alignment");
2437 break;
76da6bbe 2438
a5bcd848 2439 case EF_ARM_NEW_ABI:
f3485b74
NC		 2440 strcat (buf, ", uses new ABI");
2441 break;
76da6bbe 2442
a5bcd848 2443 case EF_ARM_OLD_ABI:
f3485b74
NC		 2444 strcat (buf, ", uses old ABI");
2445 break;
76da6bbe 2446
a5bcd848 2447 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2448 strcat (buf, ", software FP");
2449 break;
76da6bbe 2450
90e01f86
ILT		 2451 case EF_ARM_VFP_FLOAT:
2452 strcat (buf, ", VFP");
2453 break;
2454
fde78edd
NC		 2455 case EF_ARM_MAVERICK_FLOAT:
2456 strcat (buf, ", Maverick FP");
2457 break;
2458
f3485b74
NC		 2459 default:
2460 unknown = 1;
2461 break;
2462 }
2463 }
2464 }
f3485b74
NC		 2465
2466 if (unknown)
2b692964 2467 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2468}
2469
343433df
AB		 2470static void
2471decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2472{
2473 --size; /* Leave space for null terminator. */
2474
2475 switch (e_flags & EF_AVR_MACH)
2476 {
2477 case E_AVR_MACH_AVR1:
2478 strncat (buf, ", avr:1", size);
2479 break;
2480 case E_AVR_MACH_AVR2:
2481 strncat (buf, ", avr:2", size);
2482 break;
2483 case E_AVR_MACH_AVR25:
2484 strncat (buf, ", avr:25", size);
2485 break;
2486 case E_AVR_MACH_AVR3:
2487 strncat (buf, ", avr:3", size);
2488 break;
2489 case E_AVR_MACH_AVR31:
2490 strncat (buf, ", avr:31", size);
2491 break;
2492 case E_AVR_MACH_AVR35:
2493 strncat (buf, ", avr:35", size);
2494 break;
2495 case E_AVR_MACH_AVR4:
2496 strncat (buf, ", avr:4", size);
2497 break;
2498 case E_AVR_MACH_AVR5:
2499 strncat (buf, ", avr:5", size);
2500 break;
2501 case E_AVR_MACH_AVR51:
2502 strncat (buf, ", avr:51", size);
2503 break;
2504 case E_AVR_MACH_AVR6:
2505 strncat (buf, ", avr:6", size);
2506 break;
2507 case E_AVR_MACH_AVRTINY:
2508 strncat (buf, ", avr:100", size);
2509 break;
2510 case E_AVR_MACH_XMEGA1:
2511 strncat (buf, ", avr:101", size);
2512 break;
2513 case E_AVR_MACH_XMEGA2:
2514 strncat (buf, ", avr:102", size);
2515 break;
2516 case E_AVR_MACH_XMEGA3:
2517 strncat (buf, ", avr:103", size);
2518 break;
2519 case E_AVR_MACH_XMEGA4:
2520 strncat (buf, ", avr:104", size);
2521 break;
2522 case E_AVR_MACH_XMEGA5:
2523 strncat (buf, ", avr:105", size);
2524 break;
2525 case E_AVR_MACH_XMEGA6:
2526 strncat (buf, ", avr:106", size);
2527 break;
2528 case E_AVR_MACH_XMEGA7:
2529 strncat (buf, ", avr:107", size);
2530 break;
2531 default:
2532 strncat (buf, ", avr:<unknown>", size);
2533 break;
2534 }
2535
2536 size -= strlen (buf);
2537 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2538 strncat (buf, ", link-relax", size);
2539}
2540
35c08157
KLC		 2541static void
2542decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2543{
2544 unsigned abi;
2545 unsigned arch;
2546 unsigned config;
2547 unsigned version;
2548 int has_fpu = 0;
2549 int r = 0;
2550
2551 static const char *ABI_STRINGS[] =
2552 {
2553 "ABI v0", /* use r5 as return register; only used in N1213HC */
2554 "ABI v1", /* use r0 as return register */
2555 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2556 "ABI v2fp", /* for FPU */
40c7a7cb
KLC		 2557 "AABI",
2558 "ABI2 FP+"
35c08157
KLC		 2559 };
2560 static const char *VER_STRINGS[] =
2561 {
2562 "Andes ELF V1.3 or older",
2563 "Andes ELF V1.3.1",
2564 "Andes ELF V1.4"
2565 };
2566 static const char *ARCH_STRINGS[] =
2567 {
2568 "",
2569 "Andes Star v1.0",
2570 "Andes Star v2.0",
2571 "Andes Star v3.0",
2572 "Andes Star v3.0m"
2573 };
2574
2575 abi = EF_NDS_ABI & e_flags;
2576 arch = EF_NDS_ARCH & e_flags;
2577 config = EF_NDS_INST & e_flags;
2578 version = EF_NDS32_ELF_VERSION & e_flags;
2579
2580 memset (buf, 0, size);
2581
2582 switch (abi)
2583 {
2584 case E_NDS_ABI_V0:
2585 case E_NDS_ABI_V1:
2586 case E_NDS_ABI_V2:
2587 case E_NDS_ABI_V2FP:
2588 case E_NDS_ABI_AABI:
40c7a7cb 2589 case E_NDS_ABI_V2FP_PLUS:
35c08157
KLC		 2590 /* In case there are holes in the array. */
2591 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2592 break;
2593
2594 default:
2595 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2596 break;
2597 }
2598
2599 switch (version)
2600 {
2601 case E_NDS32_ELF_VER_1_2:
2602 case E_NDS32_ELF_VER_1_3:
2603 case E_NDS32_ELF_VER_1_4:
2604 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2605 break;
2606
2607 default:
2608 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2609 break;
2610 }
2611
2612 if (E_NDS_ABI_V0 == abi)
2613 {
2614 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2615 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2616 if (arch == E_NDS_ARCH_STAR_V1_0)
2617 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2618 return;
2619 }
2620
2621 switch (arch)
2622 {
2623 case E_NDS_ARCH_STAR_V1_0:
2624 case E_NDS_ARCH_STAR_V2_0:
2625 case E_NDS_ARCH_STAR_V3_0:
2626 case E_NDS_ARCH_STAR_V3_M:
2627 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2628 break;
2629
2630 default:
2631 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2632 /* ARCH version determines how the e_flags are interpreted.
2633 If it is unknown, we cannot proceed. */
2634 return;
2635 }
2636
2637 /* Newer ABI; Now handle architecture specific flags. */
2638 if (arch == E_NDS_ARCH_STAR_V1_0)
2639 {
2640 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2641 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2642
2643 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2644 r += snprintf (buf + r, size -r, ", MAC");
2645
2646 if (config & E_NDS32_HAS_DIV_INST)
2647 r += snprintf (buf + r, size -r, ", DIV");
2648
2649 if (config & E_NDS32_HAS_16BIT_INST)
2650 r += snprintf (buf + r, size -r, ", 16b");
2651 }
2652 else
2653 {
2654 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2655 {
2656 if (version <= E_NDS32_ELF_VER_1_3)
2657 r += snprintf (buf + r, size -r, ", [B8]");
2658 else
2659 r += snprintf (buf + r, size -r, ", EX9");
2660 }
2661
2662 if (config & E_NDS32_HAS_MAC_DX_INST)
2663 r += snprintf (buf + r, size -r, ", MAC_DX");
2664
2665 if (config & E_NDS32_HAS_DIV_DX_INST)
2666 r += snprintf (buf + r, size -r, ", DIV_DX");
2667
2668 if (config & E_NDS32_HAS_16BIT_INST)
2669 {
2670 if (version <= E_NDS32_ELF_VER_1_3)
2671 r += snprintf (buf + r, size -r, ", 16b");
2672 else
2673 r += snprintf (buf + r, size -r, ", IFC");
2674 }
2675 }
2676
2677 if (config & E_NDS32_HAS_EXT_INST)
2678 r += snprintf (buf + r, size -r, ", PERF1");
2679
2680 if (config & E_NDS32_HAS_EXT2_INST)
2681 r += snprintf (buf + r, size -r, ", PERF2");
2682
2683 if (config & E_NDS32_HAS_FPU_INST)
2684 {
2685 has_fpu = 1;
2686 r += snprintf (buf + r, size -r, ", FPU_SP");
2687 }
2688
2689 if (config & E_NDS32_HAS_FPU_DP_INST)
2690 {
2691 has_fpu = 1;
2692 r += snprintf (buf + r, size -r, ", FPU_DP");
2693 }
2694
2695 if (config & E_NDS32_HAS_FPU_MAC_INST)
2696 {
2697 has_fpu = 1;
2698 r += snprintf (buf + r, size -r, ", FPU_MAC");
2699 }
2700
2701 if (has_fpu)
2702 {
2703 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2704 {
2705 case E_NDS32_FPU_REG_8SP_4DP:
2706 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2707 break;
2708 case E_NDS32_FPU_REG_16SP_8DP:
2709 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2710 break;
2711 case E_NDS32_FPU_REG_32SP_16DP:
2712 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2713 break;
2714 case E_NDS32_FPU_REG_32SP_32DP:
2715 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2716 break;
2717 }
2718 }
2719
2720 if (config & E_NDS32_HAS_AUDIO_INST)
2721 r += snprintf (buf + r, size -r, ", AUDIO");
2722
2723 if (config & E_NDS32_HAS_STRING_INST)
2724 r += snprintf (buf + r, size -r, ", STR");
2725
2726 if (config & E_NDS32_HAS_REDUCED_REGS)
2727 r += snprintf (buf + r, size -r, ", 16REG");
2728
2729 if (config & E_NDS32_HAS_VIDEO_INST)
2730 {
2731 if (version <= E_NDS32_ELF_VER_1_3)
2732 r += snprintf (buf + r, size -r, ", VIDEO");
2733 else
2734 r += snprintf (buf + r, size -r, ", SATURATION");
2735 }
2736
2737 if (config & E_NDS32_HAS_ENCRIPT_INST)
2738 r += snprintf (buf + r, size -r, ", ENCRP");
2739
2740 if (config & E_NDS32_HAS_L2C_INST)
2741 r += snprintf (buf + r, size -r, ", L2C");
2742}
2743
252b5132 2744static char *
d3ba0551 2745get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2746{
b34976b6 2747 static char buf[1024];
252b5132
RH		 2748
2749 buf[0] = '\0';
76da6bbe 2750
252b5132
RH		 2751 if (e_flags)
2752 {
2753 switch (e_machine)
2754 {
2755 default:
2756 break;
2757
f3485b74
NC		 2758 case EM_ARM:
2759 decode_ARM_machine_flags (e_flags, buf);
2760 break;
76da6bbe 2761
343433df
AB		 2762 case EM_AVR:
2763 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2764 break;
2765
781303ce
MF		 2766 case EM_BLACKFIN:
2767 if (e_flags & EF_BFIN_PIC)
2768 strcat (buf, ", PIC");
2769
2770 if (e_flags & EF_BFIN_FDPIC)
2771 strcat (buf, ", FDPIC");
2772
2773 if (e_flags & EF_BFIN_CODE_IN_L1)
2774 strcat (buf, ", code in L1");
2775
2776 if (e_flags & EF_BFIN_DATA_IN_L1)
2777 strcat (buf, ", data in L1");
2778
2779 break;
2780
ec2dfb42
AO		 2781 case EM_CYGNUS_FRV:
2782 switch (e_flags & EF_FRV_CPU_MASK)
2783 {
2784 case EF_FRV_CPU_GENERIC:
2785 break;
2786
2787 default:
2788 strcat (buf, ", fr???");
2789 break;
57346661 2790
ec2dfb42
AO		 2791 case EF_FRV_CPU_FR300:
2792 strcat (buf, ", fr300");
2793 break;
2794
2795 case EF_FRV_CPU_FR400:
2796 strcat (buf, ", fr400");
2797 break;
2798 case EF_FRV_CPU_FR405:
2799 strcat (buf, ", fr405");
2800 break;
2801
2802 case EF_FRV_CPU_FR450:
2803 strcat (buf, ", fr450");
2804 break;
2805
2806 case EF_FRV_CPU_FR500:
2807 strcat (buf, ", fr500");
2808 break;
2809 case EF_FRV_CPU_FR550:
2810 strcat (buf, ", fr550");
2811 break;
2812
2813 case EF_FRV_CPU_SIMPLE:
2814 strcat (buf, ", simple");
2815 break;
2816 case EF_FRV_CPU_TOMCAT:
2817 strcat (buf, ", tomcat");
2818 break;
2819 }
1c877e87 2820 break;
ec2dfb42 2821
53c7db4b 2822 case EM_68K:
425c6cb0 2823 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2824 strcat (buf, ", m68000");
425c6cb0 2825 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2826 strcat (buf, ", cpu32");
2827 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2828 strcat (buf, ", fido_a");
425c6cb0 2829 else
266abb8f 2830 {
2cf0635d
NC		 2831 char const * isa = _("unknown");
2832 char const * mac = _("unknown mac");
2833 char const * additional = NULL;
0112cd26 2834
c694fd50 2835 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2836 {
c694fd50 2837 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2838 isa = "A";
2839 additional = ", nodiv";
2840 break;
c694fd50 2841 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2842 isa = "A";
2843 break;
c694fd50 2844 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2845 isa = "A+";
2846 break;
c694fd50 2847 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2848 isa = "B";
2849 additional = ", nousp";
2850 break;
c694fd50 2851 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2852 isa = "B";
2853 break;
f608cd77
NS		 2854 case EF_M68K_CF_ISA_C:
2855 isa = "C";
2856 break;
2857 case EF_M68K_CF_ISA_C_NODIV:
2858 isa = "C";
2859 additional = ", nodiv";
2860 break;
266abb8f
NS		 2861 }
2862 strcat (buf, ", cf, isa ");
2863 strcat (buf, isa);
0b2e31dc
NS		 2864 if (additional)
2865 strcat (buf, additional);
c694fd50 2866 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2867 strcat (buf, ", float");
c694fd50 2868 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2869 {
2870 case 0:
2871 mac = NULL;
2872 break;
c694fd50 2873 case EF_M68K_CF_MAC:
266abb8f
NS		 2874 mac = "mac";
2875 break;
c694fd50 2876 case EF_M68K_CF_EMAC:
266abb8f
NS		 2877 mac = "emac";
2878 break;
f608cd77
NS		 2879 case EF_M68K_CF_EMAC_B:
2880 mac = "emac_b";
2881 break;
266abb8f
NS		 2882 }
2883 if (mac)
2884 {
2885 strcat (buf, ", ");
2886 strcat (buf, mac);
2887 }
266abb8f 2888 }
53c7db4b 2889 break;
33c63f9d 2890
153a2776
NC		 2891 case EM_CYGNUS_MEP:
2892 switch (e_flags & EF_MEP_CPU_MASK)
2893 {
2894 case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
2895 case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
2896 case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
2897 case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
2898 case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
2899 case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
2900 default: strcat (buf, _(", <unknown MeP cpu type>")); break;
2901 }
2902
2903 switch (e_flags & EF_MEP_COP_MASK)
2904 {
2905 case EF_MEP_COP_NONE: break;
2906 case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
2907 case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
2908 case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
2909 case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
2910 default: strcat (buf, _("<unknown MeP copro type>")); break;
2911 }
2912
2913 if (e_flags & EF_MEP_LIBRARY)
2914 strcat (buf, ", Built for Library");
2915
2916 if (e_flags & EF_MEP_INDEX_MASK)
2917 sprintf (buf + strlen (buf), ", Configuration Index: %#x",
2918 e_flags & EF_MEP_INDEX_MASK);
2919
2920 if (e_flags & ~ EF_MEP_ALL_FLAGS)
2921 sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
2922 e_flags & ~ EF_MEP_ALL_FLAGS);
2923 break;
2924
252b5132
RH		 2925 case EM_PPC:
2926 if (e_flags & EF_PPC_EMB)
2927 strcat (buf, ", emb");
2928
2929 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2930 strcat (buf, _(", relocatable"));
252b5132
RH		 2931
2932 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 2933 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 2934 break;
2935
ee67d69a
AM		 2936 case EM_PPC64:
2937 if (e_flags & EF_PPC64_ABI)
2938 {
2939 char abi[] = ", abiv0";
2940
2941 abi[6] += e_flags & EF_PPC64_ABI;
2942 strcat (buf, abi);
2943 }
2944 break;
2945
708e2187
NC		 2946 case EM_V800:
2947 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2948 strcat (buf, ", RH850 ABI");
0b4362b0 2949
708e2187
NC		 2950 if (e_flags & EF_V800_850E3)
2951 strcat (buf, ", V3 architecture");
2952
2953 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2954 strcat (buf, ", FPU not used");
2955
2956 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2957 strcat (buf, ", regmode: COMMON");
2958
2959 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2960 strcat (buf, ", r4 not used");
2961
2962 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2963 strcat (buf, ", r30 not used");
2964
2965 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2966 strcat (buf, ", r5 not used");
2967
2968 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2969 strcat (buf, ", r2 not used");
2970
2971 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2972 {
2973 switch (e_flags & - e_flags)
2974 {
2975 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2976 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
708e2187
NC		 2977 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2978 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
708e2187
NC		 2979 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2980 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2981 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2982 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2983 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2984 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2985 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2986 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2987 default: break;
2988 }
2989 }
2990 break;
2991
2b0337b0 2992 case EM_V850:
252b5132
RH		 2993 case EM_CYGNUS_V850:
2994 switch (e_flags & EF_V850_ARCH)
2995 {
78c8d46c
NC		 2996 case E_V850E3V5_ARCH:
2997 strcat (buf, ", v850e3v5");
2998 break;
1cd986c5
NC		 2999 case E_V850E2V3_ARCH:
3000 strcat (buf, ", v850e2v3");
3001 break;
3002 case E_V850E2_ARCH:
3003 strcat (buf, ", v850e2");
3004 break;
3005 case E_V850E1_ARCH:
3006 strcat (buf, ", v850e1");
8ad30312 3007 break;
252b5132
RH		 3008 case E_V850E_ARCH:
3009 strcat (buf, ", v850e");
3010 break;
252b5132
RH		 3011 case E_V850_ARCH:
3012 strcat (buf, ", v850");
3013 break;
3014 default:
2b692964 3015 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 3016 break;
3017 }
3018 break;
3019
2b0337b0 3020 case EM_M32R:
252b5132
RH		 3021 case EM_CYGNUS_M32R:
3022 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3023 strcat (buf, ", m32r");
252b5132
RH		 3024 break;
3025
3026 case EM_MIPS:
4fe85591 3027 case EM_MIPS_RS3_LE:
252b5132
RH		 3028 if (e_flags & EF_MIPS_NOREORDER)
3029 strcat (buf, ", noreorder");
3030
3031 if (e_flags & EF_MIPS_PIC)
3032 strcat (buf, ", pic");
3033
3034 if (e_flags & EF_MIPS_CPIC)
3035 strcat (buf, ", cpic");
3036
d1bdd336
TS		 3037 if (e_flags & EF_MIPS_UCODE)
3038 strcat (buf, ", ugen_reserved");
3039
252b5132
RH		 3040 if (e_flags & EF_MIPS_ABI2)
3041 strcat (buf, ", abi2");
3042
43521d43
TS		 3043 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3044 strcat (buf, ", odk first");
3045
a5d22d2a
TS		 3046 if (e_flags & EF_MIPS_32BITMODE)
3047 strcat (buf, ", 32bitmode");
3048
ba92f887
MR		 3049 if (e_flags & EF_MIPS_NAN2008)
3050 strcat (buf, ", nan2008");
3051
fef1b0b3
SE		 3052 if (e_flags & EF_MIPS_FP64)
3053 strcat (buf, ", fp64");
3054
156c2f8b
NC		 3055 switch ((e_flags & EF_MIPS_MACH))
3056 {
3057 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3058 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3059 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 3060 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 3061 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3062 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3063 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3064 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 3065 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 3066 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 3067 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3068 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 3069 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 3070 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 3071 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
d32e5c54 3072 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
52b6b6b9 3073 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 3074 case 0:
3075 /* We simply ignore the field in this case to avoid confusion:
3076 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3077 extension. */
3078 break;
2b692964 3079 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 3080 }
43521d43
TS		 3081
3082 switch ((e_flags & EF_MIPS_ABI))
3083 {
3084 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3085 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3086 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3087 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3088 case 0:
3089 /* We simply ignore the field in this case to avoid confusion:
3090 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3091 This means it is likely to be an o32 file, but not for
3092 sure. */
3093 break;
2b692964 3094 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 3095 }
3096
3097 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3098 strcat (buf, ", mdmx");
3099
3100 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3101 strcat (buf, ", mips16");
3102
df58fc94
RS		 3103 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3104 strcat (buf, ", micromips");
3105
43521d43
TS		 3106 switch ((e_flags & EF_MIPS_ARCH))
3107 {
3108 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3109 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3110 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3111 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3112 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3113 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 3114 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
7361da2c 3115 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
43521d43 3116 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 3117 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
7361da2c 3118 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
2b692964 3119 default: strcat (buf, _(", unknown ISA")); break;
43521d43 3120 }
252b5132 3121 break;
351b4b40 3122
35c08157
KLC		 3123 case EM_NDS32:
3124 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3125 break;
3126
ccde1100
AO		 3127 case EM_SH:
3128 switch ((e_flags & EF_SH_MACH_MASK))
3129 {
3130 case EF_SH1: strcat (buf, ", sh1"); break;
3131 case EF_SH2: strcat (buf, ", sh2"); break;
3132 case EF_SH3: strcat (buf, ", sh3"); break;
3133 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3134 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3135 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3136 case EF_SH3E: strcat (buf, ", sh3e"); break;
3137 case EF_SH4: strcat (buf, ", sh4"); break;
3138 case EF_SH5: strcat (buf, ", sh5"); break;
3139 case EF_SH2E: strcat (buf, ", sh2e"); break;
3140 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 3141 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 3142 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3143 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 3144 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 3145 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3146 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3147 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3148 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3149 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3150 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 3151 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 3152 }
3153
cec6a5b8
MR		 3154 if (e_flags & EF_SH_PIC)
3155 strcat (buf, ", pic");
3156
3157 if (e_flags & EF_SH_FDPIC)
3158 strcat (buf, ", fdpic");
ccde1100 3159 break;
948f632f 3160
73589c9d
CS		 3161 case EM_OR1K:
3162 if (e_flags & EF_OR1K_NODELAY)
3163 strcat (buf, ", no delay");
3164 break;
57346661 3165
351b4b40
RH		 3166 case EM_SPARCV9:
3167 if (e_flags & EF_SPARC_32PLUS)
3168 strcat (buf, ", v8+");
3169
3170 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 3171 strcat (buf, ", ultrasparcI");
3172
3173 if (e_flags & EF_SPARC_SUN_US3)
3174 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 3175
3176 if (e_flags & EF_SPARC_HAL_R1)
3177 strcat (buf, ", halr1");
3178
3179 if (e_flags & EF_SPARC_LEDATA)
3180 strcat (buf, ", ledata");
3181
3182 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3183 strcat (buf, ", tso");
3184
3185 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3186 strcat (buf, ", pso");
3187
3188 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3189 strcat (buf, ", rmo");
3190 break;
7d466069 3191
103f02d3
UD		 3192 case EM_PARISC:
3193 switch (e_flags & EF_PARISC_ARCH)
3194 {
3195 case EFA_PARISC_1_0:
3196 strcpy (buf, ", PA-RISC 1.0");
3197 break;
3198 case EFA_PARISC_1_1:
3199 strcpy (buf, ", PA-RISC 1.1");
3200 break;
3201 case EFA_PARISC_2_0:
3202 strcpy (buf, ", PA-RISC 2.0");
3203 break;
3204 default:
3205 break;
3206 }
3207 if (e_flags & EF_PARISC_TRAPNIL)
3208 strcat (buf, ", trapnil");
3209 if (e_flags & EF_PARISC_EXT)
3210 strcat (buf, ", ext");
3211 if (e_flags & EF_PARISC_LSB)
3212 strcat (buf, ", lsb");
3213 if (e_flags & EF_PARISC_WIDE)
3214 strcat (buf, ", wide");
3215 if (e_flags & EF_PARISC_NO_KABP)
3216 strcat (buf, ", no kabp");
3217 if (e_flags & EF_PARISC_LAZYSWAP)
3218 strcat (buf, ", lazyswap");
30800947 3219 break;
76da6bbe 3220
7d466069 3221 case EM_PJ:
2b0337b0 3222 case EM_PJ_OLD:
7d466069
ILT		 3223 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3224 strcat (buf, ", new calling convention");
3225
3226 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3227 strcat (buf, ", gnu calling convention");
3228 break;
4d6ed7c8
NC		 3229
3230 case EM_IA_64:
3231 if ((e_flags & EF_IA_64_ABI64))
3232 strcat (buf, ", 64-bit");
3233 else
3234 strcat (buf, ", 32-bit");
3235 if ((e_flags & EF_IA_64_REDUCEDFP))
3236 strcat (buf, ", reduced fp model");
3237 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3238 strcat (buf, ", no function descriptors, constant gp");
3239 else if ((e_flags & EF_IA_64_CONS_GP))
3240 strcat (buf, ", constant gp");
3241 if ((e_flags & EF_IA_64_ABSOLUTE))
3242 strcat (buf, ", absolute");
28f997cf
TG		 3243 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3244 {
3245 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3246 strcat (buf, ", vms_linkages");
3247 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3248 {
3249 case EF_IA_64_VMS_COMCOD_SUCCESS:
3250 break;
3251 case EF_IA_64_VMS_COMCOD_WARNING:
3252 strcat (buf, ", warning");
3253 break;
3254 case EF_IA_64_VMS_COMCOD_ERROR:
3255 strcat (buf, ", error");
3256 break;
3257 case EF_IA_64_VMS_COMCOD_ABORT:
3258 strcat (buf, ", abort");
3259 break;
3260 default:
bee0ee85
NC		 3261 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3262 e_flags & EF_IA_64_VMS_COMCOD);
3263 strcat (buf, ", <unknown>");
28f997cf
TG		 3264 }
3265 }
4d6ed7c8 3266 break;
179d3252
JT		 3267
3268 case EM_VAX:
3269 if ((e_flags & EF_VAX_NONPIC))
3270 strcat (buf, ", non-PIC");
3271 if ((e_flags & EF_VAX_DFLOAT))
3272 strcat (buf, ", D-Float");
3273 if ((e_flags & EF_VAX_GFLOAT))
3274 strcat (buf, ", G-Float");
3275 break;
c7927a3c 3276
619ed720
EB		 3277 case EM_VISIUM:
3278 if (e_flags & EF_VISIUM_ARCH_MCM)
3279 strcat (buf, ", mcm");
3280 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3281 strcat (buf, ", mcm24");
3282 if (e_flags & EF_VISIUM_ARCH_GR6)
3283 strcat (buf, ", gr6");
3284 break;
3285
4046d87a 3286 case EM_RL78:
1740ba0c
NC		 3287 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3288 {
3289 case E_FLAG_RL78_ANY_CPU: break;
3290 case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3291 case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3292 case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3293 }
856ea05c
KP		 3294 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3295 strcat (buf, ", 64-bit doubles");
4046d87a 3296 break;
0b4362b0 3297
c7927a3c
NC		 3298 case EM_RX:
3299 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3300 strcat (buf, ", 64-bit doubles");
3301 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 3302 strcat (buf, ", dsp");
d4cb0ea0 3303 if (e_flags & E_FLAG_RX_PID)
0b4362b0 3304 strcat (buf, ", pid");
708e2187
NC		 3305 if (e_flags & E_FLAG_RX_ABI)
3306 strcat (buf, ", RX ABI");
3525236c
NC		 3307 if (e_flags & E_FLAG_RX_SINSNS_SET)
3308 strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3309 ? ", uses String instructions" : ", bans String instructions");
d4cb0ea0 3310 break;
55786da2
AK		 3311
3312 case EM_S390:
3313 if (e_flags & EF_S390_HIGH_GPRS)
3314 strcat (buf, ", highgprs");
d4cb0ea0 3315 break;
40b36596
JM		 3316
3317 case EM_TI_C6000:
3318 if ((e_flags & EF_C6000_REL))
3319 strcat (buf, ", relocatable module");
d4cb0ea0 3320 break;
13761a11
NC		 3321
3322 case EM_MSP430:
3323 strcat (buf, _(": architecture variant: "));
3324 switch (e_flags & EF_MSP430_MACH)
3325 {
3326 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3327 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3328 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3329 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3330 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3331 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3332 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3333 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3334 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3335 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3336 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3337 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3338 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3339 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3340 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3341 default:
3342 strcat (buf, _(": unknown")); break;
3343 }
3344
3345 if (e_flags & ~ EF_MSP430_MACH)
3346 strcat (buf, _(": unknown extra flag bits also present"));
252b5132
RH		 3347 }
3348 }
3349
3350 return buf;
3351}
3352
252b5132 3353static const char *
d3ba0551
AM		 3354get_osabi_name (unsigned int osabi)
3355{
3356 static char buff[32];
3357
3358 switch (osabi)
3359 {
3360 case ELFOSABI_NONE: return "UNIX - System V";
3361 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3362 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 3363 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 3364 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3365 case ELFOSABI_AIX: return "UNIX - AIX";
3366 case ELFOSABI_IRIX: return "UNIX - IRIX";
3367 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3368 case ELFOSABI_TRU64: return "UNIX - TRU64";
3369 case ELFOSABI_MODESTO: return "Novell - Modesto";
3370 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3371 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3372 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 3373 case ELFOSABI_AROS: return "AROS";
11636f9e 3374 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 3375 default:
40b36596
JM		 3376 if (osabi >= 64)
3377 switch (elf_header.e_machine)
3378 {
3379 case EM_ARM:
3380 switch (osabi)
3381 {
3382 case ELFOSABI_ARM: return "ARM";
3383 default:
3384 break;
3385 }
3386 break;
3387
3388 case EM_MSP430:
3389 case EM_MSP430_OLD:
619ed720 3390 case EM_VISIUM:
40b36596
JM		 3391 switch (osabi)
3392 {
3393 case ELFOSABI_STANDALONE: return _("Standalone App");
3394 default:
3395 break;
3396 }
3397 break;
3398
3399 case EM_TI_C6000:
3400 switch (osabi)
3401 {
3402 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3403 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3404 default:
3405 break;
3406 }
3407 break;
3408
3409 default:
3410 break;
3411 }
e9e44622 3412 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 3413 return buff;
3414 }
3415}
3416
a06ea964
NC		 3417static const char *
3418get_aarch64_segment_type (unsigned long type)
3419{
3420 switch (type)
3421 {
3422 case PT_AARCH64_ARCHEXT:
3423 return "AARCH64_ARCHEXT";
3424 default:
3425 break;
3426 }
3427
3428 return NULL;
3429}
3430
b294bdf8
MM		 3431static const char *
3432get_arm_segment_type (unsigned long type)
3433{
3434 switch (type)
3435 {
3436 case PT_ARM_EXIDX:
3437 return "EXIDX";
3438 default:
3439 break;
3440 }
3441
3442 return NULL;
3443}
3444
d3ba0551
AM		 3445static const char *
3446get_mips_segment_type (unsigned long type)
252b5132
RH		 3447{
3448 switch (type)
3449 {
3450 case PT_MIPS_REGINFO:
3451 return "REGINFO";
3452 case PT_MIPS_RTPROC:
3453 return "RTPROC";
3454 case PT_MIPS_OPTIONS:
3455 return "OPTIONS";
351cdf24
MF		 3456 case PT_MIPS_ABIFLAGS:
3457 return "ABIFLAGS";
252b5132
RH		 3458 default:
3459 break;
3460 }
3461
3462 return NULL;
3463}
3464
103f02d3 3465static const char *
d3ba0551 3466get_parisc_segment_type (unsigned long type)
103f02d3
UD		 3467{
3468 switch (type)
3469 {
3470 case PT_HP_TLS: return "HP_TLS";
3471 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3472 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3473 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3474 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3475 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3476 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3477 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3478 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3479 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3480 case PT_HP_PARALLEL: return "HP_PARALLEL";
3481 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 3482 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3483 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3484 case PT_HP_STACK: return "HP_STACK";
3485 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 3486 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3487 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 3488 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 3489 default:
3490 break;
3491 }
3492
3493 return NULL;
3494}
3495
4d6ed7c8 3496static const char *
d3ba0551 3497get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 3498{
3499 switch (type)
3500 {
3501 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3502 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 3503 case PT_HP_TLS: return "HP_TLS";
3504 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3505 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3506 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 3507 default:
3508 break;
3509 }
3510
3511 return NULL;
3512}
3513
40b36596
JM		 3514static const char *
3515get_tic6x_segment_type (unsigned long type)
3516{
3517 switch (type)
3518 {
3519 case PT_C6000_PHATTR: return "C6000_PHATTR";
3520 default:
3521 break;
3522 }
3523
3524 return NULL;
3525}
3526
252b5132 3527static const char *
d3ba0551 3528get_segment_type (unsigned long p_type)
252b5132 3529{
b34976b6 3530 static char buff[32];
252b5132
RH		 3531
3532 switch (p_type)
3533 {
b34976b6
AM		 3534 case PT_NULL: return "NULL";
3535 case PT_LOAD: return "LOAD";
252b5132 3536 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 3537 case PT_INTERP: return "INTERP";
3538 case PT_NOTE: return "NOTE";
3539 case PT_SHLIB: return "SHLIB";
3540 case PT_PHDR: return "PHDR";
13ae64f3 3541 case PT_TLS: return "TLS";
252b5132 3542
65765700
JJ		 3543 case PT_GNU_EH_FRAME:
3544 return "GNU_EH_FRAME";
2b05f1b7 3545 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 3546 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 3547
252b5132
RH		 3548 default:
3549 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3550 {
2cf0635d 3551 const char * result;
103f02d3 3552
252b5132
RH		 3553 switch (elf_header.e_machine)
3554 {
a06ea964
NC		 3555 case EM_AARCH64:
3556 result = get_aarch64_segment_type (p_type);
3557 break;
b294bdf8
MM		 3558 case EM_ARM:
3559 result = get_arm_segment_type (p_type);
3560 break;
252b5132 3561 case EM_MIPS:
4fe85591 3562 case EM_MIPS_RS3_LE:
252b5132
RH		 3563 result = get_mips_segment_type (p_type);
3564 break;
103f02d3
UD		 3565 case EM_PARISC:
3566 result = get_parisc_segment_type (p_type);
3567 break;
4d6ed7c8
NC		 3568 case EM_IA_64:
3569 result = get_ia64_segment_type (p_type);
3570 break;
40b36596
JM		 3571 case EM_TI_C6000:
3572 result = get_tic6x_segment_type (p_type);
3573 break;
252b5132
RH		 3574 default:
3575 result = NULL;
3576 break;
3577 }
103f02d3 3578
252b5132
RH		 3579 if (result != NULL)
3580 return result;
103f02d3 3581
252b5132
RH		 3582 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3583 }
3584 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3585 {
2cf0635d 3586 const char * result;
103f02d3
UD		 3587
3588 switch (elf_header.e_machine)
3589 {
3590 case EM_PARISC:
3591 result = get_parisc_segment_type (p_type);
3592 break;
00428cca
AM		 3593 case EM_IA_64:
3594 result = get_ia64_segment_type (p_type);
3595 break;
103f02d3
UD		 3596 default:
3597 result = NULL;
3598 break;
3599 }
3600
3601 if (result != NULL)
3602 return result;
3603
3604 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3605 }
252b5132 3606 else
e9e44622 3607 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3608
3609 return buff;
3610 }
3611}
3612
3613static const char *
d3ba0551 3614get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3615{
3616 switch (sh_type)
3617 {
b34976b6
AM		 3618 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3619 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3620 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3621 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3622 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3623 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3624 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3625 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3626 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3627 case SHT_MIPS_RELD: return "MIPS_RELD";
3628 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3629 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3630 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3631 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3632 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3633 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3634 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3635 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3636 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3637 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3638 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3639 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3640 case SHT_MIPS_LINE: return "MIPS_LINE";
3641 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3642 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3643 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3644 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3645 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3646 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3647 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3648 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3649 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3650 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3651 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3652 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3653 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3654 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3655 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132 3656 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
351cdf24 3657 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
252b5132
RH		 3658 default:
3659 break;
3660 }
3661 return NULL;
3662}
3663
103f02d3 3664static const char *
d3ba0551 3665get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3666{
3667 switch (sh_type)
3668 {
3669 case SHT_PARISC_EXT: return "PARISC_EXT";
3670 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3671 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3672 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3673 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3674 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3675 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3676 default:
3677 break;
3678 }
3679 return NULL;
3680}
3681
4d6ed7c8 3682static const char *
d3ba0551 3683get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3684{
18bd398b 3685 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3686 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3687 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3688
4d6ed7c8
NC		 3689 switch (sh_type)
3690 {
148b93f2
NC		 3691 case SHT_IA_64_EXT: return "IA_64_EXT";
3692 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3693 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3694 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3695 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3696 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3697 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3698 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3699 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3700 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3701 default:
3702 break;
3703 }
3704 return NULL;
3705}
3706
d2b2c203
DJ		 3707static const char *
3708get_x86_64_section_type_name (unsigned int sh_type)
3709{
3710 switch (sh_type)
3711 {
3712 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3713 default:
3714 break;
3715 }
3716 return NULL;
3717}
3718
a06ea964
NC		 3719static const char *
3720get_aarch64_section_type_name (unsigned int sh_type)
3721{
3722 switch (sh_type)
3723 {
3724 case SHT_AARCH64_ATTRIBUTES:
3725 return "AARCH64_ATTRIBUTES";
3726 default:
3727 break;
3728 }
3729 return NULL;
3730}
3731
40a18ebd
NC		 3732static const char *
3733get_arm_section_type_name (unsigned int sh_type)
3734{
3735 switch (sh_type)
3736 {
7f6fed87
NC		 3737 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3738 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3739 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3740 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3741 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3742 default:
3743 break;
3744 }
3745 return NULL;
3746}
3747
40b36596
JM		 3748static const char *
3749get_tic6x_section_type_name (unsigned int sh_type)
3750{
3751 switch (sh_type)
3752 {
3753 case SHT_C6000_UNWIND:
3754 return "C6000_UNWIND";
3755 case SHT_C6000_PREEMPTMAP:
3756 return "C6000_PREEMPTMAP";
3757 case SHT_C6000_ATTRIBUTES:
3758 return "C6000_ATTRIBUTES";
3759 case SHT_TI_ICODE:
3760 return "TI_ICODE";
3761 case SHT_TI_XREF:
3762 return "TI_XREF";
3763 case SHT_TI_HANDLER:
3764 return "TI_HANDLER";
3765 case SHT_TI_INITINFO:
3766 return "TI_INITINFO";
3767 case SHT_TI_PHATTRS:
3768 return "TI_PHATTRS";
3769 default:
3770 break;
3771 }
3772 return NULL;
3773}
3774
13761a11
NC		 3775static const char *
3776get_msp430x_section_type_name (unsigned int sh_type)
3777{
3778 switch (sh_type)
3779 {
3780 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3781 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3782 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3783 default: return NULL;
3784 }
3785}
3786
685080f2
NC		 3787static const char *
3788get_v850_section_type_name (unsigned int sh_type)
3789{
3790 switch (sh_type)
3791 {
3792 case SHT_V850_SCOMMON: return "V850 Small Common";
3793 case SHT_V850_TCOMMON: return "V850 Tiny Common";
3794 case SHT_V850_ZCOMMON: return "V850 Zero Common";
3795 case SHT_RENESAS_IOP: return "RENESAS IOP";
3796 case SHT_RENESAS_INFO: return "RENESAS INFO";
3797 default: return NULL;
3798 }
3799}
3800
252b5132 3801static const char *
d3ba0551 3802get_section_type_name (unsigned int sh_type)
252b5132 3803{
b34976b6 3804 static char buff[32];
252b5132
RH		 3805
3806 switch (sh_type)
3807 {
3808 case SHT_NULL: return "NULL";
3809 case SHT_PROGBITS: return "PROGBITS";
3810 case SHT_SYMTAB: return "SYMTAB";
3811 case SHT_STRTAB: return "STRTAB";
3812 case SHT_RELA: return "RELA";
3813 case SHT_HASH: return "HASH";
3814 case SHT_DYNAMIC: return "DYNAMIC";
3815 case SHT_NOTE: return "NOTE";
3816 case SHT_NOBITS: return "NOBITS";
3817 case SHT_REL: return "REL";
3818 case SHT_SHLIB: return "SHLIB";
3819 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3820 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3821 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3822 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3823 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3824 case SHT_GROUP: return "GROUP";
3825 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3826 case SHT_GNU_verdef: return "VERDEF";
3827 case SHT_GNU_verneed: return "VERNEED";
3828 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3829 case 0x6ffffff0: return "VERSYM";
3830 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3831 case 0x7ffffffd: return "AUXILIARY";
3832 case 0x7fffffff: return "FILTER";
047b2264 3833 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3834
3835 default:
3836 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3837 {
2cf0635d 3838 const char * result;
252b5132
RH		 3839
3840 switch (elf_header.e_machine)
3841 {
3842 case EM_MIPS:
4fe85591 3843 case EM_MIPS_RS3_LE:
252b5132
RH		 3844 result = get_mips_section_type_name (sh_type);
3845 break;
103f02d3
UD		 3846 case EM_PARISC:
3847 result = get_parisc_section_type_name (sh_type);
3848 break;
4d6ed7c8
NC		 3849 case EM_IA_64:
3850 result = get_ia64_section_type_name (sh_type);
3851 break;
d2b2c203 3852 case EM_X86_64:
8a9036a4 3853 case EM_L1OM:
7a9068fe 3854 case EM_K1OM:
d2b2c203
DJ		 3855 result = get_x86_64_section_type_name (sh_type);
3856 break;
a06ea964
NC		 3857 case EM_AARCH64:
3858 result = get_aarch64_section_type_name (sh_type);
3859 break;
40a18ebd
NC		 3860 case EM_ARM:
3861 result = get_arm_section_type_name (sh_type);
3862 break;
40b36596
JM		 3863 case EM_TI_C6000:
3864 result = get_tic6x_section_type_name (sh_type);
3865 break;
13761a11
NC		 3866 case EM_MSP430:
3867 result = get_msp430x_section_type_name (sh_type);
3868 break;
685080f2
NC		 3869 case EM_V800:
3870 case EM_V850:
3871 case EM_CYGNUS_V850:
3872 result = get_v850_section_type_name (sh_type);
3873 break;
252b5132
RH		 3874 default:
3875 result = NULL;
3876 break;
3877 }
3878
3879 if (result != NULL)
3880 return result;
3881
c91d0dfb 3882 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3883 }
3884 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3885 {
2cf0635d 3886 const char * result;
148b93f2
NC		 3887
3888 switch (elf_header.e_machine)
3889 {
3890 case EM_IA_64:
3891 result = get_ia64_section_type_name (sh_type);
3892 break;
3893 default:
3894 result = NULL;
3895 break;
3896 }
3897
3898 if (result != NULL)
3899 return result;
3900
3901 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3902 }
252b5132 3903 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
685080f2
NC		 3904 {
3905 switch (elf_header.e_machine)
3906 {
3907 case EM_V800:
3908 case EM_V850:
3909 case EM_CYGNUS_V850:
3910 return get_v850_section_type_name (sh_type);
3911 default:
3912 break;
3913 }
3914
3915 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3916 }
252b5132 3917 else
a7dbfd1c
NC		 3918 /* This message is probably going to be displayed in a 15
3919 character wide field, so put the hex value first. */
3920 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3921
252b5132
RH		 3922 return buff;
3923 }
3924}
3925
2979dc34 3926#define OPTION_DEBUG_DUMP 512
2c610e4b 3927#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3928#define OPTION_DWARF_DEPTH 514
3929#define OPTION_DWARF_START 515
4723351a 3930#define OPTION_DWARF_CHECK 516
2979dc34 3931
85b1c36d 3932static struct option options[] =
252b5132 3933{
b34976b6 3934 {"all", no_argument, 0, 'a'},
252b5132
RH		 3935 {"file-header", no_argument, 0, 'h'},
3936 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3937 {"headers", no_argument, 0, 'e'},
3938 {"histogram", no_argument, 0, 'I'},
3939 {"segments", no_argument, 0, 'l'},
3940 {"sections", no_argument, 0, 'S'},
252b5132 3941 {"section-headers", no_argument, 0, 'S'},
f5842774 3942 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3943 {"section-details", no_argument, 0, 't'},
595cf52e 3944 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3945 {"symbols", no_argument, 0, 's'},
3946 {"syms", no_argument, 0, 's'},
2c610e4b 3947 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3948 {"relocs", no_argument, 0, 'r'},
3949 {"notes", no_argument, 0, 'n'},
3950 {"dynamic", no_argument, 0, 'd'},
a952a375 3951 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3952 {"version-info", no_argument, 0, 'V'},
3953 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3954 {"unwind", no_argument, 0, 'u'},
4145f1d5 3955 {"archive-index", no_argument, 0, 'c'},
b34976b6 3956 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3957 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3958 {"string-dump", required_argument, 0, 'p'},
0e602686 3959 {"decompress", no_argument, 0, 'z'},
252b5132
RH		 3960#ifdef SUPPORT_DISASSEMBLY
3961 {"instruction-dump", required_argument, 0, 'i'},
3962#endif
cf13d699 3963 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3964
fd2f0033
TT		 3965 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3966 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 3967 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 3968
b34976b6
AM		 3969 {"version", no_argument, 0, 'v'},
3970 {"wide", no_argument, 0, 'W'},
3971 {"help", no_argument, 0, 'H'},
3972 {0, no_argument, 0, 0}
252b5132
RH		 3973};
3974
3975static void
2cf0635d 3976usage (FILE * stream)
252b5132 3977{
92f01d61
JM		 3978 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3979 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3980 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3981 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3982 -h --file-header Display the ELF file header\n\
3983 -l --program-headers Display the program headers\n\
3984 --segments An alias for --program-headers\n\
3985 -S --section-headers Display the sections' header\n\
3986 --sections An alias for --section-headers\n\
f5842774 3987 -g --section-groups Display the section groups\n\
5477e8a0 3988 -t --section-details Display the section details\n\
8b53311e
NC		 3989 -e --headers Equivalent to: -h -l -S\n\
3990 -s --syms Display the symbol table\n\
3f08eb35 3991 --symbols An alias for --syms\n\
2c610e4b 3992 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3993 -n --notes Display the core notes (if present)\n\
3994 -r --relocs Display the relocations (if present)\n\
3995 -u --unwind Display the unwind info (if present)\n\
b2d38a17 3996 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 3997 -V --version-info Display the version sections (if present)\n\
1b31d05e 3998 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 3999 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 4000 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 4001 -x --hex-dump=<number|name>\n\
4002 Dump the contents of section <number|name> as bytes\n\
4003 -p --string-dump=<number|name>\n\
4004 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 4005 -R --relocated-dump=<number|name>\n\
4006 Dump the contents of section <number|name> as relocated bytes\n\
0e602686 4007 -z --decompress Decompress section before dumping it\n\
f9f0e732 4008 -w[lLiaprmfFsoRt] or\n\
1ed06042 4009 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 4010 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 4011 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4012 =addr,=cu_index]\n\
8b53311e 4013 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 4014 fprintf (stream, _("\
4015 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4016 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4017 or deeper\n"));
252b5132 4018#ifdef SUPPORT_DISASSEMBLY
92f01d61 4019 fprintf (stream, _("\
09c11c86
NC		 4020 -i --instruction-dump=<number|name>\n\
4021 Disassemble the contents of section <number|name>\n"));
252b5132 4022#endif
92f01d61 4023 fprintf (stream, _("\
8b53311e
NC		 4024 -I --histogram Display histogram of bucket list lengths\n\
4025 -W --wide Allow output width to exceed 80 characters\n\
07012eee 4026 @<file> Read options from <file>\n\
8b53311e
NC		 4027 -H --help Display this information\n\
4028 -v --version Display the version number of readelf\n"));
1118d252 4029
92f01d61
JM		 4030 if (REPORT_BUGS_TO[0] && stream == stdout)
4031 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 4032
92f01d61 4033 exit (stream == stdout ? 0 : 1);
252b5132
RH		 4034}
4035
18bd398b
NC		 4036/* Record the fact that the user wants the contents of section number
4037 SECTION to be displayed using the method(s) encoded as flags bits
4038 in TYPE. Note, TYPE can be zero if we are creating the array for
4039 the first time. */
4040
252b5132 4041static void
09c11c86 4042request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 4043{
4044 if (section >= num_dump_sects)
4045 {
2cf0635d 4046 dump_type * new_dump_sects;
252b5132 4047
3f5e193b
NC		 4048 new_dump_sects = (dump_type *) calloc (section + 1,
4049 sizeof (* dump_sects));
252b5132
RH		 4050
4051 if (new_dump_sects == NULL)
591a748a 4052 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 4053 else
4054 {
4055 /* Copy current flag settings. */
09c11c86 4056 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 4057
4058 free (dump_sects);
4059
4060 dump_sects = new_dump_sects;
4061 num_dump_sects = section + 1;
4062 }
4063 }
4064
4065 if (dump_sects)
b34976b6 4066 dump_sects[section] |= type;
252b5132
RH		 4067
4068 return;
4069}
4070
aef1f6d0
DJ		 4071/* Request a dump by section name. */
4072
4073static void
2cf0635d 4074request_dump_byname (const char * section, dump_type type)
aef1f6d0 4075{
2cf0635d 4076 struct dump_list_entry * new_request;
aef1f6d0 4077
3f5e193b
NC		 4078 new_request = (struct dump_list_entry *)
4079 malloc (sizeof (struct dump_list_entry));
aef1f6d0 4080 if (!new_request)
591a748a 4081 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4082
4083 new_request->name = strdup (section);
4084 if (!new_request->name)
591a748a 4085 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4086
4087 new_request->type = type;
4088
4089 new_request->next = dump_sects_byname;
4090 dump_sects_byname = new_request;
4091}
4092
cf13d699
NC		 4093static inline void
4094request_dump (dump_type type)
4095{
4096 int section;
4097 char * cp;
4098
4099 do_dump++;
4100 section = strtoul (optarg, & cp, 0);
4101
4102 if (! *cp && section >= 0)
4103 request_dump_bynumber (section, type);
4104 else
4105 request_dump_byname (optarg, type);
4106}
4107
4108
252b5132 4109static void
2cf0635d 4110parse_args (int argc, char ** argv)
252b5132
RH		 4111{
4112 int c;
4113
4114 if (argc < 2)
92f01d61 4115 usage (stderr);
252b5132
RH		 4116
4117 while ((c = getopt_long
0e602686 4118 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
252b5132 4119 {
252b5132
RH		 4120 switch (c)
4121 {
4122 case 0:
4123 /* Long options. */
4124 break;
4125 case 'H':
92f01d61 4126 usage (stdout);
252b5132
RH		 4127 break;
4128
4129 case 'a':
b34976b6
AM		 4130 do_syms++;
4131 do_reloc++;
4132 do_unwind++;
4133 do_dynamic++;
4134 do_header++;
4135 do_sections++;
f5842774 4136 do_section_groups++;
b34976b6
AM		 4137 do_segments++;
4138 do_version++;
4139 do_histogram++;
4140 do_arch++;
4141 do_notes++;
252b5132 4142 break;
f5842774
L		 4143 case 'g':
4144 do_section_groups++;
4145 break;
5477e8a0 4146 case 't':
595cf52e 4147 case 'N':
5477e8a0
L		 4148 do_sections++;
4149 do_section_details++;
595cf52e 4150 break;
252b5132 4151 case 'e':
b34976b6
AM		 4152 do_header++;
4153 do_sections++;
4154 do_segments++;
252b5132 4155 break;
a952a375 4156 case 'A':
b34976b6 4157 do_arch++;
a952a375 4158 break;
252b5132 4159 case 'D':
b34976b6 4160 do_using_dynamic++;
252b5132
RH		 4161 break;
4162 case 'r':
b34976b6 4163 do_reloc++;
252b5132 4164 break;
4d6ed7c8 4165 case 'u':
b34976b6 4166 do_unwind++;
4d6ed7c8 4167 break;
252b5132 4168 case 'h':
b34976b6 4169 do_header++;
252b5132
RH		 4170 break;
4171 case 'l':
b34976b6 4172 do_segments++;
252b5132
RH		 4173 break;
4174 case 's':
b34976b6 4175 do_syms++;
252b5132
RH		 4176 break;
4177 case 'S':
b34976b6 4178 do_sections++;
252b5132
RH		 4179 break;
4180 case 'd':
b34976b6 4181 do_dynamic++;
252b5132 4182 break;
a952a375 4183 case 'I':
b34976b6 4184 do_histogram++;
a952a375 4185 break;
779fe533 4186 case 'n':
b34976b6 4187 do_notes++;
779fe533 4188 break;
4145f1d5
NC		 4189 case 'c':
4190 do_archive_index++;
4191 break;
252b5132 4192 case 'x':
cf13d699 4193 request_dump (HEX_DUMP);
aef1f6d0 4194 break;
09c11c86 4195 case 'p':
cf13d699
NC		 4196 request_dump (STRING_DUMP);
4197 break;
4198 case 'R':
4199 request_dump (RELOC_DUMP);
09c11c86 4200 break;
0e602686
NC		 4201 case 'z':
4202 decompress_dumps++;
4203 break;
252b5132 4204 case 'w':
b34976b6 4205 do_dump++;
252b5132 4206 if (optarg == 0)
613ff48b
CC		 4207 {
4208 do_debugging = 1;
4209 dwarf_select_sections_all ();
4210 }
252b5132
RH		 4211 else
4212 {
4213 do_debugging = 0;
4cb93e3b 4214 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 4215 }
4216 break;
2979dc34 4217 case OPTION_DEBUG_DUMP:
b34976b6 4218 do_dump++;
2979dc34
JJ		 4219 if (optarg == 0)
4220 do_debugging = 1;
4221 else
4222 {
2979dc34 4223 do_debugging = 0;
4cb93e3b 4224 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 4225 }
4226 break;
fd2f0033
TT		 4227 case OPTION_DWARF_DEPTH:
4228 {
4229 char *cp;
4230
4231 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4232 }
4233 break;
4234 case OPTION_DWARF_START:
4235 {
4236 char *cp;
4237
4238 dwarf_start_die = strtoul (optarg, & cp, 0);
4239 }
4240 break;
4723351a
CC		 4241 case OPTION_DWARF_CHECK:
4242 dwarf_check = 1;
4243 break;
2c610e4b
L		 4244 case OPTION_DYN_SYMS:
4245 do_dyn_syms++;
4246 break;
252b5132
RH		 4247#ifdef SUPPORT_DISASSEMBLY
4248 case 'i':
cf13d699
NC		 4249 request_dump (DISASS_DUMP);
4250 break;
252b5132
RH		 4251#endif
4252 case 'v':
4253 print_version (program_name);
4254 break;
4255 case 'V':
b34976b6 4256 do_version++;
252b5132 4257 break;
d974e256 4258 case 'W':
b34976b6 4259 do_wide++;
d974e256 4260 break;
252b5132 4261 default:
252b5132
RH		 4262 /* xgettext:c-format */
4263 error (_("Invalid option '-%c'\n"), c);
4264 /* Drop through. */
4265 case '?':
92f01d61 4266 usage (stderr);
252b5132
RH		 4267 }
4268 }
4269
4d6ed7c8 4270 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 4271 && !do_segments && !do_header && !do_dump && !do_version
f5842774 4272 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 4273 && !do_section_groups && !do_archive_index
4274 && !do_dyn_syms)
92f01d61 4275 usage (stderr);
252b5132
RH		 4276}
4277
4278static const char *
d3ba0551 4279get_elf_class (unsigned int elf_class)
252b5132 4280{
b34976b6 4281 static char buff[32];
103f02d3 4282
252b5132
RH		 4283 switch (elf_class)
4284 {
4285 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 4286 case ELFCLASS32: return "ELF32";
4287 case ELFCLASS64: return "ELF64";
ab5e7794 4288 default:
e9e44622 4289 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 4290 return buff;
252b5132
RH		 4291 }
4292}
4293
4294static const char *
d3ba0551 4295get_data_encoding (unsigned int encoding)
252b5132 4296{
b34976b6 4297 static char buff[32];
103f02d3 4298
252b5132
RH		 4299 switch (encoding)
4300 {
4301 case ELFDATANONE: return _("none");
33c63f9d
CM		 4302 case ELFDATA2LSB: return _("2's complement, little endian");
4303 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 4304 default:
e9e44622 4305 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 4306 return buff;
252b5132
RH		 4307 }
4308}
4309
252b5132 4310/* Decode the data held in 'elf_header'. */
ee42cf8c 4311
252b5132 4312static int
d3ba0551 4313process_file_header (void)
252b5132 4314{
b34976b6
AM		 4315 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4316 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4317 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4318 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 4319 {
4320 error
4321 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4322 return 0;
4323 }
4324
2dc4cec1
L		 4325 init_dwarf_regnames (elf_header.e_machine);
4326
252b5132
RH		 4327 if (do_header)
4328 {
4329 int i;
4330
4331 printf (_("ELF Header:\n"));
4332 printf (_(" Magic: "));
b34976b6
AM		 4333 for (i = 0; i < EI_NIDENT; i++)
4334 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 4335 printf ("\n");
4336 printf (_(" Class: %s\n"),
b34976b6 4337 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 4338 printf (_(" Data: %s\n"),
b34976b6 4339 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 4340 printf (_(" Version: %d %s\n"),
b34976b6
AM		 4341 elf_header.e_ident[EI_VERSION],
4342 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 4343 ? "(current)"
b34976b6 4344 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 4345 ? _("<unknown: %lx>")
789be9f7 4346 : "")));
252b5132 4347 printf (_(" OS/ABI: %s\n"),
b34976b6 4348 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 4349 printf (_(" ABI Version: %d\n"),
b34976b6 4350 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 4351 printf (_(" Type: %s\n"),
4352 get_file_type (elf_header.e_type));
4353 printf (_(" Machine: %s\n"),
4354 get_machine_name (elf_header.e_machine));
4355 printf (_(" Version: 0x%lx\n"),
4356 (unsigned long) elf_header.e_version);
76da6bbe 4357
f7a99963
NC		 4358 printf (_(" Entry point address: "));
4359 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4360 printf (_("\n Start of program headers: "));
4361 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4362 printf (_(" (bytes into file)\n Start of section headers: "));
4363 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4364 printf (_(" (bytes into file)\n"));
76da6bbe 4365
252b5132
RH		 4366 printf (_(" Flags: 0x%lx%s\n"),
4367 (unsigned long) elf_header.e_flags,
4368 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4369 printf (_(" Size of this header: %ld (bytes)\n"),
4370 (long) elf_header.e_ehsize);
4371 printf (_(" Size of program headers: %ld (bytes)\n"),
4372 (long) elf_header.e_phentsize);
2046a35d 4373 printf (_(" Number of program headers: %ld"),
252b5132 4374 (long) elf_header.e_phnum);
2046a35d
AM		 4375 if (section_headers != NULL
4376 && elf_header.e_phnum == PN_XNUM
4377 && section_headers[0].sh_info != 0)
cc5914eb 4378 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 4379 putc ('\n', stdout);
252b5132
RH		 4380 printf (_(" Size of section headers: %ld (bytes)\n"),
4381 (long) elf_header.e_shentsize);
560f3c1c 4382 printf (_(" Number of section headers: %ld"),
252b5132 4383 (long) elf_header.e_shnum);
4fbb74a6 4384 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 4385 printf (" (%ld)", (long) section_headers[0].sh_size);
4386 putc ('\n', stdout);
4387 printf (_(" Section header string table index: %ld"),
252b5132 4388 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 4389 if (section_headers != NULL
4390 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 4391 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 4392 else if (elf_header.e_shstrndx != SHN_UNDEF
4393 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 4394 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 4395 putc ('\n', stdout);
4396 }
4397
4398 if (section_headers != NULL)
4399 {
2046a35d
AM		 4400 if (elf_header.e_phnum == PN_XNUM
4401 && section_headers[0].sh_info != 0)
4402 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 4403 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 4404 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 4405 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 4406 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 4407 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 4408 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 4409 free (section_headers);
4410 section_headers = NULL;
252b5132 4411 }
103f02d3 4412
9ea033b2
NC		 4413 return 1;
4414}
4415
e0a31db1 4416static bfd_boolean
91d6fa6a 4417get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4418{
2cf0635d
NC		 4419 Elf32_External_Phdr * phdrs;
4420 Elf32_External_Phdr * external;
4421 Elf_Internal_Phdr * internal;
b34976b6 4422 unsigned int i;
e0a31db1
NC		 4423 unsigned int size = elf_header.e_phentsize;
4424 unsigned int num = elf_header.e_phnum;
4425
4426 /* PR binutils/17531: Cope with unexpected section header sizes. */
4427 if (size == 0 || num == 0)
4428 return FALSE;
4429 if (size < sizeof * phdrs)
4430 {
4431 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4432 return FALSE;
4433 }
4434 if (size > sizeof * phdrs)
4435 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4436
3f5e193b 4437 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1
NC		 4438 size, num, _("program headers"));
4439 if (phdrs == NULL)
4440 return FALSE;
9ea033b2 4441
91d6fa6a 4442 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4443 i < elf_header.e_phnum;
b34976b6 4444 i++, internal++, external++)
252b5132 4445 {
9ea033b2
NC		 4446 internal->p_type = BYTE_GET (external->p_type);
4447 internal->p_offset = BYTE_GET (external->p_offset);
4448 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4449 internal->p_paddr = BYTE_GET (external->p_paddr);
4450 internal->p_filesz = BYTE_GET (external->p_filesz);
4451 internal->p_memsz = BYTE_GET (external->p_memsz);
4452 internal->p_flags = BYTE_GET (external->p_flags);
4453 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 4454 }
4455
9ea033b2 4456 free (phdrs);
e0a31db1 4457 return TRUE;
252b5132
RH		 4458}
4459
e0a31db1 4460static bfd_boolean
91d6fa6a 4461get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4462{
2cf0635d
NC		 4463 Elf64_External_Phdr * phdrs;
4464 Elf64_External_Phdr * external;
4465 Elf_Internal_Phdr * internal;
b34976b6 4466 unsigned int i;
e0a31db1
NC		 4467 unsigned int size = elf_header.e_phentsize;
4468 unsigned int num = elf_header.e_phnum;
4469
4470 /* PR binutils/17531: Cope with unexpected section header sizes. */
4471 if (size == 0 || num == 0)
4472 return FALSE;
4473 if (size < sizeof * phdrs)
4474 {
4475 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4476 return FALSE;
4477 }
4478 if (size > sizeof * phdrs)
4479 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4480
3f5e193b 4481 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1 4482 size, num, _("program headers"));
a6e9f9df 4483 if (!phdrs)
e0a31db1 4484 return FALSE;
9ea033b2 4485
91d6fa6a 4486 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4487 i < elf_header.e_phnum;
b34976b6 4488 i++, internal++, external++)
9ea033b2
NC		 4489 {
4490 internal->p_type = BYTE_GET (external->p_type);
4491 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 4492 internal->p_offset = BYTE_GET (external->p_offset);
4493 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4494 internal->p_paddr = BYTE_GET (external->p_paddr);
4495 internal->p_filesz = BYTE_GET (external->p_filesz);
4496 internal->p_memsz = BYTE_GET (external->p_memsz);
4497 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 4498 }
4499
4500 free (phdrs);
e0a31db1 4501 return TRUE;
9ea033b2 4502}
252b5132 4503
d93f0186
NC		 4504/* Returns 1 if the program headers were read into `program_headers'. */
4505
4506static int
2cf0635d 4507get_program_headers (FILE * file)
d93f0186 4508{
2cf0635d 4509 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 4510
4511 /* Check cache of prior read. */
4512 if (program_headers != NULL)
4513 return 1;
4514
3f5e193b
NC		 4515 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4516 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 4517
4518 if (phdrs == NULL)
4519 {
8b73c356
NC		 4520 error (_("Out of memory reading %u program headers\n"),
4521 elf_header.e_phnum);
d93f0186
NC		 4522 return 0;
4523 }
4524
4525 if (is_32bit_elf
4526 ? get_32bit_program_headers (file, phdrs)
4527 : get_64bit_program_headers (file, phdrs))
4528 {
4529 program_headers = phdrs;
4530 return 1;
4531 }
4532
4533 free (phdrs);
4534 return 0;
4535}
4536
2f62977e
NC		 4537/* Returns 1 if the program headers were loaded. */
4538
252b5132 4539static int
2cf0635d 4540process_program_headers (FILE * file)
252b5132 4541{
2cf0635d 4542 Elf_Internal_Phdr * segment;
b34976b6 4543 unsigned int i;
252b5132
RH		 4544
4545 if (elf_header.e_phnum == 0)
4546 {
82f2dbf7
NC		 4547 /* PR binutils/12467. */
4548 if (elf_header.e_phoff != 0)
4549 warn (_("possibly corrupt ELF header - it has a non-zero program"
9035ed51 4550 " header offset, but no program headers\n"));
82f2dbf7 4551 else if (do_segments)
252b5132 4552 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 4553 return 0;
252b5132
RH		 4554 }
4555
4556 if (do_segments && !do_header)
4557 {
f7a99963
NC		 4558 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4559 printf (_("Entry point "));
4560 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4561 printf (_("\nThere are %d program headers, starting at offset "),
4562 elf_header.e_phnum);
4563 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4564 printf ("\n");
252b5132
RH		 4565 }
4566
d93f0186 4567 if (! get_program_headers (file))
252b5132 4568 return 0;
103f02d3 4569
252b5132
RH		 4570 if (do_segments)
4571 {
3a1a2036
NC		 4572 if (elf_header.e_phnum > 1)
4573 printf (_("\nProgram Headers:\n"));
4574 else
4575 printf (_("\nProgram Headers:\n"));
76da6bbe 4576
f7a99963
NC		 4577 if (is_32bit_elf)
4578 printf
4579 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 4580 else if (do_wide)
4581 printf
4582 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 4583 else
4584 {
4585 printf
4586 (_(" Type Offset VirtAddr PhysAddr\n"));
4587 printf
4588 (_(" FileSiz MemSiz Flags Align\n"));
4589 }
252b5132
RH		 4590 }
4591
252b5132 4592 dynamic_addr = 0;
1b228002 4593 dynamic_size = 0;
252b5132
RH		 4594
4595 for (i = 0, segment = program_headers;
4596 i < elf_header.e_phnum;
b34976b6 4597 i++, segment++)
252b5132
RH		 4598 {
4599 if (do_segments)
4600 {
103f02d3 4601 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 4602
4603 if (is_32bit_elf)
4604 {
4605 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4606 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4607 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4608 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4609 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4610 printf ("%c%c%c ",
4611 (segment->p_flags & PF_R ? 'R' : ' '),
4612 (segment->p_flags & PF_W ? 'W' : ' '),
4613 (segment->p_flags & PF_X ? 'E' : ' '));
4614 printf ("%#lx", (unsigned long) segment->p_align);
4615 }
d974e256
JJ		 4616 else if (do_wide)
4617 {
4618 if ((unsigned long) segment->p_offset == segment->p_offset)
4619 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4620 else
4621 {
4622 print_vma (segment->p_offset, FULL_HEX);
4623 putchar (' ');
4624 }
4625
4626 print_vma (segment->p_vaddr, FULL_HEX);
4627 putchar (' ');
4628 print_vma (segment->p_paddr, FULL_HEX);
4629 putchar (' ');
4630
4631 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4632 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4633 else
4634 {
4635 print_vma (segment->p_filesz, FULL_HEX);
4636 putchar (' ');
4637 }
4638
4639 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4640 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4641 else
4642 {
f48e6c45 4643 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 4644 }
4645
4646 printf (" %c%c%c ",
4647 (segment->p_flags & PF_R ? 'R' : ' '),
4648 (segment->p_flags & PF_W ? 'W' : ' '),
4649 (segment->p_flags & PF_X ? 'E' : ' '));
4650
4651 if ((unsigned long) segment->p_align == segment->p_align)
4652 printf ("%#lx", (unsigned long) segment->p_align);
4653 else
4654 {
4655 print_vma (segment->p_align, PREFIX_HEX);
4656 }
4657 }
f7a99963
NC		 4658 else
4659 {
4660 print_vma (segment->p_offset, FULL_HEX);
4661 putchar (' ');
4662 print_vma (segment->p_vaddr, FULL_HEX);
4663 putchar (' ');
4664 print_vma (segment->p_paddr, FULL_HEX);
4665 printf ("\n ");
4666 print_vma (segment->p_filesz, FULL_HEX);
4667 putchar (' ');
4668 print_vma (segment->p_memsz, FULL_HEX);
4669 printf (" %c%c%c ",
4670 (segment->p_flags & PF_R ? 'R' : ' '),
4671 (segment->p_flags & PF_W ? 'W' : ' '),
4672 (segment->p_flags & PF_X ? 'E' : ' '));
4673 print_vma (segment->p_align, HEX);
4674 }
252b5132
RH		 4675 }
4676
f54498b4
NC		 4677 if (do_segments)
4678 putc ('\n', stdout);
4679
252b5132
RH		 4680 switch (segment->p_type)
4681 {
252b5132
RH		 4682 case PT_DYNAMIC:
4683 if (dynamic_addr)
4684 error (_("more than one dynamic segment\n"));
4685
20737c13
AM		 4686 /* By default, assume that the .dynamic section is the first
4687 section in the DYNAMIC segment. */
4688 dynamic_addr = segment->p_offset;
4689 dynamic_size = segment->p_filesz;
f54498b4
NC		 4690 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4691 if (dynamic_addr + dynamic_size >= current_file_size)
4692 {
4693 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4694 dynamic_addr = dynamic_size = 0;
4695 }
20737c13 4696
b2d38a17
NC		 4697 /* Try to locate the .dynamic section. If there is
4698 a section header table, we can easily locate it. */
4699 if (section_headers != NULL)
4700 {
2cf0635d 4701 Elf_Internal_Shdr * sec;
b2d38a17 4702
89fac5e3
RS		 4703 sec = find_section (".dynamic");
4704 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4705 {
28f997cf
TG		 4706 /* A corresponding .dynamic section is expected, but on
4707 IA-64/OpenVMS it is OK for it to be missing. */
4708 if (!is_ia64_vms ())
4709 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 4710 break;
4711 }
4712
42bb2e33 4713 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 4714 {
4715 dynamic_size = 0;
4716 break;
4717 }
42bb2e33 4718
b2d38a17
NC		 4719 dynamic_addr = sec->sh_offset;
4720 dynamic_size = sec->sh_size;
4721
4722 if (dynamic_addr < segment->p_offset
4723 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 4724 warn (_("the .dynamic section is not contained"
4725 " within the dynamic segment\n"));
b2d38a17 4726 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 4727 warn (_("the .dynamic section is not the first section"
4728 " in the dynamic segment.\n"));
b2d38a17 4729 }
252b5132
RH		 4730 break;
4731
4732 case PT_INTERP:
fb52b2f4
NC		 4733 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4734 SEEK_SET))
252b5132
RH		 4735 error (_("Unable to find program interpreter name\n"));
4736 else
4737 {
f8eae8b2 4738 char fmt [32];
9495b2e6 4739 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
f8eae8b2
L		 4740
4741 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4742 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4743
252b5132 4744 program_interpreter[0] = 0;
7bd7b3ef
AM		 4745 if (fscanf (file, fmt, program_interpreter) <= 0)
4746 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 4747
4748 if (do_segments)
f54498b4 4749 printf (_(" [Requesting program interpreter: %s]\n"),
252b5132
RH		 4750 program_interpreter);
4751 }
4752 break;
4753 }
252b5132
RH		 4754 }
4755
c256ffe7 4756 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 4757 {
4758 printf (_("\n Section to Segment mapping:\n"));
4759 printf (_(" Segment Sections...\n"));
4760
252b5132
RH		 4761 for (i = 0; i < elf_header.e_phnum; i++)
4762 {
9ad5cbcf 4763 unsigned int j;
2cf0635d 4764 Elf_Internal_Shdr * section;
252b5132
RH		 4765
4766 segment = program_headers + i;
b391a3e3 4767 section = section_headers + 1;
252b5132
RH		 4768
4769 printf (" %2.2d ", i);
4770
b34976b6 4771 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4772 {
f4638467
AM		 4773 if (!ELF_TBSS_SPECIAL (section, segment)
4774 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
74e1a04b 4775 printf ("%s ", printable_section_name (section));
252b5132
RH		 4776 }
4777
4778 putc ('\n',stdout);
4779 }
4780 }
4781
252b5132
RH		 4782 return 1;
4783}
4784
4785
d93f0186
NC		 4786/* Find the file offset corresponding to VMA by using the program headers. */
4787
4788static long
2cf0635d 4789offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4790{
2cf0635d 4791 Elf_Internal_Phdr * seg;
d93f0186
NC		 4792
4793 if (! get_program_headers (file))
4794 {
4795 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4796 return (long) vma;
4797 }
4798
4799 for (seg = program_headers;
4800 seg < program_headers + elf_header.e_phnum;
4801 ++seg)
4802 {
4803 if (seg->p_type != PT_LOAD)
4804 continue;
4805
4806 if (vma >= (seg->p_vaddr & -seg->p_align)
4807 && vma + size <= seg->p_vaddr + seg->p_filesz)
4808 return vma - seg->p_vaddr + seg->p_offset;
4809 }
4810
4811 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4812 (unsigned long) vma);
d93f0186
NC		 4813 return (long) vma;
4814}
4815
4816
049b0c3a
NC		 4817/* Allocate memory and load the sections headers into the global pointer
4818 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4819 generate any error messages if the load fails. */
4820
4821static bfd_boolean
4822get_32bit_section_headers (FILE * file, bfd_boolean probe)
252b5132 4823{
2cf0635d
NC		 4824 Elf32_External_Shdr * shdrs;
4825 Elf_Internal_Shdr * internal;
b34976b6 4826 unsigned int i;
049b0c3a
NC		 4827 unsigned int size = elf_header.e_shentsize;
4828 unsigned int num = probe ? 1 : elf_header.e_shnum;
4829
4830 /* PR binutils/17531: Cope with unexpected section header sizes. */
4831 if (size == 0 || num == 0)
4832 return FALSE;
4833 if (size < sizeof * shdrs)
4834 {
4835 if (! probe)
4836 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4837 return FALSE;
4838 }
4839 if (!probe && size > sizeof * shdrs)
4840 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
252b5132 4841
3f5e193b 4842 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4843 size, num,
4844 probe ? NULL : _("section headers"));
4845 if (shdrs == NULL)
4846 return FALSE;
252b5132 4847
049b0c3a
NC		 4848 if (section_headers != NULL)
4849 free (section_headers);
3f5e193b
NC		 4850 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4851 sizeof (Elf_Internal_Shdr));
252b5132
RH		 4852 if (section_headers == NULL)
4853 {
049b0c3a 4854 if (!probe)
8b73c356 4855 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4856 return FALSE;
252b5132
RH		 4857 }
4858
4859 for (i = 0, internal = section_headers;
560f3c1c 4860 i < num;
b34976b6 4861 i++, internal++)
252b5132
RH		 4862 {
4863 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4864 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4865 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4866 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4867 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4868 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4869 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4870 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4871 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4872 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4873 }
4874
4875 free (shdrs);
049b0c3a 4876 return TRUE;
252b5132
RH		 4877}
4878
049b0c3a
NC		 4879static bfd_boolean
4880get_64bit_section_headers (FILE * file, bfd_boolean probe)
9ea033b2 4881{
2cf0635d
NC		 4882 Elf64_External_Shdr * shdrs;
4883 Elf_Internal_Shdr * internal;
b34976b6 4884 unsigned int i;
049b0c3a
NC		 4885 unsigned int size = elf_header.e_shentsize;
4886 unsigned int num = probe ? 1 : elf_header.e_shnum;
4887
4888 /* PR binutils/17531: Cope with unexpected section header sizes. */
4889 if (size == 0 || num == 0)
4890 return FALSE;
4891 if (size < sizeof * shdrs)
4892 {
4893 if (! probe)
4894 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4895 return FALSE;
4896 }
4897 if (! probe && size > sizeof * shdrs)
4898 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
9ea033b2 4899
3f5e193b 4900 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4901 size, num,
4902 probe ? NULL : _("section headers"));
4903 if (shdrs == NULL)
4904 return FALSE;
9ea033b2 4905
049b0c3a
NC		 4906 if (section_headers != NULL)
4907 free (section_headers);
3f5e193b
NC		 4908 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4909 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4910 if (section_headers == NULL)
4911 {
049b0c3a 4912 if (! probe)
8b73c356 4913 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4914 return FALSE;
9ea033b2
NC		 4915 }
4916
4917 for (i = 0, internal = section_headers;
560f3c1c 4918 i < num;
b34976b6 4919 i++, internal++)
9ea033b2
NC		 4920 {
4921 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4922 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4923 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4924 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4925 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4926 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4927 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4928 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4929 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4930 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4931 }
4932
4933 free (shdrs);
049b0c3a 4934 return TRUE;
9ea033b2
NC		 4935}
4936
252b5132 4937static Elf_Internal_Sym *
ba5cdace
NC		 4938get_32bit_elf_symbols (FILE * file,
4939 Elf_Internal_Shdr * section,
4940 unsigned long * num_syms_return)
252b5132 4941{
ba5cdace 4942 unsigned long number = 0;
dd24e3da 4943 Elf32_External_Sym * esyms = NULL;
ba5cdace 4944 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 4945 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4946 Elf_Internal_Sym * psym;
b34976b6 4947 unsigned int j;
252b5132 4948
c9c1d674
EG		 4949 if (section->sh_size == 0)
4950 {
4951 if (num_syms_return != NULL)
4952 * num_syms_return = 0;
4953 return NULL;
4954 }
4955
dd24e3da 4956 /* Run some sanity checks first. */
c9c1d674 4957 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 4958 {
c9c1d674
EG		 4959 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4960 printable_section_name (section), (unsigned long) section->sh_entsize);
ba5cdace 4961 goto exit_point;
dd24e3da
NC		 4962 }
4963
f54498b4
NC		 4964 if (section->sh_size > current_file_size)
4965 {
4966 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
74e1a04b 4967 printable_section_name (section), (unsigned long) section->sh_size);
f54498b4
NC		 4968 goto exit_point;
4969 }
4970
dd24e3da
NC		 4971 number = section->sh_size / section->sh_entsize;
4972
4973 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4974 {
c9c1d674 4975 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 4976 (unsigned long) section->sh_size,
4977 printable_section_name (section),
4978 (unsigned long) section->sh_entsize);
ba5cdace 4979 goto exit_point;
dd24e3da
NC		 4980 }
4981
3f5e193b
NC		 4982 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4983 section->sh_size, _("symbols"));
dd24e3da 4984 if (esyms == NULL)
ba5cdace 4985 goto exit_point;
252b5132 4986
9ad5cbcf
AM		 4987 shndx = NULL;
4988 if (symtab_shndx_hdr != NULL
4989 && (symtab_shndx_hdr->sh_link
4fbb74a6 4990 == (unsigned long) (section - section_headers)))
9ad5cbcf 4991 {
3f5e193b
NC		 4992 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4993 symtab_shndx_hdr->sh_offset,
4994 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4995 _("symbol table section indicies"));
dd24e3da
NC		 4996 if (shndx == NULL)
4997 goto exit_point;
c9c1d674
EG		 4998 /* PR17531: file: heap-buffer-overflow */
4999 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5000 {
5001 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5002 printable_section_name (symtab_shndx_hdr),
5003 (unsigned long) symtab_shndx_hdr->sh_size,
5004 (unsigned long) section->sh_size);
5005 goto exit_point;
5006 }
9ad5cbcf
AM		 5007 }
5008
3f5e193b 5009 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 5010
5011 if (isyms == NULL)
5012 {
8b73c356
NC		 5013 error (_("Out of memory reading %lu symbols\n"),
5014 (unsigned long) number);
dd24e3da 5015 goto exit_point;
252b5132
RH		 5016 }
5017
dd24e3da 5018 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 5019 {
5020 psym->st_name = BYTE_GET (esyms[j].st_name);
5021 psym->st_value = BYTE_GET (esyms[j].st_value);
5022 psym->st_size = BYTE_GET (esyms[j].st_size);
5023 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 5024 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5025 psym->st_shndx
5026 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5027 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5028 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 5029 psym->st_info = BYTE_GET (esyms[j].st_info);
5030 psym->st_other = BYTE_GET (esyms[j].st_other);
5031 }
5032
dd24e3da 5033 exit_point:
ba5cdace 5034 if (shndx != NULL)
9ad5cbcf 5035 free (shndx);
ba5cdace 5036 if (esyms != NULL)
dd24e3da 5037 free (esyms);
252b5132 5038
ba5cdace
NC		 5039 if (num_syms_return != NULL)
5040 * num_syms_return = isyms == NULL ? 0 : number;
5041
252b5132
RH		 5042 return isyms;
5043}
5044
9ea033b2 5045static Elf_Internal_Sym *
ba5cdace
NC		 5046get_64bit_elf_symbols (FILE * file,
5047 Elf_Internal_Shdr * section,
5048 unsigned long * num_syms_return)
9ea033b2 5049{
ba5cdace
NC		 5050 unsigned long number = 0;
5051 Elf64_External_Sym * esyms = NULL;
5052 Elf_External_Sym_Shndx * shndx = NULL;
5053 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5054 Elf_Internal_Sym * psym;
b34976b6 5055 unsigned int j;
9ea033b2 5056
c9c1d674
EG		 5057 if (section->sh_size == 0)
5058 {
5059 if (num_syms_return != NULL)
5060 * num_syms_return = 0;
5061 return NULL;
5062 }
5063
dd24e3da 5064 /* Run some sanity checks first. */
c9c1d674 5065 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5066 {
c9c1d674 5067 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
8066deb1
AM		 5068 printable_section_name (section),
5069 (unsigned long) section->sh_entsize);
ba5cdace 5070 goto exit_point;
dd24e3da
NC		 5071 }
5072
f54498b4
NC		 5073 if (section->sh_size > current_file_size)
5074 {
5075 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
8066deb1
AM		 5076 printable_section_name (section),
5077 (unsigned long) section->sh_size);
f54498b4
NC		 5078 goto exit_point;
5079 }
5080
dd24e3da
NC		 5081 number = section->sh_size / section->sh_entsize;
5082
5083 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5084 {
c9c1d674 5085 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5086 (unsigned long) section->sh_size,
5087 printable_section_name (section),
5088 (unsigned long) section->sh_entsize);
ba5cdace 5089 goto exit_point;
dd24e3da
NC		 5090 }
5091
3f5e193b
NC		 5092 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5093 section->sh_size, _("symbols"));
a6e9f9df 5094 if (!esyms)
ba5cdace 5095 goto exit_point;
9ea033b2 5096
9ad5cbcf
AM		 5097 if (symtab_shndx_hdr != NULL
5098 && (symtab_shndx_hdr->sh_link
4fbb74a6 5099 == (unsigned long) (section - section_headers)))
9ad5cbcf 5100 {
3f5e193b
NC		 5101 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5102 symtab_shndx_hdr->sh_offset,
5103 1, symtab_shndx_hdr->sh_size,
9cf03b7e 5104 _("symbol table section indicies"));
ba5cdace
NC		 5105 if (shndx == NULL)
5106 goto exit_point;
c9c1d674
EG		 5107 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5108 {
5109 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5110 printable_section_name (symtab_shndx_hdr),
5111 (unsigned long) symtab_shndx_hdr->sh_size,
5112 (unsigned long) section->sh_size);
5113 goto exit_point;
5114 }
9ad5cbcf
AM		 5115 }
5116
3f5e193b 5117 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 5118
5119 if (isyms == NULL)
5120 {
8b73c356
NC		 5121 error (_("Out of memory reading %lu symbols\n"),
5122 (unsigned long) number);
ba5cdace 5123 goto exit_point;
9ea033b2
NC		 5124 }
5125
ba5cdace 5126 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 5127 {
5128 psym->st_name = BYTE_GET (esyms[j].st_name);
5129 psym->st_info = BYTE_GET (esyms[j].st_info);
5130 psym->st_other = BYTE_GET (esyms[j].st_other);
5131 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 5132
4fbb74a6 5133 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5134 psym->st_shndx
5135 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5136 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5137 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 5138
66543521
AM		 5139 psym->st_value = BYTE_GET (esyms[j].st_value);
5140 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 5141 }
5142
ba5cdace
NC		 5143 exit_point:
5144 if (shndx != NULL)
9ad5cbcf 5145 free (shndx);
ba5cdace
NC		 5146 if (esyms != NULL)
5147 free (esyms);
5148
5149 if (num_syms_return != NULL)
5150 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 5151
5152 return isyms;
5153}
5154
d1133906 5155static const char *
d3ba0551 5156get_elf_section_flags (bfd_vma sh_flags)
d1133906 5157{
5477e8a0 5158 static char buff[1024];
2cf0635d 5159 char * p = buff;
8d5ff12c 5160 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 5161 int sindex;
5162 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 5163 bfd_vma os_flags = 0;
5164 bfd_vma proc_flags = 0;
5165 bfd_vma unknown_flags = 0;
148b93f2 5166 static const struct
5477e8a0 5167 {
2cf0635d 5168 const char * str;
5477e8a0
L		 5169 int len;
5170 }
5171 flags [] =
5172 {
cfcac11d
NC		 5173 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5174 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5175 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5176 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5177 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5178 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5179 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5180 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5181 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5182 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5183 /* IA-64 specific. */
5184 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5185 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5186 /* IA-64 OpenVMS specific. */
5187 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5188 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5189 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5190 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5191 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5192 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 5193 /* Generic. */
cfcac11d 5194 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 5195 /* SPARC specific. */
77115a4a
L		 5196 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5197 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") }
5477e8a0
L		 5198 };
5199
5200 if (do_section_details)
5201 {
8d5ff12c
L		 5202 sprintf (buff, "[%*.*lx]: ",
5203 field_size, field_size, (unsigned long) sh_flags);
5204 p += field_size + 4;
5477e8a0 5205 }
76da6bbe 5206
d1133906
NC		 5207 while (sh_flags)
5208 {
5209 bfd_vma flag;
5210
5211 flag = sh_flags & - sh_flags;
5212 sh_flags &= ~ flag;
76da6bbe 5213
5477e8a0 5214 if (do_section_details)
d1133906 5215 {
5477e8a0
L		 5216 switch (flag)
5217 {
91d6fa6a
NC		 5218 case SHF_WRITE: sindex = 0; break;
5219 case SHF_ALLOC: sindex = 1; break;
5220 case SHF_EXECINSTR: sindex = 2; break;
5221 case SHF_MERGE: sindex = 3; break;
5222 case SHF_STRINGS: sindex = 4; break;
5223 case SHF_INFO_LINK: sindex = 5; break;
5224 case SHF_LINK_ORDER: sindex = 6; break;
5225 case SHF_OS_NONCONFORMING: sindex = 7; break;
5226 case SHF_GROUP: sindex = 8; break;
5227 case SHF_TLS: sindex = 9; break;
18ae9cc1 5228 case SHF_EXCLUDE: sindex = 18; break;
77115a4a 5229 case SHF_COMPRESSED: sindex = 20; break;
76da6bbe 5230
5477e8a0 5231 default:
91d6fa6a 5232 sindex = -1;
cfcac11d 5233 switch (elf_header.e_machine)
148b93f2 5234 {
cfcac11d 5235 case EM_IA_64:
148b93f2 5236 if (flag == SHF_IA_64_SHORT)
91d6fa6a 5237 sindex = 10;
148b93f2 5238 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 5239 sindex = 11;
148b93f2
NC		 5240#ifdef BFD64
5241 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5242 switch (flag)
5243 {
91d6fa6a
NC		 5244 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5245 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5246 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5247 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5248 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5249 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 5250 default: break;
5251 }
5252#endif
cfcac11d
NC		 5253 break;
5254
caa83f8b 5255 case EM_386:
22abe556 5256 case EM_IAMCU:
caa83f8b 5257 case EM_X86_64:
7f502d6c 5258 case EM_L1OM:
7a9068fe 5259 case EM_K1OM:
cfcac11d
NC		 5260 case EM_OLD_SPARCV9:
5261 case EM_SPARC32PLUS:
5262 case EM_SPARCV9:
5263 case EM_SPARC:
18ae9cc1 5264 if (flag == SHF_ORDERED)
91d6fa6a 5265 sindex = 19;
cfcac11d
NC		 5266 break;
5267 default:
5268 break;
148b93f2 5269 }
5477e8a0
L		 5270 }
5271
91d6fa6a 5272 if (sindex != -1)
5477e8a0 5273 {
8d5ff12c
L		 5274 if (p != buff + field_size + 4)
5275 {
5276 if (size < (10 + 2))
bee0ee85
NC		 5277 {
5278 warn (_("Internal error: not enough buffer room for section flag info"));
5279 return _("<unknown>");
5280 }
8d5ff12c
L		 5281 size -= 2;
5282 *p++ = ',';
5283 *p++ = ' ';
5284 }
5285
91d6fa6a
NC		 5286 size -= flags [sindex].len;
5287 p = stpcpy (p, flags [sindex].str);
5477e8a0 5288 }
3b22753a 5289 else if (flag & SHF_MASKOS)
8d5ff12c 5290 os_flags |= flag;
d1133906 5291 else if (flag & SHF_MASKPROC)
8d5ff12c 5292 proc_flags |= flag;
d1133906 5293 else
8d5ff12c 5294 unknown_flags |= flag;
5477e8a0
L		 5295 }
5296 else
5297 {
5298 switch (flag)
5299 {
5300 case SHF_WRITE: *p = 'W'; break;
5301 case SHF_ALLOC: *p = 'A'; break;
5302 case SHF_EXECINSTR: *p = 'X'; break;
5303 case SHF_MERGE: *p = 'M'; break;
5304 case SHF_STRINGS: *p = 'S'; break;
5305 case SHF_INFO_LINK: *p = 'I'; break;
5306 case SHF_LINK_ORDER: *p = 'L'; break;
5307 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5308 case SHF_GROUP: *p = 'G'; break;
5309 case SHF_TLS: *p = 'T'; break;
18ae9cc1 5310 case SHF_EXCLUDE: *p = 'E'; break;
77115a4a 5311 case SHF_COMPRESSED: *p = 'C'; break;
5477e8a0
L		 5312
5313 default:
8a9036a4 5314 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 5315 || elf_header.e_machine == EM_L1OM
5316 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 5317 && flag == SHF_X86_64_LARGE)
5318 *p = 'l';
5319 else if (flag & SHF_MASKOS)
5320 {
5321 *p = 'o';
5322 sh_flags &= ~ SHF_MASKOS;
5323 }
5324 else if (flag & SHF_MASKPROC)
5325 {
5326 *p = 'p';
5327 sh_flags &= ~ SHF_MASKPROC;
5328 }
5329 else
5330 *p = 'x';
5331 break;
5332 }
5333 p++;
d1133906
NC		 5334 }
5335 }
76da6bbe 5336
8d5ff12c
L		 5337 if (do_section_details)
5338 {
5339 if (os_flags)
5340 {
5341 size -= 5 + field_size;
5342 if (p != buff + field_size + 4)
5343 {
5344 if (size < (2 + 1))
bee0ee85
NC		 5345 {
5346 warn (_("Internal error: not enough buffer room for section flag info"));
5347 return _("<unknown>");
5348 }
8d5ff12c
L		 5349 size -= 2;
5350 *p++ = ',';
5351 *p++ = ' ';
5352 }
5353 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5354 (unsigned long) os_flags);
5355 p += 5 + field_size;
5356 }
5357 if (proc_flags)
5358 {
5359 size -= 7 + field_size;
5360 if (p != buff + field_size + 4)
5361 {
5362 if (size < (2 + 1))
bee0ee85
NC		 5363 {
5364 warn (_("Internal error: not enough buffer room for section flag info"));
5365 return _("<unknown>");
5366 }
8d5ff12c
L		 5367 size -= 2;
5368 *p++ = ',';
5369 *p++ = ' ';
5370 }
5371 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5372 (unsigned long) proc_flags);
5373 p += 7 + field_size;
5374 }
5375 if (unknown_flags)
5376 {
5377 size -= 10 + field_size;
5378 if (p != buff + field_size + 4)
5379 {
5380 if (size < (2 + 1))
bee0ee85
NC		 5381 {
5382 warn (_("Internal error: not enough buffer room for section flag info"));
5383 return _("<unknown>");
5384 }
8d5ff12c
L		 5385 size -= 2;
5386 *p++ = ',';
5387 *p++ = ' ';
5388 }
2b692964 5389 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 5390 (unsigned long) unknown_flags);
5391 p += 10 + field_size;
5392 }
5393 }
5394
e9e44622 5395 *p = '\0';
d1133906
NC		 5396 return buff;
5397}
5398
77115a4a
L		 5399static unsigned int
5400get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf)
5401{
5402 if (is_32bit_elf)
5403 {
5404 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5405 chdr->ch_type = BYTE_GET (echdr->ch_type);
5406 chdr->ch_size = BYTE_GET (echdr->ch_size);
5407 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5408 return sizeof (*echdr);
5409 }
5410 else
5411 {
5412 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5413 chdr->ch_type = BYTE_GET (echdr->ch_type);
5414 chdr->ch_size = BYTE_GET (echdr->ch_size);
5415 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5416 return sizeof (*echdr);
5417 }
5418}
5419
252b5132 5420static int
2cf0635d 5421process_section_headers (FILE * file)
252b5132 5422{
2cf0635d 5423 Elf_Internal_Shdr * section;
b34976b6 5424 unsigned int i;
252b5132
RH		 5425
5426 section_headers = NULL;
5427
5428 if (elf_header.e_shnum == 0)
5429 {
82f2dbf7
NC		 5430 /* PR binutils/12467. */
5431 if (elf_header.e_shoff != 0)
5432 warn (_("possibly corrupt ELF file header - it has a non-zero"
5433 " section header offset, but no section headers\n"));
5434 else if (do_sections)
252b5132
RH		 5435 printf (_("\nThere are no sections in this file.\n"));
5436
5437 return 1;
5438 }
5439
5440 if (do_sections && !do_header)
9ea033b2 5441 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 5442 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5443
9ea033b2
NC		 5444 if (is_32bit_elf)
5445 {
049b0c3a 5446 if (! get_32bit_section_headers (file, FALSE))
9ea033b2
NC		 5447 return 0;
5448 }
049b0c3a 5449 else if (! get_64bit_section_headers (file, FALSE))
252b5132
RH		 5450 return 0;
5451
5452 /* Read in the string table, so that we have names to display. */
0b49d371 5453 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 5454 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 5455 {
4fbb74a6 5456 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 5457
c256ffe7
JJ		 5458 if (section->sh_size != 0)
5459 {
3f5e193b
NC		 5460 string_table = (char *) get_data (NULL, file, section->sh_offset,
5461 1, section->sh_size,
5462 _("string table"));
0de14b54 5463
c256ffe7
JJ		 5464 string_table_length = string_table != NULL ? section->sh_size : 0;
5465 }
252b5132
RH		 5466 }
5467
5468 /* Scan the sections for the dynamic symbol table
e3c8793a 5469 and dynamic string table and debug sections. */
252b5132
RH		 5470 dynamic_symbols = NULL;
5471 dynamic_strings = NULL;
5472 dynamic_syminfo = NULL;
f1ef08cb 5473 symtab_shndx_hdr = NULL;
103f02d3 5474
89fac5e3
RS		 5475 eh_addr_size = is_32bit_elf ? 4 : 8;
5476 switch (elf_header.e_machine)
5477 {
5478 case EM_MIPS:
5479 case EM_MIPS_RS3_LE:
5480 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5481 FDE addresses. However, the ABI also has a semi-official ILP32
5482 variant for which the normal FDE address size rules apply.
5483
5484 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5485 section, where XX is the size of longs in bits. Unfortunately,
5486 earlier compilers provided no way of distinguishing ILP32 objects
5487 from LP64 objects, so if there's any doubt, we should assume that
5488 the official LP64 form is being used. */
5489 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5490 && find_section (".gcc_compiled_long32") == NULL)
5491 eh_addr_size = 8;
5492 break;
0f56a26a
DD		 5493
5494 case EM_H8_300:
5495 case EM_H8_300H:
5496 switch (elf_header.e_flags & EF_H8_MACH)
5497 {
5498 case E_H8_MACH_H8300:
5499 case E_H8_MACH_H8300HN:
5500 case E_H8_MACH_H8300SN:
5501 case E_H8_MACH_H8300SXN:
5502 eh_addr_size = 2;
5503 break;
5504 case E_H8_MACH_H8300H:
5505 case E_H8_MACH_H8300S:
5506 case E_H8_MACH_H8300SX:
5507 eh_addr_size = 4;
5508 break;
5509 }
f4236fe4
DD		 5510 break;
5511
ff7eeb89 5512 case EM_M32C_OLD:
f4236fe4
DD		 5513 case EM_M32C:
5514 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5515 {
5516 case EF_M32C_CPU_M16C:
5517 eh_addr_size = 2;
5518 break;
5519 }
5520 break;
89fac5e3
RS		 5521 }
5522
76ca31c0
NC		 5523#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5524 do \
5525 { \
5526 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5527 if (section->sh_entsize != expected_entsize) \
9dd3a467 5528 { \
76ca31c0
NC		 5529 char buf[40]; \
5530 sprintf_vma (buf, section->sh_entsize); \
5531 /* Note: coded this way so that there is a single string for \
5532 translation. */ \
5533 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5534 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5535 (unsigned) expected_entsize); \
9dd3a467 5536 section->sh_entsize = expected_entsize; \
76ca31c0
NC		 5537 } \
5538 } \
08d8fa11 5539 while (0)
9dd3a467
NC		 5540
5541#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 5542 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5543 sizeof (Elf64_External_##type))
5544
252b5132
RH		 5545 for (i = 0, section = section_headers;
5546 i < elf_header.e_shnum;
b34976b6 5547 i++, section++)
252b5132 5548 {
2cf0635d 5549 char * name = SECTION_NAME (section);
252b5132
RH		 5550
5551 if (section->sh_type == SHT_DYNSYM)
5552 {
5553 if (dynamic_symbols != NULL)
5554 {
5555 error (_("File contains multiple dynamic symbol tables\n"));
5556 continue;
5557 }
5558
08d8fa11 5559 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 5560 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 5561 }
5562 else if (section->sh_type == SHT_STRTAB
18bd398b 5563 && streq (name, ".dynstr"))
252b5132
RH		 5564 {
5565 if (dynamic_strings != NULL)
5566 {
5567 error (_("File contains multiple dynamic string tables\n"));
5568 continue;
5569 }
5570
3f5e193b
NC		 5571 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5572 1, section->sh_size,
5573 _("dynamic strings"));
59245841 5574 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 5575 }
9ad5cbcf
AM		 5576 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5577 {
5578 if (symtab_shndx_hdr != NULL)
5579 {
5580 error (_("File contains multiple symtab shndx tables\n"));
5581 continue;
5582 }
5583 symtab_shndx_hdr = section;
5584 }
08d8fa11
JJ		 5585 else if (section->sh_type == SHT_SYMTAB)
5586 CHECK_ENTSIZE (section, i, Sym);
5587 else if (section->sh_type == SHT_GROUP)
5588 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5589 else if (section->sh_type == SHT_REL)
5590 CHECK_ENTSIZE (section, i, Rel);
5591 else if (section->sh_type == SHT_RELA)
5592 CHECK_ENTSIZE (section, i, Rela);
252b5132 5593 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 5594 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 5595 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 5596 || do_debug_str || do_debug_loc || do_debug_ranges
5597 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 5598 && (const_strneq (name, ".debug_")
5599 || const_strneq (name, ".zdebug_")))
252b5132 5600 {
1b315056
CS		 5601 if (name[1] == 'z')
5602 name += sizeof (".zdebug_") - 1;
5603 else
5604 name += sizeof (".debug_") - 1;
252b5132
RH		 5605
5606 if (do_debugging
4723351a
CC		 5607 || (do_debug_info && const_strneq (name, "info"))
5608 || (do_debug_info && const_strneq (name, "types"))
5609 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 5610 || (do_debug_lines && strcmp (name, "line") == 0)
5611 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 5612 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5613 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
459d52c8
DE		 5614 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5615 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4723351a
CC		 5616 || (do_debug_aranges && const_strneq (name, "aranges"))
5617 || (do_debug_ranges && const_strneq (name, "ranges"))
5618 || (do_debug_frames && const_strneq (name, "frame"))
5619 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5620 || (do_debug_macinfo && const_strneq (name, "macro"))
5621 || (do_debug_str && const_strneq (name, "str"))
5622 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 5623 || (do_debug_addr && const_strneq (name, "addr"))
5624 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5625 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 5626 )
09c11c86 5627 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 5628 }
a262ae96 5629 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 5630 else if ((do_debugging || do_debug_info)
0112cd26 5631 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 5632 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 5633 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 5634 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 5635 else if (do_gdb_index && streq (name, ".gdb_index"))
5636 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 5637 /* Trace sections for Itanium VMS. */
5638 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5639 || do_trace_aranges)
5640 && const_strneq (name, ".trace_"))
5641 {
5642 name += sizeof (".trace_") - 1;
5643
5644 if (do_debugging
5645 || (do_trace_info && streq (name, "info"))
5646 || (do_trace_abbrevs && streq (name, "abbrev"))
5647 || (do_trace_aranges && streq (name, "aranges"))
5648 )
5649 request_dump_bynumber (i, DEBUG_DUMP);
5650 }
252b5132
RH		 5651 }
5652
5653 if (! do_sections)
5654 return 1;
5655
3a1a2036
NC		 5656 if (elf_header.e_shnum > 1)
5657 printf (_("\nSection Headers:\n"));
5658 else
5659 printf (_("\nSection Header:\n"));
76da6bbe 5660
f7a99963 5661 if (is_32bit_elf)
595cf52e 5662 {
5477e8a0 5663 if (do_section_details)
595cf52e
L		 5664 {
5665 printf (_(" [Nr] Name\n"));
5477e8a0 5666 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 5667 }
5668 else
5669 printf
5670 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5671 }
d974e256 5672 else if (do_wide)
595cf52e 5673 {
5477e8a0 5674 if (do_section_details)
595cf52e
L		 5675 {
5676 printf (_(" [Nr] Name\n"));
5477e8a0 5677 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 5678 }
5679 else
5680 printf
5681 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5682 }
f7a99963
NC		 5683 else
5684 {
5477e8a0 5685 if (do_section_details)
595cf52e
L		 5686 {
5687 printf (_(" [Nr] Name\n"));
5477e8a0
L		 5688 printf (_(" Type Address Offset Link\n"));
5689 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 5690 }
5691 else
5692 {
5693 printf (_(" [Nr] Name Type Address Offset\n"));
5694 printf (_(" Size EntSize Flags Link Info Align\n"));
5695 }
f7a99963 5696 }
252b5132 5697
5477e8a0
L		 5698 if (do_section_details)
5699 printf (_(" Flags\n"));
5700
252b5132
RH		 5701 for (i = 0, section = section_headers;
5702 i < elf_header.e_shnum;
b34976b6 5703 i++, section++)
252b5132 5704 {
7bfd842d 5705 printf (" [%2u] ", i);
5477e8a0 5706 if (do_section_details)
74e1a04b 5707 printf ("%s\n ", printable_section_name (section));
595cf52e 5708 else
74e1a04b 5709 print_symbol (-17, SECTION_NAME (section));
0b4362b0 5710
ea52a088
NC		 5711 printf (do_wide ? " %-15s " : " %-15.15s ",
5712 get_section_type_name (section->sh_type));
0b4362b0 5713
f7a99963
NC		 5714 if (is_32bit_elf)
5715 {
cfcac11d
NC		 5716 const char * link_too_big = NULL;
5717
f7a99963 5718 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 5719
f7a99963
NC		 5720 printf ( " %6.6lx %6.6lx %2.2lx",
5721 (unsigned long) section->sh_offset,
5722 (unsigned long) section->sh_size,
5723 (unsigned long) section->sh_entsize);
d1133906 5724
5477e8a0
L		 5725 if (do_section_details)
5726 fputs (" ", stdout);
5727 else
5728 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5729
cfcac11d
NC		 5730 if (section->sh_link >= elf_header.e_shnum)
5731 {
5732 link_too_big = "";
5733 /* The sh_link value is out of range. Normally this indicates
caa83f8b 5734 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 5735 switch (elf_header.e_machine)
5736 {
caa83f8b 5737 case EM_386:
22abe556 5738 case EM_IAMCU:
caa83f8b 5739 case EM_X86_64:
7f502d6c 5740 case EM_L1OM:
7a9068fe 5741 case EM_K1OM:
cfcac11d
NC		 5742 case EM_OLD_SPARCV9:
5743 case EM_SPARC32PLUS:
5744 case EM_SPARCV9:
5745 case EM_SPARC:
5746 if (section->sh_link == (SHN_BEFORE & 0xffff))
5747 link_too_big = "BEFORE";
5748 else if (section->sh_link == (SHN_AFTER & 0xffff))
5749 link_too_big = "AFTER";
5750 break;
5751 default:
5752 break;
5753 }
5754 }
5755
5756 if (do_section_details)
5757 {
5758 if (link_too_big != NULL && * link_too_big)
5759 printf ("<%s> ", link_too_big);
5760 else
5761 printf ("%2u ", section->sh_link);
5762 printf ("%3u %2lu\n", section->sh_info,
5763 (unsigned long) section->sh_addralign);
5764 }
5765 else
5766 printf ("%2u %3u %2lu\n",
5767 section->sh_link,
5768 section->sh_info,
5769 (unsigned long) section->sh_addralign);
5770
5771 if (link_too_big && ! * link_too_big)
5772 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5773 i, section->sh_link);
f7a99963 5774 }
d974e256
JJ		 5775 else if (do_wide)
5776 {
5777 print_vma (section->sh_addr, LONG_HEX);
5778
5779 if ((long) section->sh_offset == section->sh_offset)
5780 printf (" %6.6lx", (unsigned long) section->sh_offset);
5781 else
5782 {
5783 putchar (' ');
5784 print_vma (section->sh_offset, LONG_HEX);
5785 }
5786
5787 if ((unsigned long) section->sh_size == section->sh_size)
5788 printf (" %6.6lx", (unsigned long) section->sh_size);
5789 else
5790 {
5791 putchar (' ');
5792 print_vma (section->sh_size, LONG_HEX);
5793 }
5794
5795 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5796 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5797 else
5798 {
5799 putchar (' ');
5800 print_vma (section->sh_entsize, LONG_HEX);
5801 }
5802
5477e8a0
L		 5803 if (do_section_details)
5804 fputs (" ", stdout);
5805 else
5806 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 5807
72de5009 5808 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 5809
5810 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 5811 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 5812 else
5813 {
5814 print_vma (section->sh_addralign, DEC);
5815 putchar ('\n');
5816 }
5817 }
5477e8a0 5818 else if (do_section_details)
595cf52e 5819 {
5477e8a0 5820 printf (" %-15.15s ",
595cf52e 5821 get_section_type_name (section->sh_type));
595cf52e
L		 5822 print_vma (section->sh_addr, LONG_HEX);
5823 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 5824 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 5825 else
5826 {
5827 printf (" ");
5828 print_vma (section->sh_offset, LONG_HEX);
5829 }
72de5009 5830 printf (" %u\n ", section->sh_link);
595cf52e 5831 print_vma (section->sh_size, LONG_HEX);
5477e8a0 5832 putchar (' ');
595cf52e
L		 5833 print_vma (section->sh_entsize, LONG_HEX);
5834
72de5009
AM		 5835 printf (" %-16u %lu\n",
5836 section->sh_info,
595cf52e
L		 5837 (unsigned long) section->sh_addralign);
5838 }
f7a99963
NC		 5839 else
5840 {
5841 putchar (' ');
5842 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 5843 if ((long) section->sh_offset == section->sh_offset)
5844 printf (" %8.8lx", (unsigned long) section->sh_offset);
5845 else
5846 {
5847 printf (" ");
5848 print_vma (section->sh_offset, LONG_HEX);
5849 }
f7a99963
NC		 5850 printf ("\n ");
5851 print_vma (section->sh_size, LONG_HEX);
5852 printf (" ");
5853 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 5854
d1133906 5855 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5856
72de5009
AM		 5857 printf (" %2u %3u %lu\n",
5858 section->sh_link,
5859 section->sh_info,
f7a99963
NC		 5860 (unsigned long) section->sh_addralign);
5861 }
5477e8a0
L		 5862
5863 if (do_section_details)
77115a4a
L		 5864 {
5865 printf (" %s\n", get_elf_section_flags (section->sh_flags));
5866 if ((section->sh_flags & SHF_COMPRESSED) != 0)
5867 {
5868 /* Minimum section size is 12 bytes for 32-bit compression
5869 header + 12 bytes for compressed data header. */
5870 unsigned char buf[24];
5871 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
5872 if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
5873 sizeof (buf), _("compression header")))
5874 {
5875 Elf_Internal_Chdr chdr;
5876 get_compression_header (&chdr, buf);
5877 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
5878 printf (" ZLIB, ");
5879 else
5880 printf (_(" [<unknown>: 0x%x], "),
5881 chdr.ch_type);
5882 print_vma (chdr.ch_size, LONG_HEX);
5883 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
5884 }
5885 }
5886 }
252b5132
RH		 5887 }
5888
5477e8a0 5889 if (!do_section_details)
3dbcc61d
NC		 5890 {
5891 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 5892 || elf_header.e_machine == EM_L1OM
5893 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 5894 printf (_("Key to Flags:\n\
5895 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5896 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5897 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5898 else
5899 printf (_("Key to Flags:\n\
e3c8793a 5900 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 5901 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 5902 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
0b4362b0 5903 }
d1133906 5904
252b5132
RH		 5905 return 1;
5906}
5907
f5842774
L		 5908static const char *
5909get_group_flags (unsigned int flags)
5910{
5911 static char buff[32];
5912 switch (flags)
5913 {
220453ec
AM		 5914 case 0:
5915 return "";
5916
f5842774 5917 case GRP_COMDAT:
220453ec 5918 return "COMDAT ";
f5842774
L		 5919
5920 default:
220453ec 5921 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 5922 break;
5923 }
5924 return buff;
5925}
5926
5927static int
2cf0635d 5928process_section_groups (FILE * file)
f5842774 5929{
2cf0635d 5930 Elf_Internal_Shdr * section;
f5842774 5931 unsigned int i;
2cf0635d
NC		 5932 struct group * group;
5933 Elf_Internal_Shdr * symtab_sec;
5934 Elf_Internal_Shdr * strtab_sec;
5935 Elf_Internal_Sym * symtab;
ba5cdace 5936 unsigned long num_syms;
2cf0635d 5937 char * strtab;
c256ffe7 5938 size_t strtab_size;
d1f5c6e3
L		 5939
5940 /* Don't process section groups unless needed. */
5941 if (!do_unwind && !do_section_groups)
5942 return 1;
f5842774
L		 5943
5944 if (elf_header.e_shnum == 0)
5945 {
5946 if (do_section_groups)
82f2dbf7 5947 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 5948
5949 return 1;
5950 }
5951
5952 if (section_headers == NULL)
5953 {
5954 error (_("Section headers are not available!\n"));
fa1908fd
NC		 5955 /* PR 13622: This can happen with a corrupt ELF header. */
5956 return 0;
f5842774
L		 5957 }
5958
3f5e193b
NC		 5959 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5960 sizeof (struct group *));
e4b17d5c
L		 5961
5962 if (section_headers_groups == NULL)
5963 {
8b73c356
NC		 5964 error (_("Out of memory reading %u section group headers\n"),
5965 elf_header.e_shnum);
e4b17d5c
L		 5966 return 0;
5967 }
5968
f5842774 5969 /* Scan the sections for the group section. */
d1f5c6e3 5970 group_count = 0;
f5842774
L		 5971 for (i = 0, section = section_headers;
5972 i < elf_header.e_shnum;
5973 i++, section++)
e4b17d5c
L		 5974 if (section->sh_type == SHT_GROUP)
5975 group_count++;
5976
d1f5c6e3
L		 5977 if (group_count == 0)
5978 {
5979 if (do_section_groups)
5980 printf (_("\nThere are no section groups in this file.\n"));
5981
5982 return 1;
5983 }
5984
3f5e193b 5985 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 5986
5987 if (section_groups == NULL)
5988 {
8b73c356
NC		 5989 error (_("Out of memory reading %lu groups\n"),
5990 (unsigned long) group_count);
e4b17d5c
L		 5991 return 0;
5992 }
5993
d1f5c6e3
L		 5994 symtab_sec = NULL;
5995 strtab_sec = NULL;
5996 symtab = NULL;
ba5cdace 5997 num_syms = 0;
d1f5c6e3 5998 strtab = NULL;
c256ffe7 5999 strtab_size = 0;
e4b17d5c
L		 6000 for (i = 0, section = section_headers, group = section_groups;
6001 i < elf_header.e_shnum;
6002 i++, section++)
f5842774
L		 6003 {
6004 if (section->sh_type == SHT_GROUP)
6005 {
74e1a04b
NC		 6006 const char * name = printable_section_name (section);
6007 const char * group_name;
2cf0635d
NC		 6008 unsigned char * start;
6009 unsigned char * indices;
f5842774 6010 unsigned int entry, j, size;
2cf0635d
NC		 6011 Elf_Internal_Shdr * sec;
6012 Elf_Internal_Sym * sym;
f5842774
L		 6013
6014 /* Get the symbol table. */
4fbb74a6
AM		 6015 if (section->sh_link >= elf_header.e_shnum
6016 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 6017 != SHT_SYMTAB))
f5842774
L		 6018 {
6019 error (_("Bad sh_link in group section `%s'\n"), name);
6020 continue;
6021 }
d1f5c6e3
L		 6022
6023 if (symtab_sec != sec)
6024 {
6025 symtab_sec = sec;
6026 if (symtab)
6027 free (symtab);
ba5cdace 6028 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 6029 }
f5842774 6030
dd24e3da
NC		 6031 if (symtab == NULL)
6032 {
6033 error (_("Corrupt header in group section `%s'\n"), name);
6034 continue;
6035 }
6036
ba5cdace
NC		 6037 if (section->sh_info >= num_syms)
6038 {
6039 error (_("Bad sh_info in group section `%s'\n"), name);
6040 continue;
6041 }
6042
f5842774
L		 6043 sym = symtab + section->sh_info;
6044
6045 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6046 {
4fbb74a6
AM		 6047 if (sym->st_shndx == 0
6048 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 6049 {
6050 error (_("Bad sh_info in group section `%s'\n"), name);
6051 continue;
6052 }
ba2685cc 6053
4fbb74a6 6054 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 6055 strtab_sec = NULL;
6056 if (strtab)
6057 free (strtab);
f5842774 6058 strtab = NULL;
c256ffe7 6059 strtab_size = 0;
f5842774
L		 6060 }
6061 else
6062 {
6063 /* Get the string table. */
4fbb74a6 6064 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 6065 {
6066 strtab_sec = NULL;
6067 if (strtab)
6068 free (strtab);
6069 strtab = NULL;
6070 strtab_size = 0;
6071 }
6072 else if (strtab_sec
4fbb74a6 6073 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 6074 {
6075 strtab_sec = sec;
6076 if (strtab)
6077 free (strtab);
071436c6 6078
3f5e193b 6079 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
071436c6
NC		 6080 1, strtab_sec->sh_size,
6081 _("string table"));
c256ffe7 6082 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 6083 }
c256ffe7 6084 group_name = sym->st_name < strtab_size
2b692964 6085 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 6086 }
6087
c9c1d674
EG		 6088 /* PR 17531: file: loop. */
6089 if (section->sh_entsize > section->sh_size)
6090 {
6091 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6092 printable_section_name (section),
8066deb1
AM		 6093 (unsigned long) section->sh_entsize,
6094 (unsigned long) section->sh_size);
c9c1d674
EG		 6095 break;
6096 }
6097
3f5e193b
NC		 6098 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6099 1, section->sh_size,
6100 _("section data"));
59245841
NC		 6101 if (start == NULL)
6102 continue;
f5842774
L		 6103
6104 indices = start;
6105 size = (section->sh_size / section->sh_entsize) - 1;
6106 entry = byte_get (indices, 4);
6107 indices += 4;
e4b17d5c
L		 6108
6109 if (do_section_groups)
6110 {
2b692964 6111 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 6112 get_group_flags (entry), i, name, group_name, size);
ba2685cc 6113
e4b17d5c
L		 6114 printf (_(" [Index] Name\n"));
6115 }
6116
6117 group->group_index = i;
6118
f5842774
L		 6119 for (j = 0; j < size; j++)
6120 {
2cf0635d 6121 struct group_list * g;
e4b17d5c 6122
f5842774
L		 6123 entry = byte_get (indices, 4);
6124 indices += 4;
6125
4fbb74a6 6126 if (entry >= elf_header.e_shnum)
391cb864 6127 {
57028622
NC		 6128 static unsigned num_group_errors = 0;
6129
6130 if (num_group_errors ++ < 10)
6131 {
6132 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6133 entry, i, elf_header.e_shnum - 1);
6134 if (num_group_errors == 10)
6135 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6136 }
391cb864
L		 6137 continue;
6138 }
391cb864 6139
4fbb74a6 6140 if (section_headers_groups [entry] != NULL)
e4b17d5c 6141 {
d1f5c6e3
L		 6142 if (entry)
6143 {
57028622
NC		 6144 static unsigned num_errs = 0;
6145
6146 if (num_errs ++ < 10)
6147 {
6148 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6149 entry, i,
6150 section_headers_groups [entry]->group_index);
6151 if (num_errs == 10)
6152 warn (_("Further error messages about already contained group sections suppressed\n"));
6153 }
d1f5c6e3
L		 6154 continue;
6155 }
6156 else
6157 {
6158 /* Intel C/C++ compiler may put section 0 in a
6159 section group. We just warn it the first time
6160 and ignore it afterwards. */
6161 static int warned = 0;
6162 if (!warned)
6163 {
6164 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 6165 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 6166 warned++;
6167 }
6168 }
e4b17d5c
L		 6169 }
6170
4fbb74a6 6171 section_headers_groups [entry] = group;
e4b17d5c
L		 6172
6173 if (do_section_groups)
6174 {
4fbb74a6 6175 sec = section_headers + entry;
74e1a04b 6176 printf (" [%5u] %s\n", entry, printable_section_name (sec));
ba2685cc
AM		 6177 }
6178
3f5e193b 6179 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 6180 g->section_index = entry;
6181 g->next = group->root;
6182 group->root = g;
f5842774
L		 6183 }
6184
f5842774
L		 6185 if (start)
6186 free (start);
e4b17d5c
L		 6187
6188 group++;
f5842774
L		 6189 }
6190 }
6191
d1f5c6e3
L		 6192 if (symtab)
6193 free (symtab);
6194 if (strtab)
6195 free (strtab);
f5842774
L		 6196 return 1;
6197}
6198
28f997cf
TG		 6199/* Data used to display dynamic fixups. */
6200
6201struct ia64_vms_dynfixup
6202{
6203 bfd_vma needed_ident; /* Library ident number. */
6204 bfd_vma needed; /* Index in the dstrtab of the library name. */
6205 bfd_vma fixup_needed; /* Index of the library. */
6206 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6207 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6208};
6209
6210/* Data used to display dynamic relocations. */
6211
6212struct ia64_vms_dynimgrela
6213{
6214 bfd_vma img_rela_cnt; /* Number of relocations. */
6215 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6216};
6217
6218/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6219 library). */
6220
6221static void
6222dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6223 const char *strtab, unsigned int strtab_sz)
6224{
6225 Elf64_External_VMS_IMAGE_FIXUP *imfs;
6226 long i;
6227 const char *lib_name;
6228
6229 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6230 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6231 _("dynamic section image fixups"));
6232 if (!imfs)
6233 return;
6234
6235 if (fixup->needed < strtab_sz)
6236 lib_name = strtab + fixup->needed;
6237 else
6238 {
6239 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 6240 (unsigned long) fixup->needed);
28f997cf
TG		 6241 lib_name = "???";
6242 }
6243 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6244 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6245 printf
6246 (_("Seg Offset Type SymVec DataType\n"));
6247
6248 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6249 {
6250 unsigned int type;
6251 const char *rtype;
6252
6253 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6254 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6255 type = BYTE_GET (imfs [i].type);
6256 rtype = elf_ia64_reloc_type (type);
6257 if (rtype == NULL)
6258 printf (" 0x%08x ", type);
6259 else
6260 printf (" %-32s ", rtype);
6261 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6262 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6263 }
6264
6265 free (imfs);
6266}
6267
6268/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6269
6270static void
6271dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6272{
6273 Elf64_External_VMS_IMAGE_RELA *imrs;
6274 long i;
6275
6276 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6277 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 6278 _("dynamic section image relocations"));
28f997cf
TG		 6279 if (!imrs)
6280 return;
6281
6282 printf (_("\nImage relocs\n"));
6283 printf
6284 (_("Seg Offset Type Addend Seg Sym Off\n"));
6285
6286 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6287 {
6288 unsigned int type;
6289 const char *rtype;
6290
6291 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6292 printf ("%08" BFD_VMA_FMT "x ",
6293 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6294 type = BYTE_GET (imrs [i].type);
6295 rtype = elf_ia64_reloc_type (type);
6296 if (rtype == NULL)
6297 printf ("0x%08x ", type);
6298 else
6299 printf ("%-31s ", rtype);
6300 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6301 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6302 printf ("%08" BFD_VMA_FMT "x\n",
6303 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6304 }
6305
6306 free (imrs);
6307}
6308
6309/* Display IA-64 OpenVMS dynamic relocations and fixups. */
6310
6311static int
6312process_ia64_vms_dynamic_relocs (FILE *file)
6313{
6314 struct ia64_vms_dynfixup fixup;
6315 struct ia64_vms_dynimgrela imgrela;
6316 Elf_Internal_Dyn *entry;
6317 int res = 0;
6318 bfd_vma strtab_off = 0;
6319 bfd_vma strtab_sz = 0;
6320 char *strtab = NULL;
6321
6322 memset (&fixup, 0, sizeof (fixup));
6323 memset (&imgrela, 0, sizeof (imgrela));
6324
6325 /* Note: the order of the entries is specified by the OpenVMS specs. */
6326 for (entry = dynamic_section;
6327 entry < dynamic_section + dynamic_nent;
6328 entry++)
6329 {
6330 switch (entry->d_tag)
6331 {
6332 case DT_IA_64_VMS_STRTAB_OFFSET:
6333 strtab_off = entry->d_un.d_val;
6334 break;
6335 case DT_STRSZ:
6336 strtab_sz = entry->d_un.d_val;
6337 if (strtab == NULL)
6338 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6339 1, strtab_sz, _("dynamic string section"));
6340 break;
6341
6342 case DT_IA_64_VMS_NEEDED_IDENT:
6343 fixup.needed_ident = entry->d_un.d_val;
6344 break;
6345 case DT_NEEDED:
6346 fixup.needed = entry->d_un.d_val;
6347 break;
6348 case DT_IA_64_VMS_FIXUP_NEEDED:
6349 fixup.fixup_needed = entry->d_un.d_val;
6350 break;
6351 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6352 fixup.fixup_rela_cnt = entry->d_un.d_val;
6353 break;
6354 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6355 fixup.fixup_rela_off = entry->d_un.d_val;
6356 res++;
6357 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6358 break;
6359
6360 case DT_IA_64_VMS_IMG_RELA_CNT:
6361 imgrela.img_rela_cnt = entry->d_un.d_val;
6362 break;
6363 case DT_IA_64_VMS_IMG_RELA_OFF:
6364 imgrela.img_rela_off = entry->d_un.d_val;
6365 res++;
6366 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6367 break;
6368
6369 default:
6370 break;
6371 }
6372 }
6373
6374 if (strtab != NULL)
6375 free (strtab);
6376
6377 return res;
6378}
6379
85b1c36d 6380static struct
566b0d53 6381{
2cf0635d 6382 const char * name;
566b0d53
L		 6383 int reloc;
6384 int size;
6385 int rela;
6386} dynamic_relocations [] =
6387{
6388 { "REL", DT_REL, DT_RELSZ, FALSE },
6389 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6390 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6391};
6392
252b5132 6393/* Process the reloc section. */
18bd398b 6394
252b5132 6395static int
2cf0635d 6396process_relocs (FILE * file)
252b5132 6397{
b34976b6
AM		 6398 unsigned long rel_size;
6399 unsigned long rel_offset;
252b5132
RH		 6400
6401
6402 if (!do_reloc)
6403 return 1;
6404
6405 if (do_using_dynamic)
6406 {
566b0d53 6407 int is_rela;
2cf0635d 6408 const char * name;
566b0d53
L		 6409 int has_dynamic_reloc;
6410 unsigned int i;
0de14b54 6411
566b0d53 6412 has_dynamic_reloc = 0;
252b5132 6413
566b0d53 6414 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 6415 {
566b0d53
L		 6416 is_rela = dynamic_relocations [i].rela;
6417 name = dynamic_relocations [i].name;
6418 rel_size = dynamic_info [dynamic_relocations [i].size];
6419 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 6420
566b0d53
L		 6421 has_dynamic_reloc |= rel_size;
6422
6423 if (is_rela == UNKNOWN)
aa903cfb 6424 {
566b0d53
L		 6425 if (dynamic_relocations [i].reloc == DT_JMPREL)
6426 switch (dynamic_info[DT_PLTREL])
6427 {
6428 case DT_REL:
6429 is_rela = FALSE;
6430 break;
6431 case DT_RELA:
6432 is_rela = TRUE;
6433 break;
6434 }
aa903cfb 6435 }
252b5132 6436
566b0d53
L		 6437 if (rel_size)
6438 {
6439 printf
6440 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6441 name, rel_offset, rel_size);
252b5132 6442
d93f0186
NC		 6443 dump_relocations (file,
6444 offset_from_vma (file, rel_offset, rel_size),
6445 rel_size,
566b0d53 6446 dynamic_symbols, num_dynamic_syms,
bb4d2ac2
L		 6447 dynamic_strings, dynamic_strings_length,
6448 is_rela, 1);
566b0d53 6449 }
252b5132 6450 }
566b0d53 6451
28f997cf
TG		 6452 if (is_ia64_vms ())
6453 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6454
566b0d53 6455 if (! has_dynamic_reloc)
252b5132
RH		 6456 printf (_("\nThere are no dynamic relocations in this file.\n"));
6457 }
6458 else
6459 {
2cf0635d 6460 Elf_Internal_Shdr * section;
b34976b6
AM		 6461 unsigned long i;
6462 int found = 0;
252b5132
RH		 6463
6464 for (i = 0, section = section_headers;
6465 i < elf_header.e_shnum;
b34976b6 6466 i++, section++)
252b5132
RH		 6467 {
6468 if ( section->sh_type != SHT_RELA
6469 && section->sh_type != SHT_REL)
6470 continue;
6471
6472 rel_offset = section->sh_offset;
6473 rel_size = section->sh_size;
6474
6475 if (rel_size)
6476 {
2cf0635d 6477 Elf_Internal_Shdr * strsec;
b34976b6 6478 int is_rela;
103f02d3 6479
252b5132
RH		 6480 printf (_("\nRelocation section "));
6481
6482 if (string_table == NULL)
19936277 6483 printf ("%d", section->sh_name);
252b5132 6484 else
74e1a04b 6485 printf ("'%s'", printable_section_name (section));
252b5132
RH		 6486
6487 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6488 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6489
d79b3d50
NC		 6490 is_rela = section->sh_type == SHT_RELA;
6491
4fbb74a6
AM		 6492 if (section->sh_link != 0
6493 && section->sh_link < elf_header.e_shnum)
af3fc3bc 6494 {
2cf0635d
NC		 6495 Elf_Internal_Shdr * symsec;
6496 Elf_Internal_Sym * symtab;
d79b3d50 6497 unsigned long nsyms;
c256ffe7 6498 unsigned long strtablen = 0;
2cf0635d 6499 char * strtab = NULL;
57346661 6500
4fbb74a6 6501 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 6502 if (symsec->sh_type != SHT_SYMTAB
6503 && symsec->sh_type != SHT_DYNSYM)
6504 continue;
6505
ba5cdace 6506 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 6507
af3fc3bc
AM		 6508 if (symtab == NULL)
6509 continue;
252b5132 6510
4fbb74a6
AM		 6511 if (symsec->sh_link != 0
6512 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 6513 {
4fbb74a6 6514 strsec = section_headers + symsec->sh_link;
103f02d3 6515
3f5e193b 6516 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
071436c6
NC		 6517 1, strsec->sh_size,
6518 _("string table"));
c256ffe7
JJ		 6519 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6520 }
252b5132 6521
d79b3d50 6522 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2
L		 6523 symtab, nsyms, strtab, strtablen,
6524 is_rela,
6525 symsec->sh_type == SHT_DYNSYM);
d79b3d50
NC		 6526 if (strtab)
6527 free (strtab);
6528 free (symtab);
6529 }
6530 else
6531 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2 6532 NULL, 0, NULL, 0, is_rela, 0);
252b5132
RH		 6533
6534 found = 1;
6535 }
6536 }
6537
6538 if (! found)
6539 printf (_("\nThere are no relocations in this file.\n"));
6540 }
6541
6542 return 1;
6543}
6544
4d6ed7c8
NC		 6545/* An absolute address consists of a section and an offset. If the
6546 section is NULL, the offset itself is the address, otherwise, the
6547 address equals to LOAD_ADDRESS(section) + offset. */
6548
6549struct absaddr
948f632f
DA		 6550{
6551 unsigned short section;
6552 bfd_vma offset;
6553};
4d6ed7c8 6554
1949de15
L		 6555#define ABSADDR(a) \
6556 ((a).section \
6557 ? section_headers [(a).section].sh_addr + (a).offset \
6558 : (a).offset)
6559
948f632f
DA		 6560/* Find the nearest symbol at or below ADDR. Returns the symbol
6561 name, if found, and the offset from the symbol to ADDR. */
4d6ed7c8 6562
4d6ed7c8 6563static void
2cf0635d 6564find_symbol_for_address (Elf_Internal_Sym * symtab,
948f632f
DA		 6565 unsigned long nsyms,
6566 const char * strtab,
6567 unsigned long strtab_size,
6568 struct absaddr addr,
6569 const char ** symname,
6570 bfd_vma * offset)
4d6ed7c8 6571{
d3ba0551 6572 bfd_vma dist = 0x100000;
2cf0635d 6573 Elf_Internal_Sym * sym;
948f632f
DA		 6574 Elf_Internal_Sym * beg;
6575 Elf_Internal_Sym * end;
2cf0635d 6576 Elf_Internal_Sym * best = NULL;
4d6ed7c8 6577
0b6ae522 6578 REMOVE_ARCH_BITS (addr.offset);
948f632f
DA		 6579 beg = symtab;
6580 end = symtab + nsyms;
0b6ae522 6581
948f632f 6582 while (beg < end)
4d6ed7c8 6583 {
948f632f
DA		 6584 bfd_vma value;
6585
6586 sym = beg + (end - beg) / 2;
0b6ae522 6587
948f632f 6588 value = sym->st_value;
0b6ae522
DJ		 6589 REMOVE_ARCH_BITS (value);
6590
948f632f 6591 if (sym->st_name != 0
4d6ed7c8 6592 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 6593 && addr.offset >= value
6594 && addr.offset - value < dist)
4d6ed7c8
NC		 6595 {
6596 best = sym;
0b6ae522 6597 dist = addr.offset - value;
4d6ed7c8
NC		 6598 if (!dist)
6599 break;
6600 }
948f632f
DA		 6601
6602 if (addr.offset < value)
6603 end = sym;
6604 else
6605 beg = sym + 1;
4d6ed7c8 6606 }
1b31d05e 6607
4d6ed7c8
NC		 6608 if (best)
6609 {
57346661 6610 *symname = (best->st_name >= strtab_size
2b692964 6611 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 6612 *offset = dist;
6613 return;
6614 }
1b31d05e 6615
4d6ed7c8
NC		 6616 *symname = NULL;
6617 *offset = addr.offset;
6618}
6619
948f632f
DA		 6620static int
6621symcmp (const void *p, const void *q)
6622{
6623 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
6624 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
6625
6626 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
6627}
6628
6629/* Process the unwind section. */
6630
6631#include "unwind-ia64.h"
6632
6633struct ia64_unw_table_entry
6634{
6635 struct absaddr start;
6636 struct absaddr end;
6637 struct absaddr info;
6638};
6639
6640struct ia64_unw_aux_info
6641{
6642 struct ia64_unw_table_entry *table; /* Unwind table. */
6643 unsigned long table_len; /* Length of unwind table. */
6644 unsigned char * info; /* Unwind info. */
6645 unsigned long info_size; /* Size of unwind info. */
6646 bfd_vma info_addr; /* Starting address of unwind info. */
6647 bfd_vma seg_base; /* Starting address of segment. */
6648 Elf_Internal_Sym * symtab; /* The symbol table. */
6649 unsigned long nsyms; /* Number of symbols. */
6650 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
6651 unsigned long nfuns; /* Number of entries in funtab. */
6652 char * strtab; /* The string table. */
6653 unsigned long strtab_size; /* Size of string table. */
6654};
6655
4d6ed7c8 6656static void
2cf0635d 6657dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 6658{
2cf0635d 6659 struct ia64_unw_table_entry * tp;
948f632f 6660 unsigned long j, nfuns;
4d6ed7c8 6661 int in_body;
7036c0e1 6662
948f632f
DA		 6663 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
6664 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
6665 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
6666 aux->funtab[nfuns++] = aux->symtab[j];
6667 aux->nfuns = nfuns;
6668 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
6669
4d6ed7c8
NC		 6670 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6671 {
6672 bfd_vma stamp;
6673 bfd_vma offset;
2cf0635d
NC		 6674 const unsigned char * dp;
6675 const unsigned char * head;
53774b7e 6676 const unsigned char * end;
2cf0635d 6677 const char * procname;
4d6ed7c8 6678
948f632f 6679 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661 6680 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 6681
6682 fputs ("\n<", stdout);
6683
6684 if (procname)
6685 {
6686 fputs (procname, stdout);
6687
6688 if (offset)
6689 printf ("+%lx", (unsigned long) offset);
6690 }
6691
6692 fputs (">: [", stdout);
6693 print_vma (tp->start.offset, PREFIX_HEX);
6694 fputc ('-', stdout);
6695 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 6696 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 6697 (unsigned long) (tp->info.offset - aux->seg_base));
6698
53774b7e
NC		 6699 /* PR 17531: file: 86232b32. */
6700 if (aux->info == NULL)
6701 continue;
6702
6703 /* PR 17531: file: 0997b4d1. */
6704 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6705 {
6706 warn (_("Invalid offset %lx in table entry %ld\n"),
6707 (long) tp->info.offset, (long) (tp - aux->table));
6708 continue;
6709 }
6710
1949de15 6711 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 6712 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 6713
86f55779 6714 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 6715 (unsigned) UNW_VER (stamp),
6716 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6717 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6718 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 6719 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 6720
6721 if (UNW_VER (stamp) != 1)
6722 {
2b692964 6723 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 6724 continue;
6725 }
6726
6727 in_body = 0;
53774b7e
NC		 6728 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6729 /* PR 17531: file: 16ceda89. */
6730 if (end > aux->info + aux->info_size)
6731 end = aux->info + aux->info_size;
6732 for (dp = head + 8; dp < end;)
b4477bc8 6733 dp = unw_decode (dp, in_body, & in_body, end);
4d6ed7c8 6734 }
948f632f
DA		 6735
6736 free (aux->funtab);
4d6ed7c8
NC		 6737}
6738
53774b7e 6739static bfd_boolean
2cf0635d
NC		 6740slurp_ia64_unwind_table (FILE * file,
6741 struct ia64_unw_aux_info * aux,
6742 Elf_Internal_Shdr * sec)
4d6ed7c8 6743{
89fac5e3 6744 unsigned long size, nrelas, i;
2cf0635d
NC		 6745 Elf_Internal_Phdr * seg;
6746 struct ia64_unw_table_entry * tep;
6747 Elf_Internal_Shdr * relsec;
6748 Elf_Internal_Rela * rela;
6749 Elf_Internal_Rela * rp;
6750 unsigned char * table;
6751 unsigned char * tp;
6752 Elf_Internal_Sym * sym;
6753 const char * relname;
4d6ed7c8 6754
53774b7e
NC		 6755 aux->table_len = 0;
6756
4d6ed7c8
NC		 6757 /* First, find the starting address of the segment that includes
6758 this section: */
6759
6760 if (elf_header.e_phnum)
6761 {
d93f0186 6762 if (! get_program_headers (file))
53774b7e 6763 return FALSE;
4d6ed7c8 6764
d93f0186
NC		 6765 for (seg = program_headers;
6766 seg < program_headers + elf_header.e_phnum;
6767 ++seg)
4d6ed7c8
NC		 6768 {
6769 if (seg->p_type != PT_LOAD)
6770 continue;
6771
6772 if (sec->sh_addr >= seg->p_vaddr
6773 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6774 {
6775 aux->seg_base = seg->p_vaddr;
6776 break;
6777 }
6778 }
4d6ed7c8
NC		 6779 }
6780
6781 /* Second, build the unwind table from the contents of the unwind section: */
6782 size = sec->sh_size;
3f5e193b
NC		 6783 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6784 _("unwind table"));
a6e9f9df 6785 if (!table)
53774b7e 6786 return FALSE;
4d6ed7c8 6787
53774b7e 6788 aux->table_len = size / (3 * eh_addr_size);
3f5e193b 6789 aux->table = (struct ia64_unw_table_entry *)
53774b7e 6790 xcmalloc (aux->table_len, sizeof (aux->table[0]));
89fac5e3 6791 tep = aux->table;
53774b7e
NC		 6792
6793 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
4d6ed7c8
NC		 6794 {
6795 tep->start.section = SHN_UNDEF;
6796 tep->end.section = SHN_UNDEF;
6797 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 6798 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6799 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6800 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 6801 tep->start.offset += aux->seg_base;
6802 tep->end.offset += aux->seg_base;
6803 tep->info.offset += aux->seg_base;
6804 }
6805 free (table);
6806
41e92641 6807 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 6808 for (relsec = section_headers;
6809 relsec < section_headers + elf_header.e_shnum;
6810 ++relsec)
6811 {
6812 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6813 || relsec->sh_info >= elf_header.e_shnum
6814 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 6815 continue;
6816
6817 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6818 & rela, & nrelas))
53774b7e
NC		 6819 {
6820 free (aux->table);
6821 aux->table = NULL;
6822 aux->table_len = 0;
6823 return FALSE;
6824 }
4d6ed7c8
NC		 6825
6826 for (rp = rela; rp < rela + nrelas; ++rp)
6827 {
aca88567
NC		 6828 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6829 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 6830
82b1b41b
NC		 6831 /* PR 17531: file: 9fa67536. */
6832 if (relname == NULL)
6833 {
6834 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
6835 continue;
6836 }
948f632f 6837
0112cd26 6838 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 6839 {
82b1b41b 6840 warn (_("Skipping unexpected relocation type: %s\n"), relname);
4d6ed7c8
NC		 6841 continue;
6842 }
6843
89fac5e3 6844 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 6845
53774b7e
NC		 6846 /* PR 17531: file: 5bc8d9bf. */
6847 if (i >= aux->table_len)
6848 {
6849 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
6850 continue;
6851 }
6852
6853 switch (rp->r_offset / eh_addr_size % 3)
4d6ed7c8
NC		 6854 {
6855 case 0:
6856 aux->table[i].start.section = sym->st_shndx;
e466bc6e 6857 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6858 break;
6859 case 1:
6860 aux->table[i].end.section = sym->st_shndx;
e466bc6e 6861 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6862 break;
6863 case 2:
6864 aux->table[i].info.section = sym->st_shndx;
e466bc6e 6865 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6866 break;
6867 default:
6868 break;
6869 }
6870 }
6871
6872 free (rela);
6873 }
6874
53774b7e 6875 return TRUE;
4d6ed7c8
NC		 6876}
6877
1b31d05e 6878static void
2cf0635d 6879ia64_process_unwind (FILE * file)
4d6ed7c8 6880{
2cf0635d
NC		 6881 Elf_Internal_Shdr * sec;
6882 Elf_Internal_Shdr * unwsec = NULL;
6883 Elf_Internal_Shdr * strsec;
89fac5e3 6884 unsigned long i, unwcount = 0, unwstart = 0;
57346661 6885 struct ia64_unw_aux_info aux;
f1467e33 6886
4d6ed7c8
NC		 6887 memset (& aux, 0, sizeof (aux));
6888
4d6ed7c8
NC		 6889 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6890 {
c256ffe7 6891 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6892 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 6893 {
ba5cdace 6894 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 6895
4fbb74a6 6896 strsec = section_headers + sec->sh_link;
4082ef84
NC		 6897 if (aux.strtab != NULL)
6898 {
6899 error (_("Multiple auxillary string tables encountered\n"));
6900 free (aux.strtab);
6901 }
3f5e193b
NC		 6902 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6903 1, strsec->sh_size,
6904 _("string table"));
c256ffe7 6905 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 6906 }
6907 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 6908 unwcount++;
6909 }
6910
6911 if (!unwcount)
6912 printf (_("\nThere are no unwind sections in this file.\n"));
6913
6914 while (unwcount-- > 0)
6915 {
2cf0635d 6916 char * suffix;
579f31ac
JJ		 6917 size_t len, len2;
6918
4082ef84 6919 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
579f31ac
JJ		 6920 i < elf_header.e_shnum; ++i, ++sec)
6921 if (sec->sh_type == SHT_IA_64_UNWIND)
6922 {
6923 unwsec = sec;
6924 break;
6925 }
4082ef84
NC		 6926 /* We have already counted the number of SHT_IA64_UNWIND
6927 sections so the loop above should never fail. */
6928 assert (unwsec != NULL);
579f31ac
JJ		 6929
6930 unwstart = i + 1;
6931 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6932
e4b17d5c
L		 6933 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6934 {
6935 /* We need to find which section group it is in. */
4082ef84 6936 struct group_list * g;
e4b17d5c 6937
4082ef84
NC		 6938 if (section_headers_groups == NULL
6939 || section_headers_groups [i] == NULL)
6940 i = elf_header.e_shnum;
6941 else
e4b17d5c 6942 {
4082ef84 6943 g = section_headers_groups [i]->root;
18bd398b 6944
4082ef84
NC		 6945 for (; g != NULL; g = g->next)
6946 {
6947 sec = section_headers + g->section_index;
e4b17d5c 6948
4082ef84
NC		 6949 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6950 break;
6951 }
6952
6953 if (g == NULL)
6954 i = elf_header.e_shnum;
6955 }
e4b17d5c 6956 }
18bd398b 6957 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 6958 {
18bd398b 6959 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 6960 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6961 suffix = SECTION_NAME (unwsec) + len;
6962 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6963 ++i, ++sec)
18bd398b
NC		 6964 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6965 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6966 break;
6967 }
6968 else
6969 {
6970 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 6971 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 6972 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6973 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6974 suffix = "";
18bd398b 6975 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 6976 suffix = SECTION_NAME (unwsec) + len;
6977 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6978 ++i, ++sec)
18bd398b
NC		 6979 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6980 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6981 break;
6982 }
6983
6984 if (i == elf_header.e_shnum)
6985 {
6986 printf (_("\nCould not find unwind info section for "));
6987
6988 if (string_table == NULL)
6989 printf ("%d", unwsec->sh_name);
6990 else
74e1a04b 6991 printf ("'%s'", printable_section_name (unwsec));
579f31ac
JJ		 6992 }
6993 else
4d6ed7c8 6994 {
4d6ed7c8 6995 aux.info_addr = sec->sh_addr;
3f5e193b 6996 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
4082ef84
NC		 6997 sec->sh_size,
6998 _("unwind info"));
59245841 6999 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 7000
579f31ac 7001 printf (_("\nUnwind section "));
4d6ed7c8 7002
579f31ac
JJ		 7003 if (string_table == NULL)
7004 printf ("%d", unwsec->sh_name);
7005 else
74e1a04b 7006 printf ("'%s'", printable_section_name (unwsec));
4d6ed7c8 7007
579f31ac 7008 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 7009 (unsigned long) unwsec->sh_offset,
89fac5e3 7010 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 7011
53774b7e
NC		 7012 if (slurp_ia64_unwind_table (file, & aux, unwsec)
7013 && aux.table_len > 0)
579f31ac
JJ		 7014 dump_ia64_unwind (& aux);
7015
7016 if (aux.table)
7017 free ((char *) aux.table);
7018 if (aux.info)
7019 free ((char *) aux.info);
7020 aux.table = NULL;
7021 aux.info = NULL;
7022 }
4d6ed7c8 7023 }
4d6ed7c8 7024
4d6ed7c8
NC		 7025 if (aux.symtab)
7026 free (aux.symtab);
7027 if (aux.strtab)
7028 free ((char *) aux.strtab);
4d6ed7c8
NC		 7029}
7030
3f5e193b
NC		 7031struct hppa_unw_table_entry
7032 {
7033 struct absaddr start;
7034 struct absaddr end;
948f632f 7035 unsigned int Cannot_unwind:1; /* 0 */
3f5e193b
NC		 7036 unsigned int Millicode:1; /* 1 */
7037 unsigned int Millicode_save_sr0:1; /* 2 */
7038 unsigned int Region_description:2; /* 3..4 */
7039 unsigned int reserved1:1; /* 5 */
7040 unsigned int Entry_SR:1; /* 6 */
7041 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
7042 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
7043 unsigned int Args_stored:1; /* 16 */
948f632f
DA		 7044 unsigned int Variable_Frame:1; /* 17 */
7045 unsigned int Separate_Package_Body:1; /* 18 */
3f5e193b 7046 unsigned int Frame_Extension_Millicode:1; /* 19 */
948f632f
DA		 7047 unsigned int Stack_Overflow_Check:1; /* 20 */
7048 unsigned int Two_Instruction_SP_Increment:1;/* 21 */
3f5e193b
NC		 7049 unsigned int Ada_Region:1; /* 22 */
7050 unsigned int cxx_info:1; /* 23 */
948f632f
DA		 7051 unsigned int cxx_try_catch:1; /* 24 */
7052 unsigned int sched_entry_seq:1; /* 25 */
3f5e193b 7053 unsigned int reserved2:1; /* 26 */
948f632f
DA		 7054 unsigned int Save_SP:1; /* 27 */
7055 unsigned int Save_RP:1; /* 28 */
3f5e193b
NC		 7056 unsigned int Save_MRP_in_frame:1; /* 29 */
7057 unsigned int extn_ptr_defined:1; /* 30 */
948f632f 7058 unsigned int Cleanup_defined:1; /* 31 */
3f5e193b 7059
948f632f
DA		 7060 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7061 unsigned int HP_UX_interrupt_marker:1; /* 1 */
3f5e193b 7062 unsigned int Large_frame:1; /* 2 */
948f632f 7063 unsigned int Pseudo_SP_Set:1; /* 3 */
3f5e193b
NC		 7064 unsigned int reserved4:1; /* 4 */
7065 unsigned int Total_frame_size:27; /* 5..31 */
7066 };
7067
57346661 7068struct hppa_unw_aux_info
948f632f
DA		 7069{
7070 struct hppa_unw_table_entry * table; /* Unwind table. */
7071 unsigned long table_len; /* Length of unwind table. */
7072 bfd_vma seg_base; /* Starting address of segment. */
7073 Elf_Internal_Sym * symtab; /* The symbol table. */
7074 unsigned long nsyms; /* Number of symbols. */
7075 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7076 unsigned long nfuns; /* Number of entries in funtab. */
7077 char * strtab; /* The string table. */
7078 unsigned long strtab_size; /* Size of string table. */
7079};
57346661
AM		 7080
7081static void
2cf0635d 7082dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 7083{
2cf0635d 7084 struct hppa_unw_table_entry * tp;
948f632f
DA		 7085 unsigned long j, nfuns;
7086
7087 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7088 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7089 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7090 aux->funtab[nfuns++] = aux->symtab[j];
7091 aux->nfuns = nfuns;
7092 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
57346661 7093
57346661
AM		 7094 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7095 {
7096 bfd_vma offset;
2cf0635d 7097 const char * procname;
57346661 7098
948f632f 7099 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661
AM		 7100 aux->strtab_size, tp->start, &procname,
7101 &offset);
7102
7103 fputs ("\n<", stdout);
7104
7105 if (procname)
7106 {
7107 fputs (procname, stdout);
7108
7109 if (offset)
7110 printf ("+%lx", (unsigned long) offset);
7111 }
7112
7113 fputs (">: [", stdout);
7114 print_vma (tp->start.offset, PREFIX_HEX);
7115 fputc ('-', stdout);
7116 print_vma (tp->end.offset, PREFIX_HEX);
7117 printf ("]\n\t");
7118
18bd398b
NC		 7119#define PF(_m) if (tp->_m) printf (#_m " ");
7120#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 7121 PF(Cannot_unwind);
7122 PF(Millicode);
7123 PF(Millicode_save_sr0);
18bd398b 7124 /* PV(Region_description); */
57346661
AM		 7125 PF(Entry_SR);
7126 PV(Entry_FR);
7127 PV(Entry_GR);
7128 PF(Args_stored);
7129 PF(Variable_Frame);
7130 PF(Separate_Package_Body);
7131 PF(Frame_Extension_Millicode);
7132 PF(Stack_Overflow_Check);
7133 PF(Two_Instruction_SP_Increment);
7134 PF(Ada_Region);
7135 PF(cxx_info);
7136 PF(cxx_try_catch);
7137 PF(sched_entry_seq);
7138 PF(Save_SP);
7139 PF(Save_RP);
7140 PF(Save_MRP_in_frame);
7141 PF(extn_ptr_defined);
7142 PF(Cleanup_defined);
7143 PF(MPE_XL_interrupt_marker);
7144 PF(HP_UX_interrupt_marker);
7145 PF(Large_frame);
7146 PF(Pseudo_SP_Set);
7147 PV(Total_frame_size);
7148#undef PF
7149#undef PV
7150 }
7151
18bd398b 7152 printf ("\n");
948f632f
DA		 7153
7154 free (aux->funtab);
57346661
AM		 7155}
7156
7157static int
2cf0635d
NC		 7158slurp_hppa_unwind_table (FILE * file,
7159 struct hppa_unw_aux_info * aux,
7160 Elf_Internal_Shdr * sec)
57346661 7161{
1c0751b2 7162 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 7163 Elf_Internal_Phdr * seg;
7164 struct hppa_unw_table_entry * tep;
7165 Elf_Internal_Shdr * relsec;
7166 Elf_Internal_Rela * rela;
7167 Elf_Internal_Rela * rp;
7168 unsigned char * table;
7169 unsigned char * tp;
7170 Elf_Internal_Sym * sym;
7171 const char * relname;
57346661 7172
57346661
AM		 7173 /* First, find the starting address of the segment that includes
7174 this section. */
7175
7176 if (elf_header.e_phnum)
7177 {
7178 if (! get_program_headers (file))
7179 return 0;
7180
7181 for (seg = program_headers;
7182 seg < program_headers + elf_header.e_phnum;
7183 ++seg)
7184 {
7185 if (seg->p_type != PT_LOAD)
7186 continue;
7187
7188 if (sec->sh_addr >= seg->p_vaddr
7189 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7190 {
7191 aux->seg_base = seg->p_vaddr;
7192 break;
7193 }
7194 }
7195 }
7196
7197 /* Second, build the unwind table from the contents of the unwind
7198 section. */
7199 size = sec->sh_size;
3f5e193b
NC		 7200 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7201 _("unwind table"));
57346661
AM		 7202 if (!table)
7203 return 0;
7204
1c0751b2
DA		 7205 unw_ent_size = 16;
7206 nentries = size / unw_ent_size;
7207 size = unw_ent_size * nentries;
57346661 7208
3f5e193b
NC		 7209 tep = aux->table = (struct hppa_unw_table_entry *)
7210 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 7211
1c0751b2 7212 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 7213 {
7214 unsigned int tmp1, tmp2;
7215
7216 tep->start.section = SHN_UNDEF;
7217 tep->end.section = SHN_UNDEF;
7218
1c0751b2
DA		 7219 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7220 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7221 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7222 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7223
7224 tep->start.offset += aux->seg_base;
7225 tep->end.offset += aux->seg_base;
57346661
AM		 7226
7227 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7228 tep->Millicode = (tmp1 >> 30) & 0x1;
7229 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7230 tep->Region_description = (tmp1 >> 27) & 0x3;
7231 tep->reserved1 = (tmp1 >> 26) & 0x1;
7232 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7233 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7234 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7235 tep->Args_stored = (tmp1 >> 15) & 0x1;
7236 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7237 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7238 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7239 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7240 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7241 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7242 tep->cxx_info = (tmp1 >> 8) & 0x1;
7243 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7244 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7245 tep->reserved2 = (tmp1 >> 5) & 0x1;
7246 tep->Save_SP = (tmp1 >> 4) & 0x1;
7247 tep->Save_RP = (tmp1 >> 3) & 0x1;
7248 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7249 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7250 tep->Cleanup_defined = tmp1 & 0x1;
7251
7252 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7253 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7254 tep->Large_frame = (tmp2 >> 29) & 0x1;
7255 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7256 tep->reserved4 = (tmp2 >> 27) & 0x1;
7257 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 7258 }
7259 free (table);
7260
7261 /* Third, apply any relocations to the unwind table. */
57346661
AM		 7262 for (relsec = section_headers;
7263 relsec < section_headers + elf_header.e_shnum;
7264 ++relsec)
7265 {
7266 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7267 || relsec->sh_info >= elf_header.e_shnum
7268 || section_headers + relsec->sh_info != sec)
57346661
AM		 7269 continue;
7270
7271 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7272 & rela, & nrelas))
7273 return 0;
7274
7275 for (rp = rela; rp < rela + nrelas; ++rp)
7276 {
aca88567
NC		 7277 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7278 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 7279
7280 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 7281 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 7282 {
7283 warn (_("Skipping unexpected relocation type %s\n"), relname);
7284 continue;
7285 }
7286
7287 i = rp->r_offset / unw_ent_size;
7288
89fac5e3 7289 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 7290 {
7291 case 0:
7292 aux->table[i].start.section = sym->st_shndx;
1e456d54 7293 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 7294 break;
7295 case 1:
7296 aux->table[i].end.section = sym->st_shndx;
1e456d54 7297 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 7298 break;
7299 default:
7300 break;
7301 }
7302 }
7303
7304 free (rela);
7305 }
7306
1c0751b2 7307 aux->table_len = nentries;
57346661
AM		 7308
7309 return 1;
7310}
7311
1b31d05e 7312static void
2cf0635d 7313hppa_process_unwind (FILE * file)
57346661 7314{
57346661 7315 struct hppa_unw_aux_info aux;
2cf0635d
NC		 7316 Elf_Internal_Shdr * unwsec = NULL;
7317 Elf_Internal_Shdr * strsec;
7318 Elf_Internal_Shdr * sec;
18bd398b 7319 unsigned long i;
57346661 7320
c256ffe7 7321 if (string_table == NULL)
1b31d05e
NC		 7322 return;
7323
7324 memset (& aux, 0, sizeof (aux));
57346661
AM		 7325
7326 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7327 {
c256ffe7 7328 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7329 && sec->sh_link < elf_header.e_shnum)
57346661 7330 {
ba5cdace 7331 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 7332
4fbb74a6 7333 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7334 if (aux.strtab != NULL)
7335 {
7336 error (_("Multiple auxillary string tables encountered\n"));
7337 free (aux.strtab);
7338 }
3f5e193b
NC		 7339 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7340 1, strsec->sh_size,
7341 _("string table"));
c256ffe7 7342 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 7343 }
18bd398b 7344 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 7345 unwsec = sec;
7346 }
7347
7348 if (!unwsec)
7349 printf (_("\nThere are no unwind sections in this file.\n"));
7350
7351 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7352 {
18bd398b 7353 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 7354 {
74e1a04b
NC		 7355 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7356 printable_section_name (sec),
57346661 7357 (unsigned long) sec->sh_offset,
89fac5e3 7358 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 7359
7360 slurp_hppa_unwind_table (file, &aux, sec);
7361 if (aux.table_len > 0)
7362 dump_hppa_unwind (&aux);
7363
7364 if (aux.table)
7365 free ((char *) aux.table);
7366 aux.table = NULL;
7367 }
7368 }
7369
7370 if (aux.symtab)
7371 free (aux.symtab);
7372 if (aux.strtab)
7373 free ((char *) aux.strtab);
57346661
AM		 7374}
7375
0b6ae522
DJ		 7376struct arm_section
7377{
a734115a
NC		 7378 unsigned char * data; /* The unwind data. */
7379 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7380 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7381 unsigned long nrelas; /* The number of relocations. */
7382 unsigned int rel_type; /* REL or RELA ? */
7383 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 7384};
7385
7386struct arm_unw_aux_info
7387{
a734115a
NC		 7388 FILE * file; /* The file containing the unwind sections. */
7389 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7390 unsigned long nsyms; /* Number of symbols. */
948f632f
DA		 7391 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7392 unsigned long nfuns; /* Number of these symbols. */
a734115a
NC		 7393 char * strtab; /* The file's string table. */
7394 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 7395};
7396
7397static const char *
7398arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7399 bfd_vma fn, struct absaddr addr)
7400{
7401 const char *procname;
7402 bfd_vma sym_offset;
7403
7404 if (addr.section == SHN_UNDEF)
7405 addr.offset = fn;
7406
948f632f 7407 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
0b6ae522
DJ		 7408 aux->strtab_size, addr, &procname,
7409 &sym_offset);
7410
7411 print_vma (fn, PREFIX_HEX);
7412
7413 if (procname)
7414 {
7415 fputs (" <", stdout);
7416 fputs (procname, stdout);
7417
7418 if (sym_offset)
7419 printf ("+0x%lx", (unsigned long) sym_offset);
7420 fputc ('>', stdout);
7421 }
7422
7423 return procname;
7424}
7425
7426static void
7427arm_free_section (struct arm_section *arm_sec)
7428{
7429 if (arm_sec->data != NULL)
7430 free (arm_sec->data);
7431
7432 if (arm_sec->rela != NULL)
7433 free (arm_sec->rela);
7434}
7435
a734115a
NC		 7436/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7437 cached section and install SEC instead.
7438 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7439 and return its valued in * WORDP, relocating if necessary.
1b31d05e 7440 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 7441 relocation's offset in ADDR.
1b31d05e
NC		 7442 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7443 into the string table of the symbol associated with the reloc. If no
7444 reloc was applied store -1 there.
7445 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 7446
7447static bfd_boolean
1b31d05e
NC		 7448get_unwind_section_word (struct arm_unw_aux_info * aux,
7449 struct arm_section * arm_sec,
7450 Elf_Internal_Shdr * sec,
7451 bfd_vma word_offset,
7452 unsigned int * wordp,
7453 struct absaddr * addr,
7454 bfd_vma * sym_name)
0b6ae522
DJ		 7455{
7456 Elf_Internal_Rela *rp;
7457 Elf_Internal_Sym *sym;
7458 const char * relname;
7459 unsigned int word;
7460 bfd_boolean wrapped;
7461
e0a31db1
NC		 7462 if (sec == NULL || arm_sec == NULL)
7463 return FALSE;
7464
0b6ae522
DJ		 7465 addr->section = SHN_UNDEF;
7466 addr->offset = 0;
7467
1b31d05e
NC		 7468 if (sym_name != NULL)
7469 *sym_name = (bfd_vma) -1;
7470
a734115a 7471 /* If necessary, update the section cache. */
0b6ae522
DJ		 7472 if (sec != arm_sec->sec)
7473 {
7474 Elf_Internal_Shdr *relsec;
7475
7476 arm_free_section (arm_sec);
7477
7478 arm_sec->sec = sec;
7479 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7480 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 7481 arm_sec->rela = NULL;
7482 arm_sec->nrelas = 0;
7483
7484 for (relsec = section_headers;
7485 relsec < section_headers + elf_header.e_shnum;
7486 ++relsec)
7487 {
7488 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 7489 || section_headers + relsec->sh_info != sec
7490 /* PR 15745: Check the section type as well. */
7491 || (relsec->sh_type != SHT_REL
7492 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 7493 continue;
7494
a734115a 7495 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 7496 if (relsec->sh_type == SHT_REL)
7497 {
7498 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7499 relsec->sh_size,
7500 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7501 return FALSE;
0b6ae522 7502 }
1ae40aa4 7503 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 7504 {
7505 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7506 relsec->sh_size,
7507 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7508 return FALSE;
0b6ae522 7509 }
1ae40aa4 7510 break;
0b6ae522
DJ		 7511 }
7512
7513 arm_sec->next_rela = arm_sec->rela;
7514 }
7515
a734115a 7516 /* If there is no unwind data we can do nothing. */
0b6ae522 7517 if (arm_sec->data == NULL)
a734115a 7518 return FALSE;
0b6ae522 7519
e0a31db1
NC		 7520 /* If the offset is invalid then fail. */
7521 if (word_offset > sec->sh_size - 4)
7522 return FALSE;
7523
a734115a 7524 /* Get the word at the required offset. */
0b6ae522
DJ		 7525 word = byte_get (arm_sec->data + word_offset, 4);
7526
0eff7165
NC		 7527 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7528 if (arm_sec->rela == NULL)
7529 {
7530 * wordp = word;
7531 return TRUE;
7532 }
7533
a734115a 7534 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 7535 wrapped = FALSE;
7536 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7537 {
7538 bfd_vma prelval, offset;
7539
7540 if (rp->r_offset > word_offset && !wrapped)
7541 {
7542 rp = arm_sec->rela;
7543 wrapped = TRUE;
7544 }
7545 if (rp->r_offset > word_offset)
7546 break;
7547
7548 if (rp->r_offset & 3)
7549 {
7550 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7551 (unsigned long) rp->r_offset);
7552 continue;
7553 }
7554
7555 if (rp->r_offset < word_offset)
7556 continue;
7557
74e1a04b
NC		 7558 /* PR 17531: file: 027-161405-0.004 */
7559 if (aux->symtab == NULL)
7560 continue;
7561
0b6ae522
DJ		 7562 if (arm_sec->rel_type == SHT_REL)
7563 {
7564 offset = word & 0x7fffffff;
7565 if (offset & 0x40000000)
7566 offset |= ~ (bfd_vma) 0x7fffffff;
7567 }
a734115a 7568 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 7569 offset = rp->r_addend;
a734115a 7570 else
74e1a04b
NC		 7571 {
7572 error (_("Unknown section relocation type %d encountered\n"),
7573 arm_sec->rel_type);
7574 break;
7575 }
0b6ae522 7576
071436c6
NC		 7577 /* PR 17531 file: 027-1241568-0.004. */
7578 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7579 {
7580 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7581 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7582 break;
7583 }
7584
7585 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
0b6ae522
DJ		 7586 offset += sym->st_value;
7587 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7588
a734115a
NC		 7589 /* Check that we are processing the expected reloc type. */
7590 if (elf_header.e_machine == EM_ARM)
7591 {
7592 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7593 if (relname == NULL)
7594 {
7595 warn (_("Skipping unknown ARM relocation type: %d\n"),
7596 (int) ELF32_R_TYPE (rp->r_info));
7597 continue;
7598 }
a734115a
NC		 7599
7600 if (streq (relname, "R_ARM_NONE"))
7601 continue;
0b4362b0 7602
a734115a
NC		 7603 if (! streq (relname, "R_ARM_PREL31"))
7604 {
071436c6 7605 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
a734115a
NC		 7606 continue;
7607 }
7608 }
7609 else if (elf_header.e_machine == EM_TI_C6000)
7610 {
7611 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7612 if (relname == NULL)
7613 {
7614 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7615 (int) ELF32_R_TYPE (rp->r_info));
7616 continue;
7617 }
0b4362b0 7618
a734115a
NC		 7619 if (streq (relname, "R_C6000_NONE"))
7620 continue;
7621
7622 if (! streq (relname, "R_C6000_PREL31"))
7623 {
071436c6 7624 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
a734115a
NC		 7625 continue;
7626 }
7627
7628 prelval >>= 1;
7629 }
7630 else
74e1a04b
NC		 7631 {
7632 /* This function currently only supports ARM and TI unwinders. */
7633 warn (_("Only TI and ARM unwinders are currently supported\n"));
7634 break;
7635 }
fa197c1c 7636
0b6ae522
DJ		 7637 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7638 addr->section = sym->st_shndx;
7639 addr->offset = offset;
74e1a04b 7640
1b31d05e
NC		 7641 if (sym_name)
7642 * sym_name = sym->st_name;
0b6ae522
DJ		 7643 break;
7644 }
7645
7646 *wordp = word;
7647 arm_sec->next_rela = rp;
7648
a734115a 7649 return TRUE;
0b6ae522
DJ		 7650}
7651
a734115a
NC		 7652static const char *tic6x_unwind_regnames[16] =
7653{
0b4362b0
RM		 7654 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7655 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 7656 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7657};
fa197c1c 7658
0b6ae522 7659static void
fa197c1c 7660decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 7661{
fa197c1c
PB		 7662 int i;
7663
7664 for (i = 12; mask; mask >>= 1, i--)
7665 {
7666 if (mask & 1)
7667 {
7668 fputs (tic6x_unwind_regnames[i], stdout);
7669 if (mask > 1)
7670 fputs (", ", stdout);
7671 }
7672 }
7673}
0b6ae522
DJ		 7674
7675#define ADVANCE \
7676 if (remaining == 0 && more_words) \
7677 { \
7678 data_offset += 4; \
1b31d05e
NC		 7679 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7680 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 7681 return; \
7682 remaining = 4; \
7683 more_words--; \
7684 } \
7685
7686#define GET_OP(OP) \
7687 ADVANCE; \
7688 if (remaining) \
7689 { \
7690 remaining--; \
7691 (OP) = word >> 24; \
7692 word <<= 8; \
7693 } \
7694 else \
7695 { \
2b692964 7696 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 7697 return; \
7698 } \
cc5914eb 7699 printf ("0x%02x ", OP)
0b6ae522 7700
fa197c1c 7701static void
948f632f
DA		 7702decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
7703 unsigned int word,
7704 unsigned int remaining,
7705 unsigned int more_words,
7706 bfd_vma data_offset,
7707 Elf_Internal_Shdr * data_sec,
7708 struct arm_section * data_arm_sec)
fa197c1c
PB		 7709{
7710 struct absaddr addr;
0b6ae522
DJ		 7711
7712 /* Decode the unwinding instructions. */
7713 while (1)
7714 {
7715 unsigned int op, op2;
7716
7717 ADVANCE;
7718 if (remaining == 0)
7719 break;
7720 remaining--;
7721 op = word >> 24;
7722 word <<= 8;
7723
cc5914eb 7724 printf (" 0x%02x ", op);
0b6ae522
DJ		 7725
7726 if ((op & 0xc0) == 0x00)
7727 {
7728 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7729
cc5914eb 7730 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 7731 }
7732 else if ((op & 0xc0) == 0x40)
7733 {
7734 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7735
cc5914eb 7736 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 7737 }
7738 else if ((op & 0xf0) == 0x80)
7739 {
7740 GET_OP (op2);
7741 if (op == 0x80 && op2 == 0)
7742 printf (_("Refuse to unwind"));
7743 else
7744 {
7745 unsigned int mask = ((op & 0x0f) << 8) | op2;
7746 int first = 1;
7747 int i;
2b692964 7748
0b6ae522
DJ		 7749 printf ("pop {");
7750 for (i = 0; i < 12; i++)
7751 if (mask & (1 << i))
7752 {
7753 if (first)
7754 first = 0;
7755 else
7756 printf (", ");
7757 printf ("r%d", 4 + i);
7758 }
7759 printf ("}");
7760 }
7761 }
7762 else if ((op & 0xf0) == 0x90)
7763 {
7764 if (op == 0x9d || op == 0x9f)
7765 printf (_(" [Reserved]"));
7766 else
cc5914eb 7767 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 7768 }
7769 else if ((op & 0xf0) == 0xa0)
7770 {
7771 int end = 4 + (op & 0x07);
7772 int first = 1;
7773 int i;
61865e30 7774
0b6ae522
DJ		 7775 printf (" pop {");
7776 for (i = 4; i <= end; i++)
7777 {
7778 if (first)
7779 first = 0;
7780 else
7781 printf (", ");
7782 printf ("r%d", i);
7783 }
7784 if (op & 0x08)
7785 {
1b31d05e 7786 if (!first)
0b6ae522
DJ		 7787 printf (", ");
7788 printf ("r14");
7789 }
7790 printf ("}");
7791 }
7792 else if (op == 0xb0)
7793 printf (_(" finish"));
7794 else if (op == 0xb1)
7795 {
7796 GET_OP (op2);
7797 if (op2 == 0 || (op2 & 0xf0) != 0)
7798 printf (_("[Spare]"));
7799 else
7800 {
7801 unsigned int mask = op2 & 0x0f;
7802 int first = 1;
7803 int i;
61865e30 7804
0b6ae522
DJ		 7805 printf ("pop {");
7806 for (i = 0; i < 12; i++)
7807 if (mask & (1 << i))
7808 {
7809 if (first)
7810 first = 0;
7811 else
7812 printf (", ");
7813 printf ("r%d", i);
7814 }
7815 printf ("}");
7816 }
7817 }
7818 else if (op == 0xb2)
7819 {
b115cf96 7820 unsigned char buf[9];
0b6ae522
DJ		 7821 unsigned int i, len;
7822 unsigned long offset;
61865e30 7823
b115cf96 7824 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 7825 {
7826 GET_OP (buf[i]);
7827 if ((buf[i] & 0x80) == 0)
7828 break;
7829 }
4082ef84
NC		 7830 if (i == sizeof (buf))
7831 printf (_("corrupt change to vsp"));
7832 else
7833 {
7834 offset = read_uleb128 (buf, &len, buf + i + 1);
7835 assert (len == i + 1);
7836 offset = offset * 4 + 0x204;
7837 printf ("vsp = vsp + %ld", offset);
7838 }
0b6ae522 7839 }
61865e30 7840 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 7841 {
61865e30
NC		 7842 unsigned int first, last;
7843
7844 GET_OP (op2);
7845 first = op2 >> 4;
7846 last = op2 & 0x0f;
7847 if (op == 0xc8)
7848 first = first + 16;
7849 printf ("pop {D%d", first);
7850 if (last)
7851 printf ("-D%d", first + last);
7852 printf ("}");
7853 }
7854 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7855 {
7856 unsigned int count = op & 0x07;
7857
7858 printf ("pop {D8");
7859 if (count)
7860 printf ("-D%d", 8 + count);
7861 printf ("}");
7862 }
7863 else if (op >= 0xc0 && op <= 0xc5)
7864 {
7865 unsigned int count = op & 0x07;
7866
7867 printf (" pop {wR10");
7868 if (count)
7869 printf ("-wR%d", 10 + count);
7870 printf ("}");
7871 }
7872 else if (op == 0xc6)
7873 {
7874 unsigned int first, last;
7875
7876 GET_OP (op2);
7877 first = op2 >> 4;
7878 last = op2 & 0x0f;
7879 printf ("pop {wR%d", first);
7880 if (last)
7881 printf ("-wR%d", first + last);
7882 printf ("}");
7883 }
7884 else if (op == 0xc7)
7885 {
7886 GET_OP (op2);
7887 if (op2 == 0 || (op2 & 0xf0) != 0)
7888 printf (_("[Spare]"));
0b6ae522
DJ		 7889 else
7890 {
61865e30
NC		 7891 unsigned int mask = op2 & 0x0f;
7892 int first = 1;
7893 int i;
7894
7895 printf ("pop {");
7896 for (i = 0; i < 4; i++)
7897 if (mask & (1 << i))
7898 {
7899 if (first)
7900 first = 0;
7901 else
7902 printf (", ");
7903 printf ("wCGR%d", i);
7904 }
7905 printf ("}");
0b6ae522
DJ		 7906 }
7907 }
61865e30
NC		 7908 else
7909 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 7910 printf ("\n");
7911 }
fa197c1c
PB		 7912}
7913
7914static void
948f632f
DA		 7915decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
7916 unsigned int word,
7917 unsigned int remaining,
7918 unsigned int more_words,
7919 bfd_vma data_offset,
7920 Elf_Internal_Shdr * data_sec,
7921 struct arm_section * data_arm_sec)
fa197c1c
PB		 7922{
7923 struct absaddr addr;
7924
7925 /* Decode the unwinding instructions. */
7926 while (1)
7927 {
7928 unsigned int op, op2;
7929
7930 ADVANCE;
7931 if (remaining == 0)
7932 break;
7933 remaining--;
7934 op = word >> 24;
7935 word <<= 8;
7936
9cf03b7e 7937 printf (" 0x%02x ", op);
fa197c1c
PB		 7938
7939 if ((op & 0xc0) == 0x00)
7940 {
7941 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 7942 printf (" sp = sp + %d", offset);
fa197c1c
PB		 7943 }
7944 else if ((op & 0xc0) == 0x80)
7945 {
7946 GET_OP (op2);
7947 if (op == 0x80 && op2 == 0)
7948 printf (_("Refuse to unwind"));
7949 else
7950 {
7951 unsigned int mask = ((op & 0x1f) << 8) | op2;
7952 if (op & 0x20)
7953 printf ("pop compact {");
7954 else
7955 printf ("pop {");
7956
7957 decode_tic6x_unwind_regmask (mask);
7958 printf("}");
7959 }
7960 }
7961 else if ((op & 0xf0) == 0xc0)
7962 {
7963 unsigned int reg;
7964 unsigned int nregs;
7965 unsigned int i;
7966 const char *name;
a734115a
NC		 7967 struct
7968 {
fa197c1c
PB		 7969 unsigned int offset;
7970 unsigned int reg;
7971 } regpos[16];
7972
7973 /* Scan entire instruction first so that GET_OP output is not
7974 interleaved with disassembly. */
7975 nregs = 0;
7976 for (i = 0; nregs < (op & 0xf); i++)
7977 {
7978 GET_OP (op2);
7979 reg = op2 >> 4;
7980 if (reg != 0xf)
7981 {
7982 regpos[nregs].offset = i * 2;
7983 regpos[nregs].reg = reg;
7984 nregs++;
7985 }
7986
7987 reg = op2 & 0xf;
7988 if (reg != 0xf)
7989 {
7990 regpos[nregs].offset = i * 2 + 1;
7991 regpos[nregs].reg = reg;
7992 nregs++;
7993 }
7994 }
7995
7996 printf (_("pop frame {"));
7997 reg = nregs - 1;
7998 for (i = i * 2; i > 0; i--)
7999 {
8000 if (regpos[reg].offset == i - 1)
8001 {
8002 name = tic6x_unwind_regnames[regpos[reg].reg];
8003 if (reg > 0)
8004 reg--;
8005 }
8006 else
8007 name = _("[pad]");
8008
8009 fputs (name, stdout);
8010 if (i > 1)
8011 printf (", ");
8012 }
8013
8014 printf ("}");
8015 }
8016 else if (op == 0xd0)
8017 printf (" MOV FP, SP");
8018 else if (op == 0xd1)
8019 printf (" __c6xabi_pop_rts");
8020 else if (op == 0xd2)
8021 {
8022 unsigned char buf[9];
8023 unsigned int i, len;
8024 unsigned long offset;
a734115a 8025
fa197c1c
PB		 8026 for (i = 0; i < sizeof (buf); i++)
8027 {
8028 GET_OP (buf[i]);
8029 if ((buf[i] & 0x80) == 0)
8030 break;
8031 }
0eff7165
NC		 8032 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8033 if (i == sizeof (buf))
8034 {
8035 printf ("<corrupt sp adjust>\n");
8036 warn (_("Corrupt stack pointer adjustment detected\n"));
8037 return;
8038 }
948f632f 8039
f6f0e17b 8040 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 8041 assert (len == i + 1);
8042 offset = offset * 8 + 0x408;
8043 printf (_("sp = sp + %ld"), offset);
8044 }
8045 else if ((op & 0xf0) == 0xe0)
8046 {
8047 if ((op & 0x0f) == 7)
8048 printf (" RETURN");
8049 else
8050 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8051 }
8052 else
8053 {
8054 printf (_(" [unsupported opcode]"));
8055 }
8056 putchar ('\n');
8057 }
8058}
8059
8060static bfd_vma
a734115a 8061arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 8062{
8063 bfd_vma offset;
8064
8065 offset = word & 0x7fffffff;
8066 if (offset & 0x40000000)
8067 offset |= ~ (bfd_vma) 0x7fffffff;
8068
8069 if (elf_header.e_machine == EM_TI_C6000)
8070 offset <<= 1;
8071
8072 return offset + where;
8073}
8074
8075static void
1b31d05e
NC		 8076decode_arm_unwind (struct arm_unw_aux_info * aux,
8077 unsigned int word,
8078 unsigned int remaining,
8079 bfd_vma data_offset,
8080 Elf_Internal_Shdr * data_sec,
8081 struct arm_section * data_arm_sec)
fa197c1c
PB		 8082{
8083 int per_index;
8084 unsigned int more_words = 0;
37e14bc3 8085 struct absaddr addr;
1b31d05e 8086 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 8087
8088 if (remaining == 0)
8089 {
1b31d05e
NC		 8090 /* Fetch the first word.
8091 Note - when decoding an object file the address extracted
8092 here will always be 0. So we also pass in the sym_name
8093 parameter so that we can find the symbol associated with
8094 the personality routine. */
8095 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8096 & word, & addr, & sym_name))
fa197c1c 8097 return;
1b31d05e 8098
fa197c1c
PB		 8099 remaining = 4;
8100 }
8101
8102 if ((word & 0x80000000) == 0)
8103 {
8104 /* Expand prel31 for personality routine. */
8105 bfd_vma fn;
8106 const char *procname;
8107
a734115a 8108 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 8109 printf (_(" Personality routine: "));
1b31d05e
NC		 8110 if (fn == 0
8111 && addr.section == SHN_UNDEF && addr.offset == 0
8112 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8113 {
8114 procname = aux->strtab + sym_name;
8115 print_vma (fn, PREFIX_HEX);
8116 if (procname)
8117 {
8118 fputs (" <", stdout);
8119 fputs (procname, stdout);
8120 fputc ('>', stdout);
8121 }
8122 }
8123 else
8124 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 8125 fputc ('\n', stdout);
8126
8127 /* The GCC personality routines use the standard compact
8128 encoding, starting with one byte giving the number of
8129 words. */
8130 if (procname != NULL
8131 && (const_strneq (procname, "__gcc_personality_v0")
8132 || const_strneq (procname, "__gxx_personality_v0")
8133 || const_strneq (procname, "__gcj_personality_v0")
8134 || const_strneq (procname, "__gnu_objc_personality_v0")))
8135 {
8136 remaining = 0;
8137 more_words = 1;
8138 ADVANCE;
8139 if (!remaining)
8140 {
8141 printf (_(" [Truncated data]\n"));
8142 return;
8143 }
8144 more_words = word >> 24;
8145 word <<= 8;
8146 remaining--;
8147 per_index = -1;
8148 }
8149 else
8150 return;
8151 }
8152 else
8153 {
1b31d05e 8154 /* ARM EHABI Section 6.3:
0b4362b0 8155
1b31d05e 8156 An exception-handling table entry for the compact model looks like:
0b4362b0 8157
1b31d05e
NC		 8158 31 30-28 27-24 23-0
8159 -- ----- ----- ----
8160 1 0 index Data for personalityRoutine[index] */
8161
8162 if (elf_header.e_machine == EM_ARM
8163 && (word & 0x70000000))
83c257ca 8164 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 8165
fa197c1c 8166 per_index = (word >> 24) & 0x7f;
1b31d05e 8167 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 8168 if (per_index == 0)
8169 {
8170 more_words = 0;
8171 word <<= 8;
8172 remaining--;
8173 }
8174 else if (per_index < 3)
8175 {
8176 more_words = (word >> 16) & 0xff;
8177 word <<= 16;
8178 remaining -= 2;
8179 }
8180 }
8181
8182 switch (elf_header.e_machine)
8183 {
8184 case EM_ARM:
8185 if (per_index < 3)
8186 {
8187 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8188 data_offset, data_sec, data_arm_sec);
8189 }
8190 else
1b31d05e
NC		 8191 {
8192 warn (_("Unknown ARM compact model index encountered\n"));
8193 printf (_(" [reserved]\n"));
8194 }
fa197c1c
PB		 8195 break;
8196
8197 case EM_TI_C6000:
8198 if (per_index < 3)
8199 {
8200 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 8201 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 8202 }
8203 else if (per_index < 5)
8204 {
8205 if (((word >> 17) & 0x7f) == 0x7f)
8206 printf (_(" Restore stack from frame pointer\n"));
8207 else
8208 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8209 printf (_(" Registers restored: "));
8210 if (per_index == 4)
8211 printf (" (compact) ");
8212 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8213 putchar ('\n');
8214 printf (_(" Return register: %s\n"),
8215 tic6x_unwind_regnames[word & 0xf]);
8216 }
8217 else
1b31d05e 8218 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 8219 break;
8220
8221 default:
74e1a04b 8222 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
1b31d05e 8223 elf_header.e_machine);
fa197c1c 8224 }
0b6ae522
DJ		 8225
8226 /* Decode the descriptors. Not implemented. */
8227}
8228
8229static void
8230dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8231{
8232 struct arm_section exidx_arm_sec, extab_arm_sec;
8233 unsigned int i, exidx_len;
948f632f 8234 unsigned long j, nfuns;
0b6ae522
DJ		 8235
8236 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8237 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8238 exidx_len = exidx_sec->sh_size / 8;
8239
948f632f
DA		 8240 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8241 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8242 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8243 aux->funtab[nfuns++] = aux->symtab[j];
8244 aux->nfuns = nfuns;
8245 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8246
0b6ae522
DJ		 8247 for (i = 0; i < exidx_len; i++)
8248 {
8249 unsigned int exidx_fn, exidx_entry;
8250 struct absaddr fn_addr, entry_addr;
8251 bfd_vma fn;
8252
8253 fputc ('\n', stdout);
8254
1b31d05e
NC		 8255 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8256 8 * i, & exidx_fn, & fn_addr, NULL)
8257 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8258 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 8259 {
948f632f 8260 free (aux->funtab);
1b31d05e
NC		 8261 arm_free_section (& exidx_arm_sec);
8262 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 8263 return;
8264 }
8265
83c257ca
NC		 8266 /* ARM EHABI, Section 5:
8267 An index table entry consists of 2 words.
8268 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8269 if (exidx_fn & 0x80000000)
8270 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8271
a734115a 8272 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 8273
a734115a 8274 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 8275 fputs (": ", stdout);
8276
8277 if (exidx_entry == 1)
8278 {
8279 print_vma (exidx_entry, PREFIX_HEX);
8280 fputs (" [cantunwind]\n", stdout);
8281 }
8282 else if (exidx_entry & 0x80000000)
8283 {
8284 print_vma (exidx_entry, PREFIX_HEX);
8285 fputc ('\n', stdout);
8286 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8287 }
8288 else
8289 {
8f73510c 8290 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 8291 Elf_Internal_Shdr *table_sec;
8292
8293 fputs ("@", stdout);
a734115a 8294 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 8295 print_vma (table, PREFIX_HEX);
8296 printf ("\n");
8297
8298 /* Locate the matching .ARM.extab. */
8299 if (entry_addr.section != SHN_UNDEF
8300 && entry_addr.section < elf_header.e_shnum)
8301 {
8302 table_sec = section_headers + entry_addr.section;
8303 table_offset = entry_addr.offset;
8304 }
8305 else
8306 {
8307 table_sec = find_section_by_address (table);
8308 if (table_sec != NULL)
8309 table_offset = table - table_sec->sh_addr;
8310 }
8311 if (table_sec == NULL)
8312 {
8313 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8314 (unsigned long) table);
8315 continue;
8316 }
8317 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8318 &extab_arm_sec);
8319 }
8320 }
8321
8322 printf ("\n");
8323
948f632f 8324 free (aux->funtab);
0b6ae522
DJ		 8325 arm_free_section (&exidx_arm_sec);
8326 arm_free_section (&extab_arm_sec);
8327}
8328
fa197c1c 8329/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 8330
8331static void
0b6ae522
DJ		 8332arm_process_unwind (FILE *file)
8333{
8334 struct arm_unw_aux_info aux;
8335 Elf_Internal_Shdr *unwsec = NULL;
8336 Elf_Internal_Shdr *strsec;
8337 Elf_Internal_Shdr *sec;
8338 unsigned long i;
fa197c1c 8339 unsigned int sec_type;
0b6ae522 8340
fa197c1c
PB		 8341 switch (elf_header.e_machine)
8342 {
8343 case EM_ARM:
8344 sec_type = SHT_ARM_EXIDX;
8345 break;
8346
8347 case EM_TI_C6000:
8348 sec_type = SHT_C6000_UNWIND;
8349 break;
8350
0b4362b0 8351 default:
74e1a04b 8352 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
1b31d05e
NC		 8353 elf_header.e_machine);
8354 return;
fa197c1c
PB		 8355 }
8356
0b6ae522 8357 if (string_table == NULL)
1b31d05e
NC		 8358 return;
8359
8360 memset (& aux, 0, sizeof (aux));
8361 aux.file = file;
0b6ae522
DJ		 8362
8363 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8364 {
8365 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8366 {
ba5cdace 8367 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 8368
8369 strsec = section_headers + sec->sh_link;
74e1a04b
NC		 8370
8371 /* PR binutils/17531 file: 011-12666-0.004. */
8372 if (aux.strtab != NULL)
8373 {
4082ef84 8374 error (_("Multiple string tables found in file.\n"));
74e1a04b
NC		 8375 free (aux.strtab);
8376 }
0b6ae522
DJ		 8377 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8378 1, strsec->sh_size, _("string table"));
8379 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8380 }
fa197c1c 8381 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 8382 unwsec = sec;
8383 }
8384
1b31d05e 8385 if (unwsec == NULL)
0b6ae522 8386 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 8387 else
8388 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8389 {
8390 if (sec->sh_type == sec_type)
8391 {
8392 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
74e1a04b 8393 printable_section_name (sec),
1b31d05e
NC		 8394 (unsigned long) sec->sh_offset,
8395 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 8396
1b31d05e
NC		 8397 dump_arm_unwind (&aux, sec);
8398 }
8399 }
0b6ae522
DJ		 8400
8401 if (aux.symtab)
8402 free (aux.symtab);
8403 if (aux.strtab)
8404 free ((char *) aux.strtab);
0b6ae522
DJ		 8405}
8406
1b31d05e 8407static void
2cf0635d 8408process_unwind (FILE * file)
57346661 8409{
2cf0635d
NC		 8410 struct unwind_handler
8411 {
57346661 8412 int machtype;
1b31d05e 8413 void (* handler)(FILE *);
2cf0635d
NC		 8414 } handlers[] =
8415 {
0b6ae522 8416 { EM_ARM, arm_process_unwind },
57346661
AM		 8417 { EM_IA_64, ia64_process_unwind },
8418 { EM_PARISC, hppa_process_unwind },
fa197c1c 8419 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 8420 { 0, 0 }
8421 };
8422 int i;
8423
8424 if (!do_unwind)
1b31d05e 8425 return;
57346661
AM		 8426
8427 for (i = 0; handlers[i].handler != NULL; i++)
8428 if (elf_header.e_machine == handlers[i].machtype)
9f758fdc
NC		 8429 {
8430 handlers[i].handler (file);
8431 return;
8432 }
57346661 8433
1b31d05e
NC		 8434 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8435 get_machine_name (elf_header.e_machine));
57346661
AM		 8436}
8437
252b5132 8438static void
2cf0635d 8439dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 8440{
8441 switch (entry->d_tag)
8442 {
8443 case DT_MIPS_FLAGS:
8444 if (entry->d_un.d_val == 0)
4b68bca3 8445 printf (_("NONE"));
252b5132
RH		 8446 else
8447 {
8448 static const char * opts[] =
8449 {
8450 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8451 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8452 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8453 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8454 "RLD_ORDER_SAFE"
8455 };
8456 unsigned int cnt;
8457 int first = 1;
2b692964 8458
60bca95a 8459 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 8460 if (entry->d_un.d_val & (1 << cnt))
8461 {
8462 printf ("%s%s", first ? "" : " ", opts[cnt]);
8463 first = 0;
8464 }
252b5132
RH		 8465 }
8466 break;
103f02d3 8467
252b5132 8468 case DT_MIPS_IVERSION:
d79b3d50 8469 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 8470 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8471 else
76ca31c0
NC		 8472 {
8473 char buf[40];
8474 sprintf_vma (buf, entry->d_un.d_ptr);
8475 /* Note: coded this way so that there is a single string for translation. */
8476 printf (_("<corrupt: %s>"), buf);
8477 }
252b5132 8478 break;
103f02d3 8479
252b5132
RH		 8480 case DT_MIPS_TIME_STAMP:
8481 {
8482 char timebuf[20];
2cf0635d 8483 struct tm * tmp;
91d6fa6a 8484 time_t atime = entry->d_un.d_val;
82b1b41b 8485
91d6fa6a 8486 tmp = gmtime (&atime);
82b1b41b
NC		 8487 /* PR 17531: file: 6accc532. */
8488 if (tmp == NULL)
8489 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8490 else
8491 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8492 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8493 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 8494 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 8495 }
8496 break;
103f02d3 8497
252b5132
RH		 8498 case DT_MIPS_RLD_VERSION:
8499 case DT_MIPS_LOCAL_GOTNO:
8500 case DT_MIPS_CONFLICTNO:
8501 case DT_MIPS_LIBLISTNO:
8502 case DT_MIPS_SYMTABNO:
8503 case DT_MIPS_UNREFEXTNO:
8504 case DT_MIPS_HIPAGENO:
8505 case DT_MIPS_DELTA_CLASS_NO:
8506 case DT_MIPS_DELTA_INSTANCE_NO:
8507 case DT_MIPS_DELTA_RELOC_NO:
8508 case DT_MIPS_DELTA_SYM_NO:
8509 case DT_MIPS_DELTA_CLASSSYM_NO:
8510 case DT_MIPS_COMPACT_SIZE:
4b68bca3 8511 print_vma (entry->d_un.d_ptr, DEC);
252b5132 8512 break;
103f02d3
UD		 8513
8514 default:
4b68bca3 8515 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 8516 }
4b68bca3 8517 putchar ('\n');
103f02d3
UD		 8518}
8519
103f02d3 8520static void
2cf0635d 8521dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 8522{
8523 switch (entry->d_tag)
8524 {
8525 case DT_HP_DLD_FLAGS:
8526 {
8527 static struct
8528 {
8529 long int bit;
2cf0635d 8530 const char * str;
5e220199
NC		 8531 }
8532 flags[] =
8533 {
8534 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8535 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8536 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8537 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8538 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8539 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8540 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8541 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8542 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8543 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 8544 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8545 { DT_HP_GST, "HP_GST" },
8546 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8547 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8548 { DT_HP_NODELETE, "HP_NODELETE" },
8549 { DT_HP_GROUP, "HP_GROUP" },
8550 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 8551 };
103f02d3 8552 int first = 1;
5e220199 8553 size_t cnt;
f7a99963 8554 bfd_vma val = entry->d_un.d_val;
103f02d3 8555
60bca95a 8556 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 8557 if (val & flags[cnt].bit)
30800947
NC		 8558 {
8559 if (! first)
8560 putchar (' ');
8561 fputs (flags[cnt].str, stdout);
8562 first = 0;
8563 val ^= flags[cnt].bit;
8564 }
76da6bbe 8565
103f02d3 8566 if (val != 0 || first)
f7a99963
NC		 8567 {
8568 if (! first)
8569 putchar (' ');
8570 print_vma (val, HEX);
8571 }
103f02d3
UD		 8572 }
8573 break;
76da6bbe 8574
252b5132 8575 default:
f7a99963
NC		 8576 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8577 break;
252b5132 8578 }
35b1837e 8579 putchar ('\n');
252b5132
RH		 8580}
8581
28f997cf
TG		 8582#ifdef BFD64
8583
8584/* VMS vs Unix time offset and factor. */
8585
8586#define VMS_EPOCH_OFFSET 35067168000000000LL
8587#define VMS_GRANULARITY_FACTOR 10000000
8588
8589/* Display a VMS time in a human readable format. */
8590
8591static void
8592print_vms_time (bfd_int64_t vmstime)
8593{
8594 struct tm *tm;
8595 time_t unxtime;
8596
8597 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8598 tm = gmtime (&unxtime);
8599 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8600 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8601 tm->tm_hour, tm->tm_min, tm->tm_sec);
8602}
8603#endif /* BFD64 */
8604
ecc51f48 8605static void
2cf0635d 8606dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 8607{
8608 switch (entry->d_tag)
8609 {
0de14b54 8610 case DT_IA_64_PLT_RESERVE:
bdf4d63a 8611 /* First 3 slots reserved. */
ecc51f48
NC		 8612 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8613 printf (" -- ");
8614 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 8615 break;
8616
28f997cf
TG		 8617 case DT_IA_64_VMS_LINKTIME:
8618#ifdef BFD64
8619 print_vms_time (entry->d_un.d_val);
8620#endif
8621 break;
8622
8623 case DT_IA_64_VMS_LNKFLAGS:
8624 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8625 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8626 printf (" CALL_DEBUG");
8627 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8628 printf (" NOP0BUFS");
8629 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8630 printf (" P0IMAGE");
8631 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8632 printf (" MKTHREADS");
8633 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8634 printf (" UPCALLS");
8635 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8636 printf (" IMGSTA");
8637 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8638 printf (" INITIALIZE");
8639 if (entry->d_un.d_val & VMS_LF_MAIN)
8640 printf (" MAIN");
8641 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8642 printf (" EXE_INIT");
8643 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8644 printf (" TBK_IN_IMG");
8645 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8646 printf (" DBG_IN_IMG");
8647 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8648 printf (" TBK_IN_DSF");
8649 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8650 printf (" DBG_IN_DSF");
8651 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8652 printf (" SIGNATURES");
8653 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8654 printf (" REL_SEG_OFF");
8655 break;
8656
bdf4d63a
JJ		 8657 default:
8658 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8659 break;
ecc51f48 8660 }
bdf4d63a 8661 putchar ('\n');
ecc51f48
NC		 8662}
8663
252b5132 8664static int
2cf0635d 8665get_32bit_dynamic_section (FILE * file)
252b5132 8666{
2cf0635d
NC		 8667 Elf32_External_Dyn * edyn;
8668 Elf32_External_Dyn * ext;
8669 Elf_Internal_Dyn * entry;
103f02d3 8670
3f5e193b
NC		 8671 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8672 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8673 if (!edyn)
8674 return 0;
103f02d3 8675
071436c6
NC		 8676 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8677 might not have the luxury of section headers. Look for the DT_NULL
8678 terminator to determine the number of entries. */
ba2685cc 8679 for (ext = edyn, dynamic_nent = 0;
53c3012c 8680 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 8681 ext++)
8682 {
8683 dynamic_nent++;
8684 if (BYTE_GET (ext->d_tag) == DT_NULL)
8685 break;
8686 }
252b5132 8687
3f5e193b
NC		 8688 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8689 sizeof (* entry));
b2d38a17 8690 if (dynamic_section == NULL)
252b5132 8691 {
8b73c356
NC		 8692 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8693 (unsigned long) dynamic_nent);
9ea033b2
NC		 8694 free (edyn);
8695 return 0;
8696 }
252b5132 8697
fb514b26 8698 for (ext = edyn, entry = dynamic_section;
ba2685cc 8699 entry < dynamic_section + dynamic_nent;
fb514b26 8700 ext++, entry++)
9ea033b2 8701 {
fb514b26
AM		 8702 entry->d_tag = BYTE_GET (ext->d_tag);
8703 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8704 }
8705
9ea033b2
NC		 8706 free (edyn);
8707
8708 return 1;
8709}
8710
8711static int
2cf0635d 8712get_64bit_dynamic_section (FILE * file)
9ea033b2 8713{
2cf0635d
NC		 8714 Elf64_External_Dyn * edyn;
8715 Elf64_External_Dyn * ext;
8716 Elf_Internal_Dyn * entry;
103f02d3 8717
071436c6 8718 /* Read in the data. */
3f5e193b
NC		 8719 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8720 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8721 if (!edyn)
8722 return 0;
103f02d3 8723
071436c6
NC		 8724 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8725 might not have the luxury of section headers. Look for the DT_NULL
8726 terminator to determine the number of entries. */
ba2685cc 8727 for (ext = edyn, dynamic_nent = 0;
53c3012c
AM		 8728 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
8729 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 8730 ext++)
8731 {
8732 dynamic_nent++;
66543521 8733 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 8734 break;
8735 }
252b5132 8736
3f5e193b
NC		 8737 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8738 sizeof (* entry));
b2d38a17 8739 if (dynamic_section == NULL)
252b5132 8740 {
8b73c356
NC		 8741 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8742 (unsigned long) dynamic_nent);
252b5132
RH		 8743 free (edyn);
8744 return 0;
8745 }
8746
071436c6 8747 /* Convert from external to internal formats. */
fb514b26 8748 for (ext = edyn, entry = dynamic_section;
ba2685cc 8749 entry < dynamic_section + dynamic_nent;
fb514b26 8750 ext++, entry++)
252b5132 8751 {
66543521
AM		 8752 entry->d_tag = BYTE_GET (ext->d_tag);
8753 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8754 }
8755
8756 free (edyn);
8757
9ea033b2
NC		 8758 return 1;
8759}
8760
e9e44622
JJ		 8761static void
8762print_dynamic_flags (bfd_vma flags)
d1133906 8763{
e9e44622 8764 int first = 1;
13ae64f3 8765
d1133906
NC		 8766 while (flags)
8767 {
8768 bfd_vma flag;
8769
8770 flag = flags & - flags;
8771 flags &= ~ flag;
8772
e9e44622
JJ		 8773 if (first)
8774 first = 0;
8775 else
8776 putc (' ', stdout);
13ae64f3 8777
d1133906
NC		 8778 switch (flag)
8779 {
e9e44622
JJ		 8780 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
8781 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
8782 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
8783 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
8784 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 8785 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 8786 }
8787 }
e9e44622 8788 puts ("");
d1133906
NC		 8789}
8790
b2d38a17
NC		 8791/* Parse and display the contents of the dynamic section. */
8792
9ea033b2 8793static int
2cf0635d 8794process_dynamic_section (FILE * file)
9ea033b2 8795{
2cf0635d 8796 Elf_Internal_Dyn * entry;
9ea033b2
NC		 8797
8798 if (dynamic_size == 0)
8799 {
8800 if (do_dynamic)
b2d38a17 8801 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 8802
8803 return 1;
8804 }
8805
8806 if (is_32bit_elf)
8807 {
b2d38a17 8808 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 8809 return 0;
8810 }
b2d38a17 8811 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 8812 return 0;
8813
252b5132
RH		 8814 /* Find the appropriate symbol table. */
8815 if (dynamic_symbols == NULL)
8816 {
86dba8ee
AM		 8817 for (entry = dynamic_section;
8818 entry < dynamic_section + dynamic_nent;
8819 ++entry)
252b5132 8820 {
c8286bd1 8821 Elf_Internal_Shdr section;
252b5132
RH		 8822
8823 if (entry->d_tag != DT_SYMTAB)
8824 continue;
8825
8826 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8827
8828 /* Since we do not know how big the symbol table is,
8829 we default to reading in the entire file (!) and
8830 processing that. This is overkill, I know, but it
e3c8793a 8831 should work. */
d93f0186 8832 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 8833
fb52b2f4
NC		 8834 if (archive_file_offset != 0)
8835 section.sh_size = archive_file_size - section.sh_offset;
8836 else
8837 {
8838 if (fseek (file, 0, SEEK_END))
591a748a 8839 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 8840
8841 section.sh_size = ftell (file) - section.sh_offset;
8842 }
252b5132 8843
9ea033b2 8844 if (is_32bit_elf)
9ad5cbcf 8845 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 8846 else
9ad5cbcf 8847 section.sh_entsize = sizeof (Elf64_External_Sym);
071436c6 8848 section.sh_name = string_table_length;
252b5132 8849
ba5cdace 8850 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 8851 if (num_dynamic_syms < 1)
252b5132
RH		 8852 {
8853 error (_("Unable to determine the number of symbols to load\n"));
8854 continue;
8855 }
252b5132
RH		 8856 }
8857 }
8858
8859 /* Similarly find a string table. */
8860 if (dynamic_strings == NULL)
8861 {
86dba8ee
AM		 8862 for (entry = dynamic_section;
8863 entry < dynamic_section + dynamic_nent;
8864 ++entry)
252b5132
RH		 8865 {
8866 unsigned long offset;
b34976b6 8867 long str_tab_len;
252b5132
RH		 8868
8869 if (entry->d_tag != DT_STRTAB)
8870 continue;
8871
8872 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8873
8874 /* Since we do not know how big the string table is,
8875 we default to reading in the entire file (!) and
8876 processing that. This is overkill, I know, but it
e3c8793a 8877 should work. */
252b5132 8878
d93f0186 8879 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 8880
8881 if (archive_file_offset != 0)
8882 str_tab_len = archive_file_size - offset;
8883 else
8884 {
8885 if (fseek (file, 0, SEEK_END))
8886 error (_("Unable to seek to end of file\n"));
8887 str_tab_len = ftell (file) - offset;
8888 }
252b5132
RH		 8889
8890 if (str_tab_len < 1)
8891 {
8892 error
8893 (_("Unable to determine the length of the dynamic string table\n"));
8894 continue;
8895 }
8896
3f5e193b
NC		 8897 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8898 str_tab_len,
8899 _("dynamic string table"));
59245841 8900 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 8901 break;
8902 }
8903 }
8904
8905 /* And find the syminfo section if available. */
8906 if (dynamic_syminfo == NULL)
8907 {
3e8bba36 8908 unsigned long syminsz = 0;
252b5132 8909
86dba8ee
AM		 8910 for (entry = dynamic_section;
8911 entry < dynamic_section + dynamic_nent;
8912 ++entry)
252b5132
RH		 8913 {
8914 if (entry->d_tag == DT_SYMINENT)
8915 {
8916 /* Note: these braces are necessary to avoid a syntax
8917 error from the SunOS4 C compiler. */
049b0c3a
NC		 8918 /* PR binutils/17531: A corrupt file can trigger this test.
8919 So do not use an assert, instead generate an error message. */
8920 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
071436c6 8921 error (_("Bad value (%d) for SYMINENT entry\n"),
049b0c3a 8922 (int) entry->d_un.d_val);
252b5132
RH		 8923 }
8924 else if (entry->d_tag == DT_SYMINSZ)
8925 syminsz = entry->d_un.d_val;
8926 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 8927 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8928 syminsz);
252b5132
RH		 8929 }
8930
8931 if (dynamic_syminfo_offset != 0 && syminsz != 0)
8932 {
2cf0635d
NC		 8933 Elf_External_Syminfo * extsyminfo;
8934 Elf_External_Syminfo * extsym;
8935 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 8936
8937 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 8938 extsyminfo = (Elf_External_Syminfo *)
8939 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8940 _("symbol information"));
a6e9f9df
AM		 8941 if (!extsyminfo)
8942 return 0;
252b5132 8943
3f5e193b 8944 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 8945 if (dynamic_syminfo == NULL)
8946 {
8b73c356
NC		 8947 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8948 (unsigned long) syminsz);
252b5132
RH		 8949 return 0;
8950 }
8951
8952 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 8953 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8954 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8955 ++syminfo, ++extsym)
252b5132 8956 {
86dba8ee
AM		 8957 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8958 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 8959 }
8960
8961 free (extsyminfo);
8962 }
8963 }
8964
8965 if (do_dynamic && dynamic_addr)
8b73c356
NC		 8966 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8967 dynamic_addr, (unsigned long) dynamic_nent);
252b5132
RH		 8968 if (do_dynamic)
8969 printf (_(" Tag Type Name/Value\n"));
8970
86dba8ee
AM		 8971 for (entry = dynamic_section;
8972 entry < dynamic_section + dynamic_nent;
8973 entry++)
252b5132
RH		 8974 {
8975 if (do_dynamic)
f7a99963 8976 {
2cf0635d 8977 const char * dtype;
e699b9ff 8978
f7a99963
NC		 8979 putchar (' ');
8980 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 8981 dtype = get_dynamic_type (entry->d_tag);
8982 printf (" (%s)%*s", dtype,
8983 ((is_32bit_elf ? 27 : 19)
8984 - (int) strlen (dtype)),
f7a99963
NC		 8985 " ");
8986 }
252b5132
RH		 8987
8988 switch (entry->d_tag)
8989 {
d1133906
NC		 8990 case DT_FLAGS:
8991 if (do_dynamic)
e9e44622 8992 print_dynamic_flags (entry->d_un.d_val);
d1133906 8993 break;
76da6bbe 8994
252b5132
RH		 8995 case DT_AUXILIARY:
8996 case DT_FILTER:
019148e4
L		 8997 case DT_CONFIG:
8998 case DT_DEPAUDIT:
8999 case DT_AUDIT:
252b5132
RH		 9000 if (do_dynamic)
9001 {
019148e4 9002 switch (entry->d_tag)
b34976b6 9003 {
019148e4
L		 9004 case DT_AUXILIARY:
9005 printf (_("Auxiliary library"));
9006 break;
9007
9008 case DT_FILTER:
9009 printf (_("Filter library"));
9010 break;
9011
b34976b6 9012 case DT_CONFIG:
019148e4
L		 9013 printf (_("Configuration file"));
9014 break;
9015
9016 case DT_DEPAUDIT:
9017 printf (_("Dependency audit library"));
9018 break;
9019
9020 case DT_AUDIT:
9021 printf (_("Audit library"));
9022 break;
9023 }
252b5132 9024
d79b3d50
NC		 9025 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9026 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 9027 else
f7a99963
NC		 9028 {
9029 printf (": ");
9030 print_vma (entry->d_un.d_val, PREFIX_HEX);
9031 putchar ('\n');
9032 }
252b5132
RH		 9033 }
9034 break;
9035
dcefbbbd 9036 case DT_FEATURE:
252b5132
RH		 9037 if (do_dynamic)
9038 {
9039 printf (_("Flags:"));
86f55779 9040
252b5132
RH		 9041 if (entry->d_un.d_val == 0)
9042 printf (_(" None\n"));
9043 else
9044 {
9045 unsigned long int val = entry->d_un.d_val;
86f55779 9046
252b5132
RH		 9047 if (val & DTF_1_PARINIT)
9048 {
9049 printf (" PARINIT");
9050 val ^= DTF_1_PARINIT;
9051 }
dcefbbbd
L		 9052 if (val & DTF_1_CONFEXP)
9053 {
9054 printf (" CONFEXP");
9055 val ^= DTF_1_CONFEXP;
9056 }
252b5132
RH		 9057 if (val != 0)
9058 printf (" %lx", val);
9059 puts ("");
9060 }
9061 }
9062 break;
9063
9064 case DT_POSFLAG_1:
9065 if (do_dynamic)
9066 {
9067 printf (_("Flags:"));
86f55779 9068
252b5132
RH		 9069 if (entry->d_un.d_val == 0)
9070 printf (_(" None\n"));
9071 else
9072 {
9073 unsigned long int val = entry->d_un.d_val;
86f55779 9074
252b5132
RH		 9075 if (val & DF_P1_LAZYLOAD)
9076 {
9077 printf (" LAZYLOAD");
9078 val ^= DF_P1_LAZYLOAD;
9079 }
9080 if (val & DF_P1_GROUPPERM)
9081 {
9082 printf (" GROUPPERM");
9083 val ^= DF_P1_GROUPPERM;
9084 }
9085 if (val != 0)
9086 printf (" %lx", val);
9087 puts ("");
9088 }
9089 }
9090 break;
9091
9092 case DT_FLAGS_1:
9093 if (do_dynamic)
9094 {
9095 printf (_("Flags:"));
9096 if (entry->d_un.d_val == 0)
9097 printf (_(" None\n"));
9098 else
9099 {
9100 unsigned long int val = entry->d_un.d_val;
86f55779 9101
252b5132
RH		 9102 if (val & DF_1_NOW)
9103 {
9104 printf (" NOW");
9105 val ^= DF_1_NOW;
9106 }
9107 if (val & DF_1_GLOBAL)
9108 {
9109 printf (" GLOBAL");
9110 val ^= DF_1_GLOBAL;
9111 }
9112 if (val & DF_1_GROUP)
9113 {
9114 printf (" GROUP");
9115 val ^= DF_1_GROUP;
9116 }
9117 if (val & DF_1_NODELETE)
9118 {
9119 printf (" NODELETE");
9120 val ^= DF_1_NODELETE;
9121 }
9122 if (val & DF_1_LOADFLTR)
9123 {
9124 printf (" LOADFLTR");
9125 val ^= DF_1_LOADFLTR;
9126 }
9127 if (val & DF_1_INITFIRST)
9128 {
9129 printf (" INITFIRST");
9130 val ^= DF_1_INITFIRST;
9131 }
9132 if (val & DF_1_NOOPEN)
9133 {
9134 printf (" NOOPEN");
9135 val ^= DF_1_NOOPEN;
9136 }
9137 if (val & DF_1_ORIGIN)
9138 {
9139 printf (" ORIGIN");
9140 val ^= DF_1_ORIGIN;
9141 }
9142 if (val & DF_1_DIRECT)
9143 {
9144 printf (" DIRECT");
9145 val ^= DF_1_DIRECT;
9146 }
9147 if (val & DF_1_TRANS)
9148 {
9149 printf (" TRANS");
9150 val ^= DF_1_TRANS;
9151 }
9152 if (val & DF_1_INTERPOSE)
9153 {
9154 printf (" INTERPOSE");
9155 val ^= DF_1_INTERPOSE;
9156 }
f7db6139 9157 if (val & DF_1_NODEFLIB)
dcefbbbd 9158 {
f7db6139
L		 9159 printf (" NODEFLIB");
9160 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 9161 }
9162 if (val & DF_1_NODUMP)
9163 {
9164 printf (" NODUMP");
9165 val ^= DF_1_NODUMP;
9166 }
34b60028 9167 if (val & DF_1_CONFALT)
dcefbbbd 9168 {
34b60028
L		 9169 printf (" CONFALT");
9170 val ^= DF_1_CONFALT;
9171 }
9172 if (val & DF_1_ENDFILTEE)
9173 {
9174 printf (" ENDFILTEE");
9175 val ^= DF_1_ENDFILTEE;
9176 }
9177 if (val & DF_1_DISPRELDNE)
9178 {
9179 printf (" DISPRELDNE");
9180 val ^= DF_1_DISPRELDNE;
9181 }
9182 if (val & DF_1_DISPRELPND)
9183 {
9184 printf (" DISPRELPND");
9185 val ^= DF_1_DISPRELPND;
9186 }
9187 if (val & DF_1_NODIRECT)
9188 {
9189 printf (" NODIRECT");
9190 val ^= DF_1_NODIRECT;
9191 }
9192 if (val & DF_1_IGNMULDEF)
9193 {
9194 printf (" IGNMULDEF");
9195 val ^= DF_1_IGNMULDEF;
9196 }
9197 if (val & DF_1_NOKSYMS)
9198 {
9199 printf (" NOKSYMS");
9200 val ^= DF_1_NOKSYMS;
9201 }
9202 if (val & DF_1_NOHDR)
9203 {
9204 printf (" NOHDR");
9205 val ^= DF_1_NOHDR;
9206 }
9207 if (val & DF_1_EDITED)
9208 {
9209 printf (" EDITED");
9210 val ^= DF_1_EDITED;
9211 }
9212 if (val & DF_1_NORELOC)
9213 {
9214 printf (" NORELOC");
9215 val ^= DF_1_NORELOC;
9216 }
9217 if (val & DF_1_SYMINTPOSE)
9218 {
9219 printf (" SYMINTPOSE");
9220 val ^= DF_1_SYMINTPOSE;
9221 }
9222 if (val & DF_1_GLOBAUDIT)
9223 {
9224 printf (" GLOBAUDIT");
9225 val ^= DF_1_GLOBAUDIT;
9226 }
9227 if (val & DF_1_SINGLETON)
9228 {
9229 printf (" SINGLETON");
9230 val ^= DF_1_SINGLETON;
dcefbbbd 9231 }
252b5132
RH		 9232 if (val != 0)
9233 printf (" %lx", val);
9234 puts ("");
9235 }
9236 }
9237 break;
9238
9239 case DT_PLTREL:
566b0d53 9240 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9241 if (do_dynamic)
9242 puts (get_dynamic_type (entry->d_un.d_val));
9243 break;
9244
9245 case DT_NULL :
9246 case DT_NEEDED :
9247 case DT_PLTGOT :
9248 case DT_HASH :
9249 case DT_STRTAB :
9250 case DT_SYMTAB :
9251 case DT_RELA :
9252 case DT_INIT :
9253 case DT_FINI :
9254 case DT_SONAME :
9255 case DT_RPATH :
9256 case DT_SYMBOLIC:
9257 case DT_REL :
9258 case DT_DEBUG :
9259 case DT_TEXTREL :
9260 case DT_JMPREL :
019148e4 9261 case DT_RUNPATH :
252b5132
RH		 9262 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9263
9264 if (do_dynamic)
9265 {
2cf0635d 9266 char * name;
252b5132 9267
d79b3d50
NC		 9268 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9269 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9270 else
d79b3d50 9271 name = NULL;
252b5132
RH		 9272
9273 if (name)
9274 {
9275 switch (entry->d_tag)
9276 {
9277 case DT_NEEDED:
9278 printf (_("Shared library: [%s]"), name);
9279
18bd398b 9280 if (streq (name, program_interpreter))
f7a99963 9281 printf (_(" program interpreter"));
252b5132
RH		 9282 break;
9283
9284 case DT_SONAME:
f7a99963 9285 printf (_("Library soname: [%s]"), name);
252b5132
RH		 9286 break;
9287
9288 case DT_RPATH:
f7a99963 9289 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 9290 break;
9291
019148e4
L		 9292 case DT_RUNPATH:
9293 printf (_("Library runpath: [%s]"), name);
9294 break;
9295
252b5132 9296 default:
f7a99963
NC		 9297 print_vma (entry->d_un.d_val, PREFIX_HEX);
9298 break;
252b5132
RH		 9299 }
9300 }
9301 else
f7a99963
NC		 9302 print_vma (entry->d_un.d_val, PREFIX_HEX);
9303
9304 putchar ('\n');
252b5132
RH		 9305 }
9306 break;
9307
9308 case DT_PLTRELSZ:
9309 case DT_RELASZ :
9310 case DT_STRSZ :
9311 case DT_RELSZ :
9312 case DT_RELAENT :
9313 case DT_SYMENT :
9314 case DT_RELENT :
566b0d53 9315 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9316 case DT_PLTPADSZ:
9317 case DT_MOVEENT :
9318 case DT_MOVESZ :
9319 case DT_INIT_ARRAYSZ:
9320 case DT_FINI_ARRAYSZ:
047b2264
JJ		 9321 case DT_GNU_CONFLICTSZ:
9322 case DT_GNU_LIBLISTSZ:
252b5132 9323 if (do_dynamic)
f7a99963
NC		 9324 {
9325 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 9326 printf (_(" (bytes)\n"));
f7a99963 9327 }
252b5132
RH		 9328 break;
9329
9330 case DT_VERDEFNUM:
9331 case DT_VERNEEDNUM:
9332 case DT_RELACOUNT:
9333 case DT_RELCOUNT:
9334 if (do_dynamic)
f7a99963
NC		 9335 {
9336 print_vma (entry->d_un.d_val, UNSIGNED);
9337 putchar ('\n');
9338 }
252b5132
RH		 9339 break;
9340
9341 case DT_SYMINSZ:
9342 case DT_SYMINENT:
9343 case DT_SYMINFO:
9344 case DT_USED:
9345 case DT_INIT_ARRAY:
9346 case DT_FINI_ARRAY:
9347 if (do_dynamic)
9348 {
d79b3d50
NC		 9349 if (entry->d_tag == DT_USED
9350 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 9351 {
2cf0635d 9352 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9353
b34976b6 9354 if (*name)
252b5132
RH		 9355 {
9356 printf (_("Not needed object: [%s]\n"), name);
9357 break;
9358 }
9359 }
103f02d3 9360
f7a99963
NC		 9361 print_vma (entry->d_un.d_val, PREFIX_HEX);
9362 putchar ('\n');
252b5132
RH		 9363 }
9364 break;
9365
9366 case DT_BIND_NOW:
9367 /* The value of this entry is ignored. */
35b1837e
AM		 9368 if (do_dynamic)
9369 putchar ('\n');
252b5132 9370 break;
103f02d3 9371
047b2264
JJ		 9372 case DT_GNU_PRELINKED:
9373 if (do_dynamic)
9374 {
2cf0635d 9375 struct tm * tmp;
91d6fa6a 9376 time_t atime = entry->d_un.d_val;
047b2264 9377
91d6fa6a 9378 tmp = gmtime (&atime);
071436c6
NC		 9379 /* PR 17533 file: 041-1244816-0.004. */
9380 if (tmp == NULL)
5a2cbcf4
L		 9381 printf (_("<corrupt time val: %lx"),
9382 (unsigned long) atime);
071436c6
NC		 9383 else
9384 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9385 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9386 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 9387
9388 }
9389 break;
9390
fdc90cb4
JJ		 9391 case DT_GNU_HASH:
9392 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9393 if (do_dynamic)
9394 {
9395 print_vma (entry->d_un.d_val, PREFIX_HEX);
9396 putchar ('\n');
9397 }
9398 break;
9399
252b5132
RH		 9400 default:
9401 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 9402 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 9403 entry->d_un.d_val;
9404
9405 if (do_dynamic)
9406 {
9407 switch (elf_header.e_machine)
9408 {
9409 case EM_MIPS:
4fe85591 9410 case EM_MIPS_RS3_LE:
b2d38a17 9411 dynamic_section_mips_val (entry);
252b5132 9412 break;
103f02d3 9413 case EM_PARISC:
b2d38a17 9414 dynamic_section_parisc_val (entry);
103f02d3 9415 break;
ecc51f48 9416 case EM_IA_64:
b2d38a17 9417 dynamic_section_ia64_val (entry);
ecc51f48 9418 break;
252b5132 9419 default:
f7a99963
NC		 9420 print_vma (entry->d_un.d_val, PREFIX_HEX);
9421 putchar ('\n');
252b5132
RH		 9422 }
9423 }
9424 break;
9425 }
9426 }
9427
9428 return 1;
9429}
9430
9431static char *
d3ba0551 9432get_ver_flags (unsigned int flags)
252b5132 9433{
b34976b6 9434 static char buff[32];
252b5132
RH		 9435
9436 buff[0] = 0;
9437
9438 if (flags == 0)
9439 return _("none");
9440
9441 if (flags & VER_FLG_BASE)
9442 strcat (buff, "BASE ");
9443
9444 if (flags & VER_FLG_WEAK)
9445 {
9446 if (flags & VER_FLG_BASE)
9447 strcat (buff, "| ");
9448
9449 strcat (buff, "WEAK ");
9450 }
9451
44ec90b9
RO		 9452 if (flags & VER_FLG_INFO)
9453 {
9454 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9455 strcat (buff, "| ");
9456
9457 strcat (buff, "INFO ");
9458 }
9459
9460 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 9461 strcat (buff, _("| <unknown>"));
252b5132
RH		 9462
9463 return buff;
9464}
9465
9466/* Display the contents of the version sections. */
98fb390a 9467
252b5132 9468static int
2cf0635d 9469process_version_sections (FILE * file)
252b5132 9470{
2cf0635d 9471 Elf_Internal_Shdr * section;
b34976b6
AM		 9472 unsigned i;
9473 int found = 0;
252b5132
RH		 9474
9475 if (! do_version)
9476 return 1;
9477
9478 for (i = 0, section = section_headers;
9479 i < elf_header.e_shnum;
b34976b6 9480 i++, section++)
252b5132
RH		 9481 {
9482 switch (section->sh_type)
9483 {
9484 case SHT_GNU_verdef:
9485 {
2cf0635d 9486 Elf_External_Verdef * edefs;
b34976b6
AM		 9487 unsigned int idx;
9488 unsigned int cnt;
2cf0635d 9489 char * endbuf;
252b5132
RH		 9490
9491 found = 1;
9492
74e1a04b
NC		 9493 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9494 printable_section_name (section),
9495 section->sh_info);
252b5132
RH		 9496
9497 printf (_(" Addr: 0x"));
9498 printf_vma (section->sh_addr);
74e1a04b 9499 printf (_(" Offset: %#08lx Link: %u (%s)"),
1b228002 9500 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9501 printable_section_name_from_index (section->sh_link));
252b5132 9502
3f5e193b
NC		 9503 edefs = (Elf_External_Verdef *)
9504 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9505 _("version definition section"));
a6e9f9df
AM		 9506 if (!edefs)
9507 break;
59245841 9508 endbuf = (char *) edefs + section->sh_size;
252b5132 9509
b34976b6 9510 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 9511 {
2cf0635d
NC		 9512 char * vstart;
9513 Elf_External_Verdef * edef;
b34976b6 9514 Elf_Internal_Verdef ent;
2cf0635d 9515 Elf_External_Verdaux * eaux;
b34976b6
AM		 9516 Elf_Internal_Verdaux aux;
9517 int j;
9518 int isum;
103f02d3 9519
7e26601c
NC		 9520 /* Check for very large indicies. */
9521 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 9522 break;
9523
252b5132 9524 vstart = ((char *) edefs) + idx;
54806181
AM		 9525 if (vstart + sizeof (*edef) > endbuf)
9526 break;
252b5132
RH		 9527
9528 edef = (Elf_External_Verdef *) vstart;
9529
9530 ent.vd_version = BYTE_GET (edef->vd_version);
9531 ent.vd_flags = BYTE_GET (edef->vd_flags);
9532 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9533 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9534 ent.vd_hash = BYTE_GET (edef->vd_hash);
9535 ent.vd_aux = BYTE_GET (edef->vd_aux);
9536 ent.vd_next = BYTE_GET (edef->vd_next);
9537
9538 printf (_(" %#06x: Rev: %d Flags: %s"),
9539 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9540
9541 printf (_(" Index: %d Cnt: %d "),
9542 ent.vd_ndx, ent.vd_cnt);
9543
dd24e3da 9544 /* Check for overflow. */
7e26601c 9545 if (ent.vd_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 9546 break;
9547
252b5132
RH		 9548 vstart += ent.vd_aux;
9549
9550 eaux = (Elf_External_Verdaux *) vstart;
9551
9552 aux.vda_name = BYTE_GET (eaux->vda_name);
9553 aux.vda_next = BYTE_GET (eaux->vda_next);
9554
d79b3d50
NC		 9555 if (VALID_DYNAMIC_NAME (aux.vda_name))
9556 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9557 else
9558 printf (_("Name index: %ld\n"), aux.vda_name);
9559
9560 isum = idx + ent.vd_aux;
9561
b34976b6 9562 for (j = 1; j < ent.vd_cnt; j++)
252b5132 9563 {
dd24e3da 9564 /* Check for overflow. */
7e26601c 9565 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 9566 break;
9567
252b5132
RH		 9568 isum += aux.vda_next;
9569 vstart += aux.vda_next;
9570
9571 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 9572 if (vstart + sizeof (*eaux) > endbuf)
9573 break;
252b5132
RH		 9574
9575 aux.vda_name = BYTE_GET (eaux->vda_name);
9576 aux.vda_next = BYTE_GET (eaux->vda_next);
9577
d79b3d50 9578 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 9579 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 9580 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9581 else
9582 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9583 isum, j, aux.vda_name);
9584 }
dd24e3da 9585
54806181
AM		 9586 if (j < ent.vd_cnt)
9587 printf (_(" Version def aux past end of section\n"));
252b5132 9588
5d921cbd
NC		 9589 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9590 if (idx + ent.vd_next <= idx)
9591 break;
9592
252b5132
RH		 9593 idx += ent.vd_next;
9594 }
dd24e3da 9595
54806181
AM		 9596 if (cnt < section->sh_info)
9597 printf (_(" Version definition past end of section\n"));
252b5132
RH		 9598
9599 free (edefs);
9600 }
9601 break;
103f02d3 9602
252b5132
RH		 9603 case SHT_GNU_verneed:
9604 {
2cf0635d 9605 Elf_External_Verneed * eneed;
b34976b6
AM		 9606 unsigned int idx;
9607 unsigned int cnt;
2cf0635d 9608 char * endbuf;
252b5132
RH		 9609
9610 found = 1;
9611
72de5009 9612 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
74e1a04b 9613 printable_section_name (section), section->sh_info);
252b5132
RH		 9614
9615 printf (_(" Addr: 0x"));
9616 printf_vma (section->sh_addr);
72de5009 9617 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9618 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9619 printable_section_name_from_index (section->sh_link));
252b5132 9620
3f5e193b
NC		 9621 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9622 section->sh_offset, 1,
9623 section->sh_size,
9cf03b7e 9624 _("Version Needs section"));
a6e9f9df
AM		 9625 if (!eneed)
9626 break;
59245841 9627 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 9628
9629 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9630 {
2cf0635d 9631 Elf_External_Verneed * entry;
b34976b6
AM		 9632 Elf_Internal_Verneed ent;
9633 int j;
9634 int isum;
2cf0635d 9635 char * vstart;
252b5132 9636
7e26601c 9637 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 9638 break;
9639
252b5132 9640 vstart = ((char *) eneed) + idx;
54806181
AM		 9641 if (vstart + sizeof (*entry) > endbuf)
9642 break;
252b5132
RH		 9643
9644 entry = (Elf_External_Verneed *) vstart;
9645
9646 ent.vn_version = BYTE_GET (entry->vn_version);
9647 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
9648 ent.vn_file = BYTE_GET (entry->vn_file);
9649 ent.vn_aux = BYTE_GET (entry->vn_aux);
9650 ent.vn_next = BYTE_GET (entry->vn_next);
9651
9652 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
9653
d79b3d50
NC		 9654 if (VALID_DYNAMIC_NAME (ent.vn_file))
9655 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 9656 else
9657 printf (_(" File: %lx"), ent.vn_file);
9658
9659 printf (_(" Cnt: %d\n"), ent.vn_cnt);
9660
dd24e3da 9661 /* Check for overflow. */
7e26601c 9662 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da 9663 break;
252b5132
RH		 9664 vstart += ent.vn_aux;
9665
9666 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9667 {
2cf0635d 9668 Elf_External_Vernaux * eaux;
b34976b6 9669 Elf_Internal_Vernaux aux;
252b5132 9670
54806181
AM		 9671 if (vstart + sizeof (*eaux) > endbuf)
9672 break;
252b5132
RH		 9673 eaux = (Elf_External_Vernaux *) vstart;
9674
9675 aux.vna_hash = BYTE_GET (eaux->vna_hash);
9676 aux.vna_flags = BYTE_GET (eaux->vna_flags);
9677 aux.vna_other = BYTE_GET (eaux->vna_other);
9678 aux.vna_name = BYTE_GET (eaux->vna_name);
9679 aux.vna_next = BYTE_GET (eaux->vna_next);
9680
d79b3d50 9681 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 9682 printf (_(" %#06x: Name: %s"),
d79b3d50 9683 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 9684 else
ecc2063b 9685 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 9686 isum, aux.vna_name);
9687
9688 printf (_(" Flags: %s Version: %d\n"),
9689 get_ver_flags (aux.vna_flags), aux.vna_other);
9690
dd24e3da 9691 /* Check for overflow. */
53774b7e
NC		 9692 if (aux.vna_next > (size_t) (endbuf - vstart)
9693 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9694 {
9695 warn (_("Invalid vna_next field of %lx\n"),
9696 aux.vna_next);
9697 j = ent.vn_cnt;
9698 break;
9699 }
252b5132
RH		 9700 isum += aux.vna_next;
9701 vstart += aux.vna_next;
9702 }
9cf03b7e 9703
54806181 9704 if (j < ent.vn_cnt)
9cf03b7e 9705 warn (_("Missing Version Needs auxillary information\n"));
252b5132 9706
bcf83b2a 9707 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
c24cf8b6
NC		 9708 {
9709 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9710 cnt = section->sh_info;
9711 break;
9712 }
252b5132
RH		 9713 idx += ent.vn_next;
9714 }
9cf03b7e 9715
54806181 9716 if (cnt < section->sh_info)
9cf03b7e 9717 warn (_("Missing Version Needs information\n"));
103f02d3 9718
252b5132
RH		 9719 free (eneed);
9720 }
9721 break;
9722
9723 case SHT_GNU_versym:
9724 {
2cf0635d 9725 Elf_Internal_Shdr * link_section;
8b73c356
NC		 9726 size_t total;
9727 unsigned int cnt;
2cf0635d
NC		 9728 unsigned char * edata;
9729 unsigned short * data;
9730 char * strtab;
9731 Elf_Internal_Sym * symbols;
9732 Elf_Internal_Shdr * string_sec;
ba5cdace 9733 unsigned long num_syms;
d3ba0551 9734 long off;
252b5132 9735
4fbb74a6 9736 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9737 break;
9738
4fbb74a6 9739 link_section = section_headers + section->sh_link;
08d8fa11 9740 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 9741
4fbb74a6 9742 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9743 break;
9744
252b5132
RH		 9745 found = 1;
9746
ba5cdace 9747 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 9748 if (symbols == NULL)
9749 break;
252b5132 9750
4fbb74a6 9751 string_sec = section_headers + link_section->sh_link;
252b5132 9752
3f5e193b
NC		 9753 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9754 string_sec->sh_size,
9755 _("version string table"));
a6e9f9df 9756 if (!strtab)
0429c154
MS		 9757 {
9758 free (symbols);
9759 break;
9760 }
252b5132 9761
8b73c356
NC		 9762 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9763 printable_section_name (section), (unsigned long) total);
252b5132
RH		 9764
9765 printf (_(" Addr: "));
9766 printf_vma (section->sh_addr);
72de5009 9767 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9768 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9769 printable_section_name (link_section));
252b5132 9770
d3ba0551
AM		 9771 off = offset_from_vma (file,
9772 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9773 total * sizeof (short));
3f5e193b
NC		 9774 edata = (unsigned char *) get_data (NULL, file, off, total,
9775 sizeof (short),
9776 _("version symbol data"));
a6e9f9df
AM		 9777 if (!edata)
9778 {
9779 free (strtab);
0429c154 9780 free (symbols);
a6e9f9df
AM		 9781 break;
9782 }
252b5132 9783
3f5e193b 9784 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 9785
9786 for (cnt = total; cnt --;)
b34976b6
AM		 9787 data[cnt] = byte_get (edata + cnt * sizeof (short),
9788 sizeof (short));
252b5132
RH		 9789
9790 free (edata);
9791
9792 for (cnt = 0; cnt < total; cnt += 4)
9793 {
9794 int j, nn;
00d93f34 9795 int check_def, check_need;
2cf0635d 9796 char * name;
252b5132
RH		 9797
9798 printf (" %03x:", cnt);
9799
9800 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 9801 switch (data[cnt + j])
252b5132
RH		 9802 {
9803 case 0:
9804 fputs (_(" 0 (*local*) "), stdout);
9805 break;
9806
9807 case 1:
9808 fputs (_(" 1 (*global*) "), stdout);
9809 break;
9810
9811 default:
c244d050
NC		 9812 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9813 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 9814
dd24e3da 9815 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 9816 array, break to avoid an out-of-bounds read. */
9817 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 9818 {
9819 warn (_("invalid index into symbol array\n"));
9820 break;
9821 }
9822
00d93f34
JJ		 9823 check_def = 1;
9824 check_need = 1;
4fbb74a6
AM		 9825 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9826 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 9827 != SHT_NOBITS)
252b5132 9828 {
b34976b6 9829 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 9830 check_def = 0;
9831 else
9832 check_need = 0;
252b5132 9833 }
00d93f34
JJ		 9834
9835 if (check_need
b34976b6 9836 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 9837 {
b34976b6
AM		 9838 Elf_Internal_Verneed ivn;
9839 unsigned long offset;
252b5132 9840
d93f0186
NC		 9841 offset = offset_from_vma
9842 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9843 sizeof (Elf_External_Verneed));
252b5132 9844
b34976b6 9845 do
252b5132 9846 {
b34976b6
AM		 9847 Elf_Internal_Vernaux ivna;
9848 Elf_External_Verneed evn;
9849 Elf_External_Vernaux evna;
9850 unsigned long a_off;
252b5132 9851
59245841
NC		 9852 if (get_data (&evn, file, offset, sizeof (evn), 1,
9853 _("version need")) == NULL)
9854 break;
0b4362b0 9855
252b5132
RH		 9856 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9857 ivn.vn_next = BYTE_GET (evn.vn_next);
9858
9859 a_off = offset + ivn.vn_aux;
9860
9861 do
9862 {
59245841
NC		 9863 if (get_data (&evna, file, a_off, sizeof (evna),
9864 1, _("version need aux (2)")) == NULL)
9865 {
9866 ivna.vna_next = 0;
9867 ivna.vna_other = 0;
9868 }
9869 else
9870 {
9871 ivna.vna_next = BYTE_GET (evna.vna_next);
9872 ivna.vna_other = BYTE_GET (evna.vna_other);
9873 }
252b5132
RH		 9874
9875 a_off += ivna.vna_next;
9876 }
b34976b6 9877 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 9878 && ivna.vna_next != 0);
9879
b34976b6 9880 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 9881 {
9882 ivna.vna_name = BYTE_GET (evna.vna_name);
9883
54806181
AM		 9884 if (ivna.vna_name >= string_sec->sh_size)
9885 name = _("*invalid*");
9886 else
9887 name = strtab + ivna.vna_name;
252b5132 9888 nn += printf ("(%s%-*s",
16062207
ILT		 9889 name,
9890 12 - (int) strlen (name),
252b5132 9891 ")");
00d93f34 9892 check_def = 0;
252b5132
RH		 9893 break;
9894 }
9895
9896 offset += ivn.vn_next;
9897 }
9898 while (ivn.vn_next);
9899 }
00d93f34 9900
b34976b6
AM		 9901 if (check_def && data[cnt + j] != 0x8001
9902 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9903 {
b34976b6
AM		 9904 Elf_Internal_Verdef ivd;
9905 Elf_External_Verdef evd;
9906 unsigned long offset;
252b5132 9907
d93f0186
NC		 9908 offset = offset_from_vma
9909 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9910 sizeof evd);
252b5132
RH		 9911
9912 do
9913 {
59245841
NC		 9914 if (get_data (&evd, file, offset, sizeof (evd), 1,
9915 _("version def")) == NULL)
9916 {
9917 ivd.vd_next = 0;
948f632f 9918 /* PR 17531: file: 046-1082287-0.004. */
3102e897
NC		 9919 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
9920 break;
59245841
NC		 9921 }
9922 else
9923 {
9924 ivd.vd_next = BYTE_GET (evd.vd_next);
9925 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9926 }
252b5132
RH		 9927
9928 offset += ivd.vd_next;
9929 }
c244d050 9930 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 9931 && ivd.vd_next != 0);
9932
c244d050 9933 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 9934 {
b34976b6
AM		 9935 Elf_External_Verdaux evda;
9936 Elf_Internal_Verdaux ivda;
252b5132
RH		 9937
9938 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9939
59245841
NC		 9940 if (get_data (&evda, file,
9941 offset - ivd.vd_next + ivd.vd_aux,
9942 sizeof (evda), 1,
9943 _("version def aux")) == NULL)
9944 break;
252b5132
RH		 9945
9946 ivda.vda_name = BYTE_GET (evda.vda_name);
9947
54806181
AM		 9948 if (ivda.vda_name >= string_sec->sh_size)
9949 name = _("*invalid*");
9950 else
9951 name = strtab + ivda.vda_name;
252b5132 9952 nn += printf ("(%s%-*s",
16062207
ILT		 9953 name,
9954 12 - (int) strlen (name),
252b5132
RH		 9955 ")");
9956 }
9957 }
9958
9959 if (nn < 18)
9960 printf ("%*c", 18 - nn, ' ');
9961 }
9962
9963 putchar ('\n');
9964 }
9965
9966 free (data);
9967 free (strtab);
9968 free (symbols);
9969 }
9970 break;
103f02d3 9971
252b5132
RH		 9972 default:
9973 break;
9974 }
9975 }
9976
9977 if (! found)
9978 printf (_("\nNo version information found in this file.\n"));
9979
9980 return 1;
9981}
9982
d1133906 9983static const char *
d3ba0551 9984get_symbol_binding (unsigned int binding)
252b5132 9985{
b34976b6 9986 static char buff[32];
252b5132
RH		 9987
9988 switch (binding)
9989 {
b34976b6
AM		 9990 case STB_LOCAL: return "LOCAL";
9991 case STB_GLOBAL: return "GLOBAL";
9992 case STB_WEAK: return "WEAK";
252b5132
RH		 9993 default:
9994 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 9995 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9996 binding);
252b5132 9997 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 9998 {
9999 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 10000 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10001 /* GNU is still using the default value 0. */
3e7a7d11
NC		 10002 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10003 return "UNIQUE";
10004 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10005 }
252b5132 10006 else
e9e44622 10007 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 10008 return buff;
10009 }
10010}
10011
d1133906 10012static const char *
d3ba0551 10013get_symbol_type (unsigned int type)
252b5132 10014{
b34976b6 10015 static char buff[32];
252b5132
RH		 10016
10017 switch (type)
10018 {
b34976b6
AM		 10019 case STT_NOTYPE: return "NOTYPE";
10020 case STT_OBJECT: return "OBJECT";
10021 case STT_FUNC: return "FUNC";
10022 case STT_SECTION: return "SECTION";
10023 case STT_FILE: return "FILE";
10024 case STT_COMMON: return "COMMON";
10025 case STT_TLS: return "TLS";
15ab5209
DB		 10026 case STT_RELC: return "RELC";
10027 case STT_SRELC: return "SRELC";
252b5132
RH		 10028 default:
10029 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 10030 {
3510a7b8
NC		 10031 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10032 return "THUMB_FUNC";
103f02d3 10033
351b4b40 10034 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 10035 return "REGISTER";
10036
10037 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10038 return "PARISC_MILLI";
10039
e9e44622 10040 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 10041 }
252b5132 10042 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 10043 {
10044 if (elf_header.e_machine == EM_PARISC)
10045 {
10046 if (type == STT_HP_OPAQUE)
10047 return "HP_OPAQUE";
10048 if (type == STT_HP_STUB)
10049 return "HP_STUB";
10050 }
10051
d8045f23 10052 if (type == STT_GNU_IFUNC
9c55345c 10053 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 10054 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 10055 /* GNU is still using the default value 0. */
d8045f23
NC		 10056 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10057 return "IFUNC";
10058
e9e44622 10059 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 10060 }
252b5132 10061 else
e9e44622 10062 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 10063 return buff;
10064 }
10065}
10066
d1133906 10067static const char *
d3ba0551 10068get_symbol_visibility (unsigned int visibility)
d1133906
NC		 10069{
10070 switch (visibility)
10071 {
b34976b6
AM		 10072 case STV_DEFAULT: return "DEFAULT";
10073 case STV_INTERNAL: return "INTERNAL";
10074 case STV_HIDDEN: return "HIDDEN";
d1133906 10075 case STV_PROTECTED: return "PROTECTED";
bee0ee85
NC		 10076 default:
10077 error (_("Unrecognized visibility value: %u"), visibility);
10078 return _("<unknown>");
d1133906
NC		 10079 }
10080}
10081
5e2b0d47
NC		 10082static const char *
10083get_mips_symbol_other (unsigned int other)
10084{
10085 switch (other)
10086 {
df58fc94
RS		 10087 case STO_OPTIONAL:
10088 return "OPTIONAL";
10089 case STO_MIPS_PLT:
10090 return "MIPS PLT";
10091 case STO_MIPS_PIC:
10092 return "MIPS PIC";
10093 case STO_MICROMIPS:
10094 return "MICROMIPS";
10095 case STO_MICROMIPS | STO_MIPS_PIC:
10096 return "MICROMIPS, MIPS PIC";
10097 case STO_MIPS16:
10098 return "MIPS16";
10099 default:
10100 return NULL;
5e2b0d47
NC		 10101 }
10102}
10103
28f997cf
TG		 10104static const char *
10105get_ia64_symbol_other (unsigned int other)
10106{
10107 if (is_ia64_vms ())
10108 {
10109 static char res[32];
10110
10111 res[0] = 0;
10112
10113 /* Function types is for images and .STB files only. */
10114 switch (elf_header.e_type)
10115 {
10116 case ET_DYN:
10117 case ET_EXEC:
10118 switch (VMS_ST_FUNC_TYPE (other))
10119 {
10120 case VMS_SFT_CODE_ADDR:
10121 strcat (res, " CA");
10122 break;
10123 case VMS_SFT_SYMV_IDX:
10124 strcat (res, " VEC");
10125 break;
10126 case VMS_SFT_FD:
10127 strcat (res, " FD");
10128 break;
10129 case VMS_SFT_RESERVE:
10130 strcat (res, " RSV");
10131 break;
10132 default:
bee0ee85
NC		 10133 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10134 VMS_ST_FUNC_TYPE (other));
10135 strcat (res, " <unknown>");
10136 break;
28f997cf
TG		 10137 }
10138 break;
10139 default:
10140 break;
10141 }
10142 switch (VMS_ST_LINKAGE (other))
10143 {
10144 case VMS_STL_IGNORE:
10145 strcat (res, " IGN");
10146 break;
10147 case VMS_STL_RESERVE:
10148 strcat (res, " RSV");
10149 break;
10150 case VMS_STL_STD:
10151 strcat (res, " STD");
10152 break;
10153 case VMS_STL_LNK:
10154 strcat (res, " LNK");
10155 break;
10156 default:
bee0ee85
NC		 10157 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10158 VMS_ST_LINKAGE (other));
10159 strcat (res, " <unknown>");
10160 break;
28f997cf
TG		 10161 }
10162
10163 if (res[0] != 0)
10164 return res + 1;
10165 else
10166 return res;
10167 }
10168 return NULL;
10169}
10170
6911b7dc
AM		 10171static const char *
10172get_ppc64_symbol_other (unsigned int other)
10173{
10174 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10175 {
10176 static char buf[32];
10177 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10178 PPC64_LOCAL_ENTRY_OFFSET (other));
10179 return buf;
10180 }
10181 return NULL;
10182}
10183
5e2b0d47
NC		 10184static const char *
10185get_symbol_other (unsigned int other)
10186{
10187 const char * result = NULL;
10188 static char buff [32];
10189
10190 if (other == 0)
10191 return "";
10192
10193 switch (elf_header.e_machine)
10194 {
10195 case EM_MIPS:
10196 result = get_mips_symbol_other (other);
28f997cf
TG		 10197 break;
10198 case EM_IA_64:
10199 result = get_ia64_symbol_other (other);
10200 break;
6911b7dc
AM		 10201 case EM_PPC64:
10202 result = get_ppc64_symbol_other (other);
10203 break;
5e2b0d47
NC		 10204 default:
10205 break;
10206 }
10207
10208 if (result)
10209 return result;
10210
10211 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10212 return buff;
10213}
10214
d1133906 10215static const char *
d3ba0551 10216get_symbol_index_type (unsigned int type)
252b5132 10217{
b34976b6 10218 static char buff[32];
5cf1065c 10219
252b5132
RH		 10220 switch (type)
10221 {
b34976b6
AM		 10222 case SHN_UNDEF: return "UND";
10223 case SHN_ABS: return "ABS";
10224 case SHN_COMMON: return "COM";
252b5132 10225 default:
9ce701e2
L		 10226 if (type == SHN_IA_64_ANSI_COMMON
10227 && elf_header.e_machine == EM_IA_64
10228 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10229 return "ANSI_COM";
8a9036a4 10230 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 10231 || elf_header.e_machine == EM_L1OM
10232 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 10233 && type == SHN_X86_64_LCOMMON)
10234 return "LARGE_COM";
ac145307
BS		 10235 else if ((type == SHN_MIPS_SCOMMON
10236 && elf_header.e_machine == EM_MIPS)
10237 || (type == SHN_TIC6X_SCOMMON
10238 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 10239 return "SCOM";
10240 else if (type == SHN_MIPS_SUNDEFINED
10241 && elf_header.e_machine == EM_MIPS)
10242 return "SUND";
9ce701e2 10243 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 10244 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 10245 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 10246 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10247 else if (type >= SHN_LORESERVE)
10248 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4 10249 else if (type >= elf_header.e_shnum)
e0a31db1 10250 sprintf (buff, _("bad section index[%3d]"), type);
252b5132 10251 else
232e7cb8 10252 sprintf (buff, "%3d", type);
5cf1065c 10253 break;
252b5132 10254 }
5cf1065c
NC		 10255
10256 return buff;
252b5132
RH		 10257}
10258
66543521 10259static bfd_vma *
57028622 10260get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
252b5132 10261{
2cf0635d
NC		 10262 unsigned char * e_data;
10263 bfd_vma * i_data;
252b5132 10264
57028622
NC		 10265 /* If the size_t type is smaller than the bfd_size_type, eg because
10266 you are building a 32-bit tool on a 64-bit host, then make sure
10267 that when (number) is cast to (size_t) no information is lost. */
10268 if (sizeof (size_t) < sizeof (bfd_size_type)
10269 && (bfd_size_type) ((size_t) number) != number)
10270 {
10271 error (_("Size truncation prevents reading %llu elements of size %u\n"),
10272 (unsigned long long) number, ent_size);
10273 return NULL;
10274 }
948f632f 10275
3102e897
NC		 10276 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10277 attempting to allocate memory when the read is bound to fail. */
10278 if (ent_size * number > current_file_size)
10279 {
57028622
NC		 10280 error (_("Invalid number of dynamic entries: %llu\n"),
10281 (unsigned long long) number);
3102e897
NC		 10282 return NULL;
10283 }
10284
57028622 10285 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
252b5132
RH		 10286 if (e_data == NULL)
10287 {
57028622
NC		 10288 error (_("Out of memory reading %llu dynamic entries\n"),
10289 (unsigned long long) number);
252b5132
RH		 10290 return NULL;
10291 }
10292
57028622 10293 if (fread (e_data, ent_size, (size_t) number, file) != number)
252b5132 10294 {
57028622
NC		 10295 error (_("Unable to read in %llu bytes of dynamic data\n"),
10296 (unsigned long long) (number * ent_size));
3102e897 10297 free (e_data);
252b5132
RH		 10298 return NULL;
10299 }
10300
57028622 10301 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
252b5132
RH		 10302 if (i_data == NULL)
10303 {
57028622
NC		 10304 error (_("Out of memory allocating space for %llu dynamic entries\n"),
10305 (unsigned long long) number);
252b5132
RH		 10306 free (e_data);
10307 return NULL;
10308 }
10309
10310 while (number--)
66543521 10311 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 10312
10313 free (e_data);
10314
10315 return i_data;
10316}
10317
6bd1a22c
L		 10318static void
10319print_dynamic_symbol (bfd_vma si, unsigned long hn)
10320{
2cf0635d 10321 Elf_Internal_Sym * psym;
6bd1a22c
L		 10322 int n;
10323
6bd1a22c
L		 10324 n = print_vma (si, DEC_5);
10325 if (n < 5)
0b4362b0 10326 fputs (&" "[n], stdout);
6bd1a22c 10327 printf (" %3lu: ", hn);
e0a31db1
NC		 10328
10329 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10330 {
3102e897
NC		 10331 printf (_("<No info available for dynamic symbol number %lu>\n"),
10332 (unsigned long) si);
e0a31db1
NC		 10333 return;
10334 }
10335
10336 psym = dynamic_symbols + si;
6bd1a22c
L		 10337 print_vma (psym->st_value, LONG_HEX);
10338 putchar (' ');
10339 print_vma (psym->st_size, DEC_5);
10340
f4be36b3
AM		 10341 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10342 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10343 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 10344 /* Check to see if any other bits in the st_other field are set.
10345 Note - displaying this information disrupts the layout of the
10346 table being generated, but for the moment this case is very
10347 rare. */
10348 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10349 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10350 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10351 if (VALID_DYNAMIC_NAME (psym->st_name))
10352 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10353 else
2b692964 10354 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 10355 putchar ('\n');
10356}
10357
bb4d2ac2
L		 10358static const char *
10359get_symbol_version_string (FILE *file, int is_dynsym,
10360 const char *strtab,
10361 unsigned long int strtab_size,
10362 unsigned int si, Elf_Internal_Sym *psym,
10363 enum versioned_symbol_info *sym_info,
10364 unsigned short *vna_other)
10365{
10366 const char *version_string = NULL;
10367
10368 if (is_dynsym
10369 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
10370 {
10371 unsigned char data[2];
10372 unsigned short vers_data;
10373 unsigned long offset;
10374 int is_nobits;
10375 int check_def;
10376
10377 offset = offset_from_vma
10378 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10379 sizeof data + si * sizeof (vers_data));
10380
10381 if (get_data (&data, file, offset + si * sizeof (vers_data),
10382 sizeof (data), 1, _("version data")) == NULL)
10383 return NULL;
10384
10385 vers_data = byte_get (data, 2);
10386
53774b7e
NC		 10387 is_nobits = (section_headers != NULL
10388 && psym->st_shndx < elf_header.e_shnum
bb4d2ac2
L		 10389 && section_headers[psym->st_shndx].sh_type
10390 == SHT_NOBITS);
10391
10392 check_def = (psym->st_shndx != SHN_UNDEF);
10393
10394 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
10395 {
10396 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
10397 && (is_nobits || ! check_def))
10398 {
10399 Elf_External_Verneed evn;
10400 Elf_Internal_Verneed ivn;
10401 Elf_Internal_Vernaux ivna;
10402
10403 /* We must test both. */
10404 offset = offset_from_vma
10405 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10406 sizeof evn);
10407
10408 do
10409 {
10410 unsigned long vna_off;
10411
10412 if (get_data (&evn, file, offset, sizeof (evn), 1,
10413 _("version need")) == NULL)
10414 {
10415 ivna.vna_next = 0;
10416 ivna.vna_other = 0;
10417 ivna.vna_name = 0;
10418 break;
10419 }
10420
10421 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10422 ivn.vn_next = BYTE_GET (evn.vn_next);
10423
10424 vna_off = offset + ivn.vn_aux;
10425
10426 do
10427 {
10428 Elf_External_Vernaux evna;
10429
10430 if (get_data (&evna, file, vna_off,
10431 sizeof (evna), 1,
10432 _("version need aux (3)")) == NULL)
10433 {
10434 ivna.vna_next = 0;
10435 ivna.vna_other = 0;
10436 ivna.vna_name = 0;
10437 }
10438 else
10439 {
10440 ivna.vna_other = BYTE_GET (evna.vna_other);
10441 ivna.vna_next = BYTE_GET (evna.vna_next);
10442 ivna.vna_name = BYTE_GET (evna.vna_name);
10443 }
10444
10445 vna_off += ivna.vna_next;
10446 }
10447 while (ivna.vna_other != vers_data
10448 && ivna.vna_next != 0);
10449
10450 if (ivna.vna_other == vers_data)
10451 break;
10452
10453 offset += ivn.vn_next;
10454 }
10455 while (ivn.vn_next != 0);
10456
10457 if (ivna.vna_other == vers_data)
10458 {
10459 *sym_info = symbol_undefined;
10460 *vna_other = ivna.vna_other;
10461 version_string = (ivna.vna_name < strtab_size
10462 ? strtab + ivna.vna_name
10463 : _("<corrupt>"));
10464 check_def = 0;
10465 }
10466 else if (! is_nobits)
10467 error (_("bad dynamic symbol\n"));
10468 else
10469 check_def = 1;
10470 }
10471
10472 if (check_def)
10473 {
10474 if (vers_data != 0x8001
10475 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10476 {
10477 Elf_Internal_Verdef ivd;
10478 Elf_Internal_Verdaux ivda;
10479 Elf_External_Verdaux evda;
10480 unsigned long off;
10481
10482 off = offset_from_vma
10483 (file,
10484 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10485 sizeof (Elf_External_Verdef));
10486
10487 do
10488 {
10489 Elf_External_Verdef evd;
10490
10491 if (get_data (&evd, file, off, sizeof (evd),
10492 1, _("version def")) == NULL)
10493 {
10494 ivd.vd_ndx = 0;
10495 ivd.vd_aux = 0;
10496 ivd.vd_next = 0;
10497 }
10498 else
10499 {
10500 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10501 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10502 ivd.vd_next = BYTE_GET (evd.vd_next);
10503 }
10504
10505 off += ivd.vd_next;
10506 }
10507 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10508 && ivd.vd_next != 0);
10509
10510 off -= ivd.vd_next;
10511 off += ivd.vd_aux;
10512
10513 if (get_data (&evda, file, off, sizeof (evda),
10514 1, _("version def aux")) == NULL)
10515 return version_string;
10516
10517 ivda.vda_name = BYTE_GET (evda.vda_name);
10518
10519 if (psym->st_name != ivda.vda_name)
10520 {
10521 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10522 ? symbol_hidden : symbol_public);
10523 version_string = (ivda.vda_name < strtab_size
10524 ? strtab + ivda.vda_name
10525 : _("<corrupt>"));
10526 }
10527 }
10528 }
10529 }
10530 }
10531 return version_string;
10532}
10533
e3c8793a 10534/* Dump the symbol table. */
252b5132 10535static int
2cf0635d 10536process_symbol_table (FILE * file)
252b5132 10537{
2cf0635d 10538 Elf_Internal_Shdr * section;
8b73c356
NC		 10539 bfd_size_type nbuckets = 0;
10540 bfd_size_type nchains = 0;
2cf0635d
NC		 10541 bfd_vma * buckets = NULL;
10542 bfd_vma * chains = NULL;
fdc90cb4 10543 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 10544 bfd_vma * gnubuckets = NULL;
10545 bfd_vma * gnuchains = NULL;
6bd1a22c 10546 bfd_vma gnusymidx = 0;
071436c6 10547 bfd_size_type ngnuchains = 0;
252b5132 10548
2c610e4b 10549 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 10550 return 1;
10551
6bd1a22c
L		 10552 if (dynamic_info[DT_HASH]
10553 && (do_histogram
2c610e4b
L		 10554 || (do_using_dynamic
10555 && !do_dyn_syms
10556 && dynamic_strings != NULL)))
252b5132 10557 {
66543521
AM		 10558 unsigned char nb[8];
10559 unsigned char nc[8];
8b73c356 10560 unsigned int hash_ent_size = 4;
66543521
AM		 10561
10562 if ((elf_header.e_machine == EM_ALPHA
10563 || elf_header.e_machine == EM_S390
10564 || elf_header.e_machine == EM_S390_OLD)
10565 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10566 hash_ent_size = 8;
10567
fb52b2f4
NC		 10568 if (fseek (file,
10569 (archive_file_offset
10570 + offset_from_vma (file, dynamic_info[DT_HASH],
10571 sizeof nb + sizeof nc)),
d93f0186 10572 SEEK_SET))
252b5132 10573 {
591a748a 10574 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10575 goto no_hash;
252b5132
RH		 10576 }
10577
66543521 10578 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 10579 {
10580 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10581 goto no_hash;
252b5132
RH		 10582 }
10583
66543521 10584 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 10585 {
10586 error (_("Failed to read in number of chains\n"));
d3a44ec6 10587 goto no_hash;
252b5132
RH		 10588 }
10589
66543521
AM		 10590 nbuckets = byte_get (nb, hash_ent_size);
10591 nchains = byte_get (nc, hash_ent_size);
252b5132 10592
66543521
AM		 10593 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10594 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 10595
d3a44ec6 10596 no_hash:
252b5132 10597 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 10598 {
10599 if (do_using_dynamic)
10600 return 0;
10601 free (buckets);
10602 free (chains);
10603 buckets = NULL;
10604 chains = NULL;
10605 nbuckets = 0;
10606 nchains = 0;
10607 }
252b5132
RH		 10608 }
10609
6bd1a22c
L		 10610 if (dynamic_info_DT_GNU_HASH
10611 && (do_histogram
2c610e4b
L		 10612 || (do_using_dynamic
10613 && !do_dyn_syms
10614 && dynamic_strings != NULL)))
252b5132 10615 {
6bd1a22c
L		 10616 unsigned char nb[16];
10617 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10618 bfd_vma buckets_vma;
10619
10620 if (fseek (file,
10621 (archive_file_offset
10622 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10623 sizeof nb)),
10624 SEEK_SET))
10625 {
10626 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10627 goto no_gnu_hash;
6bd1a22c 10628 }
252b5132 10629
6bd1a22c
L		 10630 if (fread (nb, 16, 1, file) != 1)
10631 {
10632 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10633 goto no_gnu_hash;
6bd1a22c
L		 10634 }
10635
10636 ngnubuckets = byte_get (nb, 4);
10637 gnusymidx = byte_get (nb + 4, 4);
10638 bitmaskwords = byte_get (nb + 8, 4);
10639 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 10640 if (is_32bit_elf)
6bd1a22c 10641 buckets_vma += bitmaskwords * 4;
f7a99963 10642 else
6bd1a22c 10643 buckets_vma += bitmaskwords * 8;
252b5132 10644
6bd1a22c
L		 10645 if (fseek (file,
10646 (archive_file_offset
10647 + offset_from_vma (file, buckets_vma, 4)),
10648 SEEK_SET))
252b5132 10649 {
6bd1a22c 10650 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10651 goto no_gnu_hash;
6bd1a22c
L		 10652 }
10653
10654 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 10655
6bd1a22c 10656 if (gnubuckets == NULL)
d3a44ec6 10657 goto no_gnu_hash;
6bd1a22c
L		 10658
10659 for (i = 0; i < ngnubuckets; i++)
10660 if (gnubuckets[i] != 0)
10661 {
10662 if (gnubuckets[i] < gnusymidx)
10663 return 0;
10664
10665 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10666 maxchain = gnubuckets[i];
10667 }
10668
10669 if (maxchain == 0xffffffff)
d3a44ec6 10670 goto no_gnu_hash;
6bd1a22c
L		 10671
10672 maxchain -= gnusymidx;
10673
10674 if (fseek (file,
10675 (archive_file_offset
10676 + offset_from_vma (file, buckets_vma
10677 + 4 * (ngnubuckets + maxchain), 4)),
10678 SEEK_SET))
10679 {
10680 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10681 goto no_gnu_hash;
6bd1a22c
L		 10682 }
10683
10684 do
10685 {
10686 if (fread (nb, 4, 1, file) != 1)
252b5132 10687 {
6bd1a22c 10688 error (_("Failed to determine last chain length\n"));
d3a44ec6 10689 goto no_gnu_hash;
6bd1a22c 10690 }
252b5132 10691
6bd1a22c 10692 if (maxchain + 1 == 0)
d3a44ec6 10693 goto no_gnu_hash;
252b5132 10694
6bd1a22c
L		 10695 ++maxchain;
10696 }
10697 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 10698
6bd1a22c
L		 10699 if (fseek (file,
10700 (archive_file_offset
10701 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10702 SEEK_SET))
10703 {
10704 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10705 goto no_gnu_hash;
6bd1a22c
L		 10706 }
10707
10708 gnuchains = get_dynamic_data (file, maxchain, 4);
071436c6 10709 ngnuchains = maxchain;
6bd1a22c 10710
d3a44ec6 10711 no_gnu_hash:
6bd1a22c 10712 if (gnuchains == NULL)
d3a44ec6
JJ		 10713 {
10714 free (gnubuckets);
d3a44ec6
JJ		 10715 gnubuckets = NULL;
10716 ngnubuckets = 0;
f64fddf1
NC		 10717 if (do_using_dynamic)
10718 return 0;
d3a44ec6 10719 }
6bd1a22c
L		 10720 }
10721
10722 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10723 && do_syms
10724 && do_using_dynamic
3102e897
NC		 10725 && dynamic_strings != NULL
10726 && dynamic_symbols != NULL)
6bd1a22c
L		 10727 {
10728 unsigned long hn;
10729
10730 if (dynamic_info[DT_HASH])
10731 {
10732 bfd_vma si;
10733
10734 printf (_("\nSymbol table for image:\n"));
10735 if (is_32bit_elf)
10736 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10737 else
10738 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10739
10740 for (hn = 0; hn < nbuckets; hn++)
10741 {
10742 if (! buckets[hn])
10743 continue;
10744
10745 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10746 print_dynamic_symbol (si, hn);
252b5132
RH		 10747 }
10748 }
6bd1a22c
L		 10749
10750 if (dynamic_info_DT_GNU_HASH)
10751 {
10752 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10753 if (is_32bit_elf)
10754 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10755 else
10756 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10757
10758 for (hn = 0; hn < ngnubuckets; ++hn)
10759 if (gnubuckets[hn] != 0)
10760 {
10761 bfd_vma si = gnubuckets[hn];
10762 bfd_vma off = si - gnusymidx;
10763
10764 do
10765 {
10766 print_dynamic_symbol (si, hn);
10767 si++;
10768 }
071436c6 10769 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
6bd1a22c
L		 10770 }
10771 }
252b5132 10772 }
8b73c356
NC		 10773 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10774 && section_headers != NULL)
252b5132 10775 {
b34976b6 10776 unsigned int i;
252b5132
RH		 10777
10778 for (i = 0, section = section_headers;
10779 i < elf_header.e_shnum;
10780 i++, section++)
10781 {
b34976b6 10782 unsigned int si;
2cf0635d 10783 char * strtab = NULL;
c256ffe7 10784 unsigned long int strtab_size = 0;
2cf0635d
NC		 10785 Elf_Internal_Sym * symtab;
10786 Elf_Internal_Sym * psym;
ba5cdace 10787 unsigned long num_syms;
252b5132 10788
2c610e4b
L		 10789 if ((section->sh_type != SHT_SYMTAB
10790 && section->sh_type != SHT_DYNSYM)
10791 || (!do_syms
10792 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 10793 continue;
10794
dd24e3da
NC		 10795 if (section->sh_entsize == 0)
10796 {
10797 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
74e1a04b 10798 printable_section_name (section));
dd24e3da
NC		 10799 continue;
10800 }
10801
252b5132 10802 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
74e1a04b 10803 printable_section_name (section),
252b5132 10804 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 10805
f7a99963 10806 if (is_32bit_elf)
ca47b30c 10807 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 10808 else
ca47b30c 10809 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 10810
ba5cdace 10811 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 10812 if (symtab == NULL)
10813 continue;
10814
10815 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 10816 {
10817 strtab = string_table;
10818 strtab_size = string_table_length;
10819 }
4fbb74a6 10820 else if (section->sh_link < elf_header.e_shnum)
252b5132 10821 {
2cf0635d 10822 Elf_Internal_Shdr * string_sec;
252b5132 10823
4fbb74a6 10824 string_sec = section_headers + section->sh_link;
252b5132 10825
3f5e193b
NC		 10826 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10827 1, string_sec->sh_size,
10828 _("string table"));
c256ffe7 10829 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 10830 }
10831
ba5cdace 10832 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 10833 {
bb4d2ac2
L		 10834 const char *version_string;
10835 enum versioned_symbol_info sym_info;
10836 unsigned short vna_other;
10837
5e220199 10838 printf ("%6d: ", si);
f7a99963
NC		 10839 print_vma (psym->st_value, LONG_HEX);
10840 putchar (' ');
10841 print_vma (psym->st_size, DEC_5);
d1133906
NC		 10842 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10843 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 10844 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 10845 /* Check to see if any other bits in the st_other field are set.
10846 Note - displaying this information disrupts the layout of the
10847 table being generated, but for the moment this case is very rare. */
10848 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10849 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 10850 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 10851 print_symbol (25, psym->st_name < strtab_size
2b692964 10852 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 10853
bb4d2ac2
L		 10854 version_string
10855 = get_symbol_version_string (file,
10856 section->sh_type == SHT_DYNSYM,
10857 strtab, strtab_size, si,
10858 psym, &sym_info, &vna_other);
10859 if (version_string)
252b5132 10860 {
bb4d2ac2
L		 10861 if (sym_info == symbol_undefined)
10862 printf ("@%s (%d)", version_string, vna_other);
10863 else
10864 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10865 version_string);
252b5132
RH		 10866 }
10867
10868 putchar ('\n');
10869 }
10870
10871 free (symtab);
10872 if (strtab != string_table)
10873 free (strtab);
10874 }
10875 }
10876 else if (do_syms)
10877 printf
10878 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10879
10880 if (do_histogram && buckets != NULL)
10881 {
2cf0635d
NC		 10882 unsigned long * lengths;
10883 unsigned long * counts;
66543521
AM		 10884 unsigned long hn;
10885 bfd_vma si;
10886 unsigned long maxlength = 0;
10887 unsigned long nzero_counts = 0;
10888 unsigned long nsyms = 0;
94d15024 10889 unsigned long chained;
252b5132 10890
66543521
AM		 10891 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10892 (unsigned long) nbuckets);
252b5132 10893
3f5e193b 10894 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 10895 if (lengths == NULL)
10896 {
8b73c356 10897 error (_("Out of memory allocating space for histogram buckets\n"));
252b5132
RH		 10898 return 0;
10899 }
8b73c356
NC		 10900
10901 printf (_(" Length Number %% of total Coverage\n"));
252b5132
RH		 10902 for (hn = 0; hn < nbuckets; ++hn)
10903 {
94d15024
MF		 10904 for (si = buckets[hn], chained = 0;
10905 si > 0 && si < nchains && si < nbuckets && chained <= nchains;
10906 si = chains[si], ++chained)
252b5132 10907 {
b34976b6 10908 ++nsyms;
252b5132 10909 if (maxlength < ++lengths[hn])
b34976b6 10910 ++maxlength;
252b5132 10911 }
94d15024
MF		 10912
10913 /* PR binutils/17531: A corrupt binary could contain broken
10914 histogram data. Do not go into an infinite loop trying
10915 to process it. */
10916 if (chained > nchains)
10917 {
10918 error (_("histogram chain is corrupt\n"));
10919 break;
10920 }
252b5132
RH		 10921 }
10922
3f5e193b 10923 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 10924 if (counts == NULL)
10925 {
b2e951ec 10926 free (lengths);
8b73c356 10927 error (_("Out of memory allocating space for histogram counts\n"));
252b5132
RH		 10928 return 0;
10929 }
10930
10931 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 10932 ++counts[lengths[hn]];
252b5132 10933
103f02d3 10934 if (nbuckets > 0)
252b5132 10935 {
66543521
AM		 10936 unsigned long i;
10937 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 10938 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 10939 for (i = 1; i <= maxlength; ++i)
103f02d3 10940 {
66543521
AM		 10941 nzero_counts += counts[i] * i;
10942 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10943 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 10944 (nzero_counts * 100.0) / nsyms);
10945 }
252b5132
RH		 10946 }
10947
10948 free (counts);
10949 free (lengths);
10950 }
10951
10952 if (buckets != NULL)
10953 {
10954 free (buckets);
10955 free (chains);
10956 }
10957
d3a44ec6 10958 if (do_histogram && gnubuckets != NULL)
fdc90cb4 10959 {
2cf0635d
NC		 10960 unsigned long * lengths;
10961 unsigned long * counts;
fdc90cb4
JJ		 10962 unsigned long hn;
10963 unsigned long maxlength = 0;
10964 unsigned long nzero_counts = 0;
10965 unsigned long nsyms = 0;
fdc90cb4 10966
8b73c356
NC		 10967 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10968 (unsigned long) ngnubuckets);
10969
3f5e193b 10970 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 10971 if (lengths == NULL)
10972 {
8b73c356 10973 error (_("Out of memory allocating space for gnu histogram buckets\n"));
fdc90cb4
JJ		 10974 return 0;
10975 }
10976
fdc90cb4
JJ		 10977 printf (_(" Length Number %% of total Coverage\n"));
10978
10979 for (hn = 0; hn < ngnubuckets; ++hn)
10980 if (gnubuckets[hn] != 0)
10981 {
10982 bfd_vma off, length = 1;
10983
6bd1a22c 10984 for (off = gnubuckets[hn] - gnusymidx;
071436c6
NC		 10985 /* PR 17531 file: 010-77222-0.004. */
10986 off < ngnuchains && (gnuchains[off] & 1) == 0;
10987 ++off)
fdc90cb4
JJ		 10988 ++length;
10989 lengths[hn] = length;
10990 if (length > maxlength)
10991 maxlength = length;
10992 nsyms += length;
10993 }
10994
3f5e193b 10995 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 10996 if (counts == NULL)
10997 {
b2e951ec 10998 free (lengths);
8b73c356 10999 error (_("Out of memory allocating space for gnu histogram counts\n"));
fdc90cb4
JJ		 11000 return 0;
11001 }
11002
11003 for (hn = 0; hn < ngnubuckets; ++hn)
11004 ++counts[lengths[hn]];
11005
11006 if (ngnubuckets > 0)
11007 {
11008 unsigned long j;
11009 printf (" 0 %-10lu (%5.1f%%)\n",
11010 counts[0], (counts[0] * 100.0) / ngnubuckets);
11011 for (j = 1; j <= maxlength; ++j)
11012 {
11013 nzero_counts += counts[j] * j;
11014 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11015 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11016 (nzero_counts * 100.0) / nsyms);
11017 }
11018 }
11019
11020 free (counts);
11021 free (lengths);
11022 free (gnubuckets);
11023 free (gnuchains);
11024 }
11025
252b5132
RH		 11026 return 1;
11027}
11028
11029static int
2cf0635d 11030process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 11031{
b4c96d0d 11032 unsigned int i;
252b5132
RH		 11033
11034 if (dynamic_syminfo == NULL
11035 || !do_dynamic)
11036 /* No syminfo, this is ok. */
11037 return 1;
11038
11039 /* There better should be a dynamic symbol section. */
11040 if (dynamic_symbols == NULL || dynamic_strings == NULL)
11041 return 0;
11042
11043 if (dynamic_addr)
11044 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11045 dynamic_syminfo_offset, dynamic_syminfo_nent);
11046
11047 printf (_(" Num: Name BoundTo Flags\n"));
11048 for (i = 0; i < dynamic_syminfo_nent; ++i)
11049 {
11050 unsigned short int flags = dynamic_syminfo[i].si_flags;
11051
31104126 11052 printf ("%4d: ", i);
4082ef84
NC		 11053 if (i >= num_dynamic_syms)
11054 printf (_("<corrupt index>"));
11055 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
d79b3d50
NC		 11056 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11057 else
2b692964 11058 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 11059 putchar (' ');
252b5132
RH		 11060
11061 switch (dynamic_syminfo[i].si_boundto)
11062 {
11063 case SYMINFO_BT_SELF:
11064 fputs ("SELF ", stdout);
11065 break;
11066 case SYMINFO_BT_PARENT:
11067 fputs ("PARENT ", stdout);
11068 break;
11069 default:
11070 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 11071 && dynamic_syminfo[i].si_boundto < dynamic_nent
11072 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 11073 {
d79b3d50 11074 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 11075 putchar (' ' );
11076 }
252b5132
RH		 11077 else
11078 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11079 break;
11080 }
11081
11082 if (flags & SYMINFO_FLG_DIRECT)
11083 printf (" DIRECT");
11084 if (flags & SYMINFO_FLG_PASSTHRU)
11085 printf (" PASSTHRU");
11086 if (flags & SYMINFO_FLG_COPY)
11087 printf (" COPY");
11088 if (flags & SYMINFO_FLG_LAZYLOAD)
11089 printf (" LAZYLOAD");
11090
11091 puts ("");
11092 }
11093
11094 return 1;
11095}
11096
cf13d699
NC		 11097/* Check to see if the given reloc needs to be handled in a target specific
11098 manner. If so then process the reloc and return TRUE otherwise return
11099 FALSE. */
09c11c86 11100
cf13d699
NC		 11101static bfd_boolean
11102target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11103 unsigned char * start,
11104 Elf_Internal_Sym * symtab)
252b5132 11105{
cf13d699 11106 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 11107
cf13d699 11108 switch (elf_header.e_machine)
252b5132 11109 {
13761a11
NC		 11110 case EM_MSP430:
11111 case EM_MSP430_OLD:
11112 {
11113 static Elf_Internal_Sym * saved_sym = NULL;
11114
11115 switch (reloc_type)
11116 {
11117 case 10: /* R_MSP430_SYM_DIFF */
11118 if (uses_msp430x_relocs ())
11119 break;
11120 case 21: /* R_MSP430X_SYM_DIFF */
11121 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11122 return TRUE;
11123
11124 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11125 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11126 goto handle_sym_diff;
0b4362b0 11127
13761a11
NC		 11128 case 5: /* R_MSP430_16_BYTE */
11129 case 9: /* R_MSP430_8 */
11130 if (uses_msp430x_relocs ())
11131 break;
11132 goto handle_sym_diff;
11133
11134 case 2: /* R_MSP430_ABS16 */
11135 case 15: /* R_MSP430X_ABS16 */
11136 if (! uses_msp430x_relocs ())
11137 break;
11138 goto handle_sym_diff;
0b4362b0 11139
13761a11
NC		 11140 handle_sym_diff:
11141 if (saved_sym != NULL)
11142 {
11143 bfd_vma value;
11144
11145 value = reloc->r_addend
11146 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11147 - saved_sym->st_value);
11148
11149 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11150
11151 saved_sym = NULL;
11152 return TRUE;
11153 }
11154 break;
11155
11156 default:
11157 if (saved_sym != NULL)
071436c6 11158 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13761a11
NC		 11159 break;
11160 }
11161 break;
11162 }
11163
cf13d699
NC		 11164 case EM_MN10300:
11165 case EM_CYGNUS_MN10300:
11166 {
11167 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 11168
cf13d699
NC		 11169 switch (reloc_type)
11170 {
11171 case 34: /* R_MN10300_ALIGN */
11172 return TRUE;
11173 case 33: /* R_MN10300_SYM_DIFF */
11174 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11175 return TRUE;
11176 case 1: /* R_MN10300_32 */
11177 case 2: /* R_MN10300_16 */
11178 if (saved_sym != NULL)
11179 {
11180 bfd_vma value;
252b5132 11181
cf13d699
NC		 11182 value = reloc->r_addend
11183 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11184 - saved_sym->st_value);
252b5132 11185
cf13d699 11186 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 11187
cf13d699
NC		 11188 saved_sym = NULL;
11189 return TRUE;
11190 }
11191 break;
11192 default:
11193 if (saved_sym != NULL)
071436c6 11194 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
cf13d699
NC		 11195 break;
11196 }
11197 break;
11198 }
6ff71e76
NC		 11199
11200 case EM_RL78:
11201 {
11202 static bfd_vma saved_sym1 = 0;
11203 static bfd_vma saved_sym2 = 0;
11204 static bfd_vma value;
11205
11206 switch (reloc_type)
11207 {
11208 case 0x80: /* R_RL78_SYM. */
11209 saved_sym1 = saved_sym2;
11210 saved_sym2 = symtab[get_reloc_symindex (reloc->r_info)].st_value;
11211 saved_sym2 += reloc->r_addend;
11212 return TRUE;
11213
11214 case 0x83: /* R_RL78_OPsub. */
11215 value = saved_sym1 - saved_sym2;
11216 saved_sym2 = saved_sym1 = 0;
11217 return TRUE;
11218 break;
11219
11220 case 0x41: /* R_RL78_ABS32. */
11221 byte_put (start + reloc->r_offset, value, 4);
11222 value = 0;
11223 return TRUE;
11224
11225 case 0x43: /* R_RL78_ABS16. */
11226 byte_put (start + reloc->r_offset, value, 2);
11227 value = 0;
11228 return TRUE;
11229
11230 default:
11231 break;
11232 }
11233 break;
11234 }
252b5132
RH		 11235 }
11236
cf13d699 11237 return FALSE;
252b5132
RH		 11238}
11239
aca88567
NC		 11240/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11241 DWARF debug sections. This is a target specific test. Note - we do not
11242 go through the whole including-target-headers-multiple-times route, (as
11243 we have already done with <elf/h8.h>) because this would become very
11244 messy and even then this function would have to contain target specific
11245 information (the names of the relocs instead of their numeric values).
11246 FIXME: This is not the correct way to solve this problem. The proper way
11247 is to have target specific reloc sizing and typing functions created by
11248 the reloc-macros.h header, in the same way that it already creates the
11249 reloc naming functions. */
11250
11251static bfd_boolean
11252is_32bit_abs_reloc (unsigned int reloc_type)
11253{
11254 switch (elf_header.e_machine)
11255 {
41e92641 11256 case EM_386:
22abe556 11257 case EM_IAMCU:
41e92641 11258 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 11259 case EM_68K:
11260 return reloc_type == 1; /* R_68K_32. */
11261 case EM_860:
11262 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 11263 case EM_960:
11264 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 11265 case EM_AARCH64:
11266 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 11267 case EM_ALPHA:
137b6b5f 11268 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 11269 case EM_ARC:
11270 return reloc_type == 1; /* R_ARC_32. */
11271 case EM_ARM:
11272 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 11273 case EM_AVR_OLD:
aca88567
NC		 11274 case EM_AVR:
11275 return reloc_type == 1;
cfb8c092
NC		 11276 case EM_ADAPTEVA_EPIPHANY:
11277 return reloc_type == 3;
aca88567
NC		 11278 case EM_BLACKFIN:
11279 return reloc_type == 0x12; /* R_byte4_data. */
11280 case EM_CRIS:
11281 return reloc_type == 3; /* R_CRIS_32. */
11282 case EM_CR16:
11283 return reloc_type == 3; /* R_CR16_NUM32. */
11284 case EM_CRX:
11285 return reloc_type == 15; /* R_CRX_NUM32. */
11286 case EM_CYGNUS_FRV:
11287 return reloc_type == 1;
41e92641
NC		 11288 case EM_CYGNUS_D10V:
11289 case EM_D10V:
11290 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 11291 case EM_CYGNUS_D30V:
11292 case EM_D30V:
11293 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 11294 case EM_DLX:
11295 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 11296 case EM_CYGNUS_FR30:
11297 case EM_FR30:
11298 return reloc_type == 3; /* R_FR30_32. */
3f8107ab
AM		 11299 case EM_FT32:
11300 return reloc_type == 1; /* R_FT32_32. */
aca88567
NC		 11301 case EM_H8S:
11302 case EM_H8_300:
11303 case EM_H8_300H:
11304 return reloc_type == 1; /* R_H8_DIR32. */
3730236a 11305 case EM_IA_64:
d1c4b12b
NC		 11306 return reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
11307 || reloc_type == 0x25; /* R_IA64_DIR32LSB. */
aca88567
NC		 11308 case EM_IP2K_OLD:
11309 case EM_IP2K:
11310 return reloc_type == 2; /* R_IP2K_32. */
11311 case EM_IQ2000:
11312 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 11313 case EM_LATTICEMICO32:
11314 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 11315 case EM_M32C_OLD:
aca88567
NC		 11316 case EM_M32C:
11317 return reloc_type == 3; /* R_M32C_32. */
11318 case EM_M32R:
11319 return reloc_type == 34; /* R_M32R_32_RELA. */
11320 case EM_MCORE:
11321 return reloc_type == 1; /* R_MCORE_ADDR32. */
11322 case EM_CYGNUS_MEP:
11323 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 11324 case EM_METAG:
11325 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 11326 case EM_MICROBLAZE:
11327 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 11328 case EM_MIPS:
11329 return reloc_type == 2; /* R_MIPS_32. */
11330 case EM_MMIX:
11331 return reloc_type == 4; /* R_MMIX_32. */
11332 case EM_CYGNUS_MN10200:
11333 case EM_MN10200:
11334 return reloc_type == 1; /* R_MN10200_32. */
11335 case EM_CYGNUS_MN10300:
11336 case EM_MN10300:
11337 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 11338 case EM_MOXIE:
11339 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 11340 case EM_MSP430_OLD:
11341 case EM_MSP430:
13761a11 11342 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 11343 case EM_MT:
11344 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 11345 case EM_NDS32:
11346 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 11347 case EM_ALTERA_NIOS2:
36591ba1 11348 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 11349 case EM_NIOS32:
11350 return reloc_type == 1; /* R_NIOS_32. */
73589c9d
CS		 11351 case EM_OR1K:
11352 return reloc_type == 1; /* R_OR1K_32. */
aca88567 11353 case EM_PARISC:
5fda8eca
NC		 11354 return (reloc_type == 1 /* R_PARISC_DIR32. */
11355 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 11356 case EM_PJ:
11357 case EM_PJ_OLD:
11358 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
11359 case EM_PPC64:
11360 return reloc_type == 1; /* R_PPC64_ADDR32. */
11361 case EM_PPC:
11362 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 11363 case EM_RL78:
11364 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 11365 case EM_RX:
11366 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 11367 case EM_S370:
11368 return reloc_type == 1; /* R_I370_ADDR31. */
11369 case EM_S390_OLD:
11370 case EM_S390:
11371 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 11372 case EM_SCORE:
11373 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 11374 case EM_SH:
11375 return reloc_type == 1; /* R_SH_DIR32. */
11376 case EM_SPARC32PLUS:
11377 case EM_SPARCV9:
11378 case EM_SPARC:
11379 return reloc_type == 3 /* R_SPARC_32. */
11380 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 11381 case EM_SPU:
11382 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 11383 case EM_TI_C6000:
11384 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 11385 case EM_TILEGX:
11386 return reloc_type == 2; /* R_TILEGX_32. */
11387 case EM_TILEPRO:
11388 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 11389 case EM_CYGNUS_V850:
11390 case EM_V850:
11391 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 11392 case EM_V800:
11393 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 11394 case EM_VAX:
11395 return reloc_type == 1; /* R_VAX_32. */
619ed720
EB		 11396 case EM_VISIUM:
11397 return reloc_type == 3; /* R_VISIUM_32. */
aca88567 11398 case EM_X86_64:
8a9036a4 11399 case EM_L1OM:
7a9068fe 11400 case EM_K1OM:
aca88567 11401 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 11402 case EM_XC16X:
11403 case EM_C166:
11404 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 11405 case EM_XGATE:
11406 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 11407 case EM_XSTORMY16:
11408 return reloc_type == 1; /* R_XSTROMY16_32. */
11409 case EM_XTENSA_OLD:
11410 case EM_XTENSA:
11411 return reloc_type == 1; /* R_XTENSA_32. */
aca88567 11412 default:
bee0ee85
NC		 11413 {
11414 static unsigned int prev_warn = 0;
11415
11416 /* Avoid repeating the same warning multiple times. */
11417 if (prev_warn != elf_header.e_machine)
11418 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11419 elf_header.e_machine);
11420 prev_warn = elf_header.e_machine;
11421 return FALSE;
11422 }
aca88567
NC		 11423 }
11424}
11425
11426/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11427 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11428
11429static bfd_boolean
11430is_32bit_pcrel_reloc (unsigned int reloc_type)
11431{
11432 switch (elf_header.e_machine)
11433 {
41e92641 11434 case EM_386:
22abe556 11435 case EM_IAMCU:
3e0873ac 11436 return reloc_type == 2; /* R_386_PC32. */
aca88567 11437 case EM_68K:
3e0873ac 11438 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 11439 case EM_AARCH64:
11440 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 11441 case EM_ADAPTEVA_EPIPHANY:
11442 return reloc_type == 6;
aca88567
NC		 11443 case EM_ALPHA:
11444 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 11445 case EM_ARM:
3e0873ac 11446 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 11447 case EM_MICROBLAZE:
11448 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
73589c9d
CS		 11449 case EM_OR1K:
11450 return reloc_type == 9; /* R_OR1K_32_PCREL. */
aca88567 11451 case EM_PARISC:
85acf597 11452 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 11453 case EM_PPC:
11454 return reloc_type == 26; /* R_PPC_REL32. */
11455 case EM_PPC64:
3e0873ac 11456 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 11457 case EM_S390_OLD:
11458 case EM_S390:
3e0873ac 11459 return reloc_type == 5; /* R_390_PC32. */
aca88567 11460 case EM_SH:
3e0873ac 11461 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 11462 case EM_SPARC32PLUS:
11463 case EM_SPARCV9:
11464 case EM_SPARC:
3e0873ac 11465 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 11466 case EM_SPU:
11467 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 11468 case EM_TILEGX:
11469 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
11470 case EM_TILEPRO:
11471 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
619ed720
EB		 11472 case EM_VISIUM:
11473 return reloc_type == 6; /* R_VISIUM_32_PCREL */
aca88567 11474 case EM_X86_64:
8a9036a4 11475 case EM_L1OM:
7a9068fe 11476 case EM_K1OM:
3e0873ac 11477 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 11478 case EM_XTENSA_OLD:
11479 case EM_XTENSA:
11480 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 11481 default:
11482 /* Do not abort or issue an error message here. Not all targets use
11483 pc-relative 32-bit relocs in their DWARF debug information and we
11484 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 11485 more helpful warning message will be generated by apply_relocations
11486 anyway, so just return. */
aca88567
NC		 11487 return FALSE;
11488 }
11489}
11490
11491/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11492 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11493
11494static bfd_boolean
11495is_64bit_abs_reloc (unsigned int reloc_type)
11496{
11497 switch (elf_header.e_machine)
11498 {
a06ea964
NC		 11499 case EM_AARCH64:
11500 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 11501 case EM_ALPHA:
11502 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 11503 case EM_IA_64:
11504 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 11505 case EM_PARISC:
11506 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 11507 case EM_PPC64:
11508 return reloc_type == 38; /* R_PPC64_ADDR64. */
11509 case EM_SPARC32PLUS:
11510 case EM_SPARCV9:
11511 case EM_SPARC:
11512 return reloc_type == 54; /* R_SPARC_UA64. */
11513 case EM_X86_64:
8a9036a4 11514 case EM_L1OM:
7a9068fe 11515 case EM_K1OM:
aca88567 11516 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 11517 case EM_S390_OLD:
11518 case EM_S390:
aa137e4d
NC		 11519 return reloc_type == 22; /* R_S390_64. */
11520 case EM_TILEGX:
11521 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 11522 case EM_MIPS:
aa137e4d 11523 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 11524 default:
11525 return FALSE;
11526 }
11527}
11528
85acf597
RH		 11529/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11530 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11531
11532static bfd_boolean
11533is_64bit_pcrel_reloc (unsigned int reloc_type)
11534{
11535 switch (elf_header.e_machine)
11536 {
a06ea964
NC		 11537 case EM_AARCH64:
11538 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 11539 case EM_ALPHA:
aa137e4d 11540 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 11541 case EM_IA_64:
aa137e4d 11542 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 11543 case EM_PARISC:
aa137e4d 11544 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 11545 case EM_PPC64:
aa137e4d 11546 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 11547 case EM_SPARC32PLUS:
11548 case EM_SPARCV9:
11549 case EM_SPARC:
aa137e4d 11550 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 11551 case EM_X86_64:
8a9036a4 11552 case EM_L1OM:
7a9068fe 11553 case EM_K1OM:
aa137e4d 11554 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 11555 case EM_S390_OLD:
11556 case EM_S390:
aa137e4d
NC		 11557 return reloc_type == 23; /* R_S390_PC64. */
11558 case EM_TILEGX:
11559 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 11560 default:
11561 return FALSE;
11562 }
11563}
11564
4dc3c23d
AM		 11565/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11566 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11567
11568static bfd_boolean
11569is_24bit_abs_reloc (unsigned int reloc_type)
11570{
11571 switch (elf_header.e_machine)
11572 {
11573 case EM_CYGNUS_MN10200:
11574 case EM_MN10200:
11575 return reloc_type == 4; /* R_MN10200_24. */
11576 default:
11577 return FALSE;
11578 }
11579}
11580
aca88567
NC		 11581/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11582 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11583
11584static bfd_boolean
11585is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 11586{
11587 switch (elf_header.e_machine)
11588 {
aca88567
NC		 11589 case EM_AVR_OLD:
11590 case EM_AVR:
11591 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 11592 case EM_ADAPTEVA_EPIPHANY:
11593 return reloc_type == 5;
41e92641
NC		 11594 case EM_CYGNUS_D10V:
11595 case EM_D10V:
11596 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 11597 case EM_H8S:
11598 case EM_H8_300:
11599 case EM_H8_300H:
aca88567
NC		 11600 return reloc_type == R_H8_DIR16;
11601 case EM_IP2K_OLD:
11602 case EM_IP2K:
11603 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 11604 case EM_M32C_OLD:
f4236fe4
DD		 11605 case EM_M32C:
11606 return reloc_type == 1; /* R_M32C_16 */
aca88567 11607 case EM_MSP430:
13761a11
NC		 11608 if (uses_msp430x_relocs ())
11609 return reloc_type == 2; /* R_MSP430_ABS16. */
78c8d46c 11610 case EM_MSP430_OLD:
aca88567 11611 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 11612 case EM_NDS32:
11613 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 11614 case EM_ALTERA_NIOS2:
36591ba1 11615 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 11616 case EM_NIOS32:
11617 return reloc_type == 9; /* R_NIOS_16. */
73589c9d
CS		 11618 case EM_OR1K:
11619 return reloc_type == 2; /* R_OR1K_16. */
40b36596
JM		 11620 case EM_TI_C6000:
11621 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 11622 case EM_XC16X:
11623 case EM_C166:
11624 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 11625 case EM_CYGNUS_MN10200:
11626 case EM_MN10200:
11627 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 11628 case EM_CYGNUS_MN10300:
11629 case EM_MN10300:
11630 return reloc_type == 2; /* R_MN10300_16. */
619ed720
EB		 11631 case EM_VISIUM:
11632 return reloc_type == 2; /* R_VISIUM_16. */
f6c1a2d5
NC		 11633 case EM_XGATE:
11634 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 11635 default:
aca88567 11636 return FALSE;
4b78141a
NC		 11637 }
11638}
11639
2a7b2e88
JK		 11640/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11641 relocation entries (possibly formerly used for SHT_GROUP sections). */
11642
11643static bfd_boolean
11644is_none_reloc (unsigned int reloc_type)
11645{
11646 switch (elf_header.e_machine)
11647 {
cb8f3167
NC		 11648 case EM_68K: /* R_68K_NONE. */
11649 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 11650 case EM_SPARC32PLUS:
11651 case EM_SPARCV9:
cb8f3167
NC		 11652 case EM_SPARC: /* R_SPARC_NONE. */
11653 case EM_MIPS: /* R_MIPS_NONE. */
11654 case EM_PARISC: /* R_PARISC_NONE. */
11655 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 11656 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 11657 case EM_PPC: /* R_PPC_NONE. */
11658 case EM_PPC64: /* R_PPC64_NONE. */
11659 case EM_ARM: /* R_ARM_NONE. */
11660 case EM_IA_64: /* R_IA64_NONE. */
11661 case EM_SH: /* R_SH_NONE. */
2a7b2e88 11662 case EM_S390_OLD:
cb8f3167
NC		 11663 case EM_S390: /* R_390_NONE. */
11664 case EM_CRIS: /* R_CRIS_NONE. */
11665 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 11666 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 11667 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 11668 case EM_MN10300: /* R_MN10300_NONE. */
3f8107ab 11669 case EM_FT32: /* R_FT32_NONE. */
5506d11a 11670 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 11671 case EM_M32R: /* R_M32R_NONE. */
40b36596 11672 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 11673 case EM_TILEGX: /* R_TILEGX_NONE. */
11674 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 11675 case EM_XC16X:
11676 case EM_C166: /* R_XC16X_NONE. */
36591ba1
SL		 11677 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
11678 case EM_NIOS32: /* R_NIOS_NONE. */
73589c9d 11679 case EM_OR1K: /* R_OR1K_NONE. */
cb8f3167 11680 return reloc_type == 0;
a06ea964
NC		 11681 case EM_AARCH64:
11682 return reloc_type == 0 || reloc_type == 256;
35c08157
KLC		 11683 case EM_NDS32:
11684 return (reloc_type == 0 /* R_XTENSA_NONE. */
11685 || reloc_type == 204 /* R_NDS32_DIFF8. */
11686 || reloc_type == 205 /* R_NDS32_DIFF16. */
11687 || reloc_type == 206 /* R_NDS32_DIFF32. */
11688 || reloc_type == 207 /* R_NDS32_ULEB128. */);
58332dda
JK		 11689 case EM_XTENSA_OLD:
11690 case EM_XTENSA:
4dc3c23d
AM		 11691 return (reloc_type == 0 /* R_XTENSA_NONE. */
11692 || reloc_type == 17 /* R_XTENSA_DIFF8. */
11693 || reloc_type == 18 /* R_XTENSA_DIFF16. */
11694 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
a3c62988
NC		 11695 case EM_METAG:
11696 return reloc_type == 3; /* R_METAG_NONE. */
2a7b2e88
JK		 11697 }
11698 return FALSE;
11699}
11700
d1c4b12b
NC		 11701/* Returns TRUE if there is a relocation against
11702 section NAME at OFFSET bytes. */
11703
11704bfd_boolean
11705reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
11706{
11707 Elf_Internal_Rela * relocs;
11708 Elf_Internal_Rela * rp;
11709
11710 if (dsec == NULL || dsec->reloc_info == NULL)
11711 return FALSE;
11712
11713 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
11714
11715 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
11716 if (rp->r_offset == offset)
11717 return TRUE;
11718
11719 return FALSE;
11720}
11721
cf13d699
NC		 11722/* Apply relocations to a section.
11723 Note: So far support has been added only for those relocations
11724 which can be found in debug sections.
d1c4b12b
NC		 11725 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
11726 loaded relocs. It is then the caller's responsibility to free them.
cf13d699 11727 FIXME: Add support for more relocations ? */
1b315056 11728
cf13d699 11729static void
d1c4b12b
NC		 11730apply_relocations (void * file,
11731 const Elf_Internal_Shdr * section,
11732 unsigned char * start,
11733 bfd_size_type size,
11734 void ** relocs_return,
11735 unsigned long * num_relocs_return)
1b315056 11736{
cf13d699 11737 Elf_Internal_Shdr * relsec;
0d2a7a93 11738 unsigned char * end = start + size;
cb8f3167 11739
d1c4b12b
NC		 11740 if (relocs_return != NULL)
11741 {
11742 * (Elf_Internal_Rela **) relocs_return = NULL;
11743 * num_relocs_return = 0;
11744 }
11745
cf13d699
NC		 11746 if (elf_header.e_type != ET_REL)
11747 return;
1b315056 11748
cf13d699 11749 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 11750 for (relsec = section_headers;
11751 relsec < section_headers + elf_header.e_shnum;
11752 ++relsec)
252b5132 11753 {
41e92641
NC		 11754 bfd_boolean is_rela;
11755 unsigned long num_relocs;
2cf0635d
NC		 11756 Elf_Internal_Rela * relocs;
11757 Elf_Internal_Rela * rp;
11758 Elf_Internal_Shdr * symsec;
11759 Elf_Internal_Sym * symtab;
ba5cdace 11760 unsigned long num_syms;
2cf0635d 11761 Elf_Internal_Sym * sym;
252b5132 11762
41e92641 11763 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 11764 || relsec->sh_info >= elf_header.e_shnum
11765 || section_headers + relsec->sh_info != section
c256ffe7 11766 || relsec->sh_size == 0
4fbb74a6 11767 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 11768 continue;
428409d5 11769
41e92641
NC		 11770 is_rela = relsec->sh_type == SHT_RELA;
11771
11772 if (is_rela)
11773 {
3f5e193b
NC		 11774 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11775 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11776 return;
11777 }
11778 else
11779 {
3f5e193b
NC		 11780 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11781 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11782 return;
11783 }
11784
11785 /* SH uses RELA but uses in place value instead of the addend field. */
11786 if (elf_header.e_machine == EM_SH)
11787 is_rela = FALSE;
428409d5 11788
4fbb74a6 11789 symsec = section_headers + relsec->sh_link;
ba5cdace 11790 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 11791
41e92641 11792 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 11793 {
41e92641
NC		 11794 bfd_vma addend;
11795 unsigned int reloc_type;
11796 unsigned int reloc_size;
91d6fa6a 11797 unsigned char * rloc;
ba5cdace 11798 unsigned long sym_index;
4b78141a 11799
aca88567 11800 reloc_type = get_reloc_type (rp->r_info);
41e92641 11801
98fb390a 11802 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 11803 continue;
98fb390a
NC		 11804 else if (is_none_reloc (reloc_type))
11805 continue;
11806 else if (is_32bit_abs_reloc (reloc_type)
11807 || is_32bit_pcrel_reloc (reloc_type))
aca88567 11808 reloc_size = 4;
85acf597
RH		 11809 else if (is_64bit_abs_reloc (reloc_type)
11810 || is_64bit_pcrel_reloc (reloc_type))
aca88567 11811 reloc_size = 8;
4dc3c23d
AM		 11812 else if (is_24bit_abs_reloc (reloc_type))
11813 reloc_size = 3;
aca88567
NC		 11814 else if (is_16bit_abs_reloc (reloc_type))
11815 reloc_size = 2;
11816 else
4b78141a 11817 {
bee0ee85
NC		 11818 static unsigned int prev_reloc = 0;
11819 if (reloc_type != prev_reloc)
11820 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11821 reloc_type, printable_section_name (section));
11822 prev_reloc = reloc_type;
4b78141a
NC		 11823 continue;
11824 }
103f02d3 11825
91d6fa6a 11826 rloc = start + rp->r_offset;
c8da6823 11827 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 11828 {
11829 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11830 (unsigned long) rp->r_offset,
74e1a04b 11831 printable_section_name (section));
700dd8b7
L		 11832 continue;
11833 }
103f02d3 11834
ba5cdace
NC		 11835 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11836 if (sym_index >= num_syms)
11837 {
11838 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
74e1a04b 11839 sym_index, printable_section_name (section));
ba5cdace
NC		 11840 continue;
11841 }
11842 sym = symtab + sym_index;
41e92641
NC		 11843
11844 /* If the reloc has a symbol associated with it,
55f25fc3
L		 11845 make sure that it is of an appropriate type.
11846
11847 Relocations against symbols without type can happen.
11848 Gcc -feliminate-dwarf2-dups may generate symbols
11849 without type for debug info.
11850
11851 Icc generates relocations against function symbols
11852 instead of local labels.
11853
11854 Relocations against object symbols can happen, eg when
11855 referencing a global array. For an example of this see
11856 the _clz.o binary in libgcc.a. */
aca88567 11857 if (sym != symtab
55f25fc3 11858 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 11859 {
41e92641 11860 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 11861 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 11862 (long int)(rp - relocs),
74e1a04b 11863 printable_section_name (relsec));
aca88567 11864 continue;
5b18a4bc 11865 }
252b5132 11866
4dc3c23d
AM		 11867 addend = 0;
11868 if (is_rela)
11869 addend += rp->r_addend;
c47320c3
AM		 11870 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11871 partial_inplace. */
4dc3c23d
AM		 11872 if (!is_rela
11873 || (elf_header.e_machine == EM_XTENSA
11874 && reloc_type == 1)
11875 || ((elf_header.e_machine == EM_PJ
11876 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 11877 && reloc_type == 1)
11878 || ((elf_header.e_machine == EM_D30V
11879 || elf_header.e_machine == EM_CYGNUS_D30V)
11880 && reloc_type == 12))
91d6fa6a 11881 addend += byte_get (rloc, reloc_size);
cb8f3167 11882
85acf597
RH		 11883 if (is_32bit_pcrel_reloc (reloc_type)
11884 || is_64bit_pcrel_reloc (reloc_type))
11885 {
11886 /* On HPPA, all pc-relative relocations are biased by 8. */
11887 if (elf_header.e_machine == EM_PARISC)
11888 addend -= 8;
91d6fa6a 11889 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 11890 reloc_size);
11891 }
41e92641 11892 else
91d6fa6a 11893 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 11894 }
252b5132 11895
5b18a4bc 11896 free (symtab);
d1c4b12b
NC		 11897
11898 if (relocs_return)
11899 {
11900 * (Elf_Internal_Rela **) relocs_return = relocs;
11901 * num_relocs_return = num_relocs;
11902 }
11903 else
11904 free (relocs);
11905
5b18a4bc
NC		 11906 break;
11907 }
5b18a4bc 11908}
103f02d3 11909
cf13d699
NC		 11910#ifdef SUPPORT_DISASSEMBLY
11911static int
11912disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11913{
74e1a04b 11914 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
cf13d699 11915
74e1a04b 11916 /* FIXME: XXX -- to be done --- XXX */
cf13d699
NC		 11917
11918 return 1;
11919}
11920#endif
11921
11922/* Reads in the contents of SECTION from FILE, returning a pointer
11923 to a malloc'ed buffer or NULL if something went wrong. */
11924
11925static char *
11926get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11927{
11928 bfd_size_type num_bytes;
11929
11930 num_bytes = section->sh_size;
11931
11932 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11933 {
11934 printf (_("\nSection '%s' has no data to dump.\n"),
74e1a04b 11935 printable_section_name (section));
cf13d699
NC		 11936 return NULL;
11937 }
11938
3f5e193b
NC		 11939 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11940 _("section contents"));
cf13d699
NC		 11941}
11942
0e602686
NC		 11943/* Uncompresses a section that was compressed using zlib, in place. */
11944
11945static bfd_boolean
11946uncompress_section_contents (unsigned char **buffer,
11947 dwarf_size_type uncompressed_size,
11948 dwarf_size_type *size)
11949{
11950 dwarf_size_type compressed_size = *size;
11951 unsigned char * compressed_buffer = *buffer;
11952 unsigned char * uncompressed_buffer;
11953 z_stream strm;
11954 int rc;
11955
11956 /* It is possible the section consists of several compressed
11957 buffers concatenated together, so we uncompress in a loop. */
11958 /* PR 18313: The state field in the z_stream structure is supposed
11959 to be invisible to the user (ie us), but some compilers will
11960 still complain about it being used without initialisation. So
11961 we first zero the entire z_stream structure and then set the fields
11962 that we need. */
11963 memset (& strm, 0, sizeof strm);
11964 strm.avail_in = compressed_size;
11965 strm.next_in = (Bytef *) compressed_buffer;
11966 strm.avail_out = uncompressed_size;
11967 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
11968
11969 rc = inflateInit (& strm);
11970 while (strm.avail_in > 0)
11971 {
11972 if (rc != Z_OK)
11973 goto fail;
11974 strm.next_out = ((Bytef *) uncompressed_buffer
11975 + (uncompressed_size - strm.avail_out));
11976 rc = inflate (&strm, Z_FINISH);
11977 if (rc != Z_STREAM_END)
11978 goto fail;
11979 rc = inflateReset (& strm);
11980 }
11981 rc = inflateEnd (& strm);
11982 if (rc != Z_OK
11983 || strm.avail_out != 0)
11984 goto fail;
11985
11986 *buffer = uncompressed_buffer;
11987 *size = uncompressed_size;
11988 return TRUE;
11989
11990 fail:
11991 free (uncompressed_buffer);
11992 /* Indicate decompression failure. */
11993 *buffer = NULL;
11994 return FALSE;
11995}
dd24e3da 11996
cf13d699
NC		 11997static void
11998dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
11999{
0e602686
NC		 12000 Elf_Internal_Shdr * relsec;
12001 bfd_size_type num_bytes;
fd8008d8
L		 12002 unsigned char * data;
12003 unsigned char * end;
12004 unsigned char * real_start;
12005 unsigned char * start;
0e602686 12006 bfd_boolean some_strings_shown;
cf13d699 12007
fd8008d8
L		 12008 real_start = start = (unsigned char *) get_section_contents (section,
12009 file);
cf13d699
NC		 12010 if (start == NULL)
12011 return;
0e602686 12012 num_bytes = section->sh_size;
cf13d699 12013
74e1a04b 12014 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
cf13d699 12015
0e602686
NC		 12016 if (decompress_dumps)
12017 {
12018 dwarf_size_type new_size = num_bytes;
12019 dwarf_size_type uncompressed_size = 0;
12020
12021 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12022 {
12023 Elf_Internal_Chdr chdr;
12024 unsigned int compression_header_size
12025 = get_compression_header (& chdr, (unsigned char *) start);
12026
813dabb9 12027 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12028 {
813dabb9
L		 12029 warn (_("section '%s' has unsupported compress type: %d\n"),
12030 printable_section_name (section), chdr.ch_type);
12031 return;
12032 }
12033 else if (chdr.ch_addralign != section->sh_addralign)
12034 {
12035 warn (_("compressed section '%s' is corrupted\n"),
12036 printable_section_name (section));
12037 return;
0e602686 12038 }
813dabb9
L		 12039 uncompressed_size = chdr.ch_size;
12040 start += compression_header_size;
12041 new_size -= compression_header_size;
0e602686
NC		 12042 }
12043 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12044 {
12045 /* Read the zlib header. In this case, it should be "ZLIB"
12046 followed by the uncompressed section size, 8 bytes in
12047 big-endian order. */
12048 uncompressed_size = start[4]; uncompressed_size <<= 8;
12049 uncompressed_size += start[5]; uncompressed_size <<= 8;
12050 uncompressed_size += start[6]; uncompressed_size <<= 8;
12051 uncompressed_size += start[7]; uncompressed_size <<= 8;
12052 uncompressed_size += start[8]; uncompressed_size <<= 8;
12053 uncompressed_size += start[9]; uncompressed_size <<= 8;
12054 uncompressed_size += start[10]; uncompressed_size <<= 8;
12055 uncompressed_size += start[11];
12056 start += 12;
12057 new_size -= 12;
12058 }
12059
12060 if (uncompressed_size
fd8008d8 12061 && uncompress_section_contents (& start,
0e602686
NC		 12062 uncompressed_size, & new_size))
12063 num_bytes = new_size;
12064 }
fd8008d8 12065
cf13d699
NC		 12066 /* If the section being dumped has relocations against it the user might
12067 be expecting these relocations to have been applied. Check for this
12068 case and issue a warning message in order to avoid confusion.
12069 FIXME: Maybe we ought to have an option that dumps a section with
12070 relocs applied ? */
12071 for (relsec = section_headers;
12072 relsec < section_headers + elf_header.e_shnum;
12073 ++relsec)
12074 {
12075 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12076 || relsec->sh_info >= elf_header.e_shnum
12077 || section_headers + relsec->sh_info != section
12078 || relsec->sh_size == 0
12079 || relsec->sh_link >= elf_header.e_shnum)
12080 continue;
12081
12082 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12083 break;
12084 }
12085
cf13d699
NC		 12086 data = start;
12087 end = start + num_bytes;
12088 some_strings_shown = FALSE;
12089
12090 while (data < end)
12091 {
12092 while (!ISPRINT (* data))
12093 if (++ data >= end)
12094 break;
12095
12096 if (data < end)
12097 {
071436c6
NC		 12098 size_t maxlen = end - data;
12099
cf13d699 12100#ifndef __MSVCRT__
c975cc98
NC		 12101 /* PR 11128: Use two separate invocations in order to work
12102 around bugs in the Solaris 8 implementation of printf. */
12103 printf (" [%6tx] ", data - start);
cf13d699 12104#else
071436c6 12105 printf (" [%6Ix] ", (size_t) (data - start));
cf13d699 12106#endif
4082ef84
NC		 12107 if (maxlen > 0)
12108 {
fd8008d8 12109 print_symbol ((int) maxlen, (const char *) data);
4082ef84 12110 putchar ('\n');
fd8008d8 12111 data += strnlen ((const char *) data, maxlen);
4082ef84
NC		 12112 }
12113 else
12114 {
12115 printf (_("<corrupt>\n"));
12116 data = end;
12117 }
cf13d699
NC		 12118 some_strings_shown = TRUE;
12119 }
12120 }
12121
12122 if (! some_strings_shown)
12123 printf (_(" No strings found in this section."));
12124
0e602686 12125 free (real_start);
cf13d699
NC		 12126
12127 putchar ('\n');
12128}
12129
12130static void
12131dump_section_as_bytes (Elf_Internal_Shdr * section,
12132 FILE * file,
12133 bfd_boolean relocate)
12134{
12135 Elf_Internal_Shdr * relsec;
0e602686
NC		 12136 bfd_size_type bytes;
12137 bfd_size_type section_size;
12138 bfd_vma addr;
12139 unsigned char * data;
12140 unsigned char * real_start;
12141 unsigned char * start;
12142
12143 real_start = start = (unsigned char *) get_section_contents (section, file);
cf13d699
NC		 12144 if (start == NULL)
12145 return;
0e602686 12146 section_size = section->sh_size;
cf13d699 12147
74e1a04b 12148 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
cf13d699 12149
0e602686
NC		 12150 if (decompress_dumps)
12151 {
12152 dwarf_size_type new_size = section_size;
12153 dwarf_size_type uncompressed_size = 0;
12154
12155 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12156 {
12157 Elf_Internal_Chdr chdr;
12158 unsigned int compression_header_size
12159 = get_compression_header (& chdr, start);
12160
813dabb9 12161 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12162 {
813dabb9
L		 12163 warn (_("section '%s' has unsupported compress type: %d\n"),
12164 printable_section_name (section), chdr.ch_type);
12165 return;
0e602686 12166 }
813dabb9
L		 12167 else if (chdr.ch_addralign != section->sh_addralign)
12168 {
12169 warn (_("compressed section '%s' is corrupted\n"),
12170 printable_section_name (section));
12171 return;
12172 }
12173 uncompressed_size = chdr.ch_size;
12174 start += compression_header_size;
12175 new_size -= compression_header_size;
0e602686
NC		 12176 }
12177 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12178 {
12179 /* Read the zlib header. In this case, it should be "ZLIB"
12180 followed by the uncompressed section size, 8 bytes in
12181 big-endian order. */
12182 uncompressed_size = start[4]; uncompressed_size <<= 8;
12183 uncompressed_size += start[5]; uncompressed_size <<= 8;
12184 uncompressed_size += start[6]; uncompressed_size <<= 8;
12185 uncompressed_size += start[7]; uncompressed_size <<= 8;
12186 uncompressed_size += start[8]; uncompressed_size <<= 8;
12187 uncompressed_size += start[9]; uncompressed_size <<= 8;
12188 uncompressed_size += start[10]; uncompressed_size <<= 8;
12189 uncompressed_size += start[11];
12190 start += 12;
12191 new_size -= 12;
12192 }
12193
12194 if (uncompressed_size
12195 && uncompress_section_contents (& start, uncompressed_size,
12196 & new_size))
12197 section_size = new_size;
12198 }
14ae95f2 12199
cf13d699
NC		 12200 if (relocate)
12201 {
0e602686 12202 apply_relocations (file, section, start, section_size, NULL, NULL);
cf13d699
NC		 12203 }
12204 else
12205 {
12206 /* If the section being dumped has relocations against it the user might
12207 be expecting these relocations to have been applied. Check for this
12208 case and issue a warning message in order to avoid confusion.
12209 FIXME: Maybe we ought to have an option that dumps a section with
12210 relocs applied ? */
12211 for (relsec = section_headers;
12212 relsec < section_headers + elf_header.e_shnum;
12213 ++relsec)
12214 {
12215 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12216 || relsec->sh_info >= elf_header.e_shnum
12217 || section_headers + relsec->sh_info != section
12218 || relsec->sh_size == 0
12219 || relsec->sh_link >= elf_header.e_shnum)
12220 continue;
12221
12222 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12223 break;
12224 }
12225 }
12226
12227 addr = section->sh_addr;
0e602686 12228 bytes = section_size;
cf13d699
NC		 12229 data = start;
12230
12231 while (bytes)
12232 {
12233 int j;
12234 int k;
12235 int lbytes;
12236
12237 lbytes = (bytes > 16 ? 16 : bytes);
12238
12239 printf (" 0x%8.8lx ", (unsigned long) addr);
12240
12241 for (j = 0; j < 16; j++)
12242 {
12243 if (j < lbytes)
12244 printf ("%2.2x", data[j]);
12245 else
12246 printf (" ");
12247
12248 if ((j & 3) == 3)
12249 printf (" ");
12250 }
12251
12252 for (j = 0; j < lbytes; j++)
12253 {
12254 k = data[j];
12255 if (k >= ' ' && k < 0x7f)
12256 printf ("%c", k);
12257 else
12258 printf (".");
12259 }
12260
12261 putchar ('\n');
12262
12263 data += lbytes;
12264 addr += lbytes;
12265 bytes -= lbytes;
12266 }
12267
0e602686 12268 free (real_start);
cf13d699
NC		 12269
12270 putchar ('\n');
12271}
12272
d966045b
DJ		 12273static int
12274load_specific_debug_section (enum dwarf_section_display_enum debug,
0d2a7a93 12275 const Elf_Internal_Shdr * sec, void * file)
1007acb3 12276{
2cf0635d 12277 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 12278 char buf [64];
1007acb3 12279
19e6b90e
L		 12280 /* If it is already loaded, do nothing. */
12281 if (section->start != NULL)
12282 return 1;
1007acb3 12283
19e6b90e
L		 12284 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12285 section->address = sec->sh_addr;
06614111 12286 section->user_data = NULL;
3f5e193b
NC		 12287 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12288 sec->sh_offset, 1,
12289 sec->sh_size, buf);
59245841
NC		 12290 if (section->start == NULL)
12291 section->size = 0;
12292 else
12293 {
77115a4a
L		 12294 unsigned char *start = section->start;
12295 dwarf_size_type size = sec->sh_size;
dab394de 12296 dwarf_size_type uncompressed_size = 0;
77115a4a
L		 12297
12298 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12299 {
12300 Elf_Internal_Chdr chdr;
12301 unsigned int compression_header_size
12302 = get_compression_header (&chdr, start);
813dabb9
L		 12303 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12304 {
12305 warn (_("section '%s' has unsupported compress type: %d\n"),
12306 section->name, chdr.ch_type);
12307 return 0;
12308 }
12309 else if (chdr.ch_addralign != sec->sh_addralign)
12310 {
12311 warn (_("compressed section '%s' is corrupted\n"),
12312 section->name);
12313 return 0;
12314 }
dab394de 12315 uncompressed_size = chdr.ch_size;
77115a4a
L		 12316 start += compression_header_size;
12317 size -= compression_header_size;
12318 }
dab394de
L		 12319 else if (size > 12 && streq ((char *) start, "ZLIB"))
12320 {
12321 /* Read the zlib header. In this case, it should be "ZLIB"
12322 followed by the uncompressed section size, 8 bytes in
12323 big-endian order. */
12324 uncompressed_size = start[4]; uncompressed_size <<= 8;
12325 uncompressed_size += start[5]; uncompressed_size <<= 8;
12326 uncompressed_size += start[6]; uncompressed_size <<= 8;
12327 uncompressed_size += start[7]; uncompressed_size <<= 8;
12328 uncompressed_size += start[8]; uncompressed_size <<= 8;
12329 uncompressed_size += start[9]; uncompressed_size <<= 8;
12330 uncompressed_size += start[10]; uncompressed_size <<= 8;
12331 uncompressed_size += start[11];
12332 start += 12;
12333 size -= 12;
12334 }
12335
12336 if (uncompressed_size
12337 && uncompress_section_contents (&start, uncompressed_size,
12338 &size))
77115a4a
L		 12339 {
12340 /* Free the compressed buffer, update the section buffer
12341 and the section size if uncompress is successful. */
12342 free (section->start);
12343 section->start = start;
77115a4a
L		 12344 }
12345 section->size = size;
59245841 12346 }
4a114e3e 12347
1b315056
CS		 12348 if (section->start == NULL)
12349 return 0;
12350
19e6b90e 12351 if (debug_displays [debug].relocate)
d1c4b12b
NC		 12352 apply_relocations ((FILE *) file, sec, section->start, section->size,
12353 & section->reloc_info, & section->num_relocs);
12354 else
12355 {
12356 section->reloc_info = NULL;
12357 section->num_relocs = 0;
12358 }
1007acb3 12359
1b315056 12360 return 1;
1007acb3
L		 12361}
12362
657d0d47
CC		 12363/* If this is not NULL, load_debug_section will only look for sections
12364 within the list of sections given here. */
12365unsigned int *section_subset = NULL;
12366
d966045b 12367int
2cf0635d 12368load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 12369{
2cf0635d
NC		 12370 struct dwarf_section * section = &debug_displays [debug].section;
12371 Elf_Internal_Shdr * sec;
d966045b
DJ		 12372
12373 /* Locate the debug section. */
657d0d47 12374 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 12375 if (sec != NULL)
12376 section->name = section->uncompressed_name;
12377 else
12378 {
657d0d47 12379 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 12380 if (sec != NULL)
12381 section->name = section->compressed_name;
12382 }
12383 if (sec == NULL)
12384 return 0;
12385
657d0d47
CC		 12386 /* If we're loading from a subset of sections, and we've loaded
12387 a section matching this name before, it's likely that it's a
12388 different one. */
12389 if (section_subset != NULL)
12390 free_debug_section (debug);
12391
3f5e193b 12392 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 12393}
12394
19e6b90e
L		 12395void
12396free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 12397{
2cf0635d 12398 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 12399
19e6b90e
L		 12400 if (section->start == NULL)
12401 return;
1007acb3 12402
19e6b90e
L		 12403 free ((char *) section->start);
12404 section->start = NULL;
12405 section->address = 0;
12406 section->size = 0;
1007acb3
L		 12407}
12408
1007acb3 12409static int
657d0d47 12410display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 12411{
2cf0635d 12412 char * name = SECTION_NAME (section);
74e1a04b 12413 const char * print_name = printable_section_name (section);
19e6b90e
L		 12414 bfd_size_type length;
12415 int result = 1;
3f5e193b 12416 int i;
1007acb3 12417
19e6b90e
L		 12418 length = section->sh_size;
12419 if (length == 0)
1007acb3 12420 {
74e1a04b 12421 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
19e6b90e 12422 return 0;
1007acb3 12423 }
5dff79d8
NC		 12424 if (section->sh_type == SHT_NOBITS)
12425 {
12426 /* There is no point in dumping the contents of a debugging section
12427 which has the NOBITS type - the bits in the file will be random.
12428 This can happen when a file containing a .eh_frame section is
12429 stripped with the --only-keep-debug command line option. */
74e1a04b
NC		 12430 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12431 print_name);
5dff79d8
NC		 12432 return 0;
12433 }
1007acb3 12434
0112cd26 12435 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 12436 name = ".debug_info";
1007acb3 12437
19e6b90e
L		 12438 /* See if we know how to display the contents of this section. */
12439 for (i = 0; i < max; i++)
1b315056 12440 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 12441 || (i == line && const_strneq (name, ".debug_line."))
1b315056 12442 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 12443 {
2cf0635d 12444 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 12445 int secondary = (section != find_section (name));
12446
12447 if (secondary)
3f5e193b 12448 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 12449
b40bf0a2
NC		 12450 if (i == line && const_strneq (name, ".debug_line."))
12451 sec->name = name;
12452 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 12453 sec->name = sec->uncompressed_name;
12454 else
12455 sec->name = sec->compressed_name;
3f5e193b
NC		 12456 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12457 section, file))
19e6b90e 12458 {
657d0d47
CC		 12459 /* If this debug section is part of a CU/TU set in a .dwp file,
12460 restrict load_debug_section to the sections in that set. */
12461 section_subset = find_cu_tu_set (file, shndx);
12462
19e6b90e 12463 result &= debug_displays[i].display (sec, file);
1007acb3 12464
657d0d47
CC		 12465 section_subset = NULL;
12466
d966045b 12467 if (secondary || (i != info && i != abbrev))
3f5e193b 12468 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 12469 }
1007acb3 12470
19e6b90e
L		 12471 break;
12472 }
1007acb3 12473
19e6b90e 12474 if (i == max)
1007acb3 12475 {
74e1a04b 12476 printf (_("Unrecognized debug section: %s\n"), print_name);
19e6b90e 12477 result = 0;
1007acb3
L		 12478 }
12479
19e6b90e 12480 return result;
5b18a4bc 12481}
103f02d3 12482
aef1f6d0
DJ		 12483/* Set DUMP_SECTS for all sections where dumps were requested
12484 based on section name. */
12485
12486static void
12487initialise_dumps_byname (void)
12488{
2cf0635d 12489 struct dump_list_entry * cur;
aef1f6d0
DJ		 12490
12491 for (cur = dump_sects_byname; cur; cur = cur->next)
12492 {
12493 unsigned int i;
12494 int any;
12495
12496 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12497 if (streq (SECTION_NAME (section_headers + i), cur->name))
12498 {
09c11c86 12499 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 12500 any = 1;
12501 }
12502
12503 if (!any)
12504 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12505 cur->name);
12506 }
12507}
12508
5b18a4bc 12509static void
2cf0635d 12510process_section_contents (FILE * file)
5b18a4bc 12511{
2cf0635d 12512 Elf_Internal_Shdr * section;
19e6b90e 12513 unsigned int i;
103f02d3 12514
19e6b90e
L		 12515 if (! do_dump)
12516 return;
103f02d3 12517
aef1f6d0
DJ		 12518 initialise_dumps_byname ();
12519
19e6b90e
L		 12520 for (i = 0, section = section_headers;
12521 i < elf_header.e_shnum && i < num_dump_sects;
12522 i++, section++)
12523 {
12524#ifdef SUPPORT_DISASSEMBLY
12525 if (dump_sects[i] & DISASS_DUMP)
12526 disassemble_section (section, file);
12527#endif
12528 if (dump_sects[i] & HEX_DUMP)
cf13d699 12529 dump_section_as_bytes (section, file, FALSE);
103f02d3 12530
cf13d699
NC		 12531 if (dump_sects[i] & RELOC_DUMP)
12532 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 12533
12534 if (dump_sects[i] & STRING_DUMP)
12535 dump_section_as_strings (section, file);
cf13d699
NC		 12536
12537 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 12538 display_debug_section (i, section, file);
5b18a4bc 12539 }
103f02d3 12540
19e6b90e
L		 12541 /* Check to see if the user requested a
12542 dump of a section that does not exist. */
12543 while (i++ < num_dump_sects)
12544 if (dump_sects[i])
12545 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 12546}
103f02d3 12547
5b18a4bc 12548static void
19e6b90e 12549process_mips_fpe_exception (int mask)
5b18a4bc 12550{
19e6b90e
L		 12551 if (mask)
12552 {
12553 int first = 1;
12554 if (mask & OEX_FPU_INEX)
12555 fputs ("INEX", stdout), first = 0;
12556 if (mask & OEX_FPU_UFLO)
12557 printf ("%sUFLO", first ? "" : "|"), first = 0;
12558 if (mask & OEX_FPU_OFLO)
12559 printf ("%sOFLO", first ? "" : "|"), first = 0;
12560 if (mask & OEX_FPU_DIV0)
12561 printf ("%sDIV0", first ? "" : "|"), first = 0;
12562 if (mask & OEX_FPU_INVAL)
12563 printf ("%sINVAL", first ? "" : "|");
12564 }
5b18a4bc 12565 else
19e6b90e 12566 fputs ("0", stdout);
5b18a4bc 12567}
103f02d3 12568
f6f0e17b
NC		 12569/* Display's the value of TAG at location P. If TAG is
12570 greater than 0 it is assumed to be an unknown tag, and
12571 a message is printed to this effect. Otherwise it is
12572 assumed that a message has already been printed.
12573
12574 If the bottom bit of TAG is set it assumed to have a
12575 string value, otherwise it is assumed to have an integer
12576 value.
12577
12578 Returns an updated P pointing to the first unread byte
12579 beyond the end of TAG's value.
12580
12581 Reads at or beyond END will not be made. */
12582
12583static unsigned char *
12584display_tag_value (int tag,
12585 unsigned char * p,
12586 const unsigned char * const end)
12587{
12588 unsigned long val;
12589
12590 if (tag > 0)
12591 printf (" Tag_unknown_%d: ", tag);
12592
12593 if (p >= end)
12594 {
4082ef84 12595 warn (_("<corrupt tag>\n"));
f6f0e17b
NC		 12596 }
12597 else if (tag & 1)
12598 {
071436c6
NC		 12599 /* PR 17531 file: 027-19978-0.004. */
12600 size_t maxlen = (end - p) - 1;
12601
12602 putchar ('"');
4082ef84
NC		 12603 if (maxlen > 0)
12604 {
12605 print_symbol ((int) maxlen, (const char *) p);
12606 p += strnlen ((char *) p, maxlen) + 1;
12607 }
12608 else
12609 {
12610 printf (_("<corrupt string tag>"));
12611 p = (unsigned char *) end;
12612 }
071436c6 12613 printf ("\"\n");
f6f0e17b
NC		 12614 }
12615 else
12616 {
12617 unsigned int len;
12618
12619 val = read_uleb128 (p, &len, end);
12620 p += len;
12621 printf ("%ld (0x%lx)\n", val, val);
12622 }
12623
4082ef84 12624 assert (p <= end);
f6f0e17b
NC		 12625 return p;
12626}
12627
11c1ff18
PB		 12628/* ARM EABI attributes section. */
12629typedef struct
12630{
70e99720 12631 unsigned int tag;
2cf0635d 12632 const char * name;
11c1ff18 12633 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 12634 unsigned int type;
2cf0635d 12635 const char ** table;
11c1ff18
PB		 12636} arm_attr_public_tag;
12637
2cf0635d 12638static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 12639 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 12640 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 12641static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12642static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 12643 {"No", "Thumb-1", "Thumb-2"};
75375b3e 12644static const char * arm_attr_tag_FP_arch[] =
bca38921 12645 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
a715796b 12646 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
2cf0635d 12647static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 12648static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 12649 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 12650static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 12651 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12652 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 12653static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 12654 {"V6", "SB", "TLS", "Unused"};
2cf0635d 12655static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 12656 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 12657static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 12658 {"Absolute", "PC-relative", "None"};
2cf0635d 12659static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 12660 {"None", "direct", "GOT-indirect"};
2cf0635d 12661static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 12662 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 12663static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12664static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 12665 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 12666static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12667static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12668static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 12669 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 12670static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 12671 {"Unused", "small", "int", "forced to int"};
2cf0635d 12672static const char * arm_attr_tag_ABI_HardFP_use[] =
99654aaf 12673 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
2cf0635d 12674static const char * arm_attr_tag_ABI_VFP_args[] =
5c294fee 12675 {"AAPCS", "VFP registers", "custom", "compatible"};
2cf0635d 12676static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 12677 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 12678static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 12679 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12680 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 12681static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 12682 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12683 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 12684static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 12685static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 12686 {"Not Allowed", "Allowed"};
2cf0635d 12687static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 12688 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 12689static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 12690 {"Not Allowed", "Allowed"};
12691static const char * arm_attr_tag_DIV_use[] =
dd24e3da 12692 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 12693 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 12694static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12695static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 12696 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 12697 "TrustZone and Virtualization Extensions"};
dd24e3da 12698static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 12699 {"Not Allowed", "Allowed"};
11c1ff18
PB		 12700
12701#define LOOKUP(id, name) \
12702 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 12703static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 12704{
12705 {4, "CPU_raw_name", 1, NULL},
12706 {5, "CPU_name", 1, NULL},
12707 LOOKUP(6, CPU_arch),
12708 {7, "CPU_arch_profile", 0, NULL},
12709 LOOKUP(8, ARM_ISA_use),
12710 LOOKUP(9, THUMB_ISA_use),
75375b3e 12711 LOOKUP(10, FP_arch),
11c1ff18 12712 LOOKUP(11, WMMX_arch),
f5f53991
AS		 12713 LOOKUP(12, Advanced_SIMD_arch),
12714 LOOKUP(13, PCS_config),
11c1ff18
PB		 12715 LOOKUP(14, ABI_PCS_R9_use),
12716 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 12717 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 12718 LOOKUP(17, ABI_PCS_GOT_use),
12719 LOOKUP(18, ABI_PCS_wchar_t),
12720 LOOKUP(19, ABI_FP_rounding),
12721 LOOKUP(20, ABI_FP_denormal),
12722 LOOKUP(21, ABI_FP_exceptions),
12723 LOOKUP(22, ABI_FP_user_exceptions),
12724 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 12725 {24, "ABI_align_needed", 0, NULL},
12726 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 12727 LOOKUP(26, ABI_enum_size),
12728 LOOKUP(27, ABI_HardFP_use),
12729 LOOKUP(28, ABI_VFP_args),
12730 LOOKUP(29, ABI_WMMX_args),
12731 LOOKUP(30, ABI_optimization_goals),
12732 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 12733 {32, "compatibility", 0, NULL},
f5f53991 12734 LOOKUP(34, CPU_unaligned_access),
75375b3e 12735 LOOKUP(36, FP_HP_extension),
8e79c3df 12736 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 12737 LOOKUP(42, MPextension_use),
12738 LOOKUP(44, DIV_use),
f5f53991
AS		 12739 {64, "nodefaults", 0, NULL},
12740 {65, "also_compatible_with", 0, NULL},
12741 LOOKUP(66, T2EE_use),
12742 {67, "conformance", 1, NULL},
12743 LOOKUP(68, Virtualization_use),
cd21e546 12744 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 12745};
12746#undef LOOKUP
12747
11c1ff18 12748static unsigned char *
f6f0e17b
NC		 12749display_arm_attribute (unsigned char * p,
12750 const unsigned char * const end)
11c1ff18 12751{
70e99720 12752 unsigned int tag;
11c1ff18 12753 unsigned int len;
70e99720 12754 unsigned int val;
2cf0635d 12755 arm_attr_public_tag * attr;
11c1ff18 12756 unsigned i;
70e99720 12757 unsigned int type;
11c1ff18 12758
f6f0e17b 12759 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 12760 p += len;
12761 attr = NULL;
2cf0635d 12762 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 12763 {
12764 if (arm_attr_public_tags[i].tag == tag)
12765 {
12766 attr = &arm_attr_public_tags[i];
12767 break;
12768 }
12769 }
12770
12771 if (attr)
12772 {
12773 printf (" Tag_%s: ", attr->name);
12774 switch (attr->type)
12775 {
12776 case 0:
12777 switch (tag)
12778 {
12779 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 12780 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12781 p += len;
12782 switch (val)
12783 {
2b692964
NC		 12784 case 0: printf (_("None\n")); break;
12785 case 'A': printf (_("Application\n")); break;
12786 case 'R': printf (_("Realtime\n")); break;
12787 case 'M': printf (_("Microcontroller\n")); break;
12788 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 12789 default: printf ("??? (%d)\n", val); break;
12790 }
12791 break;
12792
75375b3e 12793 case 24: /* Tag_align_needed. */
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\n")); break;
12800 case 2: printf (_("4-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
12812 case 25: /* Tag_align_preserved. */
f6f0e17b 12813 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12814 p += len;
12815 switch (val)
12816 {
2b692964
NC		 12817 case 0: printf (_("None\n")); break;
12818 case 1: printf (_("8-byte, except leaf SP\n")); break;
12819 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 12820 case 3: printf ("??? 3\n"); break;
12821 default:
12822 if (val <= 12)
dd24e3da 12823 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12824 1 << val);
12825 else
12826 printf ("??? (%d)\n", val);
12827 break;
12828 }
12829 break;
12830
11c1ff18 12831 case 32: /* Tag_compatibility. */
071436c6 12832 {
071436c6
NC		 12833 val = read_uleb128 (p, &len, end);
12834 p += len;
071436c6 12835 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 12836 if (p < end - 1)
12837 {
12838 size_t maxlen = (end - p) - 1;
12839
12840 print_symbol ((int) maxlen, (const char *) p);
12841 p += strnlen ((char *) p, maxlen) + 1;
12842 }
12843 else
12844 {
12845 printf (_("<corrupt>"));
12846 p = (unsigned char *) end;
12847 }
071436c6 12848 putchar ('\n');
071436c6 12849 }
11c1ff18
PB		 12850 break;
12851
f5f53991 12852 case 64: /* Tag_nodefaults. */
541a3cbd
NC		 12853 /* PR 17531: file: 001-505008-0.01. */
12854 if (p < end)
12855 p++;
2b692964 12856 printf (_("True\n"));
f5f53991
AS		 12857 break;
12858
12859 case 65: /* Tag_also_compatible_with. */
f6f0e17b 12860 val = read_uleb128 (p, &len, end);
f5f53991
AS		 12861 p += len;
12862 if (val == 6 /* Tag_CPU_arch. */)
12863 {
f6f0e17b 12864 val = read_uleb128 (p, &len, end);
f5f53991 12865 p += len;
071436c6 12866 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 12867 printf ("??? (%d)\n", val);
12868 else
12869 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12870 }
12871 else
12872 printf ("???\n");
071436c6
NC		 12873 while (p < end && *(p++) != '\0' /* NUL terminator. */)
12874 ;
f5f53991
AS		 12875 break;
12876
11c1ff18 12877 default:
bee0ee85
NC		 12878 printf (_("<unknown: %d>\n"), tag);
12879 break;
11c1ff18
PB		 12880 }
12881 return p;
12882
12883 case 1:
f6f0e17b 12884 return display_tag_value (-1, p, end);
11c1ff18 12885 case 2:
f6f0e17b 12886 return display_tag_value (0, p, end);
11c1ff18
PB		 12887
12888 default:
12889 assert (attr->type & 0x80);
f6f0e17b 12890 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12891 p += len;
12892 type = attr->type & 0x7f;
12893 if (val >= type)
12894 printf ("??? (%d)\n", val);
12895 else
12896 printf ("%s\n", attr->table[val]);
12897 return p;
12898 }
12899 }
11c1ff18 12900
f6f0e17b 12901 return display_tag_value (tag, p, end);
11c1ff18
PB		 12902}
12903
104d59d1 12904static unsigned char *
60bca95a 12905display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 12906 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12907 const unsigned char * const end)
104d59d1
JM		 12908{
12909 int tag;
12910 unsigned int len;
12911 int val;
104d59d1 12912
f6f0e17b 12913 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 12914 p += len;
12915
12916 /* Tag_compatibility is the only generic GNU attribute defined at
12917 present. */
12918 if (tag == 32)
12919 {
f6f0e17b 12920 val = read_uleb128 (p, &len, end);
104d59d1 12921 p += len;
071436c6
NC		 12922
12923 printf (_("flag = %d, vendor = "), val);
f6f0e17b
NC		 12924 if (p == end)
12925 {
071436c6 12926 printf (_("<corrupt>\n"));
f6f0e17b
NC		 12927 warn (_("corrupt vendor attribute\n"));
12928 }
12929 else
12930 {
4082ef84
NC		 12931 if (p < end - 1)
12932 {
12933 size_t maxlen = (end - p) - 1;
071436c6 12934
4082ef84
NC		 12935 print_symbol ((int) maxlen, (const char *) p);
12936 p += strnlen ((char *) p, maxlen) + 1;
12937 }
12938 else
12939 {
12940 printf (_("<corrupt>"));
12941 p = (unsigned char *) end;
12942 }
071436c6 12943 putchar ('\n');
f6f0e17b 12944 }
104d59d1
JM		 12945 return p;
12946 }
12947
12948 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 12949 return display_proc_gnu_attribute (p, tag, end);
104d59d1 12950
f6f0e17b 12951 return display_tag_value (tag, p, end);
104d59d1
JM		 12952}
12953
34c8bcba 12954static unsigned char *
f6f0e17b
NC		 12955display_power_gnu_attribute (unsigned char * p,
12956 int tag,
12957 const unsigned char * const end)
34c8bcba 12958{
34c8bcba
JM		 12959 unsigned int len;
12960 int val;
12961
12962 if (tag == Tag_GNU_Power_ABI_FP)
12963 {
f6f0e17b 12964 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 12965 p += len;
12966 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 12967
34c8bcba
JM		 12968 switch (val)
12969 {
12970 case 0:
2b692964 12971 printf (_("Hard or soft float\n"));
34c8bcba
JM		 12972 break;
12973 case 1:
2b692964 12974 printf (_("Hard float\n"));
34c8bcba
JM		 12975 break;
12976 case 2:
2b692964 12977 printf (_("Soft float\n"));
34c8bcba 12978 break;
3c7b9897 12979 case 3:
2b692964 12980 printf (_("Single-precision hard float\n"));
3c7b9897 12981 break;
34c8bcba
JM		 12982 default:
12983 printf ("??? (%d)\n", val);
12984 break;
12985 }
12986 return p;
12987 }
12988
c6e65352
DJ		 12989 if (tag == Tag_GNU_Power_ABI_Vector)
12990 {
f6f0e17b 12991 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 12992 p += len;
12993 printf (" Tag_GNU_Power_ABI_Vector: ");
12994 switch (val)
12995 {
12996 case 0:
2b692964 12997 printf (_("Any\n"));
c6e65352
DJ		 12998 break;
12999 case 1:
2b692964 13000 printf (_("Generic\n"));
c6e65352
DJ		 13001 break;
13002 case 2:
13003 printf ("AltiVec\n");
13004 break;
13005 case 3:
13006 printf ("SPE\n");
13007 break;
13008 default:
13009 printf ("??? (%d)\n", val);
13010 break;
13011 }
13012 return p;
13013 }
13014
f82e0623
NF		 13015 if (tag == Tag_GNU_Power_ABI_Struct_Return)
13016 {
f6f0e17b
NC		 13017 if (p == end)
13018 {
071436c6 13019 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
f6f0e17b
NC		 13020 return p;
13021 }
0b4362b0 13022
f6f0e17b 13023 val = read_uleb128 (p, &len, end);
f82e0623
NF		 13024 p += len;
13025 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13026 switch (val)
13027 {
13028 case 0:
2b692964 13029 printf (_("Any\n"));
f82e0623
NF		 13030 break;
13031 case 1:
13032 printf ("r3/r4\n");
13033 break;
13034 case 2:
2b692964 13035 printf (_("Memory\n"));
f82e0623
NF		 13036 break;
13037 default:
13038 printf ("??? (%d)\n", val);
13039 break;
13040 }
13041 return p;
13042 }
13043
f6f0e17b 13044 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 13045}
13046
643f7afb
AK		 13047static unsigned char *
13048display_s390_gnu_attribute (unsigned char * p,
13049 int tag,
13050 const unsigned char * const end)
13051{
13052 unsigned int len;
13053 int val;
13054
13055 if (tag == Tag_GNU_S390_ABI_Vector)
13056 {
13057 val = read_uleb128 (p, &len, end);
13058 p += len;
13059 printf (" Tag_GNU_S390_ABI_Vector: ");
13060
13061 switch (val)
13062 {
13063 case 0:
13064 printf (_("any\n"));
13065 break;
13066 case 1:
13067 printf (_("software\n"));
13068 break;
13069 case 2:
13070 printf (_("hardware\n"));
13071 break;
13072 default:
13073 printf ("??? (%d)\n", val);
13074 break;
13075 }
13076 return p;
13077 }
13078
13079 return display_tag_value (tag & 1, p, end);
13080}
13081
9e8c70f9
DM		 13082static void
13083display_sparc_hwcaps (int mask)
13084{
13085 if (mask)
13086 {
13087 int first = 1;
071436c6 13088
9e8c70f9
DM		 13089 if (mask & ELF_SPARC_HWCAP_MUL32)
13090 fputs ("mul32", stdout), first = 0;
13091 if (mask & ELF_SPARC_HWCAP_DIV32)
13092 printf ("%sdiv32", first ? "" : "|"), first = 0;
13093 if (mask & ELF_SPARC_HWCAP_FSMULD)
13094 printf ("%sfsmuld", first ? "" : "|"), first = 0;
13095 if (mask & ELF_SPARC_HWCAP_V8PLUS)
13096 printf ("%sv8plus", first ? "" : "|"), first = 0;
13097 if (mask & ELF_SPARC_HWCAP_POPC)
13098 printf ("%spopc", first ? "" : "|"), first = 0;
13099 if (mask & ELF_SPARC_HWCAP_VIS)
13100 printf ("%svis", first ? "" : "|"), first = 0;
13101 if (mask & ELF_SPARC_HWCAP_VIS2)
13102 printf ("%svis2", first ? "" : "|"), first = 0;
13103 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
13104 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
13105 if (mask & ELF_SPARC_HWCAP_FMAF)
13106 printf ("%sfmaf", first ? "" : "|"), first = 0;
13107 if (mask & ELF_SPARC_HWCAP_VIS3)
13108 printf ("%svis3", first ? "" : "|"), first = 0;
13109 if (mask & ELF_SPARC_HWCAP_HPC)
13110 printf ("%shpc", first ? "" : "|"), first = 0;
13111 if (mask & ELF_SPARC_HWCAP_RANDOM)
13112 printf ("%srandom", first ? "" : "|"), first = 0;
13113 if (mask & ELF_SPARC_HWCAP_TRANS)
13114 printf ("%strans", first ? "" : "|"), first = 0;
13115 if (mask & ELF_SPARC_HWCAP_FJFMAU)
13116 printf ("%sfjfmau", first ? "" : "|"), first = 0;
13117 if (mask & ELF_SPARC_HWCAP_IMA)
13118 printf ("%sima", first ? "" : "|"), first = 0;
13119 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
13120 printf ("%scspare", first ? "" : "|"), first = 0;
13121 }
13122 else
071436c6
NC		 13123 fputc ('0', stdout);
13124 fputc ('\n', stdout);
9e8c70f9
DM		 13125}
13126
3d68f91c
JM		 13127static void
13128display_sparc_hwcaps2 (int mask)
13129{
13130 if (mask)
13131 {
13132 int first = 1;
071436c6 13133
3d68f91c
JM		 13134 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
13135 fputs ("fjathplus", stdout), first = 0;
13136 if (mask & ELF_SPARC_HWCAP2_VIS3B)
13137 printf ("%svis3b", first ? "" : "|"), first = 0;
13138 if (mask & ELF_SPARC_HWCAP2_ADP)
13139 printf ("%sadp", first ? "" : "|"), first = 0;
13140 if (mask & ELF_SPARC_HWCAP2_SPARC5)
13141 printf ("%ssparc5", first ? "" : "|"), first = 0;
13142 if (mask & ELF_SPARC_HWCAP2_MWAIT)
13143 printf ("%smwait", first ? "" : "|"), first = 0;
13144 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
13145 printf ("%sxmpmul", first ? "" : "|"), first = 0;
13146 if (mask & ELF_SPARC_HWCAP2_XMONT)
13147 printf ("%sxmont2", first ? "" : "|"), first = 0;
13148 if (mask & ELF_SPARC_HWCAP2_NSEC)
13149 printf ("%snsec", first ? "" : "|"), first = 0;
13150 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
13151 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
13152 if (mask & ELF_SPARC_HWCAP2_FJDES)
13153 printf ("%sfjdes", first ? "" : "|"), first = 0;
13154 if (mask & ELF_SPARC_HWCAP2_FJAES)
13155 printf ("%sfjaes", first ? "" : "|"), first = 0;
13156 }
13157 else
071436c6
NC		 13158 fputc ('0', stdout);
13159 fputc ('\n', stdout);
3d68f91c
JM		 13160}
13161
9e8c70f9 13162static unsigned char *
f6f0e17b
NC		 13163display_sparc_gnu_attribute (unsigned char * p,
13164 int tag,
13165 const unsigned char * const end)
9e8c70f9 13166{
3d68f91c
JM		 13167 unsigned int len;
13168 int val;
13169
9e8c70f9
DM		 13170 if (tag == Tag_GNU_Sparc_HWCAPS)
13171 {
f6f0e17b 13172 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 13173 p += len;
13174 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 13175 display_sparc_hwcaps (val);
13176 return p;
3d68f91c
JM		 13177 }
13178 if (tag == Tag_GNU_Sparc_HWCAPS2)
13179 {
13180 val = read_uleb128 (p, &len, end);
13181 p += len;
13182 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13183 display_sparc_hwcaps2 (val);
13184 return p;
13185 }
9e8c70f9 13186
f6f0e17b 13187 return display_tag_value (tag, p, end);
9e8c70f9
DM		 13188}
13189
351cdf24
MF		 13190static void
13191print_mips_fp_abi_value (int val)
13192{
13193 switch (val)
13194 {
13195 case Val_GNU_MIPS_ABI_FP_ANY:
13196 printf (_("Hard or soft float\n"));
13197 break;
13198 case Val_GNU_MIPS_ABI_FP_DOUBLE:
13199 printf (_("Hard float (double precision)\n"));
13200 break;
13201 case Val_GNU_MIPS_ABI_FP_SINGLE:
13202 printf (_("Hard float (single precision)\n"));
13203 break;
13204 case Val_GNU_MIPS_ABI_FP_SOFT:
13205 printf (_("Soft float\n"));
13206 break;
13207 case Val_GNU_MIPS_ABI_FP_OLD_64:
13208 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13209 break;
13210 case Val_GNU_MIPS_ABI_FP_XX:
13211 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13212 break;
13213 case Val_GNU_MIPS_ABI_FP_64:
13214 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13215 break;
13216 case Val_GNU_MIPS_ABI_FP_64A:
13217 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13218 break;
3350cc01
CM		 13219 case Val_GNU_MIPS_ABI_FP_NAN2008:
13220 printf (_("NaN 2008 compatibility\n"));
13221 break;
351cdf24
MF		 13222 default:
13223 printf ("??? (%d)\n", val);
13224 break;
13225 }
13226}
13227
2cf19d5c 13228static unsigned char *
f6f0e17b
NC		 13229display_mips_gnu_attribute (unsigned char * p,
13230 int tag,
13231 const unsigned char * const end)
2cf19d5c 13232{
2cf19d5c
JM		 13233 if (tag == Tag_GNU_MIPS_ABI_FP)
13234 {
f6f0e17b
NC		 13235 unsigned int len;
13236 int val;
13237
13238 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 13239 p += len;
13240 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 13241
351cdf24
MF		 13242 print_mips_fp_abi_value (val);
13243
2cf19d5c
JM		 13244 return p;
13245 }
13246
a9f58168
CF		 13247 if (tag == Tag_GNU_MIPS_ABI_MSA)
13248 {
13249 unsigned int len;
13250 int val;
13251
13252 val = read_uleb128 (p, &len, end);
13253 p += len;
13254 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13255
13256 switch (val)
13257 {
13258 case Val_GNU_MIPS_ABI_MSA_ANY:
13259 printf (_("Any MSA or not\n"));
13260 break;
13261 case Val_GNU_MIPS_ABI_MSA_128:
13262 printf (_("128-bit MSA\n"));
13263 break;
13264 default:
13265 printf ("??? (%d)\n", val);
13266 break;
13267 }
13268 return p;
13269 }
13270
f6f0e17b 13271 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 13272}
13273
59e6276b 13274static unsigned char *
f6f0e17b
NC		 13275display_tic6x_attribute (unsigned char * p,
13276 const unsigned char * const end)
59e6276b
JM		 13277{
13278 int tag;
13279 unsigned int len;
13280 int val;
13281
f6f0e17b 13282 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 13283 p += len;
13284
13285 switch (tag)
13286 {
75fa6dc1 13287 case Tag_ISA:
f6f0e17b 13288 val = read_uleb128 (p, &len, end);
59e6276b 13289 p += len;
75fa6dc1 13290 printf (" Tag_ISA: ");
59e6276b
JM		 13291
13292 switch (val)
13293 {
75fa6dc1 13294 case C6XABI_Tag_ISA_none:
59e6276b
JM		 13295 printf (_("None\n"));
13296 break;
75fa6dc1 13297 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 13298 printf ("C62x\n");
13299 break;
75fa6dc1 13300 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 13301 printf ("C67x\n");
13302 break;
75fa6dc1 13303 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 13304 printf ("C67x+\n");
13305 break;
75fa6dc1 13306 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 13307 printf ("C64x\n");
13308 break;
75fa6dc1 13309 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 13310 printf ("C64x+\n");
13311 break;
75fa6dc1 13312 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 13313 printf ("C674x\n");
13314 break;
13315 default:
13316 printf ("??? (%d)\n", val);
13317 break;
13318 }
13319 return p;
13320
87779176 13321 case Tag_ABI_wchar_t:
f6f0e17b 13322 val = read_uleb128 (p, &len, end);
87779176
JM		 13323 p += len;
13324 printf (" Tag_ABI_wchar_t: ");
13325 switch (val)
13326 {
13327 case 0:
13328 printf (_("Not used\n"));
13329 break;
13330 case 1:
13331 printf (_("2 bytes\n"));
13332 break;
13333 case 2:
13334 printf (_("4 bytes\n"));
13335 break;
13336 default:
13337 printf ("??? (%d)\n", val);
13338 break;
13339 }
13340 return p;
13341
13342 case Tag_ABI_stack_align_needed:
f6f0e17b 13343 val = read_uleb128 (p, &len, end);
87779176
JM		 13344 p += len;
13345 printf (" Tag_ABI_stack_align_needed: ");
13346 switch (val)
13347 {
13348 case 0:
13349 printf (_("8-byte\n"));
13350 break;
13351 case 1:
13352 printf (_("16-byte\n"));
13353 break;
13354 default:
13355 printf ("??? (%d)\n", val);
13356 break;
13357 }
13358 return p;
13359
13360 case Tag_ABI_stack_align_preserved:
f6f0e17b 13361 val = read_uleb128 (p, &len, end);
87779176
JM		 13362 p += len;
13363 printf (" Tag_ABI_stack_align_preserved: ");
13364 switch (val)
13365 {
13366 case 0:
13367 printf (_("8-byte\n"));
13368 break;
13369 case 1:
13370 printf (_("16-byte\n"));
13371 break;
13372 default:
13373 printf ("??? (%d)\n", val);
13374 break;
13375 }
13376 return p;
13377
b5593623 13378 case Tag_ABI_DSBT:
f6f0e17b 13379 val = read_uleb128 (p, &len, end);
b5593623
JM		 13380 p += len;
13381 printf (" Tag_ABI_DSBT: ");
13382 switch (val)
13383 {
13384 case 0:
13385 printf (_("DSBT addressing not used\n"));
13386 break;
13387 case 1:
13388 printf (_("DSBT addressing used\n"));
13389 break;
13390 default:
13391 printf ("??? (%d)\n", val);
13392 break;
13393 }
13394 return p;
13395
87779176 13396 case Tag_ABI_PID:
f6f0e17b 13397 val = read_uleb128 (p, &len, end);
87779176
JM		 13398 p += len;
13399 printf (" Tag_ABI_PID: ");
13400 switch (val)
13401 {
13402 case 0:
13403 printf (_("Data addressing position-dependent\n"));
13404 break;
13405 case 1:
13406 printf (_("Data addressing position-independent, GOT near DP\n"));
13407 break;
13408 case 2:
13409 printf (_("Data addressing position-independent, GOT far from DP\n"));
13410 break;
13411 default:
13412 printf ("??? (%d)\n", val);
13413 break;
13414 }
13415 return p;
13416
13417 case Tag_ABI_PIC:
f6f0e17b 13418 val = read_uleb128 (p, &len, end);
87779176
JM		 13419 p += len;
13420 printf (" Tag_ABI_PIC: ");
13421 switch (val)
13422 {
13423 case 0:
13424 printf (_("Code addressing position-dependent\n"));
13425 break;
13426 case 1:
13427 printf (_("Code addressing position-independent\n"));
13428 break;
13429 default:
13430 printf ("??? (%d)\n", val);
13431 break;
13432 }
13433 return p;
13434
13435 case Tag_ABI_array_object_alignment:
f6f0e17b 13436 val = read_uleb128 (p, &len, end);
87779176
JM		 13437 p += len;
13438 printf (" Tag_ABI_array_object_alignment: ");
13439 switch (val)
13440 {
13441 case 0:
13442 printf (_("8-byte\n"));
13443 break;
13444 case 1:
13445 printf (_("4-byte\n"));
13446 break;
13447 case 2:
13448 printf (_("16-byte\n"));
13449 break;
13450 default:
13451 printf ("??? (%d)\n", val);
13452 break;
13453 }
13454 return p;
13455
13456 case Tag_ABI_array_object_align_expected:
f6f0e17b 13457 val = read_uleb128 (p, &len, end);
87779176
JM		 13458 p += len;
13459 printf (" Tag_ABI_array_object_align_expected: ");
13460 switch (val)
13461 {
13462 case 0:
13463 printf (_("8-byte\n"));
13464 break;
13465 case 1:
13466 printf (_("4-byte\n"));
13467 break;
13468 case 2:
13469 printf (_("16-byte\n"));
13470 break;
13471 default:
13472 printf ("??? (%d)\n", val);
13473 break;
13474 }
13475 return p;
13476
3cbd1c06 13477 case Tag_ABI_compatibility:
071436c6 13478 {
071436c6
NC		 13479 val = read_uleb128 (p, &len, end);
13480 p += len;
13481 printf (" Tag_ABI_compatibility: ");
071436c6 13482 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13483 if (p < end - 1)
13484 {
13485 size_t maxlen = (end - p) - 1;
13486
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 putchar ('\n');
071436c6
NC		 13496 return p;
13497 }
87779176
JM		 13498
13499 case Tag_ABI_conformance:
071436c6 13500 {
4082ef84
NC		 13501 printf (" Tag_ABI_conformance: \"");
13502 if (p < end - 1)
13503 {
13504 size_t maxlen = (end - p) - 1;
071436c6 13505
4082ef84
NC		 13506 print_symbol ((int) maxlen, (const char *) p);
13507 p += strnlen ((char *) p, maxlen) + 1;
13508 }
13509 else
13510 {
13511 printf (_("<corrupt>"));
13512 p = (unsigned char *) end;
13513 }
071436c6 13514 printf ("\"\n");
071436c6
NC		 13515 return p;
13516 }
59e6276b
JM		 13517 }
13518
f6f0e17b
NC		 13519 return display_tag_value (tag, p, end);
13520}
59e6276b 13521
f6f0e17b
NC		 13522static void
13523display_raw_attribute (unsigned char * p, unsigned char * end)
13524{
13525 unsigned long addr = 0;
13526 size_t bytes = end - p;
13527
e0a31db1 13528 assert (end > p);
f6f0e17b 13529 while (bytes)
87779176 13530 {
f6f0e17b
NC		 13531 int j;
13532 int k;
13533 int lbytes = (bytes > 16 ? 16 : bytes);
13534
13535 printf (" 0x%8.8lx ", addr);
13536
13537 for (j = 0; j < 16; j++)
13538 {
13539 if (j < lbytes)
13540 printf ("%2.2x", p[j]);
13541 else
13542 printf (" ");
13543
13544 if ((j & 3) == 3)
13545 printf (" ");
13546 }
13547
13548 for (j = 0; j < lbytes; j++)
13549 {
13550 k = p[j];
13551 if (k >= ' ' && k < 0x7f)
13552 printf ("%c", k);
13553 else
13554 printf (".");
13555 }
13556
13557 putchar ('\n');
13558
13559 p += lbytes;
13560 bytes -= lbytes;
13561 addr += lbytes;
87779176 13562 }
59e6276b 13563
f6f0e17b 13564 putchar ('\n');
59e6276b
JM		 13565}
13566
13761a11
NC		 13567static unsigned char *
13568display_msp430x_attribute (unsigned char * p,
13569 const unsigned char * const end)
13570{
13571 unsigned int len;
13572 int val;
13573 int tag;
13574
13575 tag = read_uleb128 (p, & len, end);
13576 p += len;
0b4362b0 13577
13761a11
NC		 13578 switch (tag)
13579 {
13580 case OFBA_MSPABI_Tag_ISA:
13581 val = read_uleb128 (p, &len, end);
13582 p += len;
13583 printf (" Tag_ISA: ");
13584 switch (val)
13585 {
13586 case 0: printf (_("None\n")); break;
13587 case 1: printf (_("MSP430\n")); break;
13588 case 2: printf (_("MSP430X\n")); break;
13589 default: printf ("??? (%d)\n", val); break;
13590 }
13591 break;
13592
13593 case OFBA_MSPABI_Tag_Code_Model:
13594 val = read_uleb128 (p, &len, end);
13595 p += len;
13596 printf (" Tag_Code_Model: ");
13597 switch (val)
13598 {
13599 case 0: printf (_("None\n")); break;
13600 case 1: printf (_("Small\n")); break;
13601 case 2: printf (_("Large\n")); break;
13602 default: printf ("??? (%d)\n", val); break;
13603 }
13604 break;
13605
13606 case OFBA_MSPABI_Tag_Data_Model:
13607 val = read_uleb128 (p, &len, end);
13608 p += len;
13609 printf (" Tag_Data_Model: ");
13610 switch (val)
13611 {
13612 case 0: printf (_("None\n")); break;
13613 case 1: printf (_("Small\n")); break;
13614 case 2: printf (_("Large\n")); break;
13615 case 3: printf (_("Restricted Large\n")); break;
13616 default: printf ("??? (%d)\n", val); break;
13617 }
13618 break;
13619
13620 default:
13621 printf (_(" <unknown tag %d>: "), tag);
13622
13623 if (tag & 1)
13624 {
071436c6 13625 putchar ('"');
4082ef84
NC		 13626 if (p < end - 1)
13627 {
13628 size_t maxlen = (end - p) - 1;
13629
13630 print_symbol ((int) maxlen, (const char *) p);
13631 p += strnlen ((char *) p, maxlen) + 1;
13632 }
13633 else
13634 {
13635 printf (_("<corrupt>"));
13636 p = (unsigned char *) end;
13637 }
071436c6 13638 printf ("\"\n");
13761a11
NC		 13639 }
13640 else
13641 {
13642 val = read_uleb128 (p, &len, end);
13643 p += len;
13644 printf ("%d (0x%x)\n", val, val);
13645 }
13646 break;
13647 }
13648
4082ef84 13649 assert (p <= end);
13761a11
NC		 13650 return p;
13651}
13652
11c1ff18 13653static int
60bca95a
NC		 13654process_attributes (FILE * file,
13655 const char * public_name,
104d59d1 13656 unsigned int proc_type,
f6f0e17b
NC		 13657 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13658 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 13659{
2cf0635d 13660 Elf_Internal_Shdr * sect;
11c1ff18
PB		 13661 unsigned i;
13662
13663 /* Find the section header so that we get the size. */
13664 for (i = 0, sect = section_headers;
13665 i < elf_header.e_shnum;
13666 i++, sect++)
13667 {
071436c6
NC		 13668 unsigned char * contents;
13669 unsigned char * p;
13670
104d59d1 13671 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 13672 continue;
13673
3f5e193b
NC		 13674 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13675 sect->sh_size, _("attributes"));
60bca95a 13676 if (contents == NULL)
11c1ff18 13677 continue;
60bca95a 13678
11c1ff18
PB		 13679 p = contents;
13680 if (*p == 'A')
13681 {
071436c6
NC		 13682 bfd_vma section_len;
13683
13684 section_len = sect->sh_size - 1;
11c1ff18 13685 p++;
60bca95a 13686
071436c6 13687 while (section_len > 0)
11c1ff18 13688 {
071436c6 13689 bfd_vma attr_len;
e9847026 13690 unsigned int namelen;
11c1ff18 13691 bfd_boolean public_section;
104d59d1 13692 bfd_boolean gnu_section;
11c1ff18 13693
071436c6 13694 if (section_len <= 4)
e0a31db1
NC		 13695 {
13696 error (_("Tag section ends prematurely\n"));
13697 break;
13698 }
071436c6 13699 attr_len = byte_get (p, 4);
11c1ff18 13700 p += 4;
60bca95a 13701
071436c6 13702 if (attr_len > section_len)
11c1ff18 13703 {
071436c6
NC		 13704 error (_("Bad attribute length (%u > %u)\n"),
13705 (unsigned) attr_len, (unsigned) section_len);
13706 attr_len = section_len;
11c1ff18 13707 }
74e1a04b 13708 /* PR 17531: file: 001-101425-0.004 */
071436c6 13709 else if (attr_len < 5)
74e1a04b 13710 {
071436c6 13711 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
74e1a04b
NC		 13712 break;
13713 }
e9847026 13714
071436c6
NC		 13715 section_len -= attr_len;
13716 attr_len -= 4;
13717
13718 namelen = strnlen ((char *) p, attr_len) + 1;
13719 if (namelen == 0 || namelen >= attr_len)
e9847026
NC		 13720 {
13721 error (_("Corrupt attribute section name\n"));
13722 break;
13723 }
13724
071436c6
NC		 13725 printf (_("Attribute Section: "));
13726 print_symbol (INT_MAX, (const char *) p);
13727 putchar ('\n');
60bca95a
NC		 13728
13729 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 13730 public_section = TRUE;
13731 else
13732 public_section = FALSE;
60bca95a
NC		 13733
13734 if (streq ((char *) p, "gnu"))
104d59d1
JM		 13735 gnu_section = TRUE;
13736 else
13737 gnu_section = FALSE;
60bca95a 13738
11c1ff18 13739 p += namelen;
071436c6 13740 attr_len -= namelen;
e0a31db1 13741
071436c6 13742 while (attr_len > 0 && p < contents + sect->sh_size)
11c1ff18 13743 {
e0a31db1 13744 int tag;
11c1ff18
PB		 13745 int val;
13746 bfd_vma size;
071436c6 13747 unsigned char * end;
60bca95a 13748
e0a31db1 13749 /* PR binutils/17531: Safe handling of corrupt files. */
071436c6 13750 if (attr_len < 6)
e0a31db1
NC		 13751 {
13752 error (_("Unused bytes at end of section\n"));
13753 section_len = 0;
13754 break;
13755 }
13756
13757 tag = *(p++);
11c1ff18 13758 size = byte_get (p, 4);
071436c6 13759 if (size > attr_len)
11c1ff18 13760 {
e9847026 13761 error (_("Bad subsection length (%u > %u)\n"),
071436c6
NC		 13762 (unsigned) size, (unsigned) attr_len);
13763 size = attr_len;
11c1ff18 13764 }
e0a31db1
NC		 13765 /* PR binutils/17531: Safe handling of corrupt files. */
13766 if (size < 6)
13767 {
13768 error (_("Bad subsection length (%u < 6)\n"),
13769 (unsigned) size);
13770 section_len = 0;
13771 break;
13772 }
60bca95a 13773
071436c6 13774 attr_len -= size;
11c1ff18 13775 end = p + size - 1;
071436c6 13776 assert (end <= contents + sect->sh_size);
11c1ff18 13777 p += 4;
60bca95a 13778
11c1ff18
PB		 13779 switch (tag)
13780 {
13781 case 1:
2b692964 13782 printf (_("File Attributes\n"));
11c1ff18
PB		 13783 break;
13784 case 2:
2b692964 13785 printf (_("Section Attributes:"));
11c1ff18
PB		 13786 goto do_numlist;
13787 case 3:
2b692964 13788 printf (_("Symbol Attributes:"));
11c1ff18
PB		 13789 do_numlist:
13790 for (;;)
13791 {
91d6fa6a 13792 unsigned int j;
60bca95a 13793
f6f0e17b 13794 val = read_uleb128 (p, &j, end);
91d6fa6a 13795 p += j;
11c1ff18
PB		 13796 if (val == 0)
13797 break;
13798 printf (" %d", val);
13799 }
13800 printf ("\n");
13801 break;
13802 default:
2b692964 13803 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 13804 public_section = FALSE;
13805 break;
13806 }
60bca95a 13807
071436c6 13808 if (public_section && display_pub_attribute != NULL)
11c1ff18
PB		 13809 {
13810 while (p < end)
f6f0e17b 13811 p = display_pub_attribute (p, end);
071436c6 13812 assert (p <= end);
104d59d1 13813 }
071436c6 13814 else if (gnu_section && display_proc_gnu_attribute != NULL)
104d59d1
JM		 13815 {
13816 while (p < end)
13817 p = display_gnu_attribute (p,
f6f0e17b
NC		 13818 display_proc_gnu_attribute,
13819 end);
071436c6 13820 assert (p <= end);
11c1ff18 13821 }
071436c6 13822 else if (p < end)
11c1ff18 13823 {
071436c6 13824 printf (_(" Unknown attribute:\n"));
f6f0e17b 13825 display_raw_attribute (p, end);
11c1ff18
PB		 13826 p = end;
13827 }
071436c6
NC		 13828 else
13829 attr_len = 0;
11c1ff18
PB		 13830 }
13831 }
13832 }
13833 else
e9847026 13834 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
d70c5fc7 13835
60bca95a 13836 free (contents);
11c1ff18
PB		 13837 }
13838 return 1;
13839}
13840
104d59d1 13841static int
2cf0635d 13842process_arm_specific (FILE * file)
104d59d1
JM		 13843{
13844 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13845 display_arm_attribute, NULL);
13846}
13847
34c8bcba 13848static int
2cf0635d 13849process_power_specific (FILE * file)
34c8bcba
JM		 13850{
13851 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13852 display_power_gnu_attribute);
13853}
13854
643f7afb
AK		 13855static int
13856process_s390_specific (FILE * file)
13857{
13858 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13859 display_s390_gnu_attribute);
13860}
13861
9e8c70f9
DM		 13862static int
13863process_sparc_specific (FILE * file)
13864{
13865 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13866 display_sparc_gnu_attribute);
13867}
13868
59e6276b
JM		 13869static int
13870process_tic6x_specific (FILE * file)
13871{
13872 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13873 display_tic6x_attribute, NULL);
13874}
13875
13761a11
NC		 13876static int
13877process_msp430x_specific (FILE * file)
13878{
13879 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13880 display_msp430x_attribute, NULL);
13881}
13882
ccb4c951
RS		 13883/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13884 Print the Address, Access and Initial fields of an entry at VMA ADDR
82b1b41b
NC		 13885 and return the VMA of the next entry, or -1 if there was a problem.
13886 Does not read from DATA_END or beyond. */
ccb4c951
RS		 13887
13888static bfd_vma
82b1b41b
NC		 13889print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
13890 unsigned char * data_end)
ccb4c951
RS		 13891{
13892 printf (" ");
13893 print_vma (addr, LONG_HEX);
13894 printf (" ");
13895 if (addr < pltgot + 0xfff0)
13896 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13897 else
13898 printf ("%10s", "");
13899 printf (" ");
13900 if (data == NULL)
2b692964 13901 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 13902 else
13903 {
13904 bfd_vma entry;
82b1b41b 13905 unsigned char * from = data + addr - pltgot;
ccb4c951 13906
82b1b41b
NC		 13907 if (from + (is_32bit_elf ? 4 : 8) > data_end)
13908 {
13909 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13910 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
13911 return (bfd_vma) -1;
13912 }
13913 else
13914 {
13915 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13916 print_vma (entry, LONG_HEX);
13917 }
ccb4c951
RS		 13918 }
13919 return addr + (is_32bit_elf ? 4 : 8);
13920}
13921
861fb55a
DJ		 13922/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13923 PLTGOT. Print the Address and Initial fields of an entry at VMA
13924 ADDR and return the VMA of the next entry. */
13925
13926static bfd_vma
2cf0635d 13927print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 13928{
13929 printf (" ");
13930 print_vma (addr, LONG_HEX);
13931 printf (" ");
13932 if (data == NULL)
2b692964 13933 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 13934 else
13935 {
13936 bfd_vma entry;
13937
13938 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13939 print_vma (entry, LONG_HEX);
13940 }
13941 return addr + (is_32bit_elf ? 4 : 8);
13942}
13943
351cdf24
MF		 13944static void
13945print_mips_ases (unsigned int mask)
13946{
13947 if (mask & AFL_ASE_DSP)
13948 fputs ("\n\tDSP ASE", stdout);
13949 if (mask & AFL_ASE_DSPR2)
13950 fputs ("\n\tDSP R2 ASE", stdout);
13951 if (mask & AFL_ASE_EVA)
13952 fputs ("\n\tEnhanced VA Scheme", stdout);
13953 if (mask & AFL_ASE_MCU)
13954 fputs ("\n\tMCU (MicroController) ASE", stdout);
13955 if (mask & AFL_ASE_MDMX)
13956 fputs ("\n\tMDMX ASE", stdout);
13957 if (mask & AFL_ASE_MIPS3D)
13958 fputs ("\n\tMIPS-3D ASE", stdout);
13959 if (mask & AFL_ASE_MT)
13960 fputs ("\n\tMT ASE", stdout);
13961 if (mask & AFL_ASE_SMARTMIPS)
13962 fputs ("\n\tSmartMIPS ASE", stdout);
13963 if (mask & AFL_ASE_VIRT)
13964 fputs ("\n\tVZ ASE", stdout);
13965 if (mask & AFL_ASE_MSA)
13966 fputs ("\n\tMSA ASE", stdout);
13967 if (mask & AFL_ASE_MIPS16)
13968 fputs ("\n\tMIPS16 ASE", stdout);
13969 if (mask & AFL_ASE_MICROMIPS)
13970 fputs ("\n\tMICROMIPS ASE", stdout);
13971 if (mask & AFL_ASE_XPA)
13972 fputs ("\n\tXPA ASE", stdout);
13973 if (mask == 0)
13974 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 13975 else if ((mask & ~AFL_ASE_MASK) != 0)
13976 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 13977}
13978
13979static void
13980print_mips_isa_ext (unsigned int isa_ext)
13981{
13982 switch (isa_ext)
13983 {
13984 case 0:
13985 fputs (_("None"), stdout);
13986 break;
13987 case AFL_EXT_XLR:
13988 fputs ("RMI XLR", stdout);
13989 break;
2c629856
N		 13990 case AFL_EXT_OCTEON3:
13991 fputs ("Cavium Networks Octeon3", stdout);
13992 break;
351cdf24
MF		 13993 case AFL_EXT_OCTEON2:
13994 fputs ("Cavium Networks Octeon2", stdout);
13995 break;
13996 case AFL_EXT_OCTEONP:
13997 fputs ("Cavium Networks OcteonP", stdout);
13998 break;
13999 case AFL_EXT_LOONGSON_3A:
14000 fputs ("Loongson 3A", stdout);
14001 break;
14002 case AFL_EXT_OCTEON:
14003 fputs ("Cavium Networks Octeon", stdout);
14004 break;
14005 case AFL_EXT_5900:
14006 fputs ("Toshiba R5900", stdout);
14007 break;
14008 case AFL_EXT_4650:
14009 fputs ("MIPS R4650", stdout);
14010 break;
14011 case AFL_EXT_4010:
14012 fputs ("LSI R4010", stdout);
14013 break;
14014 case AFL_EXT_4100:
14015 fputs ("NEC VR4100", stdout);
14016 break;
14017 case AFL_EXT_3900:
14018 fputs ("Toshiba R3900", stdout);
14019 break;
14020 case AFL_EXT_10000:
14021 fputs ("MIPS R10000", stdout);
14022 break;
14023 case AFL_EXT_SB1:
14024 fputs ("Broadcom SB-1", stdout);
14025 break;
14026 case AFL_EXT_4111:
14027 fputs ("NEC VR4111/VR4181", stdout);
14028 break;
14029 case AFL_EXT_4120:
14030 fputs ("NEC VR4120", stdout);
14031 break;
14032 case AFL_EXT_5400:
14033 fputs ("NEC VR5400", stdout);
14034 break;
14035 case AFL_EXT_5500:
14036 fputs ("NEC VR5500", stdout);
14037 break;
14038 case AFL_EXT_LOONGSON_2E:
14039 fputs ("ST Microelectronics Loongson 2E", stdout);
14040 break;
14041 case AFL_EXT_LOONGSON_2F:
14042 fputs ("ST Microelectronics Loongson 2F", stdout);
14043 break;
14044 default:
00ac7aa0 14045 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 14046 }
14047}
14048
14049static int
14050get_mips_reg_size (int reg_size)
14051{
14052 return (reg_size == AFL_REG_NONE) ? 0
14053 : (reg_size == AFL_REG_32) ? 32
14054 : (reg_size == AFL_REG_64) ? 64
14055 : (reg_size == AFL_REG_128) ? 128
14056 : -1;
14057}
14058
19e6b90e 14059static int
2cf0635d 14060process_mips_specific (FILE * file)
5b18a4bc 14061{
2cf0635d 14062 Elf_Internal_Dyn * entry;
351cdf24 14063 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 14064 size_t liblist_offset = 0;
14065 size_t liblistno = 0;
14066 size_t conflictsno = 0;
14067 size_t options_offset = 0;
14068 size_t conflicts_offset = 0;
861fb55a
DJ		 14069 size_t pltrelsz = 0;
14070 size_t pltrel = 0;
ccb4c951 14071 bfd_vma pltgot = 0;
861fb55a
DJ		 14072 bfd_vma mips_pltgot = 0;
14073 bfd_vma jmprel = 0;
ccb4c951
RS		 14074 bfd_vma local_gotno = 0;
14075 bfd_vma gotsym = 0;
14076 bfd_vma symtabno = 0;
103f02d3 14077
2cf19d5c
JM		 14078 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14079 display_mips_gnu_attribute);
14080
351cdf24
MF		 14081 sect = find_section (".MIPS.abiflags");
14082
14083 if (sect != NULL)
14084 {
14085 Elf_External_ABIFlags_v0 *abiflags_ext;
14086 Elf_Internal_ABIFlags_v0 abiflags_in;
14087
14088 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
14089 fputs ("\nCorrupt ABI Flags section.\n", stdout);
14090 else
14091 {
14092 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
14093 sect->sh_size, _("MIPS ABI Flags section"));
14094 if (abiflags_ext)
14095 {
14096 abiflags_in.version = BYTE_GET (abiflags_ext->version);
14097 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
14098 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
14099 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
14100 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
14101 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
14102 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
14103 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
14104 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
14105 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
14106 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
14107
14108 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
14109 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
14110 if (abiflags_in.isa_rev > 1)
14111 printf ("r%d", abiflags_in.isa_rev);
14112 printf ("\nGPR size: %d",
14113 get_mips_reg_size (abiflags_in.gpr_size));
14114 printf ("\nCPR1 size: %d",
14115 get_mips_reg_size (abiflags_in.cpr1_size));
14116 printf ("\nCPR2 size: %d",
14117 get_mips_reg_size (abiflags_in.cpr2_size));
14118 fputs ("\nFP ABI: ", stdout);
14119 print_mips_fp_abi_value (abiflags_in.fp_abi);
14120 fputs ("ISA Extension: ", stdout);
14121 print_mips_isa_ext (abiflags_in.isa_ext);
14122 fputs ("\nASEs:", stdout);
14123 print_mips_ases (abiflags_in.ases);
14124 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
14125 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
14126 fputc ('\n', stdout);
14127 free (abiflags_ext);
14128 }
14129 }
14130 }
14131
19e6b90e
L		 14132 /* We have a lot of special sections. Thanks SGI! */
14133 if (dynamic_section == NULL)
14134 /* No information available. */
14135 return 0;
252b5132 14136
071436c6
NC		 14137 for (entry = dynamic_section;
14138 /* PR 17531 file: 012-50589-0.004. */
14139 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
14140 ++entry)
252b5132
RH		 14141 switch (entry->d_tag)
14142 {
14143 case DT_MIPS_LIBLIST:
d93f0186
NC		 14144 liblist_offset
14145 = offset_from_vma (file, entry->d_un.d_val,
14146 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 14147 break;
14148 case DT_MIPS_LIBLISTNO:
14149 liblistno = entry->d_un.d_val;
14150 break;
14151 case DT_MIPS_OPTIONS:
d93f0186 14152 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 14153 break;
14154 case DT_MIPS_CONFLICT:
d93f0186
NC		 14155 conflicts_offset
14156 = offset_from_vma (file, entry->d_un.d_val,
14157 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 14158 break;
14159 case DT_MIPS_CONFLICTNO:
14160 conflictsno = entry->d_un.d_val;
14161 break;
ccb4c951 14162 case DT_PLTGOT:
861fb55a
DJ		 14163 pltgot = entry->d_un.d_ptr;
14164 break;
ccb4c951
RS		 14165 case DT_MIPS_LOCAL_GOTNO:
14166 local_gotno = entry->d_un.d_val;
14167 break;
14168 case DT_MIPS_GOTSYM:
14169 gotsym = entry->d_un.d_val;
14170 break;
14171 case DT_MIPS_SYMTABNO:
14172 symtabno = entry->d_un.d_val;
14173 break;
861fb55a
DJ		 14174 case DT_MIPS_PLTGOT:
14175 mips_pltgot = entry->d_un.d_ptr;
14176 break;
14177 case DT_PLTREL:
14178 pltrel = entry->d_un.d_val;
14179 break;
14180 case DT_PLTRELSZ:
14181 pltrelsz = entry->d_un.d_val;
14182 break;
14183 case DT_JMPREL:
14184 jmprel = entry->d_un.d_ptr;
14185 break;
252b5132
RH		 14186 default:
14187 break;
14188 }
14189
14190 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
14191 {
2cf0635d 14192 Elf32_External_Lib * elib;
252b5132
RH		 14193 size_t cnt;
14194
3f5e193b
NC		 14195 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
14196 liblistno,
14197 sizeof (Elf32_External_Lib),
9cf03b7e 14198 _("liblist section data"));
a6e9f9df 14199 if (elib)
252b5132 14200 {
2b692964 14201 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 14202 (unsigned long) liblistno);
2b692964 14203 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 14204 stdout);
14205
14206 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 14207 {
a6e9f9df 14208 Elf32_Lib liblist;
91d6fa6a 14209 time_t atime;
a6e9f9df 14210 char timebuf[20];
2cf0635d 14211 struct tm * tmp;
a6e9f9df
AM		 14212
14213 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14214 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 14215 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14216 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14217 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14218
91d6fa6a 14219 tmp = gmtime (&atime);
e9e44622
JJ		 14220 snprintf (timebuf, sizeof (timebuf),
14221 "%04u-%02u-%02uT%02u:%02u:%02u",
14222 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14223 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 14224
31104126 14225 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 14226 if (VALID_DYNAMIC_NAME (liblist.l_name))
14227 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
14228 else
2b692964 14229 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 14230 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
14231 liblist.l_version);
a6e9f9df
AM		 14232
14233 if (liblist.l_flags == 0)
2b692964 14234 puts (_(" NONE"));
a6e9f9df
AM		 14235 else
14236 {
14237 static const struct
252b5132 14238 {
2cf0635d 14239 const char * name;
a6e9f9df 14240 int bit;
252b5132 14241 }
a6e9f9df
AM		 14242 l_flags_vals[] =
14243 {
14244 { " EXACT_MATCH", LL_EXACT_MATCH },
14245 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
14246 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
14247 { " EXPORTS", LL_EXPORTS },
14248 { " DELAY_LOAD", LL_DELAY_LOAD },
14249 { " DELTA", LL_DELTA }
14250 };
14251 int flags = liblist.l_flags;
14252 size_t fcnt;
14253
60bca95a 14254 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 14255 if ((flags & l_flags_vals[fcnt].bit) != 0)
14256 {
14257 fputs (l_flags_vals[fcnt].name, stdout);
14258 flags ^= l_flags_vals[fcnt].bit;
14259 }
14260 if (flags != 0)
14261 printf (" %#x", (unsigned int) flags);
252b5132 14262
a6e9f9df
AM		 14263 puts ("");
14264 }
252b5132 14265 }
252b5132 14266
a6e9f9df
AM		 14267 free (elib);
14268 }
252b5132
RH		 14269 }
14270
14271 if (options_offset != 0)
14272 {
2cf0635d 14273 Elf_External_Options * eopt;
2cf0635d
NC		 14274 Elf_Internal_Options * iopt;
14275 Elf_Internal_Options * option;
252b5132
RH		 14276 size_t offset;
14277 int cnt;
351cdf24 14278 sect = section_headers;
252b5132
RH		 14279
14280 /* Find the section header so that we get the size. */
071436c6 14281 sect = find_section_by_type (SHT_MIPS_OPTIONS);
948f632f 14282 /* PR 17533 file: 012-277276-0.004. */
071436c6
NC		 14283 if (sect == NULL)
14284 {
14285 error (_("No MIPS_OPTIONS header found\n"));
14286 return 0;
14287 }
252b5132 14288
3f5e193b
NC		 14289 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14290 sect->sh_size, _("options"));
a6e9f9df 14291 if (eopt)
252b5132 14292 {
3f5e193b
NC		 14293 iopt = (Elf_Internal_Options *)
14294 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 14295 if (iopt == NULL)
14296 {
8b73c356 14297 error (_("Out of memory allocatinf space for MIPS options\n"));
a6e9f9df
AM		 14298 return 0;
14299 }
76da6bbe 14300
a6e9f9df
AM		 14301 offset = cnt = 0;
14302 option = iopt;
252b5132 14303
82b1b41b 14304 while (offset <= sect->sh_size - sizeof (* eopt))
a6e9f9df 14305 {
2cf0635d 14306 Elf_External_Options * eoption;
252b5132 14307
a6e9f9df 14308 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 14309
a6e9f9df
AM		 14310 option->kind = BYTE_GET (eoption->kind);
14311 option->size = BYTE_GET (eoption->size);
14312 option->section = BYTE_GET (eoption->section);
14313 option->info = BYTE_GET (eoption->info);
76da6bbe 14314
82b1b41b
NC		 14315 /* PR 17531: file: ffa0fa3b. */
14316 if (option->size < sizeof (* eopt)
14317 || offset + option->size > sect->sh_size)
14318 {
55325047
NC		 14319 error (_("Invalid size (%u) for MIPS option\n"), option->size);
14320 return 0;
82b1b41b 14321 }
a6e9f9df 14322 offset += option->size;
14ae95f2 14323
a6e9f9df
AM		 14324 ++option;
14325 ++cnt;
14326 }
252b5132 14327
a6e9f9df 14328 printf (_("\nSection '%s' contains %d entries:\n"),
74e1a04b 14329 printable_section_name (sect), cnt);
76da6bbe 14330
a6e9f9df 14331 option = iopt;
82b1b41b 14332 offset = 0;
252b5132 14333
a6e9f9df 14334 while (cnt-- > 0)
252b5132 14335 {
a6e9f9df
AM		 14336 size_t len;
14337
14338 switch (option->kind)
252b5132 14339 {
a6e9f9df
AM		 14340 case ODK_NULL:
14341 /* This shouldn't happen. */
14342 printf (" NULL %d %lx", option->section, option->info);
14343 break;
14344 case ODK_REGINFO:
14345 printf (" REGINFO ");
14346 if (elf_header.e_machine == EM_MIPS)
14347 {
14348 /* 32bit form. */
2cf0635d 14349 Elf32_External_RegInfo * ereg;
b34976b6 14350 Elf32_RegInfo reginfo;
a6e9f9df
AM		 14351
14352 ereg = (Elf32_External_RegInfo *) (option + 1);
14353 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14354 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14355 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14356 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14357 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14358 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14359
14360 printf ("GPR %08lx GP 0x%lx\n",
14361 reginfo.ri_gprmask,
14362 (unsigned long) reginfo.ri_gp_value);
14363 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14364 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14365 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14366 }
14367 else
14368 {
14369 /* 64 bit form. */
2cf0635d 14370 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 14371 Elf64_Internal_RegInfo reginfo;
14372
14373 ereg = (Elf64_External_RegInfo *) (option + 1);
14374 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14375 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14376 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14377 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14378 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 14379 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 14380
14381 printf ("GPR %08lx GP 0x",
14382 reginfo.ri_gprmask);
14383 printf_vma (reginfo.ri_gp_value);
14384 printf ("\n");
14385
14386 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14387 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14388 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14389 }
14390 ++option;
14391 continue;
14392 case ODK_EXCEPTIONS:
14393 fputs (" EXCEPTIONS fpe_min(", stdout);
14394 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14395 fputs (") fpe_max(", stdout);
14396 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14397 fputs (")", stdout);
14398
14399 if (option->info & OEX_PAGE0)
14400 fputs (" PAGE0", stdout);
14401 if (option->info & OEX_SMM)
14402 fputs (" SMM", stdout);
14403 if (option->info & OEX_FPDBUG)
14404 fputs (" FPDBUG", stdout);
14405 if (option->info & OEX_DISMISS)
14406 fputs (" DISMISS", stdout);
14407 break;
14408 case ODK_PAD:
14409 fputs (" PAD ", stdout);
14410 if (option->info & OPAD_PREFIX)
14411 fputs (" PREFIX", stdout);
14412 if (option->info & OPAD_POSTFIX)
14413 fputs (" POSTFIX", stdout);
14414 if (option->info & OPAD_SYMBOL)
14415 fputs (" SYMBOL", stdout);
14416 break;
14417 case ODK_HWPATCH:
14418 fputs (" HWPATCH ", stdout);
14419 if (option->info & OHW_R4KEOP)
14420 fputs (" R4KEOP", stdout);
14421 if (option->info & OHW_R8KPFETCH)
14422 fputs (" R8KPFETCH", stdout);
14423 if (option->info & OHW_R5KEOP)
14424 fputs (" R5KEOP", stdout);
14425 if (option->info & OHW_R5KCVTL)
14426 fputs (" R5KCVTL", stdout);
14427 break;
14428 case ODK_FILL:
14429 fputs (" FILL ", stdout);
14430 /* XXX Print content of info word? */
14431 break;
14432 case ODK_TAGS:
14433 fputs (" TAGS ", stdout);
14434 /* XXX Print content of info word? */
14435 break;
14436 case ODK_HWAND:
14437 fputs (" HWAND ", stdout);
14438 if (option->info & OHWA0_R4KEOP_CHECKED)
14439 fputs (" R4KEOP_CHECKED", stdout);
14440 if (option->info & OHWA0_R4KEOP_CLEAN)
14441 fputs (" R4KEOP_CLEAN", stdout);
14442 break;
14443 case ODK_HWOR:
14444 fputs (" HWOR ", stdout);
14445 if (option->info & OHWA0_R4KEOP_CHECKED)
14446 fputs (" R4KEOP_CHECKED", stdout);
14447 if (option->info & OHWA0_R4KEOP_CLEAN)
14448 fputs (" R4KEOP_CLEAN", stdout);
14449 break;
14450 case ODK_GP_GROUP:
14451 printf (" GP_GROUP %#06lx self-contained %#06lx",
14452 option->info & OGP_GROUP,
14453 (option->info & OGP_SELF) >> 16);
14454 break;
14455 case ODK_IDENT:
14456 printf (" IDENT %#06lx self-contained %#06lx",
14457 option->info & OGP_GROUP,
14458 (option->info & OGP_SELF) >> 16);
14459 break;
14460 default:
14461 /* This shouldn't happen. */
14462 printf (" %3d ??? %d %lx",
14463 option->kind, option->section, option->info);
14464 break;
252b5132 14465 }
a6e9f9df 14466
2cf0635d 14467 len = sizeof (* eopt);
a6e9f9df 14468 while (len < option->size)
82b1b41b 14469 {
7e27a9d5 14470 unsigned char datum = * ((unsigned char *) eopt + offset + len);
a6e9f9df 14471
82b1b41b
NC		 14472 if (ISPRINT (datum))
14473 printf ("%c", datum);
14474 else
14475 printf ("\\%03o", datum);
14476 len ++;
14477 }
a6e9f9df 14478 fputs ("\n", stdout);
82b1b41b
NC		 14479
14480 offset += option->size;
252b5132 14481 ++option;
252b5132
RH		 14482 }
14483
a6e9f9df 14484 free (eopt);
252b5132 14485 }
252b5132
RH		 14486 }
14487
14488 if (conflicts_offset != 0 && conflictsno != 0)
14489 {
2cf0635d 14490 Elf32_Conflict * iconf;
252b5132
RH		 14491 size_t cnt;
14492
14493 if (dynamic_symbols == NULL)
14494 {
591a748a 14495 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 14496 return 0;
14497 }
14498
3f5e193b 14499 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 14500 if (iconf == NULL)
14501 {
8b73c356 14502 error (_("Out of memory allocating space for dynamic conflicts\n"));
252b5132
RH		 14503 return 0;
14504 }
14505
9ea033b2 14506 if (is_32bit_elf)
252b5132 14507 {
2cf0635d 14508 Elf32_External_Conflict * econf32;
a6e9f9df 14509
3f5e193b
NC		 14510 econf32 = (Elf32_External_Conflict *)
14511 get_data (NULL, file, conflicts_offset, conflictsno,
14512 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 14513 if (!econf32)
14514 return 0;
252b5132
RH		 14515
14516 for (cnt = 0; cnt < conflictsno; ++cnt)
14517 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 14518
14519 free (econf32);
252b5132
RH		 14520 }
14521 else
14522 {
2cf0635d 14523 Elf64_External_Conflict * econf64;
a6e9f9df 14524
3f5e193b
NC		 14525 econf64 = (Elf64_External_Conflict *)
14526 get_data (NULL, file, conflicts_offset, conflictsno,
14527 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 14528 if (!econf64)
14529 return 0;
252b5132
RH		 14530
14531 for (cnt = 0; cnt < conflictsno; ++cnt)
14532 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 14533
14534 free (econf64);
252b5132
RH		 14535 }
14536
c7e7ca54
NC		 14537 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14538 (unsigned long) conflictsno);
252b5132
RH		 14539 puts (_(" Num: Index Value Name"));
14540
14541 for (cnt = 0; cnt < conflictsno; ++cnt)
14542 {
b34976b6 14543 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 14544
14545 if (iconf[cnt] >= num_dynamic_syms)
14546 printf (_("<corrupt symbol index>"));
d79b3d50 14547 else
e0a31db1
NC		 14548 {
14549 Elf_Internal_Sym * psym;
14550
14551 psym = & dynamic_symbols[iconf[cnt]];
14552 print_vma (psym->st_value, FULL_HEX);
14553 putchar (' ');
14554 if (VALID_DYNAMIC_NAME (psym->st_name))
14555 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14556 else
14557 printf (_("<corrupt: %14ld>"), psym->st_name);
14558 }
31104126 14559 putchar ('\n');
252b5132
RH		 14560 }
14561
252b5132
RH		 14562 free (iconf);
14563 }
14564
ccb4c951
RS		 14565 if (pltgot != 0 && local_gotno != 0)
14566 {
91d6fa6a 14567 bfd_vma ent, local_end, global_end;
bbeee7ea 14568 size_t i, offset;
2cf0635d 14569 unsigned char * data;
82b1b41b 14570 unsigned char * data_end;
bbeee7ea 14571 int addr_size;
ccb4c951 14572
91d6fa6a 14573 ent = pltgot;
ccb4c951
RS		 14574 addr_size = (is_32bit_elf ? 4 : 8);
14575 local_end = pltgot + local_gotno * addr_size;
ccb4c951 14576
74e1a04b
NC		 14577 /* PR binutils/17533 file: 012-111227-0.004 */
14578 if (symtabno < gotsym)
14579 {
14580 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
82b1b41b 14581 (unsigned long) gotsym, (unsigned long) symtabno);
74e1a04b
NC		 14582 return 0;
14583 }
82b1b41b 14584
74e1a04b 14585 global_end = local_end + (symtabno - gotsym) * addr_size;
82b1b41b
NC		 14586 /* PR 17531: file: 54c91a34. */
14587 if (global_end < local_end)
14588 {
14589 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14590 return 0;
14591 }
948f632f 14592
ccb4c951 14593 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 14594 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 14595 global_end - pltgot, 1,
14596 _("Global Offset Table data"));
59245841
NC		 14597 if (data == NULL)
14598 return 0;
82b1b41b 14599 data_end = data + (global_end - pltgot);
59245841 14600
ccb4c951
RS		 14601 printf (_("\nPrimary GOT:\n"));
14602 printf (_(" Canonical gp value: "));
14603 print_vma (pltgot + 0x7ff0, LONG_HEX);
14604 printf ("\n\n");
14605
14606 printf (_(" Reserved entries:\n"));
14607 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 14608 addr_size * 2, _("Address"), _("Access"),
14609 addr_size * 2, _("Initial"));
82b1b41b 14610 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14611 printf (_(" Lazy resolver\n"));
82b1b41b
NC		 14612 if (ent == (bfd_vma) -1)
14613 goto got_print_fail;
ccb4c951 14614 if (data
91d6fa6a 14615 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 14616 >> (addr_size * 8 - 1)) != 0)
14617 {
82b1b41b 14618 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14619 printf (_(" Module pointer (GNU extension)\n"));
82b1b41b
NC		 14620 if (ent == (bfd_vma) -1)
14621 goto got_print_fail;
ccb4c951
RS		 14622 }
14623 printf ("\n");
14624
91d6fa6a 14625 if (ent < local_end)
ccb4c951
RS		 14626 {
14627 printf (_(" Local entries:\n"));
cc5914eb 14628 printf (" %*s %10s %*s\n",
2b692964
NC		 14629 addr_size * 2, _("Address"), _("Access"),
14630 addr_size * 2, _("Initial"));
91d6fa6a 14631 while (ent < local_end)
ccb4c951 14632 {
82b1b41b 14633 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14634 printf ("\n");
82b1b41b
NC		 14635 if (ent == (bfd_vma) -1)
14636 goto got_print_fail;
ccb4c951
RS		 14637 }
14638 printf ("\n");
14639 }
14640
14641 if (gotsym < symtabno)
14642 {
14643 int sym_width;
14644
14645 printf (_(" Global entries:\n"));
cc5914eb 14646 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 14647 addr_size * 2, _("Address"),
14648 _("Access"),
2b692964 14649 addr_size * 2, _("Initial"),
9cf03b7e
NC		 14650 addr_size * 2, _("Sym.Val."),
14651 _("Type"),
14652 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14653 _("Ndx"), _("Name"));
0b4362b0 14654
ccb4c951 14655 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 14656
ccb4c951
RS		 14657 for (i = gotsym; i < symtabno; i++)
14658 {
82b1b41b 14659 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14660 printf (" ");
e0a31db1
NC		 14661
14662 if (dynamic_symbols == NULL)
14663 printf (_("<no dynamic symbols>"));
14664 else if (i < num_dynamic_syms)
14665 {
14666 Elf_Internal_Sym * psym = dynamic_symbols + i;
14667
14668 print_vma (psym->st_value, LONG_HEX);
14669 printf (" %-7s %3s ",
14670 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14671 get_symbol_index_type (psym->st_shndx));
14672
14673 if (VALID_DYNAMIC_NAME (psym->st_name))
14674 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14675 else
14676 printf (_("<corrupt: %14ld>"), psym->st_name);
14677 }
ccb4c951 14678 else
7fc5ac57
JBG		 14679 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14680 (unsigned long) i);
e0a31db1 14681
ccb4c951 14682 printf ("\n");
82b1b41b
NC		 14683 if (ent == (bfd_vma) -1)
14684 break;
ccb4c951
RS		 14685 }
14686 printf ("\n");
14687 }
14688
82b1b41b 14689 got_print_fail:
ccb4c951
RS		 14690 if (data)
14691 free (data);
14692 }
14693
861fb55a
DJ		 14694 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14695 {
91d6fa6a 14696 bfd_vma ent, end;
861fb55a
DJ		 14697 size_t offset, rel_offset;
14698 unsigned long count, i;
2cf0635d 14699 unsigned char * data;
861fb55a 14700 int addr_size, sym_width;
2cf0635d 14701 Elf_Internal_Rela * rels;
861fb55a
DJ		 14702
14703 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14704 if (pltrel == DT_RELA)
14705 {
14706 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14707 return 0;
14708 }
14709 else
14710 {
14711 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14712 return 0;
14713 }
14714
91d6fa6a 14715 ent = mips_pltgot;
861fb55a
DJ		 14716 addr_size = (is_32bit_elf ? 4 : 8);
14717 end = mips_pltgot + (2 + count) * addr_size;
14718
14719 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 14720 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 14721 1, _("Procedure Linkage Table data"));
59245841
NC		 14722 if (data == NULL)
14723 return 0;
14724
9cf03b7e 14725 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 14726 printf (_(" Reserved entries:\n"));
14727 printf (_(" %*s %*s Purpose\n"),
2b692964 14728 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 14729 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14730 printf (_(" PLT lazy resolver\n"));
91d6fa6a 14731 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14732 printf (_(" Module pointer\n"));
861fb55a
DJ		 14733 printf ("\n");
14734
14735 printf (_(" Entries:\n"));
cc5914eb 14736 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 14737 addr_size * 2, _("Address"),
14738 addr_size * 2, _("Initial"),
14739 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 14740 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14741 for (i = 0; i < count; i++)
14742 {
df97ab2a 14743 unsigned long idx = get_reloc_symindex (rels[i].r_info);
861fb55a 14744
91d6fa6a 14745 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 14746 printf (" ");
e0a31db1 14747
df97ab2a
MF		 14748 if (idx >= num_dynamic_syms)
14749 printf (_("<corrupt symbol index: %lu>"), idx);
861fb55a 14750 else
e0a31db1 14751 {
df97ab2a 14752 Elf_Internal_Sym * psym = dynamic_symbols + idx;
e0a31db1
NC		 14753
14754 print_vma (psym->st_value, LONG_HEX);
14755 printf (" %-7s %3s ",
14756 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14757 get_symbol_index_type (psym->st_shndx));
14758 if (VALID_DYNAMIC_NAME (psym->st_name))
14759 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14760 else
14761 printf (_("<corrupt: %14ld>"), psym->st_name);
14762 }
861fb55a
DJ		 14763 printf ("\n");
14764 }
14765 printf ("\n");
14766
14767 if (data)
14768 free (data);
14769 free (rels);
14770 }
14771
252b5132
RH		 14772 return 1;
14773}
14774
35c08157
KLC		 14775static int
14776process_nds32_specific (FILE * file)
14777{
14778 Elf_Internal_Shdr *sect = NULL;
14779
14780 sect = find_section (".nds32_e_flags");
14781 if (sect != NULL)
14782 {
14783 unsigned int *flag;
14784
14785 printf ("\nNDS32 elf flags section:\n");
14786 flag = get_data (NULL, file, sect->sh_offset, 1,
14787 sect->sh_size, _("NDS32 elf flags section"));
14788
14789 switch ((*flag) & 0x3)
14790 {
14791 case 0:
14792 printf ("(VEC_SIZE):\tNo entry.\n");
14793 break;
14794 case 1:
14795 printf ("(VEC_SIZE):\t4 bytes\n");
14796 break;
14797 case 2:
14798 printf ("(VEC_SIZE):\t16 bytes\n");
14799 break;
14800 case 3:
14801 printf ("(VEC_SIZE):\treserved\n");
14802 break;
14803 }
14804 }
14805
14806 return TRUE;
14807}
14808
047b2264 14809static int
2cf0635d 14810process_gnu_liblist (FILE * file)
047b2264 14811{
2cf0635d
NC		 14812 Elf_Internal_Shdr * section;
14813 Elf_Internal_Shdr * string_sec;
14814 Elf32_External_Lib * elib;
14815 char * strtab;
c256ffe7 14816 size_t strtab_size;
047b2264
JJ		 14817 size_t cnt;
14818 unsigned i;
14819
14820 if (! do_arch)
14821 return 0;
14822
14823 for (i = 0, section = section_headers;
14824 i < elf_header.e_shnum;
b34976b6 14825 i++, section++)
047b2264
JJ		 14826 {
14827 switch (section->sh_type)
14828 {
14829 case SHT_GNU_LIBLIST:
4fbb74a6 14830 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 14831 break;
14832
3f5e193b
NC		 14833 elib = (Elf32_External_Lib *)
14834 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 14835 _("liblist section data"));
047b2264
JJ		 14836
14837 if (elib == NULL)
14838 break;
4fbb74a6 14839 string_sec = section_headers + section->sh_link;
047b2264 14840
3f5e193b
NC		 14841 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14842 string_sec->sh_size,
14843 _("liblist string table"));
047b2264
JJ		 14844 if (strtab == NULL
14845 || section->sh_entsize != sizeof (Elf32_External_Lib))
14846 {
14847 free (elib);
2842702f 14848 free (strtab);
047b2264
JJ		 14849 break;
14850 }
59245841 14851 strtab_size = string_sec->sh_size;
047b2264
JJ		 14852
14853 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
74e1a04b 14854 printable_section_name (section),
0af1713e 14855 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 14856
2b692964 14857 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 14858
14859 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14860 ++cnt)
14861 {
14862 Elf32_Lib liblist;
91d6fa6a 14863 time_t atime;
047b2264 14864 char timebuf[20];
2cf0635d 14865 struct tm * tmp;
047b2264
JJ		 14866
14867 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14868 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 14869 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14870 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14871 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14872
91d6fa6a 14873 tmp = gmtime (&atime);
e9e44622
JJ		 14874 snprintf (timebuf, sizeof (timebuf),
14875 "%04u-%02u-%02uT%02u:%02u:%02u",
14876 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14877 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 14878
14879 printf ("%3lu: ", (unsigned long) cnt);
14880 if (do_wide)
c256ffe7 14881 printf ("%-20s", liblist.l_name < strtab_size
2b692964 14882 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 14883 else
c256ffe7 14884 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 14885 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 14886 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14887 liblist.l_version, liblist.l_flags);
14888 }
14889
14890 free (elib);
2842702f 14891 free (strtab);
047b2264
JJ		 14892 }
14893 }
14894
14895 return 1;
14896}
14897
9437c45b 14898static const char *
d3ba0551 14899get_note_type (unsigned e_type)
779fe533
NC		 14900{
14901 static char buff[64];
103f02d3 14902
1ec5cd37
NC		 14903 if (elf_header.e_type == ET_CORE)
14904 switch (e_type)
14905 {
57346661 14906 case NT_AUXV:
1ec5cd37 14907 return _("NT_AUXV (auxiliary vector)");
57346661 14908 case NT_PRSTATUS:
1ec5cd37 14909 return _("NT_PRSTATUS (prstatus structure)");
57346661 14910 case NT_FPREGSET:
1ec5cd37 14911 return _("NT_FPREGSET (floating point registers)");
57346661 14912 case NT_PRPSINFO:
1ec5cd37 14913 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 14914 case NT_TASKSTRUCT:
1ec5cd37 14915 return _("NT_TASKSTRUCT (task structure)");
57346661 14916 case NT_PRXFPREG:
1ec5cd37 14917 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 14918 case NT_PPC_VMX:
14919 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 14920 case NT_PPC_VSX:
14921 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 14922 case NT_386_TLS:
14923 return _("NT_386_TLS (x86 TLS information)");
14924 case NT_386_IOPERM:
14925 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 14926 case NT_X86_XSTATE:
14927 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 14928 case NT_S390_HIGH_GPRS:
14929 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 14930 case NT_S390_TIMER:
14931 return _("NT_S390_TIMER (s390 timer register)");
14932 case NT_S390_TODCMP:
14933 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14934 case NT_S390_TODPREG:
14935 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14936 case NT_S390_CTRS:
14937 return _("NT_S390_CTRS (s390 control registers)");
14938 case NT_S390_PREFIX:
14939 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 14940 case NT_S390_LAST_BREAK:
14941 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14942 case NT_S390_SYSTEM_CALL:
14943 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 14944 case NT_S390_TDB:
14945 return _("NT_S390_TDB (s390 transaction diagnostic block)");
4ef9f41a
AA		 14946 case NT_S390_VXRS_LOW:
14947 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
14948 case NT_S390_VXRS_HIGH:
14949 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
faa9a424
UW		 14950 case NT_ARM_VFP:
14951 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 14952 case NT_ARM_TLS:
14953 return _("NT_ARM_TLS (AArch TLS registers)");
14954 case NT_ARM_HW_BREAK:
14955 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14956 case NT_ARM_HW_WATCH:
14957 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 14958 case NT_PSTATUS:
1ec5cd37 14959 return _("NT_PSTATUS (pstatus structure)");
57346661 14960 case NT_FPREGS:
1ec5cd37 14961 return _("NT_FPREGS (floating point registers)");
57346661 14962 case NT_PSINFO:
1ec5cd37 14963 return _("NT_PSINFO (psinfo structure)");
57346661 14964 case NT_LWPSTATUS:
1ec5cd37 14965 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 14966 case NT_LWPSINFO:
1ec5cd37 14967 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 14968 case NT_WIN32PSTATUS:
1ec5cd37 14969 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 14970 case NT_SIGINFO:
14971 return _("NT_SIGINFO (siginfo_t data)");
14972 case NT_FILE:
14973 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 14974 default:
14975 break;
14976 }
14977 else
14978 switch (e_type)
14979 {
14980 case NT_VERSION:
14981 return _("NT_VERSION (version)");
14982 case NT_ARCH:
14983 return _("NT_ARCH (architecture)");
14984 default:
14985 break;
14986 }
14987
e9e44622 14988 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 14989 return buff;
779fe533
NC		 14990}
14991
9ece1fa9
TT		 14992static int
14993print_core_note (Elf_Internal_Note *pnote)
14994{
14995 unsigned int addr_size = is_32bit_elf ? 4 : 8;
14996 bfd_vma count, page_size;
14997 unsigned char *descdata, *filenames, *descend;
14998
14999 if (pnote->type != NT_FILE)
15000 return 1;
15001
15002#ifndef BFD64
15003 if (!is_32bit_elf)
15004 {
15005 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15006 /* Still "successful". */
15007 return 1;
15008 }
15009#endif
15010
15011 if (pnote->descsz < 2 * addr_size)
15012 {
15013 printf (_(" Malformed note - too short for header\n"));
15014 return 0;
15015 }
15016
15017 descdata = (unsigned char *) pnote->descdata;
15018 descend = descdata + pnote->descsz;
15019
15020 if (descdata[pnote->descsz - 1] != '\0')
15021 {
15022 printf (_(" Malformed note - does not end with \\0\n"));
15023 return 0;
15024 }
15025
15026 count = byte_get (descdata, addr_size);
15027 descdata += addr_size;
15028
15029 page_size = byte_get (descdata, addr_size);
15030 descdata += addr_size;
15031
15032 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
15033 {
15034 printf (_(" Malformed note - too short for supplied file count\n"));
15035 return 0;
15036 }
15037
15038 printf (_(" Page size: "));
15039 print_vma (page_size, DEC);
15040 printf ("\n");
15041
15042 printf (_(" %*s%*s%*s\n"),
15043 (int) (2 + 2 * addr_size), _("Start"),
15044 (int) (4 + 2 * addr_size), _("End"),
15045 (int) (4 + 2 * addr_size), _("Page Offset"));
15046 filenames = descdata + count * 3 * addr_size;
15047 while (--count > 0)
15048 {
15049 bfd_vma start, end, file_ofs;
15050
15051 if (filenames == descend)
15052 {
15053 printf (_(" Malformed note - filenames end too early\n"));
15054 return 0;
15055 }
15056
15057 start = byte_get (descdata, addr_size);
15058 descdata += addr_size;
15059 end = byte_get (descdata, addr_size);
15060 descdata += addr_size;
15061 file_ofs = byte_get (descdata, addr_size);
15062 descdata += addr_size;
15063
15064 printf (" ");
15065 print_vma (start, FULL_HEX);
15066 printf (" ");
15067 print_vma (end, FULL_HEX);
15068 printf (" ");
15069 print_vma (file_ofs, FULL_HEX);
15070 printf ("\n %s\n", filenames);
15071
15072 filenames += 1 + strlen ((char *) filenames);
15073 }
15074
15075 return 1;
15076}
15077
1118d252
RM		 15078static const char *
15079get_gnu_elf_note_type (unsigned e_type)
15080{
15081 static char buff[64];
15082
15083 switch (e_type)
15084 {
15085 case NT_GNU_ABI_TAG:
15086 return _("NT_GNU_ABI_TAG (ABI version tag)");
15087 case NT_GNU_HWCAP:
15088 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15089 case NT_GNU_BUILD_ID:
15090 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 15091 case NT_GNU_GOLD_VERSION:
15092 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 15093 default:
15094 break;
15095 }
15096
15097 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15098 return buff;
15099}
15100
664f90a3
TT		 15101static int
15102print_gnu_note (Elf_Internal_Note *pnote)
15103{
15104 switch (pnote->type)
15105 {
15106 case NT_GNU_BUILD_ID:
15107 {
15108 unsigned long i;
15109
15110 printf (_(" Build ID: "));
15111 for (i = 0; i < pnote->descsz; ++i)
15112 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 15113 printf ("\n");
664f90a3
TT		 15114 }
15115 break;
15116
15117 case NT_GNU_ABI_TAG:
15118 {
15119 unsigned long os, major, minor, subminor;
15120 const char *osname;
15121
3102e897
NC		 15122 /* PR 17531: file: 030-599401-0.004. */
15123 if (pnote->descsz < 16)
15124 {
15125 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15126 break;
15127 }
15128
664f90a3
TT		 15129 os = byte_get ((unsigned char *) pnote->descdata, 4);
15130 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15131 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
15132 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
15133
15134 switch (os)
15135 {
15136 case GNU_ABI_TAG_LINUX:
15137 osname = "Linux";
15138 break;
15139 case GNU_ABI_TAG_HURD:
15140 osname = "Hurd";
15141 break;
15142 case GNU_ABI_TAG_SOLARIS:
15143 osname = "Solaris";
15144 break;
15145 case GNU_ABI_TAG_FREEBSD:
15146 osname = "FreeBSD";
15147 break;
15148 case GNU_ABI_TAG_NETBSD:
15149 osname = "NetBSD";
15150 break;
14ae95f2
RM		 15151 case GNU_ABI_TAG_SYLLABLE:
15152 osname = "Syllable";
15153 break;
15154 case GNU_ABI_TAG_NACL:
15155 osname = "NaCl";
15156 break;
664f90a3
TT		 15157 default:
15158 osname = "Unknown";
15159 break;
15160 }
15161
15162 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
15163 major, minor, subminor);
15164 }
15165 break;
926c5385
CC		 15166
15167 case NT_GNU_GOLD_VERSION:
15168 {
15169 unsigned long i;
15170
15171 printf (_(" Version: "));
15172 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
15173 printf ("%c", pnote->descdata[i]);
15174 printf ("\n");
15175 }
15176 break;
664f90a3
TT		 15177 }
15178
15179 return 1;
15180}
15181
685080f2
NC		 15182static const char *
15183get_v850_elf_note_type (enum v850_notes n_type)
15184{
15185 static char buff[64];
15186
15187 switch (n_type)
15188 {
15189 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
15190 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
15191 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
15192 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
15193 case V850_NOTE_CACHE_INFO: return _("Use of cache");
15194 case V850_NOTE_MMU_INFO: return _("Use of MMU");
15195 default:
15196 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
15197 return buff;
15198 }
15199}
15200
15201static int
15202print_v850_note (Elf_Internal_Note * pnote)
15203{
15204 unsigned int val;
15205
15206 if (pnote->descsz != 4)
15207 return 0;
15208 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
15209
15210 if (val == 0)
15211 {
15212 printf (_("not set\n"));
15213 return 1;
15214 }
15215
15216 switch (pnote->type)
15217 {
15218 case V850_NOTE_ALIGNMENT:
15219 switch (val)
15220 {
15221 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
15222 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
15223 }
15224 break;
14ae95f2 15225
685080f2
NC		 15226 case V850_NOTE_DATA_SIZE:
15227 switch (val)
15228 {
15229 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
15230 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
15231 }
15232 break;
14ae95f2 15233
685080f2
NC		 15234 case V850_NOTE_FPU_INFO:
15235 switch (val)
15236 {
15237 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
15238 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
15239 }
15240 break;
14ae95f2 15241
685080f2
NC		 15242 case V850_NOTE_MMU_INFO:
15243 case V850_NOTE_CACHE_INFO:
15244 case V850_NOTE_SIMD_INFO:
15245 if (val == EF_RH850_SIMD)
15246 {
15247 printf (_("yes\n"));
15248 return 1;
15249 }
15250 break;
15251
15252 default:
15253 /* An 'unknown note type' message will already have been displayed. */
15254 break;
15255 }
15256
15257 printf (_("unknown value: %x\n"), val);
15258 return 0;
15259}
15260
9437c45b 15261static const char *
d3ba0551 15262get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 15263{
15264 static char buff[64];
15265
b4db1224 15266 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 15267 {
15268 /* NetBSD core "procinfo" structure. */
15269 return _("NetBSD procinfo structure");
15270 }
15271
15272 /* As of Jan 2002 there are no other machine-independent notes
15273 defined for NetBSD core files. If the note type is less
15274 than the start of the machine-dependent note types, we don't
15275 understand it. */
15276
b4db1224 15277 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 15278 {
e9e44622 15279 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 15280 return buff;
15281 }
15282
15283 switch (elf_header.e_machine)
15284 {
15285 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15286 and PT_GETFPREGS == mach+2. */
15287
15288 case EM_OLD_ALPHA:
15289 case EM_ALPHA:
15290 case EM_SPARC:
15291 case EM_SPARC32PLUS:
15292 case EM_SPARCV9:
15293 switch (e_type)
15294 {
2b692964 15295 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 15296 return _("PT_GETREGS (reg structure)");
2b692964 15297 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 15298 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15299 default:
15300 break;
15301 }
15302 break;
15303
15304 /* On all other arch's, PT_GETREGS == mach+1 and
15305 PT_GETFPREGS == mach+3. */
15306 default:
15307 switch (e_type)
15308 {
2b692964 15309 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 15310 return _("PT_GETREGS (reg structure)");
2b692964 15311 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 15312 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15313 default:
15314 break;
15315 }
15316 }
15317
9cf03b7e 15318 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 15319 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 15320 return buff;
15321}
15322
70616151
TT		 15323static const char *
15324get_stapsdt_note_type (unsigned e_type)
15325{
15326 static char buff[64];
15327
15328 switch (e_type)
15329 {
15330 case NT_STAPSDT:
15331 return _("NT_STAPSDT (SystemTap probe descriptors)");
15332
15333 default:
15334 break;
15335 }
15336
15337 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15338 return buff;
15339}
15340
c6a9fc58
TT		 15341static int
15342print_stapsdt_note (Elf_Internal_Note *pnote)
15343{
15344 int addr_size = is_32bit_elf ? 4 : 8;
15345 char *data = pnote->descdata;
15346 char *data_end = pnote->descdata + pnote->descsz;
15347 bfd_vma pc, base_addr, semaphore;
15348 char *provider, *probe, *arg_fmt;
15349
15350 pc = byte_get ((unsigned char *) data, addr_size);
15351 data += addr_size;
15352 base_addr = byte_get ((unsigned char *) data, addr_size);
15353 data += addr_size;
15354 semaphore = byte_get ((unsigned char *) data, addr_size);
15355 data += addr_size;
15356
15357 provider = data;
15358 data += strlen (data) + 1;
15359 probe = data;
15360 data += strlen (data) + 1;
15361 arg_fmt = data;
15362 data += strlen (data) + 1;
15363
15364 printf (_(" Provider: %s\n"), provider);
15365 printf (_(" Name: %s\n"), probe);
15366 printf (_(" Location: "));
15367 print_vma (pc, FULL_HEX);
15368 printf (_(", Base: "));
15369 print_vma (base_addr, FULL_HEX);
15370 printf (_(", Semaphore: "));
15371 print_vma (semaphore, FULL_HEX);
9cf03b7e 15372 printf ("\n");
c6a9fc58
TT		 15373 printf (_(" Arguments: %s\n"), arg_fmt);
15374
15375 return data == data_end;
15376}
15377
00e98fc7
TG		 15378static const char *
15379get_ia64_vms_note_type (unsigned e_type)
15380{
15381 static char buff[64];
15382
15383 switch (e_type)
15384 {
15385 case NT_VMS_MHD:
15386 return _("NT_VMS_MHD (module header)");
15387 case NT_VMS_LNM:
15388 return _("NT_VMS_LNM (language name)");
15389 case NT_VMS_SRC:
15390 return _("NT_VMS_SRC (source files)");
15391 case NT_VMS_TITLE:
9cf03b7e 15392 return "NT_VMS_TITLE";
00e98fc7
TG		 15393 case NT_VMS_EIDC:
15394 return _("NT_VMS_EIDC (consistency check)");
15395 case NT_VMS_FPMODE:
15396 return _("NT_VMS_FPMODE (FP mode)");
15397 case NT_VMS_LINKTIME:
9cf03b7e 15398 return "NT_VMS_LINKTIME";
00e98fc7
TG		 15399 case NT_VMS_IMGNAM:
15400 return _("NT_VMS_IMGNAM (image name)");
15401 case NT_VMS_IMGID:
15402 return _("NT_VMS_IMGID (image id)");
15403 case NT_VMS_LINKID:
15404 return _("NT_VMS_LINKID (link id)");
15405 case NT_VMS_IMGBID:
15406 return _("NT_VMS_IMGBID (build id)");
15407 case NT_VMS_GSTNAM:
15408 return _("NT_VMS_GSTNAM (sym table name)");
15409 case NT_VMS_ORIG_DYN:
9cf03b7e 15410 return "NT_VMS_ORIG_DYN";
00e98fc7 15411 case NT_VMS_PATCHTIME:
9cf03b7e 15412 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 15413 default:
15414 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15415 return buff;
15416 }
15417}
15418
15419static int
15420print_ia64_vms_note (Elf_Internal_Note * pnote)
15421{
15422 switch (pnote->type)
15423 {
15424 case NT_VMS_MHD:
15425 if (pnote->descsz > 36)
15426 {
15427 size_t l = strlen (pnote->descdata + 34);
15428 printf (_(" Creation date : %.17s\n"), pnote->descdata);
15429 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
15430 printf (_(" Module name : %s\n"), pnote->descdata + 34);
15431 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
15432 }
15433 else
15434 printf (_(" Invalid size\n"));
15435 break;
15436 case NT_VMS_LNM:
15437 printf (_(" Language: %s\n"), pnote->descdata);
15438 break;
15439#ifdef BFD64
15440 case NT_VMS_FPMODE:
9cf03b7e 15441 printf (_(" Floating Point mode: "));
4a5cb34f 15442 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15443 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
00e98fc7
TG		 15444 break;
15445 case NT_VMS_LINKTIME:
15446 printf (_(" Link time: "));
15447 print_vms_time
15448 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15449 printf ("\n");
15450 break;
15451 case NT_VMS_PATCHTIME:
15452 printf (_(" Patch time: "));
15453 print_vms_time
15454 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15455 printf ("\n");
15456 break;
15457 case NT_VMS_ORIG_DYN:
15458 printf (_(" Major id: %u, minor id: %u\n"),
15459 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15460 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 15461 printf (_(" Last modified : "));
00e98fc7
TG		 15462 print_vms_time
15463 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 15464 printf (_("\n Link flags : "));
4a5cb34f 15465 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15466 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
00e98fc7 15467 printf (_(" Header flags: 0x%08x\n"),
948f632f 15468 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
00e98fc7
TG		 15469 printf (_(" Image id : %s\n"), pnote->descdata + 32);
15470 break;
15471#endif
15472 case NT_VMS_IMGNAM:
15473 printf (_(" Image name: %s\n"), pnote->descdata);
15474 break;
15475 case NT_VMS_GSTNAM:
15476 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
15477 break;
15478 case NT_VMS_IMGID:
15479 printf (_(" Image id: %s\n"), pnote->descdata);
15480 break;
15481 case NT_VMS_LINKID:
15482 printf (_(" Linker id: %s\n"), pnote->descdata);
15483 break;
15484 default:
15485 break;
15486 }
15487 return 1;
15488}
15489
6d118b09
NC		 15490/* Note that by the ELF standard, the name field is already null byte
15491 terminated, and namesz includes the terminating null byte.
15492 I.E. the value of namesz for the name "FSF" is 4.
15493
e3c8793a 15494 If the value of namesz is zero, there is no name present. */
779fe533 15495static int
2cf0635d 15496process_note (Elf_Internal_Note * pnote)
779fe533 15497{
2cf0635d
NC		 15498 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15499 const char * nt;
9437c45b
JT		 15500
15501 if (pnote->namesz == 0)
1ec5cd37
NC		 15502 /* If there is no note name, then use the default set of
15503 note type strings. */
15504 nt = get_note_type (pnote->type);
15505
1118d252
RM		 15506 else if (const_strneq (pnote->namedata, "GNU"))
15507 /* GNU-specific object file notes. */
15508 nt = get_gnu_elf_note_type (pnote->type);
15509
0112cd26 15510 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 15511 /* NetBSD-specific core file notes. */
15512 nt = get_netbsd_elfcore_note_type (pnote->type);
15513
b15fa79e
AM		 15514 else if (strneq (pnote->namedata, "SPU/", 4))
15515 {
15516 /* SPU-specific core file notes. */
15517 nt = pnote->namedata + 4;
15518 name = "SPU";
15519 }
15520
00e98fc7
TG		 15521 else if (const_strneq (pnote->namedata, "IPF/VMS"))
15522 /* VMS/ia64-specific file notes. */
15523 nt = get_ia64_vms_note_type (pnote->type);
15524
70616151
TT		 15525 else if (const_strneq (pnote->namedata, "stapsdt"))
15526 nt = get_stapsdt_note_type (pnote->type);
15527
9437c45b 15528 else
1ec5cd37
NC		 15529 /* Don't recognize this note name; just use the default set of
15530 note type strings. */
00e98fc7 15531 nt = get_note_type (pnote->type);
9437c45b 15532
2aee03ae 15533 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 15534
15535 if (const_strneq (pnote->namedata, "IPF/VMS"))
15536 return print_ia64_vms_note (pnote);
664f90a3
TT		 15537 else if (const_strneq (pnote->namedata, "GNU"))
15538 return print_gnu_note (pnote);
c6a9fc58
TT		 15539 else if (const_strneq (pnote->namedata, "stapsdt"))
15540 return print_stapsdt_note (pnote);
9ece1fa9
TT		 15541 else if (const_strneq (pnote->namedata, "CORE"))
15542 return print_core_note (pnote);
00e98fc7
TG		 15543 else
15544 return 1;
779fe533
NC		 15545}
15546
6d118b09 15547
779fe533 15548static int
2cf0635d 15549process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 15550{
2cf0635d
NC		 15551 Elf_External_Note * pnotes;
15552 Elf_External_Note * external;
c8071705 15553 char * end;
b34976b6 15554 int res = 1;
103f02d3 15555
779fe533
NC		 15556 if (length <= 0)
15557 return 0;
103f02d3 15558
3f5e193b 15559 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 15560 _("notes"));
dd24e3da 15561 if (pnotes == NULL)
a6e9f9df 15562 return 0;
779fe533 15563
103f02d3 15564 external = pnotes;
103f02d3 15565
9dd3a467 15566 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 15567 (unsigned long) offset, (unsigned long) length);
2aee03ae 15568 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 15569
c8071705
NC		 15570 end = (char *) pnotes + length;
15571 while ((char *) external < end)
779fe533 15572 {
b34976b6 15573 Elf_Internal_Note inote;
15b42fb0
AM		 15574 size_t min_notesz;
15575 char *next;
2cf0635d 15576 char * temp = NULL;
c8071705 15577 size_t data_remaining = end - (char *) external;
6d118b09 15578
00e98fc7 15579 if (!is_ia64_vms ())
15b42fb0 15580 {
9dd3a467
NC		 15581 /* PR binutils/15191
15582 Make sure that there is enough data to read. */
15b42fb0
AM		 15583 min_notesz = offsetof (Elf_External_Note, name);
15584 if (data_remaining < min_notesz)
9dd3a467
NC		 15585 {
15586 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15587 (int) data_remaining);
15588 break;
15589 }
15b42fb0
AM		 15590 inote.type = BYTE_GET (external->type);
15591 inote.namesz = BYTE_GET (external->namesz);
15592 inote.namedata = external->name;
15593 inote.descsz = BYTE_GET (external->descsz);
15594 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
834f871c 15595 /* PR 17531: file: 3443835e. */
c8071705 15596 if (inote.descdata < (char *) pnotes || inote.descdata > end)
834f871c
NC		 15597 {
15598 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15599 inote.descdata = inote.namedata;
15600 inote.namesz = 0;
15601 }
14ae95f2 15602
15b42fb0
AM		 15603 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15604 next = inote.descdata + align_power (inote.descsz, 2);
15605 }
00e98fc7 15606 else
15b42fb0
AM		 15607 {
15608 Elf64_External_VMS_Note *vms_external;
00e98fc7 15609
9dd3a467
NC		 15610 /* PR binutils/15191
15611 Make sure that there is enough data to read. */
15b42fb0
AM		 15612 min_notesz = offsetof (Elf64_External_VMS_Note, name);
15613 if (data_remaining < min_notesz)
9dd3a467
NC		 15614 {
15615 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15616 (int) data_remaining);
15617 break;
15618 }
3e55a963 15619
15b42fb0
AM		 15620 vms_external = (Elf64_External_VMS_Note *) external;
15621 inote.type = BYTE_GET (vms_external->type);
15622 inote.namesz = BYTE_GET (vms_external->namesz);
15623 inote.namedata = vms_external->name;
15624 inote.descsz = BYTE_GET (vms_external->descsz);
15625 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15626 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15627 next = inote.descdata + align_power (inote.descsz, 3);
15628 }
15629
15630 if (inote.descdata < (char *) external + min_notesz
15631 || next < (char *) external + min_notesz
5d921cbd
NC		 15632 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15633 || inote.namedata + inote.namesz < inote.namedata
15634 || inote.descdata + inote.descsz < inote.descdata
15b42fb0 15635 || data_remaining < (size_t)(next - (char *) external))
3e55a963 15636 {
15b42fb0 15637 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 15638 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 15639 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 15640 inote.type, inote.namesz, inote.descsz);
15641 break;
15642 }
15643
15b42fb0 15644 external = (Elf_External_Note *) next;
dd24e3da 15645
6d118b09
NC		 15646 /* Verify that name is null terminated. It appears that at least
15647 one version of Linux (RedHat 6.0) generates corefiles that don't
15648 comply with the ELF spec by failing to include the null byte in
15649 namesz. */
8b971f9f 15650 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 15651 {
3f5e193b 15652 temp = (char *) malloc (inote.namesz + 1);
6d118b09
NC		 15653 if (temp == NULL)
15654 {
8b73c356 15655 error (_("Out of memory allocating space for inote name\n"));
6d118b09
NC		 15656 res = 0;
15657 break;
15658 }
76da6bbe 15659
6d118b09
NC		 15660 strncpy (temp, inote.namedata, inote.namesz);
15661 temp[inote.namesz] = 0;
76da6bbe 15662
6d118b09
NC		 15663 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15664 inote.namedata = temp;
15665 }
15666
15667 res &= process_note (& inote);
103f02d3 15668
6d118b09
NC		 15669 if (temp != NULL)
15670 {
15671 free (temp);
15672 temp = NULL;
15673 }
779fe533
NC		 15674 }
15675
15676 free (pnotes);
103f02d3 15677
779fe533
NC		 15678 return res;
15679}
15680
15681static int
2cf0635d 15682process_corefile_note_segments (FILE * file)
779fe533 15683{
2cf0635d 15684 Elf_Internal_Phdr * segment;
b34976b6
AM		 15685 unsigned int i;
15686 int res = 1;
103f02d3 15687
d93f0186 15688 if (! get_program_headers (file))
779fe533 15689 return 0;
103f02d3 15690
779fe533
NC		 15691 for (i = 0, segment = program_headers;
15692 i < elf_header.e_phnum;
b34976b6 15693 i++, segment++)
779fe533
NC		 15694 {
15695 if (segment->p_type == PT_NOTE)
103f02d3 15696 res &= process_corefile_note_segment (file,
30800947
NC		 15697 (bfd_vma) segment->p_offset,
15698 (bfd_vma) segment->p_filesz);
779fe533 15699 }
103f02d3 15700
779fe533
NC		 15701 return res;
15702}
15703
685080f2
NC		 15704static int
15705process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
15706{
15707 Elf_External_Note * pnotes;
15708 Elf_External_Note * external;
c8071705 15709 char * end;
685080f2
NC		 15710 int res = 1;
15711
15712 if (length <= 0)
15713 return 0;
15714
15715 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15716 _("v850 notes"));
15717 if (pnotes == NULL)
15718 return 0;
15719
15720 external = pnotes;
c8071705 15721 end = (char*) pnotes + length;
685080f2
NC		 15722
15723 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15724 (unsigned long) offset, (unsigned long) length);
15725
c8071705 15726 while ((char *) external + sizeof (Elf_External_Note) < end)
685080f2
NC		 15727 {
15728 Elf_External_Note * next;
15729 Elf_Internal_Note inote;
15730
15731 inote.type = BYTE_GET (external->type);
15732 inote.namesz = BYTE_GET (external->namesz);
15733 inote.namedata = external->name;
15734 inote.descsz = BYTE_GET (external->descsz);
15735 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15736 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15737
c8071705
NC		 15738 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
15739 {
15740 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15741 inote.descdata = inote.namedata;
15742 inote.namesz = 0;
15743 }
15744
685080f2
NC		 15745 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
15746
c8071705 15747 if ( ((char *) next > end)
685080f2
NC		 15748 || ((char *) next < (char *) pnotes))
15749 {
15750 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15751 (unsigned long) ((char *) external - (char *) pnotes));
15752 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15753 inote.type, inote.namesz, inote.descsz);
15754 break;
15755 }
15756
15757 external = next;
15758
15759 /* Prevent out-of-bounds indexing. */
c8071705 15760 if ( inote.namedata + inote.namesz > end
685080f2
NC		 15761 || inote.namedata + inote.namesz < inote.namedata)
15762 {
15763 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15764 (unsigned long) ((char *) external - (char *) pnotes));
15765 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15766 inote.type, inote.namesz, inote.descsz);
15767 break;
15768 }
15769
15770 printf (" %s: ", get_v850_elf_note_type (inote.type));
15771
15772 if (! print_v850_note (& inote))
15773 {
15774 res = 0;
15775 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15776 inote.namesz, inote.descsz);
15777 }
15778 }
15779
15780 free (pnotes);
15781
15782 return res;
15783}
15784
779fe533 15785static int
2cf0635d 15786process_note_sections (FILE * file)
1ec5cd37 15787{
2cf0635d 15788 Elf_Internal_Shdr * section;
1ec5cd37 15789 unsigned long i;
df565f32 15790 int n = 0;
1ec5cd37
NC		 15791 int res = 1;
15792
15793 for (i = 0, section = section_headers;
fa1908fd 15794 i < elf_header.e_shnum && section != NULL;
1ec5cd37 15795 i++, section++)
685080f2
NC		 15796 {
15797 if (section->sh_type == SHT_NOTE)
15798 {
15799 res &= process_corefile_note_segment (file,
15800 (bfd_vma) section->sh_offset,
15801 (bfd_vma) section->sh_size);
15802 n++;
15803 }
15804
15805 if (( elf_header.e_machine == EM_V800
15806 || elf_header.e_machine == EM_V850
15807 || elf_header.e_machine == EM_CYGNUS_V850)
15808 && section->sh_type == SHT_RENESAS_INFO)
15809 {
15810 res &= process_v850_notes (file,
15811 (bfd_vma) section->sh_offset,
15812 (bfd_vma) section->sh_size);
15813 n++;
15814 }
15815 }
df565f32
NC		 15816
15817 if (n == 0)
15818 /* Try processing NOTE segments instead. */
15819 return process_corefile_note_segments (file);
1ec5cd37
NC		 15820
15821 return res;
15822}
15823
15824static int
2cf0635d 15825process_notes (FILE * file)
779fe533
NC		 15826{
15827 /* If we have not been asked to display the notes then do nothing. */
15828 if (! do_notes)
15829 return 1;
103f02d3 15830
779fe533 15831 if (elf_header.e_type != ET_CORE)
1ec5cd37 15832 return process_note_sections (file);
103f02d3 15833
779fe533 15834 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 15835 if (elf_header.e_phnum > 0)
15836 return process_corefile_note_segments (file);
779fe533 15837
1ec5cd37
NC		 15838 printf (_("No note segments present in the core file.\n"));
15839 return 1;
779fe533
NC		 15840}
15841
252b5132 15842static int
2cf0635d 15843process_arch_specific (FILE * file)
252b5132 15844{
a952a375
NC		 15845 if (! do_arch)
15846 return 1;
15847
252b5132
RH		 15848 switch (elf_header.e_machine)
15849 {
11c1ff18
PB		 15850 case EM_ARM:
15851 return process_arm_specific (file);
252b5132 15852 case EM_MIPS:
4fe85591 15853 case EM_MIPS_RS3_LE:
252b5132
RH		 15854 return process_mips_specific (file);
15855 break;
35c08157
KLC		 15856 case EM_NDS32:
15857 return process_nds32_specific (file);
15858 break;
34c8bcba
JM		 15859 case EM_PPC:
15860 return process_power_specific (file);
15861 break;
643f7afb
AK		 15862 case EM_S390:
15863 case EM_S390_OLD:
15864 return process_s390_specific (file);
15865 break;
9e8c70f9
DM		 15866 case EM_SPARC:
15867 case EM_SPARC32PLUS:
15868 case EM_SPARCV9:
15869 return process_sparc_specific (file);
15870 break;
59e6276b
JM		 15871 case EM_TI_C6000:
15872 return process_tic6x_specific (file);
15873 break;
13761a11
NC		 15874 case EM_MSP430:
15875 return process_msp430x_specific (file);
252b5132
RH		 15876 default:
15877 break;
15878 }
15879 return 1;
15880}
15881
15882static int
2cf0635d 15883get_file_header (FILE * file)
252b5132 15884{
9ea033b2
NC		 15885 /* Read in the identity array. */
15886 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 15887 return 0;
15888
9ea033b2 15889 /* Determine how to read the rest of the header. */
b34976b6 15890 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 15891 {
15892 default: /* fall through */
15893 case ELFDATANONE: /* fall through */
adab8cdc
AO		 15894 case ELFDATA2LSB:
15895 byte_get = byte_get_little_endian;
15896 byte_put = byte_put_little_endian;
15897 break;
15898 case ELFDATA2MSB:
15899 byte_get = byte_get_big_endian;
15900 byte_put = byte_put_big_endian;
15901 break;
9ea033b2
NC		 15902 }
15903
15904 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 15905 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 15906
15907 /* Read in the rest of the header. */
15908 if (is_32bit_elf)
15909 {
15910 Elf32_External_Ehdr ehdr32;
252b5132 15911
9ea033b2
NC		 15912 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
15913 return 0;
103f02d3 15914
9ea033b2
NC		 15915 elf_header.e_type = BYTE_GET (ehdr32.e_type);
15916 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
15917 elf_header.e_version = BYTE_GET (ehdr32.e_version);
15918 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
15919 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
15920 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
15921 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
15922 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
15923 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
15924 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
15925 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
15926 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
15927 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
15928 }
252b5132 15929 else
9ea033b2
NC		 15930 {
15931 Elf64_External_Ehdr ehdr64;
a952a375
NC		 15932
15933 /* If we have been compiled with sizeof (bfd_vma) == 4, then
15934 we will not be able to cope with the 64bit data found in
15935 64 ELF files. Detect this now and abort before we start
50c2245b 15936 overwriting things. */
a952a375
NC		 15937 if (sizeof (bfd_vma) < 8)
15938 {
e3c8793a
NC		 15939 error (_("This instance of readelf has been built without support for a\n\
1594064 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 15941 return 0;
15942 }
103f02d3 15943
9ea033b2
NC		 15944 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
15945 return 0;
103f02d3 15946
9ea033b2
NC		 15947 elf_header.e_type = BYTE_GET (ehdr64.e_type);
15948 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
15949 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 15950 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
15951 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
15952 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 15953 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
15954 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
15955 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
15956 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
15957 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
15958 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
15959 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
15960 }
252b5132 15961
7ece0d85
JJ		 15962 if (elf_header.e_shoff)
15963 {
15964 /* There may be some extensions in the first section header. Don't
15965 bomb if we can't read it. */
15966 if (is_32bit_elf)
049b0c3a 15967 get_32bit_section_headers (file, TRUE);
7ece0d85 15968 else
049b0c3a 15969 get_64bit_section_headers (file, TRUE);
7ece0d85 15970 }
560f3c1c 15971
252b5132
RH		 15972 return 1;
15973}
15974
fb52b2f4
NC		 15975/* Process one ELF object file according to the command line options.
15976 This file may actually be stored in an archive. The file is
15977 positioned at the start of the ELF object. */
15978
ff78d6d6 15979static int
2cf0635d 15980process_object (char * file_name, FILE * file)
252b5132 15981{
252b5132
RH		 15982 unsigned int i;
15983
252b5132
RH		 15984 if (! get_file_header (file))
15985 {
15986 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 15987 return 1;
252b5132
RH		 15988 }
15989
15990 /* Initialise per file variables. */
60bca95a 15991 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 15992 version_info[i] = 0;
15993
60bca95a 15994 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 15995 dynamic_info[i] = 0;
5115b233 15996 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 15997
15998 /* Process the file. */
15999 if (show_name)
16000 printf (_("\nFile: %s\n"), file_name);
16001
18bd398b
NC		 16002 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16003 Note we do this even if cmdline_dump_sects is empty because we
16004 must make sure that the dump_sets array is zeroed out before each
16005 object file is processed. */
16006 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 16007 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 16008
16009 if (num_cmdline_dump_sects > 0)
16010 {
16011 if (num_dump_sects == 0)
16012 /* A sneaky way of allocating the dump_sects array. */
09c11c86 16013 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 16014
16015 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 16016 memcpy (dump_sects, cmdline_dump_sects,
16017 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 16018 }
d70c5fc7 16019
252b5132 16020 if (! process_file_header ())
fb52b2f4 16021 return 1;
252b5132 16022
d1f5c6e3 16023 if (! process_section_headers (file))
2f62977e 16024 {
d1f5c6e3
L		 16025 /* Without loaded section headers we cannot process lots of
16026 things. */
2f62977e 16027 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 16028
2f62977e 16029 if (! do_using_dynamic)
2c610e4b 16030 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 16031 }
252b5132 16032
d1f5c6e3
L		 16033 if (! process_section_groups (file))
16034 {
16035 /* Without loaded section groups we cannot process unwind. */
16036 do_unwind = 0;
16037 }
16038
2f62977e 16039 if (process_program_headers (file))
b2d38a17 16040 process_dynamic_section (file);
252b5132
RH		 16041
16042 process_relocs (file);
16043
4d6ed7c8
NC		 16044 process_unwind (file);
16045
252b5132
RH		 16046 process_symbol_table (file);
16047
16048 process_syminfo (file);
16049
16050 process_version_sections (file);
16051
16052 process_section_contents (file);
f5842774 16053
1ec5cd37 16054 process_notes (file);
103f02d3 16055
047b2264
JJ		 16056 process_gnu_liblist (file);
16057
252b5132
RH		 16058 process_arch_specific (file);
16059
d93f0186
NC		 16060 if (program_headers)
16061 {
16062 free (program_headers);
16063 program_headers = NULL;
16064 }
16065
252b5132
RH		 16066 if (section_headers)
16067 {
16068 free (section_headers);
16069 section_headers = NULL;
16070 }
16071
16072 if (string_table)
16073 {
16074 free (string_table);
16075 string_table = NULL;
d40ac9bd 16076 string_table_length = 0;
252b5132
RH		 16077 }
16078
16079 if (dynamic_strings)
16080 {
16081 free (dynamic_strings);
16082 dynamic_strings = NULL;
d79b3d50 16083 dynamic_strings_length = 0;
252b5132
RH		 16084 }
16085
16086 if (dynamic_symbols)
16087 {
16088 free (dynamic_symbols);
16089 dynamic_symbols = NULL;
19936277 16090 num_dynamic_syms = 0;
252b5132
RH		 16091 }
16092
16093 if (dynamic_syminfo)
16094 {
16095 free (dynamic_syminfo);
16096 dynamic_syminfo = NULL;
16097 }
ff78d6d6 16098
293c573e
MR		 16099 if (dynamic_section)
16100 {
16101 free (dynamic_section);
16102 dynamic_section = NULL;
16103 }
16104
e4b17d5c
L		 16105 if (section_headers_groups)
16106 {
16107 free (section_headers_groups);
16108 section_headers_groups = NULL;
16109 }
16110
16111 if (section_groups)
16112 {
2cf0635d
NC		 16113 struct group_list * g;
16114 struct group_list * next;
e4b17d5c
L		 16115
16116 for (i = 0; i < group_count; i++)
16117 {
16118 for (g = section_groups [i].root; g != NULL; g = next)
16119 {
16120 next = g->next;
16121 free (g);
16122 }
16123 }
16124
16125 free (section_groups);
16126 section_groups = NULL;
16127 }
16128
19e6b90e 16129 free_debug_memory ();
18bd398b 16130
ff78d6d6 16131 return 0;
252b5132
RH		 16132}
16133
2cf0635d
NC		 16134/* Process an ELF archive.
16135 On entry the file is positioned just after the ARMAG string. */
16136
16137static int
16138process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
16139{
16140 struct archive_info arch;
16141 struct archive_info nested_arch;
16142 size_t got;
2cf0635d
NC		 16143 int ret;
16144
16145 show_name = 1;
16146
16147 /* The ARCH structure is used to hold information about this archive. */
16148 arch.file_name = NULL;
16149 arch.file = NULL;
16150 arch.index_array = NULL;
16151 arch.sym_table = NULL;
16152 arch.longnames = NULL;
16153
16154 /* The NESTED_ARCH structure is used as a single-item cache of information
16155 about a nested archive (when members of a thin archive reside within
16156 another regular archive file). */
16157 nested_arch.file_name = NULL;
16158 nested_arch.file = NULL;
16159 nested_arch.index_array = NULL;
16160 nested_arch.sym_table = NULL;
16161 nested_arch.longnames = NULL;
16162
16163 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
16164 {
16165 ret = 1;
16166 goto out;
4145f1d5 16167 }
fb52b2f4 16168
4145f1d5
NC		 16169 if (do_archive_index)
16170 {
2cf0635d 16171 if (arch.sym_table == NULL)
4145f1d5
NC		 16172 error (_("%s: unable to dump the index as none was found\n"), file_name);
16173 else
16174 {
591f7597 16175 unsigned long i, l;
4145f1d5
NC		 16176 unsigned long current_pos;
16177
591f7597
NC		 16178 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16179 file_name, (unsigned long) arch.index_num, arch.sym_size);
4145f1d5
NC		 16180 current_pos = ftell (file);
16181
2cf0635d 16182 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 16183 {
2cf0635d
NC		 16184 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
16185 {
16186 char * member_name;
4145f1d5 16187
2cf0635d
NC		 16188 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
16189
16190 if (member_name != NULL)
16191 {
16192 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
16193
16194 if (qualified_name != NULL)
16195 {
c2a7d3f5
NC		 16196 printf (_("Contents of binary %s at offset "), qualified_name);
16197 (void) print_vma (arch.index_array[i], PREFIX_HEX);
16198 putchar ('\n');
2cf0635d
NC		 16199 free (qualified_name);
16200 }
4145f1d5
NC		 16201 }
16202 }
2cf0635d
NC		 16203
16204 if (l >= arch.sym_size)
4145f1d5
NC		 16205 {
16206 error (_("%s: end of the symbol table reached before the end of the index\n"),
16207 file_name);
cb8f3167 16208 break;
4145f1d5 16209 }
591f7597
NC		 16210 /* PR 17531: file: 0b6630b2. */
16211 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
16212 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
4145f1d5
NC		 16213 }
16214
c2a7d3f5
NC		 16215 if (arch.uses_64bit_indicies)
16216 l = (l + 7) & ~ 7;
16217 else
16218 l += l & 1;
16219
2cf0635d 16220 if (l < arch.sym_size)
c2a7d3f5
NC		 16221 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16222 file_name, arch.sym_size - l);
4145f1d5 16223
4145f1d5
NC		 16224 if (fseek (file, current_pos, SEEK_SET) != 0)
16225 {
16226 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 16227 ret = 1;
16228 goto out;
4145f1d5 16229 }
fb52b2f4 16230 }
4145f1d5
NC		 16231
16232 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
16233 && !do_segments && !do_header && !do_dump && !do_version
16234 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 16235 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 16236 {
16237 ret = 0; /* Archive index only. */
16238 goto out;
16239 }
fb52b2f4
NC		 16240 }
16241
d989285c 16242 ret = 0;
fb52b2f4
NC		 16243
16244 while (1)
16245 {
2cf0635d
NC		 16246 char * name;
16247 size_t namelen;
16248 char * qualified_name;
16249
16250 /* Read the next archive header. */
16251 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
16252 {
16253 error (_("%s: failed to seek to next archive header\n"), file_name);
16254 return 1;
16255 }
16256 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
16257 if (got != sizeof arch.arhdr)
16258 {
16259 if (got == 0)
16260 break;
16261 error (_("%s: failed to read archive header\n"), file_name);
16262 ret = 1;
16263 break;
16264 }
16265 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
16266 {
16267 error (_("%s: did not find a valid archive header\n"), arch.file_name);
16268 ret = 1;
16269 break;
16270 }
16271
16272 arch.next_arhdr_offset += sizeof arch.arhdr;
16273
16274 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
16275 if (archive_file_size & 01)
16276 ++archive_file_size;
16277
16278 name = get_archive_member_name (&arch, &nested_arch);
16279 if (name == NULL)
fb52b2f4 16280 {
0fd3a477 16281 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16282 ret = 1;
16283 break;
fb52b2f4 16284 }
2cf0635d 16285 namelen = strlen (name);
fb52b2f4 16286
2cf0635d
NC		 16287 qualified_name = make_qualified_name (&arch, &nested_arch, name);
16288 if (qualified_name == NULL)
fb52b2f4 16289 {
2cf0635d 16290 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16291 ret = 1;
16292 break;
fb52b2f4
NC		 16293 }
16294
2cf0635d
NC		 16295 if (is_thin_archive && arch.nested_member_origin == 0)
16296 {
16297 /* This is a proxy for an external member of a thin archive. */
16298 FILE * member_file;
16299 char * member_file_name = adjust_relative_path (file_name, name, namelen);
16300 if (member_file_name == NULL)
16301 {
16302 ret = 1;
16303 break;
16304 }
16305
16306 member_file = fopen (member_file_name, "rb");
16307 if (member_file == NULL)
16308 {
16309 error (_("Input file '%s' is not readable.\n"), member_file_name);
16310 free (member_file_name);
16311 ret = 1;
16312 break;
16313 }
16314
16315 archive_file_offset = arch.nested_member_origin;
16316
16317 ret |= process_object (qualified_name, member_file);
16318
16319 fclose (member_file);
16320 free (member_file_name);
16321 }
16322 else if (is_thin_archive)
16323 {
a043396b
NC		 16324 /* PR 15140: Allow for corrupt thin archives. */
16325 if (nested_arch.file == NULL)
16326 {
16327 error (_("%s: contains corrupt thin archive: %s\n"),
16328 file_name, name);
16329 ret = 1;
16330 break;
16331 }
16332
2cf0635d
NC		 16333 /* This is a proxy for a member of a nested archive. */
16334 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
16335
16336 /* The nested archive file will have been opened and setup by
16337 get_archive_member_name. */
16338 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
16339 {
16340 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
16341 ret = 1;
16342 break;
16343 }
16344
16345 ret |= process_object (qualified_name, nested_arch.file);
16346 }
16347 else
16348 {
16349 archive_file_offset = arch.next_arhdr_offset;
16350 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 16351
2cf0635d
NC		 16352 ret |= process_object (qualified_name, file);
16353 }
fb52b2f4 16354
2b52916e
L		 16355 if (dump_sects != NULL)
16356 {
16357 free (dump_sects);
16358 dump_sects = NULL;
16359 num_dump_sects = 0;
16360 }
16361
2cf0635d 16362 free (qualified_name);
fb52b2f4
NC		 16363 }
16364
4145f1d5 16365 out:
2cf0635d
NC		 16366 if (nested_arch.file != NULL)
16367 fclose (nested_arch.file);
16368 release_archive (&nested_arch);
16369 release_archive (&arch);
fb52b2f4 16370
d989285c 16371 return ret;
fb52b2f4
NC		 16372}
16373
16374static int
2cf0635d 16375process_file (char * file_name)
fb52b2f4 16376{
2cf0635d 16377 FILE * file;
fb52b2f4
NC		 16378 struct stat statbuf;
16379 char armag[SARMAG];
16380 int ret;
16381
16382 if (stat (file_name, &statbuf) < 0)
16383 {
f24ddbdd
NC		 16384 if (errno == ENOENT)
16385 error (_("'%s': No such file\n"), file_name);
16386 else
16387 error (_("Could not locate '%s'. System error message: %s\n"),
16388 file_name, strerror (errno));
16389 return 1;
16390 }
16391
16392 if (! S_ISREG (statbuf.st_mode))
16393 {
16394 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 16395 return 1;
16396 }
16397
16398 file = fopen (file_name, "rb");
16399 if (file == NULL)
16400 {
f24ddbdd 16401 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 16402 return 1;
16403 }
16404
16405 if (fread (armag, SARMAG, 1, file) != 1)
16406 {
4145f1d5 16407 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 16408 fclose (file);
16409 return 1;
16410 }
16411
f54498b4
NC		 16412 current_file_size = (bfd_size_type) statbuf.st_size;
16413
fb52b2f4 16414 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 16415 ret = process_archive (file_name, file, FALSE);
16416 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16417 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 16418 else
16419 {
4145f1d5
NC		 16420 if (do_archive_index)
16421 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16422 file_name);
16423
fb52b2f4
NC		 16424 rewind (file);
16425 archive_file_size = archive_file_offset = 0;
16426 ret = process_object (file_name, file);
16427 }
16428
16429 fclose (file);
16430
f54498b4 16431 current_file_size = 0;
fb52b2f4
NC		 16432 return ret;
16433}
16434
252b5132
RH		 16435#ifdef SUPPORT_DISASSEMBLY
16436/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 16437 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 16438 symbols. */
252b5132
RH		 16439
16440void
2cf0635d 16441print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 16442{
16443 fprintf (outfile,"0x%8.8x", addr);
16444}
16445
e3c8793a 16446/* Needed by the i386 disassembler. */
252b5132
RH		 16447void
16448db_task_printsym (unsigned int addr)
16449{
16450 print_address (addr, stderr);
16451}
16452#endif
16453
16454int
2cf0635d 16455main (int argc, char ** argv)
252b5132 16456{
ff78d6d6
L		 16457 int err;
16458
252b5132
RH		 16459#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16460 setlocale (LC_MESSAGES, "");
3882b010
L		 16461#endif
16462#if defined (HAVE_SETLOCALE)
16463 setlocale (LC_CTYPE, "");
252b5132
RH		 16464#endif
16465 bindtextdomain (PACKAGE, LOCALEDIR);
16466 textdomain (PACKAGE);
16467
869b9d07
MM		 16468 expandargv (&argc, &argv);
16469
252b5132
RH		 16470 parse_args (argc, argv);
16471
18bd398b 16472 if (num_dump_sects > 0)
59f14fc0 16473 {
18bd398b 16474 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 16475 cmdline_dump_sects = (dump_type *)
16476 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 16477 if (cmdline_dump_sects == NULL)
591a748a 16478 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 16479 else
16480 {
09c11c86
NC		 16481 memcpy (cmdline_dump_sects, dump_sects,
16482 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 16483 num_cmdline_dump_sects = num_dump_sects;
16484 }
16485 }
16486
18bd398b
NC		 16487 if (optind < (argc - 1))
16488 show_name = 1;
5656ba2c
L		 16489 else if (optind >= argc)
16490 {
16491 warn (_("Nothing to do.\n"));
16492 usage (stderr);
16493 }
18bd398b 16494
ff78d6d6 16495 err = 0;
252b5132 16496 while (optind < argc)
18bd398b 16497 err |= process_file (argv[optind++]);
252b5132
RH		 16498
16499 if (dump_sects != NULL)
16500 free (dump_sects);
59f14fc0
AS		 16501 if (cmdline_dump_sects != NULL)
16502 free (cmdline_dump_sects);
252b5132 16503
ff78d6d6 16504 return err;
252b5132 16505}
A mirror of the official binutils-gdb repository