]> Git Repo - binutils.git/blame - binutils/readelf.c
projects / binutils.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Add --decompress option to readelf to decompress sections before they are dumped.
[binutils.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 <[email protected]>
12ab83a9 5 Modifications by Nick Clifton <[email protected]>
252b5132
RH		 6
7 This file is part of GNU Binutils.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
32866df7 11 the Free Software Foundation; either version 3 of the License, or
252b5132
RH		 12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
b43b5d5f
NC		 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 02110-1301, USA. */
252b5132 23\f
9eb20dd8 24/* The difference between readelf and objdump:
252b5132 25
74013231 26 Both programs are capable of displaying the contents of ELF format files,
9eb20dd8 27 so why does the binutils project have two file dumpers ?
0de14b54 28
9eb20dd8
NC		 29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
35
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
38
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
42\f
3db64b00 43#include "sysdep.h"
252b5132 44#include <assert.h>
252b5132 45#include <time.h>
1b315056 46#include <zlib.h>
3bfcb652 47#ifdef HAVE_WCHAR_H
7bfd842d 48#include <wchar.h>
3bfcb652 49#endif
252b5132 50
a952a375 51#if __GNUC__ >= 2
19936277 52/* Define BFD64 here, even if our default architecture is 32 bit ELF
a952a375 53 as this will allow us to read in and parse 64bit and 32bit ELF files.
b34976b6 54 Only do this if we believe that the compiler can support a 64 bit
a952a375 55 data type. For now we only rely on GCC being able to do this. */
19936277 56#define BFD64
a952a375
NC		 57#endif
58
3db64b00
AM		 59#include "bfd.h"
60#include "bucomm.h"
3284fe0c 61#include "elfcomm.h"
19e6b90e 62#include "dwarf.h"
252b5132
RH		 63
64#include "elf/common.h"
65#include "elf/external.h"
66#include "elf/internal.h"
252b5132 67
4b78141a
NC		 68
69/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
73
74#include "elf/h8.h"
75#undef _ELF_H8_H
76
77/* Undo the effects of #including reloc-macros.h. */
78
79#undef START_RELOC_NUMBERS
80#undef RELOC_NUMBER
81#undef FAKE_RELOC
82#undef EMPTY_RELOC
83#undef END_RELOC_NUMBERS
84#undef _RELOC_MACROS_H
85
252b5132
RH		 86/* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
89
90#define RELOC_MACROS_GEN_FUNC
91
a06ea964 92#include "elf/aarch64.h"
252b5132 93#include "elf/alpha.h"
3b16e843 94#include "elf/arc.h"
252b5132 95#include "elf/arm.h"
3b16e843 96#include "elf/avr.h"
1d65ded4 97#include "elf/bfin.h"
60bca95a 98#include "elf/cr16.h"
3b16e843 99#include "elf/cris.h"
1c0d3aa6 100#include "elf/crx.h"
252b5132
RH		 101#include "elf/d10v.h"
102#include "elf/d30v.h"
d172d4ba 103#include "elf/dlx.h"
cfb8c092 104#include "elf/epiphany.h"
252b5132 105#include "elf/fr30.h"
5c70f934 106#include "elf/frv.h"
3f8107ab 107#include "elf/ft32.h"
3b16e843
NC		 108#include "elf/h8.h"
109#include "elf/hppa.h"
110#include "elf/i386.h"
35b1837e 111#include "elf/i370.h"
3b16e843
NC		 112#include "elf/i860.h"
113#include "elf/i960.h"
114#include "elf/ia64.h"
1e4cf259 115#include "elf/ip2k.h"
84e94c90 116#include "elf/lm32.h"
1c0d3aa6 117#include "elf/iq2000.h"
49f58d10 118#include "elf/m32c.h"
3b16e843
NC		 119#include "elf/m32r.h"
120#include "elf/m68k.h"
75751cd9 121#include "elf/m68hc11.h"
252b5132 122#include "elf/mcore.h"
15ab5209 123#include "elf/mep.h"
a3c62988 124#include "elf/metag.h"
7ba29e2a 125#include "elf/microblaze.h"
3b16e843 126#include "elf/mips.h"
3c3bdf30 127#include "elf/mmix.h"
3b16e843
NC		 128#include "elf/mn10200.h"
129#include "elf/mn10300.h"
5506d11a 130#include "elf/moxie.h"
4970f871 131#include "elf/mt.h"
2469cfa2 132#include "elf/msp430.h"
35c08157 133#include "elf/nds32.h"
13761a11 134#include "elf/nios2.h"
73589c9d 135#include "elf/or1k.h"
7d466069 136#include "elf/pj.h"
3b16e843 137#include "elf/ppc.h"
c833c019 138#include "elf/ppc64.h"
99c513f6 139#include "elf/rl78.h"
c7927a3c 140#include "elf/rx.h"
a85d7ed0 141#include "elf/s390.h"
1c0d3aa6 142#include "elf/score.h"
3b16e843
NC		 143#include "elf/sh.h"
144#include "elf/sparc.h"
e9f53129 145#include "elf/spu.h"
40b36596 146#include "elf/tic6x.h"
aa137e4d
NC		 147#include "elf/tilegx.h"
148#include "elf/tilepro.h"
3b16e843 149#include "elf/v850.h"
179d3252 150#include "elf/vax.h"
619ed720 151#include "elf/visium.h"
3b16e843 152#include "elf/x86-64.h"
c29aca4a 153#include "elf/xc16x.h"
f6c1a2d5 154#include "elf/xgate.h"
93fbbb04 155#include "elf/xstormy16.h"
88da6820 156#include "elf/xtensa.h"
252b5132 157
252b5132 158#include "getopt.h"
566b0d53 159#include "libiberty.h"
09c11c86 160#include "safe-ctype.h"
2cf0635d 161#include "filenames.h"
252b5132 162
15b42fb0
AM		 163#ifndef offsetof
164#define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
165#endif
166
2cf0635d 167char * program_name = "readelf";
c9c1d674 168static unsigned long archive_file_offset;
85b1c36d 169static unsigned long archive_file_size;
f54498b4 170static bfd_size_type current_file_size;
85b1c36d
BE		 171static unsigned long dynamic_addr;
172static bfd_size_type dynamic_size;
8b73c356 173static size_t dynamic_nent;
2cf0635d 174static char * dynamic_strings;
85b1c36d 175static unsigned long dynamic_strings_length;
2cf0635d 176static char * string_table;
85b1c36d
BE		 177static unsigned long string_table_length;
178static unsigned long num_dynamic_syms;
2cf0635d
NC		 179static Elf_Internal_Sym * dynamic_symbols;
180static Elf_Internal_Syminfo * dynamic_syminfo;
85b1c36d
BE		 181static unsigned long dynamic_syminfo_offset;
182static unsigned int dynamic_syminfo_nent;
f8eae8b2 183static char program_interpreter[PATH_MAX];
bb8a0291 184static bfd_vma dynamic_info[DT_ENCODING];
fdc90cb4 185static bfd_vma dynamic_info_DT_GNU_HASH;
85b1c36d
BE		 186static bfd_vma version_info[16];
187static Elf_Internal_Ehdr elf_header;
2cf0635d
NC		 188static Elf_Internal_Shdr * section_headers;
189static Elf_Internal_Phdr * program_headers;
190static Elf_Internal_Dyn * dynamic_section;
191static Elf_Internal_Shdr * symtab_shndx_hdr;
85b1c36d
BE		 192static int show_name;
193static int do_dynamic;
194static int do_syms;
2c610e4b 195static int do_dyn_syms;
85b1c36d
BE		 196static int do_reloc;
197static int do_sections;
198static int do_section_groups;
5477e8a0 199static int do_section_details;
85b1c36d
BE		 200static int do_segments;
201static int do_unwind;
202static int do_using_dynamic;
203static int do_header;
204static int do_dump;
205static int do_version;
85b1c36d
BE		 206static int do_histogram;
207static int do_debugging;
85b1c36d
BE		 208static int do_arch;
209static int do_notes;
4145f1d5 210static int do_archive_index;
85b1c36d 211static int is_32bit_elf;
0e602686 212static int decompress_dumps;
252b5132 213
e4b17d5c
L		 214struct group_list
215{
2cf0635d 216 struct group_list * next;
e4b17d5c
L		 217 unsigned int section_index;
218};
219
220struct group
221{
2cf0635d 222 struct group_list * root;
e4b17d5c
L		 223 unsigned int group_index;
224};
225
85b1c36d 226static size_t group_count;
2cf0635d
NC		 227static struct group * section_groups;
228static struct group ** section_headers_groups;
e4b17d5c 229
09c11c86
NC		 230
231/* Flag bits indicating particular types of dump. */
232#define HEX_DUMP (1 << 0) /* The -x command line switch. */
233#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
234#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
235#define STRING_DUMP (1 << 3) /* The -p command line switch. */
cf13d699 236#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
09c11c86
NC		 237
238typedef unsigned char dump_type;
239
240/* A linked list of the section names for which dumps were requested. */
aef1f6d0
DJ		 241struct dump_list_entry
242{
2cf0635d 243 char * name;
09c11c86 244 dump_type type;
2cf0635d 245 struct dump_list_entry * next;
aef1f6d0 246};
2cf0635d 247static struct dump_list_entry * dump_sects_byname;
aef1f6d0 248
09c11c86
NC		 249/* A dynamic array of flags indicating for which sections a dump
250 has been requested via command line switches. */
251static dump_type * cmdline_dump_sects = NULL;
252static unsigned int num_cmdline_dump_sects = 0;
18bd398b
NC		 253
254/* A dynamic array of flags indicating for which sections a dump of
255 some kind has been requested. It is reset on a per-object file
aef1f6d0
DJ		 256 basis and then initialised from the cmdline_dump_sects array,
257 the results of interpreting the -w switch, and the
258 dump_sects_byname list. */
09c11c86
NC		 259static dump_type * dump_sects = NULL;
260static unsigned int num_dump_sects = 0;
252b5132 261
252b5132 262
c256ffe7 263/* How to print a vma value. */
843dd992
NC		 264typedef enum print_mode
265{
266 HEX,
267 DEC,
268 DEC_5,
269 UNSIGNED,
270 PREFIX_HEX,
271 FULL_HEX,
272 LONG_HEX
273}
274print_mode;
275
bb4d2ac2
L		 276/* Versioned symbol info. */
277enum versioned_symbol_info
278{
279 symbol_undefined,
280 symbol_hidden,
281 symbol_public
282};
283
284static const char *get_symbol_version_string
285 (FILE *file, int is_dynsym, const char *strtab,
286 unsigned long int strtab_size, unsigned int si,
287 Elf_Internal_Sym *psym, enum versioned_symbol_info *sym_info,
288 unsigned short *vna_other);
289
9c19a809
NC		 290#define UNKNOWN -1
291
2b692964
NC		 292#define SECTION_NAME(X) \
293 ((X) == NULL ? _("<none>") \
294 : string_table == NULL ? _("<no-name>") \
295 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
0b49d371 296 : string_table + (X)->sh_name))
252b5132 297
ee42cf8c 298#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
252b5132 299
ba5cdace
NC		 300#define GET_ELF_SYMBOLS(file, section, sym_count) \
301 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
302 : get_64bit_elf_symbols (file, section, sym_count))
9ea033b2 303
d79b3d50
NC		 304#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
305/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
306 already been called and verified that the string exists. */
307#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
18bd398b 308
61865e30
NC		 309#define REMOVE_ARCH_BITS(ADDR) \
310 do \
311 { \
312 if (elf_header.e_machine == EM_ARM) \
313 (ADDR) &= ~1; \
314 } \
315 while (0)
d79b3d50 316\f
c9c1d674
EG		 317/* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
318 the offset of the current archive member, if we are examining an archive.
59245841
NC		 319 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
320 using malloc and fill that. In either case return the pointer to the start of
321 the retrieved data or NULL if something went wrong. If something does go wrong
c9c1d674
EG		 322 and REASON is not NULL then emit an error message using REASON as part of the
323 context. */
59245841 324
c256ffe7 325static void *
57028622
NC		 326get_data (void * var, FILE * file, unsigned long offset, bfd_size_type size,
327 bfd_size_type nmemb, const char * reason)
a6e9f9df 328{
2cf0635d 329 void * mvar;
57028622 330 bfd_size_type amt = size * nmemb;
a6e9f9df 331
c256ffe7 332 if (size == 0 || nmemb == 0)
a6e9f9df
AM		 333 return NULL;
334
57028622
NC		 335 /* If the size_t type is smaller than the bfd_size_type, eg because
336 you are building a 32-bit tool on a 64-bit host, then make sure
337 that when the sizes are cast to (size_t) no information is lost. */
338 if (sizeof (size_t) < sizeof (bfd_size_type)
339 && ( (bfd_size_type) ((size_t) size) != size
340 || (bfd_size_type) ((size_t) nmemb) != nmemb))
341 {
342 if (reason)
343 error (_("Size truncation prevents reading 0x%llx elements of size 0x%llx for %s\n"),
344 (unsigned long long) nmemb, (unsigned long long) size, reason);
345 return NULL;
346 }
347
348 /* Check for size overflow. */
349 if (amt < nmemb)
350 {
351 if (reason)
352 error (_("Size overflow prevents reading 0x%llx elements of size 0x%llx for %s\n"),
353 (unsigned long long) nmemb, (unsigned long long) size, reason);
354 return NULL;
355 }
356
c9c1d674
EG		 357 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
358 attempting to allocate memory when the read is bound to fail. */
359 if (amt > current_file_size
360 || offset + archive_file_offset + amt > current_file_size)
a6e9f9df 361 {
049b0c3a 362 if (reason)
57028622
NC		 363 error (_("Reading 0x%llx bytes extends past end of file for %s\n"),
364 (unsigned long long) amt, reason);
a6e9f9df
AM		 365 return NULL;
366 }
367
c9c1d674 368 if (fseek (file, archive_file_offset + offset, SEEK_SET))
071436c6
NC		 369 {
370 if (reason)
c9c1d674
EG		 371 error (_("Unable to seek to 0x%lx for %s\n"),
372 (unsigned long) archive_file_offset + offset, reason);
071436c6
NC		 373 return NULL;
374 }
375
a6e9f9df
AM		 376 mvar = var;
377 if (mvar == NULL)
378 {
c256ffe7 379 /* Check for overflow. */
57028622 380 if (nmemb < (~(bfd_size_type) 0 - 1) / size)
c256ffe7 381 /* + 1 so that we can '\0' terminate invalid string table sections. */
57028622 382 mvar = malloc ((size_t) amt + 1);
a6e9f9df
AM		 383
384 if (mvar == NULL)
385 {
049b0c3a 386 if (reason)
57028622
NC		 387 error (_("Out of memory allocating 0x%llx bytes for %s\n"),
388 (unsigned long long) amt, reason);
a6e9f9df
AM		 389 return NULL;
390 }
c256ffe7 391
c9c1d674 392 ((char *) mvar)[amt] = '\0';
a6e9f9df
AM		 393 }
394
57028622 395 if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
a6e9f9df 396 {
049b0c3a 397 if (reason)
57028622
NC		 398 error (_("Unable to read in 0x%llx bytes of %s\n"),
399 (unsigned long long) amt, reason);
a6e9f9df
AM		 400 if (mvar != var)
401 free (mvar);
402 return NULL;
403 }
404
405 return mvar;
406}
407
14a91970 408/* Print a VMA value. */
cb8f3167 409
66543521 410static int
14a91970 411print_vma (bfd_vma vma, print_mode mode)
66543521 412{
66543521
AM		 413 int nc = 0;
414
14a91970 415 switch (mode)
66543521 416 {
14a91970
AM		 417 case FULL_HEX:
418 nc = printf ("0x");
419 /* Drop through. */
66543521 420
14a91970 421 case LONG_HEX:
f7a99963 422#ifdef BFD64
14a91970 423 if (is_32bit_elf)
437c2fb7 424 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
f7a99963 425#endif
14a91970
AM		 426 printf_vma (vma);
427 return nc + 16;
b19aac67 428
14a91970
AM		 429 case DEC_5:
430 if (vma <= 99999)
431 return printf ("%5" BFD_VMA_FMT "d", vma);
432 /* Drop through. */
66543521 433
14a91970
AM		 434 case PREFIX_HEX:
435 nc = printf ("0x");
436 /* Drop through. */
66543521 437
14a91970
AM		 438 case HEX:
439 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 440
14a91970
AM		 441 case DEC:
442 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 443
14a91970
AM		 444 case UNSIGNED:
445 return printf ("%" BFD_VMA_FMT "u", vma);
f7a99963 446 }
66543521 447 return 0;
f7a99963
NC		 448}
449
7bfd842d 450/* Display a symbol on stdout. Handles the display of control characters and
3bfcb652 451 multibye characters (assuming the host environment supports them).
31104126 452
7bfd842d
NC		 453 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
454
455 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
456 padding as necessary.
171191ba
NC		 457
458 Returns the number of emitted characters. */
459
460static unsigned int
7a88bc9c 461print_symbol (int width, const char *symbol)
31104126 462{
171191ba 463 bfd_boolean extra_padding = FALSE;
7bfd842d 464 int num_printed = 0;
3bfcb652 465#ifdef HAVE_MBSTATE_T
7bfd842d 466 mbstate_t state;
3bfcb652 467#endif
7bfd842d 468 int width_remaining;
961c521f 469
7bfd842d 470 if (width < 0)
961c521f 471 {
961c521f
NC		 472 /* Keep the width positive. This also helps. */
473 width = - width;
171191ba 474 extra_padding = TRUE;
0b4362b0 475 }
74e1a04b 476 assert (width != 0);
961c521f 477
7bfd842d
NC		 478 if (do_wide)
479 /* Set the remaining width to a very large value.
480 This simplifies the code below. */
481 width_remaining = INT_MAX;
482 else
483 width_remaining = width;
cb8f3167 484
3bfcb652 485#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 486 /* Initialise the multibyte conversion state. */
487 memset (& state, 0, sizeof (state));
3bfcb652 488#endif
961c521f 489
7bfd842d
NC		 490 while (width_remaining)
491 {
492 size_t n;
7bfd842d 493 const char c = *symbol++;
961c521f 494
7bfd842d 495 if (c == 0)
961c521f
NC		 496 break;
497
7bfd842d
NC		 498 /* Do not print control characters directly as they can affect terminal
499 settings. Such characters usually appear in the names generated
500 by the assembler for local labels. */
501 if (ISCNTRL (c))
961c521f 502 {
7bfd842d 503 if (width_remaining < 2)
961c521f
NC		 504 break;
505
7bfd842d
NC		 506 printf ("^%c", c + 0x40);
507 width_remaining -= 2;
171191ba 508 num_printed += 2;
961c521f 509 }
7bfd842d
NC		 510 else if (ISPRINT (c))
511 {
512 putchar (c);
513 width_remaining --;
514 num_printed ++;
515 }
961c521f
NC		 516 else
517 {
3bfcb652
NC		 518#ifdef HAVE_MBSTATE_T
519 wchar_t w;
520#endif
7bfd842d
NC		 521 /* Let printf do the hard work of displaying multibyte characters. */
522 printf ("%.1s", symbol - 1);
523 width_remaining --;
524 num_printed ++;
525
3bfcb652 526#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 527 /* Try to find out how many bytes made up the character that was
528 just printed. Advance the symbol pointer past the bytes that
529 were displayed. */
530 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
3bfcb652
NC		 531#else
532 n = 1;
533#endif
7bfd842d
NC		 534 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
535 symbol += (n - 1);
961c521f 536 }
961c521f 537 }
171191ba 538
7bfd842d 539 if (extra_padding && num_printed < width)
171191ba
NC		 540 {
541 /* Fill in the remaining spaces. */
7bfd842d
NC		 542 printf ("%-*s", width - num_printed, " ");
543 num_printed = width;
171191ba
NC		 544 }
545
546 return num_printed;
31104126
NC		 547}
548
74e1a04b
NC		 549/* Returns a pointer to a static buffer containing a printable version of
550 the given section's name. Like print_symbol, except that it does not try
551 to print multibyte characters, it just interprets them as hex values. */
552
553static const char *
0d2a7a93 554printable_section_name (const Elf_Internal_Shdr * sec)
74e1a04b
NC		 555{
556#define MAX_PRINT_SEC_NAME_LEN 128
557 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
558 const char * name = SECTION_NAME (sec);
559 char * buf = sec_name_buf;
560 char c;
561 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
562
563 while ((c = * name ++) != 0)
564 {
565 if (ISCNTRL (c))
566 {
567 if (remaining < 2)
568 break;
948f632f 569
74e1a04b
NC		 570 * buf ++ = '^';
571 * buf ++ = c + 0x40;
572 remaining -= 2;
573 }
574 else if (ISPRINT (c))
575 {
576 * buf ++ = c;
577 remaining -= 1;
578 }
579 else
580 {
581 static char hex[17] = "0123456789ABCDEF";
582
583 if (remaining < 4)
584 break;
585 * buf ++ = '<';
586 * buf ++ = hex[(c & 0xf0) >> 4];
587 * buf ++ = hex[c & 0x0f];
588 * buf ++ = '>';
589 remaining -= 4;
590 }
591
592 if (remaining == 0)
593 break;
594 }
595
596 * buf = 0;
597 return sec_name_buf;
598}
599
600static const char *
601printable_section_name_from_index (unsigned long ndx)
602{
603 if (ndx >= elf_header.e_shnum)
604 return _("<corrupt>");
605
606 return printable_section_name (section_headers + ndx);
607}
608
89fac5e3
RS		 609/* Return a pointer to section NAME, or NULL if no such section exists. */
610
611static Elf_Internal_Shdr *
2cf0635d 612find_section (const char * name)
89fac5e3
RS		 613{
614 unsigned int i;
615
616 for (i = 0; i < elf_header.e_shnum; i++)
617 if (streq (SECTION_NAME (section_headers + i), name))
618 return section_headers + i;
619
620 return NULL;
621}
622
0b6ae522
DJ		 623/* Return a pointer to a section containing ADDR, or NULL if no such
624 section exists. */
625
626static Elf_Internal_Shdr *
627find_section_by_address (bfd_vma addr)
628{
629 unsigned int i;
630
631 for (i = 0; i < elf_header.e_shnum; i++)
632 {
633 Elf_Internal_Shdr *sec = section_headers + i;
634 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
635 return sec;
636 }
637
638 return NULL;
639}
640
071436c6
NC		 641static Elf_Internal_Shdr *
642find_section_by_type (unsigned int type)
643{
644 unsigned int i;
645
646 for (i = 0; i < elf_header.e_shnum; i++)
647 {
648 Elf_Internal_Shdr *sec = section_headers + i;
649 if (sec->sh_type == type)
650 return sec;
651 }
652
653 return NULL;
654}
655
657d0d47
CC		 656/* Return a pointer to section NAME, or NULL if no such section exists,
657 restricted to the list of sections given in SET. */
658
659static Elf_Internal_Shdr *
660find_section_in_set (const char * name, unsigned int * set)
661{
662 unsigned int i;
663
664 if (set != NULL)
665 {
666 while ((i = *set++) > 0)
667 if (streq (SECTION_NAME (section_headers + i), name))
668 return section_headers + i;
669 }
670
671 return find_section (name);
672}
673
0b6ae522
DJ		 674/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
675 bytes read. */
676
f6f0e17b
NC		 677static inline unsigned long
678read_uleb128 (unsigned char *data,
679 unsigned int *length_return,
680 const unsigned char * const end)
0b6ae522 681{
f6f0e17b 682 return read_leb128 (data, length_return, FALSE, end);
0b6ae522
DJ		 683}
684
28f997cf
TG		 685/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
686 This OS has so many departures from the ELF standard that we test it at
687 many places. */
688
689static inline int
690is_ia64_vms (void)
691{
692 return elf_header.e_machine == EM_IA_64
693 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
694}
695
bcedfee6 696/* Guess the relocation size commonly used by the specific machines. */
252b5132 697
252b5132 698static int
2dc4cec1 699guess_is_rela (unsigned int e_machine)
252b5132 700{
9c19a809 701 switch (e_machine)
252b5132
RH		 702 {
703 /* Targets that use REL relocations. */
252b5132 704 case EM_386:
22abe556 705 case EM_IAMCU:
63fcb9e9 706 case EM_960:
e9f53129 707 case EM_ARM:
2b0337b0 708 case EM_D10V:
252b5132 709 case EM_CYGNUS_D10V:
e9f53129 710 case EM_DLX:
252b5132 711 case EM_MIPS:
4fe85591 712 case EM_MIPS_RS3_LE:
e9f53129 713 case EM_CYGNUS_M32R:
1c0d3aa6 714 case EM_SCORE:
f6c1a2d5 715 case EM_XGATE:
9c19a809 716 return FALSE;
103f02d3 717
252b5132
RH		 718 /* Targets that use RELA relocations. */
719 case EM_68K:
e9f53129 720 case EM_860:
a06ea964 721 case EM_AARCH64:
cfb8c092 722 case EM_ADAPTEVA_EPIPHANY:
e9f53129
AM		 723 case EM_ALPHA:
724 case EM_ALTERA_NIOS2:
725 case EM_AVR:
726 case EM_AVR_OLD:
727 case EM_BLACKFIN:
60bca95a 728 case EM_CR16:
e9f53129
AM		 729 case EM_CRIS:
730 case EM_CRX:
2b0337b0 731 case EM_D30V:
252b5132 732 case EM_CYGNUS_D30V:
2b0337b0 733 case EM_FR30:
3f8107ab 734 case EM_FT32:
252b5132 735 case EM_CYGNUS_FR30:
5c70f934 736 case EM_CYGNUS_FRV:
e9f53129
AM		 737 case EM_H8S:
738 case EM_H8_300:
739 case EM_H8_300H:
800eeca4 740 case EM_IA_64:
1e4cf259
NC		 741 case EM_IP2K:
742 case EM_IP2K_OLD:
3b36097d 743 case EM_IQ2000:
84e94c90 744 case EM_LATTICEMICO32:
ff7eeb89 745 case EM_M32C_OLD:
49f58d10 746 case EM_M32C:
e9f53129
AM		 747 case EM_M32R:
748 case EM_MCORE:
15ab5209 749 case EM_CYGNUS_MEP:
a3c62988 750 case EM_METAG:
e9f53129
AM		 751 case EM_MMIX:
752 case EM_MN10200:
753 case EM_CYGNUS_MN10200:
754 case EM_MN10300:
755 case EM_CYGNUS_MN10300:
5506d11a 756 case EM_MOXIE:
e9f53129
AM		 757 case EM_MSP430:
758 case EM_MSP430_OLD:
d031aafb 759 case EM_MT:
35c08157 760 case EM_NDS32:
64fd6348 761 case EM_NIOS32:
73589c9d 762 case EM_OR1K:
e9f53129
AM		 763 case EM_PPC64:
764 case EM_PPC:
99c513f6 765 case EM_RL78:
c7927a3c 766 case EM_RX:
e9f53129
AM		 767 case EM_S390:
768 case EM_S390_OLD:
769 case EM_SH:
770 case EM_SPARC:
771 case EM_SPARC32PLUS:
772 case EM_SPARCV9:
773 case EM_SPU:
40b36596 774 case EM_TI_C6000:
aa137e4d
NC		 775 case EM_TILEGX:
776 case EM_TILEPRO:
708e2187 777 case EM_V800:
e9f53129
AM		 778 case EM_V850:
779 case EM_CYGNUS_V850:
780 case EM_VAX:
619ed720 781 case EM_VISIUM:
e9f53129 782 case EM_X86_64:
8a9036a4 783 case EM_L1OM:
7a9068fe 784 case EM_K1OM:
e9f53129
AM		 785 case EM_XSTORMY16:
786 case EM_XTENSA:
787 case EM_XTENSA_OLD:
7ba29e2a
NC		 788 case EM_MICROBLAZE:
789 case EM_MICROBLAZE_OLD:
9c19a809 790 return TRUE;
103f02d3 791
e9f53129
AM		 792 case EM_68HC05:
793 case EM_68HC08:
794 case EM_68HC11:
795 case EM_68HC16:
796 case EM_FX66:
797 case EM_ME16:
d1133906 798 case EM_MMA:
d1133906
NC		 799 case EM_NCPU:
800 case EM_NDR1:
e9f53129 801 case EM_PCP:
d1133906 802 case EM_ST100:
e9f53129 803 case EM_ST19:
d1133906 804 case EM_ST7:
e9f53129
AM		 805 case EM_ST9PLUS:
806 case EM_STARCORE:
d1133906 807 case EM_SVX:
e9f53129 808 case EM_TINYJ:
9c19a809
NC		 809 default:
810 warn (_("Don't know about relocations on this machine architecture\n"));
811 return FALSE;
812 }
813}
252b5132 814
9c19a809 815static int
2cf0635d 816slurp_rela_relocs (FILE * file,
d3ba0551
AM		 817 unsigned long rel_offset,
818 unsigned long rel_size,
2cf0635d
NC		 819 Elf_Internal_Rela ** relasp,
820 unsigned long * nrelasp)
9c19a809 821{
2cf0635d 822 Elf_Internal_Rela * relas;
8b73c356 823 size_t nrelas;
4d6ed7c8 824 unsigned int i;
252b5132 825
4d6ed7c8
NC		 826 if (is_32bit_elf)
827 {
2cf0635d 828 Elf32_External_Rela * erelas;
103f02d3 829
3f5e193b 830 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 831 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 832 if (!erelas)
833 return 0;
252b5132 834
4d6ed7c8 835 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 836
3f5e193b
NC		 837 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
838 sizeof (Elf_Internal_Rela));
103f02d3 839
4d6ed7c8
NC		 840 if (relas == NULL)
841 {
c256ffe7 842 free (erelas);
591a748a 843 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 844 return 0;
845 }
103f02d3 846
4d6ed7c8
NC		 847 for (i = 0; i < nrelas; i++)
848 {
849 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
850 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 851 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 852 }
103f02d3 853
4d6ed7c8
NC		 854 free (erelas);
855 }
856 else
857 {
2cf0635d 858 Elf64_External_Rela * erelas;
103f02d3 859
3f5e193b 860 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 861 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 862 if (!erelas)
863 return 0;
4d6ed7c8
NC		 864
865 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 866
3f5e193b
NC		 867 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
868 sizeof (Elf_Internal_Rela));
103f02d3 869
4d6ed7c8
NC		 870 if (relas == NULL)
871 {
c256ffe7 872 free (erelas);
591a748a 873 error (_("out of memory parsing relocs\n"));
4d6ed7c8 874 return 0;
9c19a809 875 }
4d6ed7c8
NC		 876
877 for (i = 0; i < nrelas; i++)
9c19a809 878 {
66543521
AM		 879 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
880 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 881 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 882
883 /* The #ifdef BFD64 below is to prevent a compile time
884 warning. We know that if we do not have a 64 bit data
885 type that we will never execute this code anyway. */
886#ifdef BFD64
887 if (elf_header.e_machine == EM_MIPS
888 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
889 {
890 /* In little-endian objects, r_info isn't really a
891 64-bit little-endian value: it has a 32-bit
892 little-endian symbol index followed by four
893 individual byte fields. Reorder INFO
894 accordingly. */
91d6fa6a
NC		 895 bfd_vma inf = relas[i].r_info;
896 inf = (((inf & 0xffffffff) << 32)
897 | ((inf >> 56) & 0xff)
898 | ((inf >> 40) & 0xff00)
899 | ((inf >> 24) & 0xff0000)
900 | ((inf >> 8) & 0xff000000));
901 relas[i].r_info = inf;
861fb55a
DJ		 902 }
903#endif /* BFD64 */
4d6ed7c8 904 }
103f02d3 905
4d6ed7c8
NC		 906 free (erelas);
907 }
908 *relasp = relas;
909 *nrelasp = nrelas;
910 return 1;
911}
103f02d3 912
4d6ed7c8 913static int
2cf0635d 914slurp_rel_relocs (FILE * file,
d3ba0551
AM		 915 unsigned long rel_offset,
916 unsigned long rel_size,
2cf0635d
NC		 917 Elf_Internal_Rela ** relsp,
918 unsigned long * nrelsp)
4d6ed7c8 919{
2cf0635d 920 Elf_Internal_Rela * rels;
8b73c356 921 size_t nrels;
4d6ed7c8 922 unsigned int i;
103f02d3 923
4d6ed7c8
NC		 924 if (is_32bit_elf)
925 {
2cf0635d 926 Elf32_External_Rel * erels;
103f02d3 927
3f5e193b 928 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 929 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 930 if (!erels)
931 return 0;
103f02d3 932
4d6ed7c8 933 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 934
3f5e193b 935 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 936
4d6ed7c8
NC		 937 if (rels == NULL)
938 {
c256ffe7 939 free (erels);
591a748a 940 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 941 return 0;
942 }
943
944 for (i = 0; i < nrels; i++)
945 {
946 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
947 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 948 rels[i].r_addend = 0;
9ea033b2 949 }
4d6ed7c8
NC		 950
951 free (erels);
9c19a809
NC		 952 }
953 else
954 {
2cf0635d 955 Elf64_External_Rel * erels;
9ea033b2 956
3f5e193b 957 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 958 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 959 if (!erels)
960 return 0;
103f02d3 961
4d6ed7c8 962 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 963
3f5e193b 964 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 965
4d6ed7c8 966 if (rels == NULL)
9c19a809 967 {
c256ffe7 968 free (erels);
591a748a 969 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 970 return 0;
971 }
103f02d3 972
4d6ed7c8
NC		 973 for (i = 0; i < nrels; i++)
974 {
66543521
AM		 975 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
976 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 977 rels[i].r_addend = 0;
861fb55a
DJ		 978
979 /* The #ifdef BFD64 below is to prevent a compile time
980 warning. We know that if we do not have a 64 bit data
981 type that we will never execute this code anyway. */
982#ifdef BFD64
983 if (elf_header.e_machine == EM_MIPS
984 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
985 {
986 /* In little-endian objects, r_info isn't really a
987 64-bit little-endian value: it has a 32-bit
988 little-endian symbol index followed by four
989 individual byte fields. Reorder INFO
990 accordingly. */
91d6fa6a
NC		 991 bfd_vma inf = rels[i].r_info;
992 inf = (((inf & 0xffffffff) << 32)
993 | ((inf >> 56) & 0xff)
994 | ((inf >> 40) & 0xff00)
995 | ((inf >> 24) & 0xff0000)
996 | ((inf >> 8) & 0xff000000));
997 rels[i].r_info = inf;
861fb55a
DJ		 998 }
999#endif /* BFD64 */
4d6ed7c8 1000 }
103f02d3 1001
4d6ed7c8
NC		 1002 free (erels);
1003 }
1004 *relsp = rels;
1005 *nrelsp = nrels;
1006 return 1;
1007}
103f02d3 1008
aca88567
NC		 1009/* Returns the reloc type extracted from the reloc info field. */
1010
1011static unsigned int
1012get_reloc_type (bfd_vma reloc_info)
1013{
1014 if (is_32bit_elf)
1015 return ELF32_R_TYPE (reloc_info);
1016
1017 switch (elf_header.e_machine)
1018 {
1019 case EM_MIPS:
1020 /* Note: We assume that reloc_info has already been adjusted for us. */
1021 return ELF64_MIPS_R_TYPE (reloc_info);
1022
1023 case EM_SPARCV9:
1024 return ELF64_R_TYPE_ID (reloc_info);
1025
1026 default:
1027 return ELF64_R_TYPE (reloc_info);
1028 }
1029}
1030
1031/* Return the symbol index extracted from the reloc info field. */
1032
1033static bfd_vma
1034get_reloc_symindex (bfd_vma reloc_info)
1035{
1036 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1037}
1038
13761a11
NC		 1039static inline bfd_boolean
1040uses_msp430x_relocs (void)
1041{
1042 return
1043 elf_header.e_machine == EM_MSP430 /* Paranoia. */
1044 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1045 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1046 /* TI compiler uses ELFOSABI_NONE. */
1047 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1048}
1049
d3ba0551
AM		 1050/* Display the contents of the relocation data found at the specified
1051 offset. */
ee42cf8c 1052
41e92641 1053static void
2cf0635d 1054dump_relocations (FILE * file,
d3ba0551
AM		 1055 unsigned long rel_offset,
1056 unsigned long rel_size,
2cf0635d 1057 Elf_Internal_Sym * symtab,
d3ba0551 1058 unsigned long nsyms,
2cf0635d 1059 char * strtab,
d79b3d50 1060 unsigned long strtablen,
bb4d2ac2
L		 1061 int is_rela,
1062 int is_dynsym)
4d6ed7c8 1063{
b34976b6 1064 unsigned int i;
2cf0635d 1065 Elf_Internal_Rela * rels;
103f02d3 1066
4d6ed7c8
NC		 1067 if (is_rela == UNKNOWN)
1068 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 1069
4d6ed7c8
NC		 1070 if (is_rela)
1071 {
c8286bd1 1072 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1073 return;
4d6ed7c8
NC		 1074 }
1075 else
1076 {
1077 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1078 return;
252b5132
RH		 1079 }
1080
410f7a12
L		 1081 if (is_32bit_elf)
1082 {
1083 if (is_rela)
2c71103e
NC		 1084 {
1085 if (do_wide)
1086 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1087 else
1088 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1089 }
410f7a12 1090 else
2c71103e
NC		 1091 {
1092 if (do_wide)
1093 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1094 else
1095 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1096 }
410f7a12 1097 }
252b5132 1098 else
410f7a12
L		 1099 {
1100 if (is_rela)
2c71103e
NC		 1101 {
1102 if (do_wide)
8beeaeb7 1103 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 1104 else
1105 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1106 }
410f7a12 1107 else
2c71103e
NC		 1108 {
1109 if (do_wide)
8beeaeb7 1110 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 1111 else
1112 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1113 }
410f7a12 1114 }
252b5132
RH		 1115
1116 for (i = 0; i < rel_size; i++)
1117 {
2cf0635d 1118 const char * rtype;
b34976b6 1119 bfd_vma offset;
91d6fa6a 1120 bfd_vma inf;
b34976b6
AM		 1121 bfd_vma symtab_index;
1122 bfd_vma type;
103f02d3 1123
b34976b6 1124 offset = rels[i].r_offset;
91d6fa6a 1125 inf = rels[i].r_info;
103f02d3 1126
91d6fa6a
NC		 1127 type = get_reloc_type (inf);
1128 symtab_index = get_reloc_symindex (inf);
252b5132 1129
410f7a12
L		 1130 if (is_32bit_elf)
1131 {
39dbeff8
AM		 1132 printf ("%8.8lx %8.8lx ",
1133 (unsigned long) offset & 0xffffffff,
91d6fa6a 1134 (unsigned long) inf & 0xffffffff);
410f7a12
L		 1135 }
1136 else
1137 {
39dbeff8
AM		 1138#if BFD_HOST_64BIT_LONG
1139 printf (do_wide
1140 ? "%16.16lx %16.16lx "
1141 : "%12.12lx %12.12lx ",
91d6fa6a 1142 offset, inf);
39dbeff8 1143#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 1144#ifndef __MSVCRT__
39dbeff8
AM		 1145 printf (do_wide
1146 ? "%16.16llx %16.16llx "
1147 : "%12.12llx %12.12llx ",
91d6fa6a 1148 offset, inf);
6e3d6dc1
NC		 1149#else
1150 printf (do_wide
1151 ? "%16.16I64x %16.16I64x "
1152 : "%12.12I64x %12.12I64x ",
91d6fa6a 1153 offset, inf);
6e3d6dc1 1154#endif
39dbeff8 1155#else
2c71103e
NC		 1156 printf (do_wide
1157 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1158 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 1159 _bfd_int64_high (offset),
1160 _bfd_int64_low (offset),
91d6fa6a
NC		 1161 _bfd_int64_high (inf),
1162 _bfd_int64_low (inf));
9ea033b2 1163#endif
410f7a12 1164 }
103f02d3 1165
252b5132
RH		 1166 switch (elf_header.e_machine)
1167 {
1168 default:
1169 rtype = NULL;
1170 break;
1171
a06ea964
NC		 1172 case EM_AARCH64:
1173 rtype = elf_aarch64_reloc_type (type);
1174 break;
1175
2b0337b0 1176 case EM_M32R:
252b5132 1177 case EM_CYGNUS_M32R:
9ea033b2 1178 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 1179 break;
1180
1181 case EM_386:
22abe556 1182 case EM_IAMCU:
9ea033b2 1183 rtype = elf_i386_reloc_type (type);
252b5132
RH		 1184 break;
1185
ba2685cc
AM		 1186 case EM_68HC11:
1187 case EM_68HC12:
1188 rtype = elf_m68hc11_reloc_type (type);
1189 break;
75751cd9 1190
252b5132 1191 case EM_68K:
9ea033b2 1192 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1193 break;
1194
63fcb9e9 1195 case EM_960:
9ea033b2 1196 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1197 break;
1198
adde6300 1199 case EM_AVR:
2b0337b0 1200 case EM_AVR_OLD:
adde6300
AM		 1201 rtype = elf_avr_reloc_type (type);
1202 break;
1203
9ea033b2
NC		 1204 case EM_OLD_SPARCV9:
1205 case EM_SPARC32PLUS:
1206 case EM_SPARCV9:
252b5132 1207 case EM_SPARC:
9ea033b2 1208 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1209 break;
1210
e9f53129
AM		 1211 case EM_SPU:
1212 rtype = elf_spu_reloc_type (type);
1213 break;
1214
708e2187
NC		 1215 case EM_V800:
1216 rtype = v800_reloc_type (type);
1217 break;
2b0337b0 1218 case EM_V850:
252b5132 1219 case EM_CYGNUS_V850:
9ea033b2 1220 rtype = v850_reloc_type (type);
252b5132
RH		 1221 break;
1222
2b0337b0 1223 case EM_D10V:
252b5132 1224 case EM_CYGNUS_D10V:
9ea033b2 1225 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1226 break;
1227
2b0337b0 1228 case EM_D30V:
252b5132 1229 case EM_CYGNUS_D30V:
9ea033b2 1230 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1231 break;
1232
d172d4ba
NC		 1233 case EM_DLX:
1234 rtype = elf_dlx_reloc_type (type);
1235 break;
1236
252b5132 1237 case EM_SH:
9ea033b2 1238 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1239 break;
1240
2b0337b0 1241 case EM_MN10300:
252b5132 1242 case EM_CYGNUS_MN10300:
9ea033b2 1243 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1244 break;
1245
2b0337b0 1246 case EM_MN10200:
252b5132 1247 case EM_CYGNUS_MN10200:
9ea033b2 1248 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1249 break;
1250
2b0337b0 1251 case EM_FR30:
252b5132 1252 case EM_CYGNUS_FR30:
9ea033b2 1253 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1254 break;
1255
ba2685cc
AM		 1256 case EM_CYGNUS_FRV:
1257 rtype = elf_frv_reloc_type (type);
1258 break;
5c70f934 1259
3f8107ab
AM		 1260 case EM_FT32:
1261 rtype = elf_ft32_reloc_type (type);
1262 break;
1263
252b5132 1264 case EM_MCORE:
9ea033b2 1265 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1266 break;
1267
3c3bdf30
NC		 1268 case EM_MMIX:
1269 rtype = elf_mmix_reloc_type (type);
1270 break;
1271
5506d11a
AM		 1272 case EM_MOXIE:
1273 rtype = elf_moxie_reloc_type (type);
1274 break;
1275
2469cfa2 1276 case EM_MSP430:
13761a11
NC		 1277 if (uses_msp430x_relocs ())
1278 {
1279 rtype = elf_msp430x_reloc_type (type);
1280 break;
1281 }
2469cfa2
NC		 1282 case EM_MSP430_OLD:
1283 rtype = elf_msp430_reloc_type (type);
1284 break;
1285
35c08157
KLC		 1286 case EM_NDS32:
1287 rtype = elf_nds32_reloc_type (type);
1288 break;
1289
252b5132 1290 case EM_PPC:
9ea033b2 1291 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1292 break;
1293
c833c019
AM		 1294 case EM_PPC64:
1295 rtype = elf_ppc64_reloc_type (type);
1296 break;
1297
252b5132 1298 case EM_MIPS:
4fe85591 1299 case EM_MIPS_RS3_LE:
9ea033b2 1300 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1301 break;
1302
1303 case EM_ALPHA:
9ea033b2 1304 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1305 break;
1306
1307 case EM_ARM:
9ea033b2 1308 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1309 break;
1310
584da044 1311 case EM_ARC:
9ea033b2 1312 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1313 break;
1314
1315 case EM_PARISC:
69e617ca 1316 rtype = elf_hppa_reloc_type (type);
252b5132 1317 break;
7d466069 1318
b8720f9d
JL		 1319 case EM_H8_300:
1320 case EM_H8_300H:
1321 case EM_H8S:
1322 rtype = elf_h8_reloc_type (type);
1323 break;
1324
73589c9d
CS		 1325 case EM_OR1K:
1326 rtype = elf_or1k_reloc_type (type);
3b16e843
NC		 1327 break;
1328
7d466069 1329 case EM_PJ:
2b0337b0 1330 case EM_PJ_OLD:
7d466069
ILT		 1331 rtype = elf_pj_reloc_type (type);
1332 break;
800eeca4
JW		 1333 case EM_IA_64:
1334 rtype = elf_ia64_reloc_type (type);
1335 break;
1b61cf92
HPN		 1336
1337 case EM_CRIS:
1338 rtype = elf_cris_reloc_type (type);
1339 break;
535c37ff
JE		 1340
1341 case EM_860:
1342 rtype = elf_i860_reloc_type (type);
1343 break;
bcedfee6
NC		 1344
1345 case EM_X86_64:
8a9036a4 1346 case EM_L1OM:
7a9068fe 1347 case EM_K1OM:
bcedfee6
NC		 1348 rtype = elf_x86_64_reloc_type (type);
1349 break;
a85d7ed0 1350
35b1837e
AM		 1351 case EM_S370:
1352 rtype = i370_reloc_type (type);
1353 break;
1354
53c7db4b
KH		 1355 case EM_S390_OLD:
1356 case EM_S390:
1357 rtype = elf_s390_reloc_type (type);
1358 break;
93fbbb04 1359
1c0d3aa6
NC		 1360 case EM_SCORE:
1361 rtype = elf_score_reloc_type (type);
1362 break;
1363
93fbbb04
GK		 1364 case EM_XSTORMY16:
1365 rtype = elf_xstormy16_reloc_type (type);
1366 break;
179d3252 1367
1fe1f39c
NC		 1368 case EM_CRX:
1369 rtype = elf_crx_reloc_type (type);
1370 break;
1371
179d3252
JT		 1372 case EM_VAX:
1373 rtype = elf_vax_reloc_type (type);
1374 break;
1e4cf259 1375
619ed720
EB		 1376 case EM_VISIUM:
1377 rtype = elf_visium_reloc_type (type);
1378 break;
1379
cfb8c092
NC		 1380 case EM_ADAPTEVA_EPIPHANY:
1381 rtype = elf_epiphany_reloc_type (type);
1382 break;
1383
1e4cf259
NC		 1384 case EM_IP2K:
1385 case EM_IP2K_OLD:
1386 rtype = elf_ip2k_reloc_type (type);
1387 break;
3b36097d
SC		 1388
1389 case EM_IQ2000:
1390 rtype = elf_iq2000_reloc_type (type);
1391 break;
88da6820
NC		 1392
1393 case EM_XTENSA_OLD:
1394 case EM_XTENSA:
1395 rtype = elf_xtensa_reloc_type (type);
1396 break;
a34e3ecb 1397
84e94c90
NC		 1398 case EM_LATTICEMICO32:
1399 rtype = elf_lm32_reloc_type (type);
1400 break;
1401
ff7eeb89 1402 case EM_M32C_OLD:
49f58d10
JB		 1403 case EM_M32C:
1404 rtype = elf_m32c_reloc_type (type);
1405 break;
1406
d031aafb
NS		 1407 case EM_MT:
1408 rtype = elf_mt_reloc_type (type);
a34e3ecb 1409 break;
1d65ded4
CM		 1410
1411 case EM_BLACKFIN:
1412 rtype = elf_bfin_reloc_type (type);
1413 break;
15ab5209
DB		 1414
1415 case EM_CYGNUS_MEP:
1416 rtype = elf_mep_reloc_type (type);
1417 break;
60bca95a
NC		 1418
1419 case EM_CR16:
1420 rtype = elf_cr16_reloc_type (type);
1421 break;
dd24e3da 1422
7ba29e2a
NC		 1423 case EM_MICROBLAZE:
1424 case EM_MICROBLAZE_OLD:
1425 rtype = elf_microblaze_reloc_type (type);
1426 break;
c7927a3c 1427
99c513f6
DD		 1428 case EM_RL78:
1429 rtype = elf_rl78_reloc_type (type);
1430 break;
1431
c7927a3c
NC		 1432 case EM_RX:
1433 rtype = elf_rx_reloc_type (type);
1434 break;
c29aca4a 1435
a3c62988
NC		 1436 case EM_METAG:
1437 rtype = elf_metag_reloc_type (type);
1438 break;
1439
c29aca4a
NC		 1440 case EM_XC16X:
1441 case EM_C166:
1442 rtype = elf_xc16x_reloc_type (type);
1443 break;
40b36596
JM		 1444
1445 case EM_TI_C6000:
1446 rtype = elf_tic6x_reloc_type (type);
1447 break;
aa137e4d
NC		 1448
1449 case EM_TILEGX:
1450 rtype = elf_tilegx_reloc_type (type);
1451 break;
1452
1453 case EM_TILEPRO:
1454 rtype = elf_tilepro_reloc_type (type);
1455 break;
f6c1a2d5
NC		 1456
1457 case EM_XGATE:
1458 rtype = elf_xgate_reloc_type (type);
1459 break;
36591ba1
SL		 1460
1461 case EM_ALTERA_NIOS2:
1462 rtype = elf_nios2_reloc_type (type);
1463 break;
252b5132
RH		 1464 }
1465
1466 if (rtype == NULL)
39dbeff8 1467 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1468 else
8beeaeb7 1469 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1470
7ace3541 1471 if (elf_header.e_machine == EM_ALPHA
157c2599 1472 && rtype != NULL
7ace3541
RH		 1473 && streq (rtype, "R_ALPHA_LITUSE")
1474 && is_rela)
1475 {
1476 switch (rels[i].r_addend)
1477 {
1478 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1479 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1480 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1481 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1482 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1483 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1484 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1485 default: rtype = NULL;
1486 }
1487 if (rtype)
1488 printf (" (%s)", rtype);
1489 else
1490 {
1491 putchar (' ');
1492 printf (_("<unknown addend: %lx>"),
1493 (unsigned long) rels[i].r_addend);
1494 }
1495 }
1496 else if (symtab_index)
252b5132 1497 {
af3fc3bc 1498 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1499 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1500 else
19936277 1501 {
2cf0635d 1502 Elf_Internal_Sym * psym;
bb4d2ac2
L		 1503 const char * version_string;
1504 enum versioned_symbol_info sym_info;
1505 unsigned short vna_other;
19936277 1506
af3fc3bc 1507 psym = symtab + symtab_index;
103f02d3 1508
bb4d2ac2
L		 1509 version_string
1510 = get_symbol_version_string (file, is_dynsym,
1511 strtab, strtablen,
1512 symtab_index,
1513 psym,
1514 &sym_info,
1515 &vna_other);
1516
af3fc3bc 1517 printf (" ");
171191ba 1518
d8045f23
NC		 1519 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1520 {
1521 const char * name;
1522 unsigned int len;
1523 unsigned int width = is_32bit_elf ? 8 : 14;
1524
1525 /* Relocations against GNU_IFUNC symbols do not use the value
1526 of the symbol as the address to relocate against. Instead
1527 they invoke the function named by the symbol and use its
1528 result as the address for relocation.
1529
1530 To indicate this to the user, do not display the value of
1531 the symbol in the "Symbols's Value" field. Instead show
1532 its name followed by () as a hint that the symbol is
1533 invoked. */
1534
1535 if (strtab == NULL
1536 || psym->st_name == 0
1537 || psym->st_name >= strtablen)
1538 name = "??";
1539 else
1540 name = strtab + psym->st_name;
1541
1542 len = print_symbol (width, name);
bb4d2ac2
L		 1543 if (version_string)
1544 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1545 version_string);
d8045f23
NC		 1546 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1547 }
1548 else
1549 {
1550 print_vma (psym->st_value, LONG_HEX);
171191ba 1551
d8045f23
NC		 1552 printf (is_32bit_elf ? " " : " ");
1553 }
103f02d3 1554
af3fc3bc 1555 if (psym->st_name == 0)
f1ef08cb 1556 {
2cf0635d 1557 const char * sec_name = "<null>";
f1ef08cb
AM		 1558 char name_buf[40];
1559
1560 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1561 {
4fbb74a6 1562 if (psym->st_shndx < elf_header.e_shnum)
74e1a04b 1563 sec_name = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1564 else if (psym->st_shndx == SHN_ABS)
1565 sec_name = "ABS";
1566 else if (psym->st_shndx == SHN_COMMON)
1567 sec_name = "COMMON";
ac145307
BS		 1568 else if ((elf_header.e_machine == EM_MIPS
1569 && psym->st_shndx == SHN_MIPS_SCOMMON)
1570 || (elf_header.e_machine == EM_TI_C6000
1571 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1572 sec_name = "SCOMMON";
1573 else if (elf_header.e_machine == EM_MIPS
1574 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1575 sec_name = "SUNDEF";
8a9036a4 1576 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1577 || elf_header.e_machine == EM_L1OM
1578 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1579 && psym->st_shndx == SHN_X86_64_LCOMMON)
1580 sec_name = "LARGE_COMMON";
9ce701e2
L		 1581 else if (elf_header.e_machine == EM_IA_64
1582 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1583 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1584 sec_name = "ANSI_COM";
28f997cf 1585 else if (is_ia64_vms ()
148b93f2
NC		 1586 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1587 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1588 else
1589 {
1590 sprintf (name_buf, "<section 0x%x>",
1591 (unsigned int) psym->st_shndx);
1592 sec_name = name_buf;
1593 }
1594 }
1595 print_symbol (22, sec_name);
1596 }
af3fc3bc 1597 else if (strtab == NULL)
d79b3d50 1598 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1599 else if (psym->st_name >= strtablen)
d79b3d50 1600 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1601 else
bb4d2ac2
L		 1602 {
1603 print_symbol (22, strtab + psym->st_name);
1604 if (version_string)
1605 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1606 version_string);
1607 }
103f02d3 1608
af3fc3bc 1609 if (is_rela)
171191ba 1610 {
598aaa76 1611 bfd_signed_vma off = rels[i].r_addend;
171191ba 1612
834f871c
NC		 1613 /* PR 17531: file: 2e63226f. */
1614 if (off == ((bfd_signed_vma) 1) << ((sizeof (bfd_signed_vma) * 8) - 1))
1615 printf (" + %" BFD_VMA_FMT "x", off);
1616 else if (off < 0)
598aaa76 1617 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1618 else
598aaa76 1619 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1620 }
19936277 1621 }
252b5132 1622 }
1b228002 1623 else if (is_rela)
f7a99963 1624 {
e04d7088
L		 1625 bfd_signed_vma off = rels[i].r_addend;
1626
1627 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
834f871c
NC		 1628 /* PR 17531: file: 2e63226f. */
1629 if (off == ((bfd_signed_vma) 1) << ((sizeof (bfd_signed_vma) * 8) - 1))
1630 printf ("%" BFD_VMA_FMT "x", off);
1631 else if (off < 0)
e04d7088
L		 1632 printf ("-%" BFD_VMA_FMT "x", - off);
1633 else
1634 printf ("%" BFD_VMA_FMT "x", off);
f7a99963 1635 }
252b5132 1636
157c2599
NC		 1637 if (elf_header.e_machine == EM_SPARCV9
1638 && rtype != NULL
1639 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1640 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1641
252b5132 1642 putchar ('\n');
2c71103e 1643
aca88567 1644#ifdef BFD64
53c7db4b 1645 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1646 {
91d6fa6a
NC		 1647 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1648 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1649 const char * rtype2 = elf_mips_reloc_type (type2);
1650 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1651
2c71103e
NC		 1652 printf (" Type2: ");
1653
1654 if (rtype2 == NULL)
39dbeff8
AM		 1655 printf (_("unrecognized: %-7lx"),
1656 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1657 else
1658 printf ("%-17.17s", rtype2);
1659
18bd398b 1660 printf ("\n Type3: ");
2c71103e
NC		 1661
1662 if (rtype3 == NULL)
39dbeff8
AM		 1663 printf (_("unrecognized: %-7lx"),
1664 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1665 else
1666 printf ("%-17.17s", rtype3);
1667
53c7db4b 1668 putchar ('\n');
2c71103e 1669 }
aca88567 1670#endif /* BFD64 */
252b5132
RH		 1671 }
1672
c8286bd1 1673 free (rels);
252b5132
RH		 1674}
1675
1676static const char *
d3ba0551 1677get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1678{
1679 switch (type)
1680 {
1681 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1682 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1683 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1684 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1685 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1686 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1687 case DT_MIPS_MSYM: return "MIPS_MSYM";
1688 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1689 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1690 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1691 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1692 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1693 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1694 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1695 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1696 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1697 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1698 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1699 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1700 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1701 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1702 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1703 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1704 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1705 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1706 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1707 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1708 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1709 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1710 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1711 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1712 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1713 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1714 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1715 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1716 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1717 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1718 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1719 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1720 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1721 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1722 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1723 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1724 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1725 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1726 default:
1727 return NULL;
1728 }
1729}
1730
9a097730 1731static const char *
d3ba0551 1732get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1733{
1734 switch (type)
1735 {
1736 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1737 default:
1738 return NULL;
1739 }
103f02d3
UD		 1740}
1741
7490d522
AM		 1742static const char *
1743get_ppc_dynamic_type (unsigned long type)
1744{
1745 switch (type)
1746 {
a7f2871e 1747 case DT_PPC_GOT: return "PPC_GOT";
e8910a83 1748 case DT_PPC_OPT: return "PPC_OPT";
7490d522
AM		 1749 default:
1750 return NULL;
1751 }
1752}
1753
f1cb7e17 1754static const char *
d3ba0551 1755get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1756{
1757 switch (type)
1758 {
a7f2871e
AM		 1759 case DT_PPC64_GLINK: return "PPC64_GLINK";
1760 case DT_PPC64_OPD: return "PPC64_OPD";
1761 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
e8910a83 1762 case DT_PPC64_OPT: return "PPC64_OPT";
f1cb7e17
AM		 1763 default:
1764 return NULL;
1765 }
1766}
1767
103f02d3 1768static const char *
d3ba0551 1769get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1770{
1771 switch (type)
1772 {
1773 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1774 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1775 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1776 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1777 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1778 case DT_HP_PREINIT: return "HP_PREINIT";
1779 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1780 case DT_HP_NEEDED: return "HP_NEEDED";
1781 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1782 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1783 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1784 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1785 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1786 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1787 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1788 case DT_HP_FILTERED: return "HP_FILTERED";
1789 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1790 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1791 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1792 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1793 case DT_PLT: return "PLT";
1794 case DT_PLT_SIZE: return "PLT_SIZE";
1795 case DT_DLT: return "DLT";
1796 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1797 default:
1798 return NULL;
1799 }
1800}
9a097730 1801
ecc51f48 1802static const char *
d3ba0551 1803get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1804{
1805 switch (type)
1806 {
148b93f2
NC		 1807 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1808 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1809 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1810 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1811 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1812 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1813 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1814 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1815 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1816 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1817 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1818 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1819 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1820 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1821 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1822 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1823 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1824 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1825 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1826 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1827 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1828 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1829 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1830 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1831 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1832 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1833 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1834 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1835 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1836 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1837 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1838 default:
1839 return NULL;
1840 }
1841}
1842
fabcb361
RH		 1843static const char *
1844get_alpha_dynamic_type (unsigned long type)
1845{
1846 switch (type)
1847 {
1848 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1849 default:
1850 return NULL;
1851 }
1852}
1853
1c0d3aa6
NC		 1854static const char *
1855get_score_dynamic_type (unsigned long type)
1856{
1857 switch (type)
1858 {
1859 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1860 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1861 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1862 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1863 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1864 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1865 default:
1866 return NULL;
1867 }
1868}
1869
40b36596
JM		 1870static const char *
1871get_tic6x_dynamic_type (unsigned long type)
1872{
1873 switch (type)
1874 {
1875 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1876 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1877 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1878 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1879 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1880 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1881 default:
1882 return NULL;
1883 }
1884}
1c0d3aa6 1885
36591ba1
SL		 1886static const char *
1887get_nios2_dynamic_type (unsigned long type)
1888{
1889 switch (type)
1890 {
1891 case DT_NIOS2_GP: return "NIOS2_GP";
1892 default:
1893 return NULL;
1894 }
1895}
1896
252b5132 1897static const char *
d3ba0551 1898get_dynamic_type (unsigned long type)
252b5132 1899{
e9e44622 1900 static char buff[64];
252b5132
RH		 1901
1902 switch (type)
1903 {
1904 case DT_NULL: return "NULL";
1905 case DT_NEEDED: return "NEEDED";
1906 case DT_PLTRELSZ: return "PLTRELSZ";
1907 case DT_PLTGOT: return "PLTGOT";
1908 case DT_HASH: return "HASH";
1909 case DT_STRTAB: return "STRTAB";
1910 case DT_SYMTAB: return "SYMTAB";
1911 case DT_RELA: return "RELA";
1912 case DT_RELASZ: return "RELASZ";
1913 case DT_RELAENT: return "RELAENT";
1914 case DT_STRSZ: return "STRSZ";
1915 case DT_SYMENT: return "SYMENT";
1916 case DT_INIT: return "INIT";
1917 case DT_FINI: return "FINI";
1918 case DT_SONAME: return "SONAME";
1919 case DT_RPATH: return "RPATH";
1920 case DT_SYMBOLIC: return "SYMBOLIC";
1921 case DT_REL: return "REL";
1922 case DT_RELSZ: return "RELSZ";
1923 case DT_RELENT: return "RELENT";
1924 case DT_PLTREL: return "PLTREL";
1925 case DT_DEBUG: return "DEBUG";
1926 case DT_TEXTREL: return "TEXTREL";
1927 case DT_JMPREL: return "JMPREL";
1928 case DT_BIND_NOW: return "BIND_NOW";
1929 case DT_INIT_ARRAY: return "INIT_ARRAY";
1930 case DT_FINI_ARRAY: return "FINI_ARRAY";
1931 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1932 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1933 case DT_RUNPATH: return "RUNPATH";
1934 case DT_FLAGS: return "FLAGS";
2d0e6f43 1935
d1133906
NC		 1936 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1937 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1938
05107a46 1939 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1940 case DT_PLTPADSZ: return "PLTPADSZ";
1941 case DT_MOVEENT: return "MOVEENT";
1942 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1943 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1944 case DT_POSFLAG_1: return "POSFLAG_1";
1945 case DT_SYMINSZ: return "SYMINSZ";
1946 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1947
252b5132 1948 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1949 case DT_CONFIG: return "CONFIG";
1950 case DT_DEPAUDIT: return "DEPAUDIT";
1951 case DT_AUDIT: return "AUDIT";
1952 case DT_PLTPAD: return "PLTPAD";
1953 case DT_MOVETAB: return "MOVETAB";
252b5132 1954 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1955
252b5132 1956 case DT_VERSYM: return "VERSYM";
103f02d3 1957
67a4f2b7
AO		 1958 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1959 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1960 case DT_RELACOUNT: return "RELACOUNT";
1961 case DT_RELCOUNT: return "RELCOUNT";
1962 case DT_FLAGS_1: return "FLAGS_1";
1963 case DT_VERDEF: return "VERDEF";
1964 case DT_VERDEFNUM: return "VERDEFNUM";
1965 case DT_VERNEED: return "VERNEED";
1966 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1967
019148e4 1968 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1969 case DT_USED: return "USED";
1970 case DT_FILTER: return "FILTER";
103f02d3 1971
047b2264
JJ		 1972 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1973 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1974 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1975 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1976 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1977 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1978
252b5132
RH		 1979 default:
1980 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1981 {
2cf0635d 1982 const char * result;
103f02d3 1983
252b5132
RH		 1984 switch (elf_header.e_machine)
1985 {
1986 case EM_MIPS:
4fe85591 1987 case EM_MIPS_RS3_LE:
252b5132
RH		 1988 result = get_mips_dynamic_type (type);
1989 break;
9a097730
RH		 1990 case EM_SPARCV9:
1991 result = get_sparc64_dynamic_type (type);
1992 break;
7490d522
AM		 1993 case EM_PPC:
1994 result = get_ppc_dynamic_type (type);
1995 break;
f1cb7e17
AM		 1996 case EM_PPC64:
1997 result = get_ppc64_dynamic_type (type);
1998 break;
ecc51f48
NC		 1999 case EM_IA_64:
2000 result = get_ia64_dynamic_type (type);
2001 break;
fabcb361
RH		 2002 case EM_ALPHA:
2003 result = get_alpha_dynamic_type (type);
2004 break;
1c0d3aa6
NC		 2005 case EM_SCORE:
2006 result = get_score_dynamic_type (type);
2007 break;
40b36596
JM		 2008 case EM_TI_C6000:
2009 result = get_tic6x_dynamic_type (type);
2010 break;
36591ba1
SL		 2011 case EM_ALTERA_NIOS2:
2012 result = get_nios2_dynamic_type (type);
2013 break;
252b5132
RH		 2014 default:
2015 result = NULL;
2016 break;
2017 }
2018
2019 if (result != NULL)
2020 return result;
2021
e9e44622 2022 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 2023 }
eec8f817
DA		 2024 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2025 || (elf_header.e_machine == EM_PARISC
2026 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 2027 {
2cf0635d 2028 const char * result;
103f02d3
UD		 2029
2030 switch (elf_header.e_machine)
2031 {
2032 case EM_PARISC:
2033 result = get_parisc_dynamic_type (type);
2034 break;
148b93f2
NC		 2035 case EM_IA_64:
2036 result = get_ia64_dynamic_type (type);
2037 break;
103f02d3
UD		 2038 default:
2039 result = NULL;
2040 break;
2041 }
2042
2043 if (result != NULL)
2044 return result;
2045
e9e44622
JJ		 2046 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2047 type);
103f02d3 2048 }
252b5132 2049 else
e9e44622 2050 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 2051
252b5132
RH		 2052 return buff;
2053 }
2054}
2055
2056static char *
d3ba0551 2057get_file_type (unsigned e_type)
252b5132 2058{
b34976b6 2059 static char buff[32];
252b5132
RH		 2060
2061 switch (e_type)
2062 {
2063 case ET_NONE: return _("NONE (None)");
2064 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 2065 case ET_EXEC: return _("EXEC (Executable file)");
2066 case ET_DYN: return _("DYN (Shared object file)");
2067 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 2068
2069 default:
2070 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 2071 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 2072 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 2073 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 2074 else
e9e44622 2075 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 2076 return buff;
2077 }
2078}
2079
2080static char *
d3ba0551 2081get_machine_name (unsigned e_machine)
252b5132 2082{
b34976b6 2083 static char buff[64]; /* XXX */
252b5132
RH		 2084
2085 switch (e_machine)
2086 {
c45021f2 2087 case EM_NONE: return _("None");
a06ea964 2088 case EM_AARCH64: return "AArch64";
c45021f2
NC		 2089 case EM_M32: return "WE32100";
2090 case EM_SPARC: return "Sparc";
e9f53129 2091 case EM_SPU: return "SPU";
c45021f2
NC		 2092 case EM_386: return "Intel 80386";
2093 case EM_68K: return "MC68000";
2094 case EM_88K: return "MC88000";
22abe556 2095 case EM_IAMCU: return "Intel MCU";
c45021f2
NC		 2096 case EM_860: return "Intel 80860";
2097 case EM_MIPS: return "MIPS R3000";
2098 case EM_S370: return "IBM System/370";
7036c0e1 2099 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 2100 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 2101 case EM_PARISC: return "HPPA";
252b5132 2102 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 2103 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 2104 case EM_960: return "Intel 90860";
2105 case EM_PPC: return "PowerPC";
285d1771 2106 case EM_PPC64: return "PowerPC64";
c45021f2 2107 case EM_FR20: return "Fujitsu FR20";
3f8107ab 2108 case EM_FT32: return "FTDI FT32";
c45021f2 2109 case EM_RH32: return "TRW RH32";
b34976b6 2110 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 2111 case EM_ARM: return "ARM";
2112 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 2113 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 2114 case EM_SPARCV9: return "Sparc v9";
2115 case EM_TRICORE: return "Siemens Tricore";
584da044 2116 case EM_ARC: return "ARC";
c2dcd04e
NC		 2117 case EM_H8_300: return "Renesas H8/300";
2118 case EM_H8_300H: return "Renesas H8/300H";
2119 case EM_H8S: return "Renesas H8S";
2120 case EM_H8_500: return "Renesas H8/500";
30800947 2121 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 2122 case EM_MIPS_X: return "Stanford MIPS-X";
2123 case EM_COLDFIRE: return "Motorola Coldfire";
c45021f2 2124 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 2125 case EM_CYGNUS_D10V:
2126 case EM_D10V: return "d10v";
2127 case EM_CYGNUS_D30V:
b34976b6 2128 case EM_D30V: return "d30v";
2b0337b0 2129 case EM_CYGNUS_M32R:
26597c86 2130 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 2131 case EM_CYGNUS_V850:
708e2187 2132 case EM_V800: return "Renesas V850 (using RH850 ABI)";
f6c1a2d5 2133 case EM_V850: return "Renesas V850";
2b0337b0
AO		 2134 case EM_CYGNUS_MN10300:
2135 case EM_MN10300: return "mn10300";
2136 case EM_CYGNUS_MN10200:
2137 case EM_MN10200: return "mn10200";
5506d11a 2138 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 2139 case EM_CYGNUS_FR30:
2140 case EM_FR30: return "Fujitsu FR30";
b34976b6 2141 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 2142 case EM_PJ_OLD:
b34976b6 2143 case EM_PJ: return "picoJava";
7036c0e1
AJ		 2144 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2145 case EM_PCP: return "Siemens PCP";
2146 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2147 case EM_NDR1: return "Denso NDR1 microprocesspr";
2148 case EM_STARCORE: return "Motorola Star*Core processor";
2149 case EM_ME16: return "Toyota ME16 processor";
2150 case EM_ST100: return "STMicroelectronics ST100 processor";
2151 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 2152 case EM_PDSP: return "Sony DSP processor";
2153 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2154 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 2155 case EM_FX66: return "Siemens FX66 microcontroller";
2156 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2157 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2158 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
6927f982 2159 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ		 2160 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2161 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2162 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2163 case EM_SVX: return "Silicon Graphics SVx";
2164 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2165 case EM_VAX: return "Digital VAX";
619ed720 2166 case EM_VISIUM: return "CDS VISIUMcore processor";
2b0337b0 2167 case EM_AVR_OLD:
b34976b6 2168 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 2169 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 2170 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2171 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2172 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 2173 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 2174 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 2175 case EM_PRISM: return "Vitesse Prism";
bcedfee6 2176 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 2177 case EM_L1OM: return "Intel L1OM";
7a9068fe 2178 case EM_K1OM: return "Intel K1OM";
b7498e0e 2179 case EM_S390_OLD:
b34976b6 2180 case EM_S390: return "IBM S/390";
1c0d3aa6 2181 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 2182 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
73589c9d 2183 case EM_OR1K: return "OpenRISC 1000";
11636f9e 2184 case EM_ARC_A5: return "ARC International ARCompact processor";
1fe1f39c 2185 case EM_CRX: return "National Semiconductor CRX microprocessor";
cfb8c092 2186 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
d172d4ba 2187 case EM_DLX: return "OpenDLX";
1e4cf259 2188 case EM_IP2K_OLD:
b34976b6 2189 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 2190 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 2191 case EM_XTENSA_OLD:
2192 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 2193 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2194 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2195 case EM_NS32K: return "National Semiconductor 32000 series";
2196 case EM_TPC: return "Tenor Network TPC processor";
2197 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2198 case EM_MAX: return "MAX Processor";
2199 case EM_CR: return "National Semiconductor CompactRISC";
2200 case EM_F2MC16: return "Fujitsu F2MC16";
2201 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 2202 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 2203 case EM_M32C_OLD:
49f58d10 2204 case EM_M32C: return "Renesas M32c";
d031aafb 2205 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 2206 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 2207 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2208 case EM_SEP: return "Sharp embedded microprocessor";
2209 case EM_ARCA: return "Arca RISC microprocessor";
2210 case EM_UNICORE: return "Unicore";
2211 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2212 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 2213 case EM_NIOS32: return "Altera Nios";
2214 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 2215 case EM_C166:
d70c5fc7 2216 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 2217 case EM_M16C: return "Renesas M16C series microprocessors";
2218 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2219 case EM_CE: return "Freescale Communication Engine RISC core";
2220 case EM_TSK3000: return "Altium TSK3000 core";
2221 case EM_RS08: return "Freescale RS08 embedded processor";
2222 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2223 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2224 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2225 case EM_SE_C17: return "Seiko Epson C17 family";
2226 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2227 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2228 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2229 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2230 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2231 case EM_R32C: return "Renesas R32C series microprocessors";
2232 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2233 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2234 case EM_8051: return "Intel 8051 and variants";
2235 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2236 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2237 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2238 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2239 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2240 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2241 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 2242 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 2243 case EM_CR16:
f6c1a2d5 2244 case EM_MICROBLAZE:
7ba29e2a 2245 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
99c513f6 2246 case EM_RL78: return "Renesas RL78";
c7927a3c 2247 case EM_RX: return "Renesas RX";
a3c62988 2248 case EM_METAG: return "Imagination Technologies Meta processor architecture";
11636f9e
JM		 2249 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2250 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2251 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2252 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2253 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2254 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2255 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2256 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 2257 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 2258 case EM_CUDA: return "NVIDIA CUDA architecture";
f6c1a2d5 2259 case EM_XGATE: return "Motorola XGATE embedded processor";
252b5132 2260 default:
35d9dd2f 2261 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2262 return buff;
2263 }
2264}
2265
f3485b74 2266static void
d3ba0551 2267decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2268{
2269 unsigned eabi;
2270 int unknown = 0;
2271
2272 eabi = EF_ARM_EABI_VERSION (e_flags);
2273 e_flags &= ~ EF_ARM_EABIMASK;
2274
2275 /* Handle "generic" ARM flags. */
2276 if (e_flags & EF_ARM_RELEXEC)
2277 {
2278 strcat (buf, ", relocatable executable");
2279 e_flags &= ~ EF_ARM_RELEXEC;
2280 }
76da6bbe 2281
f3485b74
NC		 2282 /* Now handle EABI specific flags. */
2283 switch (eabi)
2284 {
2285 default:
2c71103e 2286 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2287 if (e_flags)
2288 unknown = 1;
2289 break;
2290
2291 case EF_ARM_EABI_VER1:
a5bcd848 2292 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2293 while (e_flags)
2294 {
2295 unsigned flag;
76da6bbe 2296
f3485b74
NC		 2297 /* Process flags one bit at a time. */
2298 flag = e_flags & - e_flags;
2299 e_flags &= ~ flag;
76da6bbe 2300
f3485b74
NC		 2301 switch (flag)
2302 {
a5bcd848 2303 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2304 strcat (buf, ", sorted symbol tables");
2305 break;
76da6bbe 2306
f3485b74
NC		 2307 default:
2308 unknown = 1;
2309 break;
2310 }
2311 }
2312 break;
76da6bbe 2313
a5bcd848
PB		 2314 case EF_ARM_EABI_VER2:
2315 strcat (buf, ", Version2 EABI");
2316 while (e_flags)
2317 {
2318 unsigned flag;
2319
2320 /* Process flags one bit at a time. */
2321 flag = e_flags & - e_flags;
2322 e_flags &= ~ flag;
2323
2324 switch (flag)
2325 {
2326 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2327 strcat (buf, ", sorted symbol tables");
2328 break;
2329
2330 case EF_ARM_DYNSYMSUSESEGIDX:
2331 strcat (buf, ", dynamic symbols use segment index");
2332 break;
2333
2334 case EF_ARM_MAPSYMSFIRST:
2335 strcat (buf, ", mapping symbols precede others");
2336 break;
2337
2338 default:
2339 unknown = 1;
2340 break;
2341 }
2342 }
2343 break;
2344
d507cf36
PB		 2345 case EF_ARM_EABI_VER3:
2346 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2347 break;
2348
2349 case EF_ARM_EABI_VER4:
2350 strcat (buf, ", Version4 EABI");
3bfcb652
NC		 2351 while (e_flags)
2352 {
2353 unsigned flag;
2354
2355 /* Process flags one bit at a time. */
2356 flag = e_flags & - e_flags;
2357 e_flags &= ~ flag;
2358
2359 switch (flag)
2360 {
2361 case EF_ARM_BE8:
2362 strcat (buf, ", BE8");
2363 break;
2364
2365 case EF_ARM_LE8:
2366 strcat (buf, ", LE8");
2367 break;
2368
2369 default:
2370 unknown = 1;
2371 break;
2372 }
2373 break;
2374 }
2375 break;
3a4a14e9
PB		 2376
2377 case EF_ARM_EABI_VER5:
2378 strcat (buf, ", Version5 EABI");
d507cf36
PB		 2379 while (e_flags)
2380 {
2381 unsigned flag;
2382
2383 /* Process flags one bit at a time. */
2384 flag = e_flags & - e_flags;
2385 e_flags &= ~ flag;
2386
2387 switch (flag)
2388 {
2389 case EF_ARM_BE8:
2390 strcat (buf, ", BE8");
2391 break;
2392
2393 case EF_ARM_LE8:
2394 strcat (buf, ", LE8");
2395 break;
2396
3bfcb652
NC		 2397 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2398 strcat (buf, ", soft-float ABI");
2399 break;
2400
2401 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2402 strcat (buf, ", hard-float ABI");
2403 break;
2404
d507cf36
PB		 2405 default:
2406 unknown = 1;
2407 break;
2408 }
2409 }
2410 break;
2411
f3485b74 2412 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2413 strcat (buf, ", GNU EABI");
f3485b74
NC		 2414 while (e_flags)
2415 {
2416 unsigned flag;
76da6bbe 2417
f3485b74
NC		 2418 /* Process flags one bit at a time. */
2419 flag = e_flags & - e_flags;
2420 e_flags &= ~ flag;
76da6bbe 2421
f3485b74
NC		 2422 switch (flag)
2423 {
a5bcd848 2424 case EF_ARM_INTERWORK:
f3485b74
NC		 2425 strcat (buf, ", interworking enabled");
2426 break;
76da6bbe 2427
a5bcd848 2428 case EF_ARM_APCS_26:
f3485b74
NC		 2429 strcat (buf, ", uses APCS/26");
2430 break;
76da6bbe 2431
a5bcd848 2432 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2433 strcat (buf, ", uses APCS/float");
2434 break;
76da6bbe 2435
a5bcd848 2436 case EF_ARM_PIC:
f3485b74
NC		 2437 strcat (buf, ", position independent");
2438 break;
76da6bbe 2439
a5bcd848 2440 case EF_ARM_ALIGN8:
f3485b74
NC		 2441 strcat (buf, ", 8 bit structure alignment");
2442 break;
76da6bbe 2443
a5bcd848 2444 case EF_ARM_NEW_ABI:
f3485b74
NC		 2445 strcat (buf, ", uses new ABI");
2446 break;
76da6bbe 2447
a5bcd848 2448 case EF_ARM_OLD_ABI:
f3485b74
NC		 2449 strcat (buf, ", uses old ABI");
2450 break;
76da6bbe 2451
a5bcd848 2452 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2453 strcat (buf, ", software FP");
2454 break;
76da6bbe 2455
90e01f86
ILT		 2456 case EF_ARM_VFP_FLOAT:
2457 strcat (buf, ", VFP");
2458 break;
2459
fde78edd
NC		 2460 case EF_ARM_MAVERICK_FLOAT:
2461 strcat (buf, ", Maverick FP");
2462 break;
2463
f3485b74
NC		 2464 default:
2465 unknown = 1;
2466 break;
2467 }
2468 }
2469 }
f3485b74
NC		 2470
2471 if (unknown)
2b692964 2472 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2473}
2474
343433df
AB		 2475static void
2476decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2477{
2478 --size; /* Leave space for null terminator. */
2479
2480 switch (e_flags & EF_AVR_MACH)
2481 {
2482 case E_AVR_MACH_AVR1:
2483 strncat (buf, ", avr:1", size);
2484 break;
2485 case E_AVR_MACH_AVR2:
2486 strncat (buf, ", avr:2", size);
2487 break;
2488 case E_AVR_MACH_AVR25:
2489 strncat (buf, ", avr:25", size);
2490 break;
2491 case E_AVR_MACH_AVR3:
2492 strncat (buf, ", avr:3", size);
2493 break;
2494 case E_AVR_MACH_AVR31:
2495 strncat (buf, ", avr:31", size);
2496 break;
2497 case E_AVR_MACH_AVR35:
2498 strncat (buf, ", avr:35", size);
2499 break;
2500 case E_AVR_MACH_AVR4:
2501 strncat (buf, ", avr:4", size);
2502 break;
2503 case E_AVR_MACH_AVR5:
2504 strncat (buf, ", avr:5", size);
2505 break;
2506 case E_AVR_MACH_AVR51:
2507 strncat (buf, ", avr:51", size);
2508 break;
2509 case E_AVR_MACH_AVR6:
2510 strncat (buf, ", avr:6", size);
2511 break;
2512 case E_AVR_MACH_AVRTINY:
2513 strncat (buf, ", avr:100", size);
2514 break;
2515 case E_AVR_MACH_XMEGA1:
2516 strncat (buf, ", avr:101", size);
2517 break;
2518 case E_AVR_MACH_XMEGA2:
2519 strncat (buf, ", avr:102", size);
2520 break;
2521 case E_AVR_MACH_XMEGA3:
2522 strncat (buf, ", avr:103", size);
2523 break;
2524 case E_AVR_MACH_XMEGA4:
2525 strncat (buf, ", avr:104", size);
2526 break;
2527 case E_AVR_MACH_XMEGA5:
2528 strncat (buf, ", avr:105", size);
2529 break;
2530 case E_AVR_MACH_XMEGA6:
2531 strncat (buf, ", avr:106", size);
2532 break;
2533 case E_AVR_MACH_XMEGA7:
2534 strncat (buf, ", avr:107", size);
2535 break;
2536 default:
2537 strncat (buf, ", avr:<unknown>", size);
2538 break;
2539 }
2540
2541 size -= strlen (buf);
2542 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2543 strncat (buf, ", link-relax", size);
2544}
2545
35c08157
KLC		 2546static void
2547decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2548{
2549 unsigned abi;
2550 unsigned arch;
2551 unsigned config;
2552 unsigned version;
2553 int has_fpu = 0;
2554 int r = 0;
2555
2556 static const char *ABI_STRINGS[] =
2557 {
2558 "ABI v0", /* use r5 as return register; only used in N1213HC */
2559 "ABI v1", /* use r0 as return register */
2560 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2561 "ABI v2fp", /* for FPU */
40c7a7cb
KLC		 2562 "AABI",
2563 "ABI2 FP+"
35c08157
KLC		 2564 };
2565 static const char *VER_STRINGS[] =
2566 {
2567 "Andes ELF V1.3 or older",
2568 "Andes ELF V1.3.1",
2569 "Andes ELF V1.4"
2570 };
2571 static const char *ARCH_STRINGS[] =
2572 {
2573 "",
2574 "Andes Star v1.0",
2575 "Andes Star v2.0",
2576 "Andes Star v3.0",
2577 "Andes Star v3.0m"
2578 };
2579
2580 abi = EF_NDS_ABI & e_flags;
2581 arch = EF_NDS_ARCH & e_flags;
2582 config = EF_NDS_INST & e_flags;
2583 version = EF_NDS32_ELF_VERSION & e_flags;
2584
2585 memset (buf, 0, size);
2586
2587 switch (abi)
2588 {
2589 case E_NDS_ABI_V0:
2590 case E_NDS_ABI_V1:
2591 case E_NDS_ABI_V2:
2592 case E_NDS_ABI_V2FP:
2593 case E_NDS_ABI_AABI:
40c7a7cb 2594 case E_NDS_ABI_V2FP_PLUS:
35c08157
KLC		 2595 /* In case there are holes in the array. */
2596 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2597 break;
2598
2599 default:
2600 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2601 break;
2602 }
2603
2604 switch (version)
2605 {
2606 case E_NDS32_ELF_VER_1_2:
2607 case E_NDS32_ELF_VER_1_3:
2608 case E_NDS32_ELF_VER_1_4:
2609 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2610 break;
2611
2612 default:
2613 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2614 break;
2615 }
2616
2617 if (E_NDS_ABI_V0 == abi)
2618 {
2619 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2620 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2621 if (arch == E_NDS_ARCH_STAR_V1_0)
2622 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2623 return;
2624 }
2625
2626 switch (arch)
2627 {
2628 case E_NDS_ARCH_STAR_V1_0:
2629 case E_NDS_ARCH_STAR_V2_0:
2630 case E_NDS_ARCH_STAR_V3_0:
2631 case E_NDS_ARCH_STAR_V3_M:
2632 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2633 break;
2634
2635 default:
2636 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2637 /* ARCH version determines how the e_flags are interpreted.
2638 If it is unknown, we cannot proceed. */
2639 return;
2640 }
2641
2642 /* Newer ABI; Now handle architecture specific flags. */
2643 if (arch == E_NDS_ARCH_STAR_V1_0)
2644 {
2645 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2646 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2647
2648 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2649 r += snprintf (buf + r, size -r, ", MAC");
2650
2651 if (config & E_NDS32_HAS_DIV_INST)
2652 r += snprintf (buf + r, size -r, ", DIV");
2653
2654 if (config & E_NDS32_HAS_16BIT_INST)
2655 r += snprintf (buf + r, size -r, ", 16b");
2656 }
2657 else
2658 {
2659 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2660 {
2661 if (version <= E_NDS32_ELF_VER_1_3)
2662 r += snprintf (buf + r, size -r, ", [B8]");
2663 else
2664 r += snprintf (buf + r, size -r, ", EX9");
2665 }
2666
2667 if (config & E_NDS32_HAS_MAC_DX_INST)
2668 r += snprintf (buf + r, size -r, ", MAC_DX");
2669
2670 if (config & E_NDS32_HAS_DIV_DX_INST)
2671 r += snprintf (buf + r, size -r, ", DIV_DX");
2672
2673 if (config & E_NDS32_HAS_16BIT_INST)
2674 {
2675 if (version <= E_NDS32_ELF_VER_1_3)
2676 r += snprintf (buf + r, size -r, ", 16b");
2677 else
2678 r += snprintf (buf + r, size -r, ", IFC");
2679 }
2680 }
2681
2682 if (config & E_NDS32_HAS_EXT_INST)
2683 r += snprintf (buf + r, size -r, ", PERF1");
2684
2685 if (config & E_NDS32_HAS_EXT2_INST)
2686 r += snprintf (buf + r, size -r, ", PERF2");
2687
2688 if (config & E_NDS32_HAS_FPU_INST)
2689 {
2690 has_fpu = 1;
2691 r += snprintf (buf + r, size -r, ", FPU_SP");
2692 }
2693
2694 if (config & E_NDS32_HAS_FPU_DP_INST)
2695 {
2696 has_fpu = 1;
2697 r += snprintf (buf + r, size -r, ", FPU_DP");
2698 }
2699
2700 if (config & E_NDS32_HAS_FPU_MAC_INST)
2701 {
2702 has_fpu = 1;
2703 r += snprintf (buf + r, size -r, ", FPU_MAC");
2704 }
2705
2706 if (has_fpu)
2707 {
2708 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2709 {
2710 case E_NDS32_FPU_REG_8SP_4DP:
2711 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2712 break;
2713 case E_NDS32_FPU_REG_16SP_8DP:
2714 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2715 break;
2716 case E_NDS32_FPU_REG_32SP_16DP:
2717 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2718 break;
2719 case E_NDS32_FPU_REG_32SP_32DP:
2720 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2721 break;
2722 }
2723 }
2724
2725 if (config & E_NDS32_HAS_AUDIO_INST)
2726 r += snprintf (buf + r, size -r, ", AUDIO");
2727
2728 if (config & E_NDS32_HAS_STRING_INST)
2729 r += snprintf (buf + r, size -r, ", STR");
2730
2731 if (config & E_NDS32_HAS_REDUCED_REGS)
2732 r += snprintf (buf + r, size -r, ", 16REG");
2733
2734 if (config & E_NDS32_HAS_VIDEO_INST)
2735 {
2736 if (version <= E_NDS32_ELF_VER_1_3)
2737 r += snprintf (buf + r, size -r, ", VIDEO");
2738 else
2739 r += snprintf (buf + r, size -r, ", SATURATION");
2740 }
2741
2742 if (config & E_NDS32_HAS_ENCRIPT_INST)
2743 r += snprintf (buf + r, size -r, ", ENCRP");
2744
2745 if (config & E_NDS32_HAS_L2C_INST)
2746 r += snprintf (buf + r, size -r, ", L2C");
2747}
2748
252b5132 2749static char *
d3ba0551 2750get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2751{
b34976b6 2752 static char buf[1024];
252b5132
RH		 2753
2754 buf[0] = '\0';
76da6bbe 2755
252b5132
RH		 2756 if (e_flags)
2757 {
2758 switch (e_machine)
2759 {
2760 default:
2761 break;
2762
f3485b74
NC		 2763 case EM_ARM:
2764 decode_ARM_machine_flags (e_flags, buf);
2765 break;
76da6bbe 2766
343433df
AB		 2767 case EM_AVR:
2768 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2769 break;
2770
781303ce
MF		 2771 case EM_BLACKFIN:
2772 if (e_flags & EF_BFIN_PIC)
2773 strcat (buf, ", PIC");
2774
2775 if (e_flags & EF_BFIN_FDPIC)
2776 strcat (buf, ", FDPIC");
2777
2778 if (e_flags & EF_BFIN_CODE_IN_L1)
2779 strcat (buf, ", code in L1");
2780
2781 if (e_flags & EF_BFIN_DATA_IN_L1)
2782 strcat (buf, ", data in L1");
2783
2784 break;
2785
ec2dfb42
AO		 2786 case EM_CYGNUS_FRV:
2787 switch (e_flags & EF_FRV_CPU_MASK)
2788 {
2789 case EF_FRV_CPU_GENERIC:
2790 break;
2791
2792 default:
2793 strcat (buf, ", fr???");
2794 break;
57346661 2795
ec2dfb42
AO		 2796 case EF_FRV_CPU_FR300:
2797 strcat (buf, ", fr300");
2798 break;
2799
2800 case EF_FRV_CPU_FR400:
2801 strcat (buf, ", fr400");
2802 break;
2803 case EF_FRV_CPU_FR405:
2804 strcat (buf, ", fr405");
2805 break;
2806
2807 case EF_FRV_CPU_FR450:
2808 strcat (buf, ", fr450");
2809 break;
2810
2811 case EF_FRV_CPU_FR500:
2812 strcat (buf, ", fr500");
2813 break;
2814 case EF_FRV_CPU_FR550:
2815 strcat (buf, ", fr550");
2816 break;
2817
2818 case EF_FRV_CPU_SIMPLE:
2819 strcat (buf, ", simple");
2820 break;
2821 case EF_FRV_CPU_TOMCAT:
2822 strcat (buf, ", tomcat");
2823 break;
2824 }
1c877e87 2825 break;
ec2dfb42 2826
53c7db4b 2827 case EM_68K:
425c6cb0 2828 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2829 strcat (buf, ", m68000");
425c6cb0 2830 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2831 strcat (buf, ", cpu32");
2832 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2833 strcat (buf, ", fido_a");
425c6cb0 2834 else
266abb8f 2835 {
2cf0635d
NC		 2836 char const * isa = _("unknown");
2837 char const * mac = _("unknown mac");
2838 char const * additional = NULL;
0112cd26 2839
c694fd50 2840 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2841 {
c694fd50 2842 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2843 isa = "A";
2844 additional = ", nodiv";
2845 break;
c694fd50 2846 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2847 isa = "A";
2848 break;
c694fd50 2849 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2850 isa = "A+";
2851 break;
c694fd50 2852 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2853 isa = "B";
2854 additional = ", nousp";
2855 break;
c694fd50 2856 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2857 isa = "B";
2858 break;
f608cd77
NS		 2859 case EF_M68K_CF_ISA_C:
2860 isa = "C";
2861 break;
2862 case EF_M68K_CF_ISA_C_NODIV:
2863 isa = "C";
2864 additional = ", nodiv";
2865 break;
266abb8f
NS		 2866 }
2867 strcat (buf, ", cf, isa ");
2868 strcat (buf, isa);
0b2e31dc
NS		 2869 if (additional)
2870 strcat (buf, additional);
c694fd50 2871 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2872 strcat (buf, ", float");
c694fd50 2873 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2874 {
2875 case 0:
2876 mac = NULL;
2877 break;
c694fd50 2878 case EF_M68K_CF_MAC:
266abb8f
NS		 2879 mac = "mac";
2880 break;
c694fd50 2881 case EF_M68K_CF_EMAC:
266abb8f
NS		 2882 mac = "emac";
2883 break;
f608cd77
NS		 2884 case EF_M68K_CF_EMAC_B:
2885 mac = "emac_b";
2886 break;
266abb8f
NS		 2887 }
2888 if (mac)
2889 {
2890 strcat (buf, ", ");
2891 strcat (buf, mac);
2892 }
266abb8f 2893 }
53c7db4b 2894 break;
33c63f9d 2895
153a2776
NC		 2896 case EM_CYGNUS_MEP:
2897 switch (e_flags & EF_MEP_CPU_MASK)
2898 {
2899 case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
2900 case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
2901 case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
2902 case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
2903 case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
2904 case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
2905 default: strcat (buf, _(", <unknown MeP cpu type>")); break;
2906 }
2907
2908 switch (e_flags & EF_MEP_COP_MASK)
2909 {
2910 case EF_MEP_COP_NONE: break;
2911 case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
2912 case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
2913 case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
2914 case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
2915 default: strcat (buf, _("<unknown MeP copro type>")); break;
2916 }
2917
2918 if (e_flags & EF_MEP_LIBRARY)
2919 strcat (buf, ", Built for Library");
2920
2921 if (e_flags & EF_MEP_INDEX_MASK)
2922 sprintf (buf + strlen (buf), ", Configuration Index: %#x",
2923 e_flags & EF_MEP_INDEX_MASK);
2924
2925 if (e_flags & ~ EF_MEP_ALL_FLAGS)
2926 sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
2927 e_flags & ~ EF_MEP_ALL_FLAGS);
2928 break;
2929
252b5132
RH		 2930 case EM_PPC:
2931 if (e_flags & EF_PPC_EMB)
2932 strcat (buf, ", emb");
2933
2934 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2935 strcat (buf, _(", relocatable"));
252b5132
RH		 2936
2937 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 2938 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 2939 break;
2940
ee67d69a
AM		 2941 case EM_PPC64:
2942 if (e_flags & EF_PPC64_ABI)
2943 {
2944 char abi[] = ", abiv0";
2945
2946 abi[6] += e_flags & EF_PPC64_ABI;
2947 strcat (buf, abi);
2948 }
2949 break;
2950
708e2187
NC		 2951 case EM_V800:
2952 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2953 strcat (buf, ", RH850 ABI");
0b4362b0 2954
708e2187
NC		 2955 if (e_flags & EF_V800_850E3)
2956 strcat (buf, ", V3 architecture");
2957
2958 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2959 strcat (buf, ", FPU not used");
2960
2961 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2962 strcat (buf, ", regmode: COMMON");
2963
2964 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2965 strcat (buf, ", r4 not used");
2966
2967 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2968 strcat (buf, ", r30 not used");
2969
2970 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2971 strcat (buf, ", r5 not used");
2972
2973 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2974 strcat (buf, ", r2 not used");
2975
2976 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2977 {
2978 switch (e_flags & - e_flags)
2979 {
2980 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2981 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
708e2187
NC		 2982 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2983 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
708e2187
NC		 2984 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2985 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2986 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2987 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2988 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2989 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2990 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2991 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2992 default: break;
2993 }
2994 }
2995 break;
2996
2b0337b0 2997 case EM_V850:
252b5132
RH		 2998 case EM_CYGNUS_V850:
2999 switch (e_flags & EF_V850_ARCH)
3000 {
78c8d46c
NC		 3001 case E_V850E3V5_ARCH:
3002 strcat (buf, ", v850e3v5");
3003 break;
1cd986c5
NC		 3004 case E_V850E2V3_ARCH:
3005 strcat (buf, ", v850e2v3");
3006 break;
3007 case E_V850E2_ARCH:
3008 strcat (buf, ", v850e2");
3009 break;
3010 case E_V850E1_ARCH:
3011 strcat (buf, ", v850e1");
8ad30312 3012 break;
252b5132
RH		 3013 case E_V850E_ARCH:
3014 strcat (buf, ", v850e");
3015 break;
252b5132
RH		 3016 case E_V850_ARCH:
3017 strcat (buf, ", v850");
3018 break;
3019 default:
2b692964 3020 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 3021 break;
3022 }
3023 break;
3024
2b0337b0 3025 case EM_M32R:
252b5132
RH		 3026 case EM_CYGNUS_M32R:
3027 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3028 strcat (buf, ", m32r");
252b5132
RH		 3029 break;
3030
3031 case EM_MIPS:
4fe85591 3032 case EM_MIPS_RS3_LE:
252b5132
RH		 3033 if (e_flags & EF_MIPS_NOREORDER)
3034 strcat (buf, ", noreorder");
3035
3036 if (e_flags & EF_MIPS_PIC)
3037 strcat (buf, ", pic");
3038
3039 if (e_flags & EF_MIPS_CPIC)
3040 strcat (buf, ", cpic");
3041
d1bdd336
TS		 3042 if (e_flags & EF_MIPS_UCODE)
3043 strcat (buf, ", ugen_reserved");
3044
252b5132
RH		 3045 if (e_flags & EF_MIPS_ABI2)
3046 strcat (buf, ", abi2");
3047
43521d43
TS		 3048 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3049 strcat (buf, ", odk first");
3050
a5d22d2a
TS		 3051 if (e_flags & EF_MIPS_32BITMODE)
3052 strcat (buf, ", 32bitmode");
3053
ba92f887
MR		 3054 if (e_flags & EF_MIPS_NAN2008)
3055 strcat (buf, ", nan2008");
3056
fef1b0b3
SE		 3057 if (e_flags & EF_MIPS_FP64)
3058 strcat (buf, ", fp64");
3059
156c2f8b
NC		 3060 switch ((e_flags & EF_MIPS_MACH))
3061 {
3062 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3063 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3064 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 3065 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 3066 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3067 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3068 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3069 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 3070 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 3071 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 3072 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3073 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 3074 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 3075 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 3076 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
d32e5c54 3077 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
52b6b6b9 3078 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 3079 case 0:
3080 /* We simply ignore the field in this case to avoid confusion:
3081 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3082 extension. */
3083 break;
2b692964 3084 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 3085 }
43521d43
TS		 3086
3087 switch ((e_flags & EF_MIPS_ABI))
3088 {
3089 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3090 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3091 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3092 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3093 case 0:
3094 /* We simply ignore the field in this case to avoid confusion:
3095 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3096 This means it is likely to be an o32 file, but not for
3097 sure. */
3098 break;
2b692964 3099 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 3100 }
3101
3102 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3103 strcat (buf, ", mdmx");
3104
3105 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3106 strcat (buf, ", mips16");
3107
df58fc94
RS		 3108 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3109 strcat (buf, ", micromips");
3110
43521d43
TS		 3111 switch ((e_flags & EF_MIPS_ARCH))
3112 {
3113 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3114 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3115 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3116 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3117 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3118 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 3119 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
7361da2c 3120 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
43521d43 3121 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 3122 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
7361da2c 3123 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
2b692964 3124 default: strcat (buf, _(", unknown ISA")); break;
43521d43 3125 }
252b5132 3126 break;
351b4b40 3127
35c08157
KLC		 3128 case EM_NDS32:
3129 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3130 break;
3131
ccde1100
AO		 3132 case EM_SH:
3133 switch ((e_flags & EF_SH_MACH_MASK))
3134 {
3135 case EF_SH1: strcat (buf, ", sh1"); break;
3136 case EF_SH2: strcat (buf, ", sh2"); break;
3137 case EF_SH3: strcat (buf, ", sh3"); break;
3138 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3139 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3140 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3141 case EF_SH3E: strcat (buf, ", sh3e"); break;
3142 case EF_SH4: strcat (buf, ", sh4"); break;
3143 case EF_SH5: strcat (buf, ", sh5"); break;
3144 case EF_SH2E: strcat (buf, ", sh2e"); break;
3145 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 3146 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 3147 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3148 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 3149 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 3150 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3151 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3152 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3153 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3154 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3155 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 3156 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 3157 }
3158
cec6a5b8
MR		 3159 if (e_flags & EF_SH_PIC)
3160 strcat (buf, ", pic");
3161
3162 if (e_flags & EF_SH_FDPIC)
3163 strcat (buf, ", fdpic");
ccde1100 3164 break;
948f632f 3165
73589c9d
CS		 3166 case EM_OR1K:
3167 if (e_flags & EF_OR1K_NODELAY)
3168 strcat (buf, ", no delay");
3169 break;
57346661 3170
351b4b40
RH		 3171 case EM_SPARCV9:
3172 if (e_flags & EF_SPARC_32PLUS)
3173 strcat (buf, ", v8+");
3174
3175 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 3176 strcat (buf, ", ultrasparcI");
3177
3178 if (e_flags & EF_SPARC_SUN_US3)
3179 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 3180
3181 if (e_flags & EF_SPARC_HAL_R1)
3182 strcat (buf, ", halr1");
3183
3184 if (e_flags & EF_SPARC_LEDATA)
3185 strcat (buf, ", ledata");
3186
3187 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3188 strcat (buf, ", tso");
3189
3190 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3191 strcat (buf, ", pso");
3192
3193 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3194 strcat (buf, ", rmo");
3195 break;
7d466069 3196
103f02d3
UD		 3197 case EM_PARISC:
3198 switch (e_flags & EF_PARISC_ARCH)
3199 {
3200 case EFA_PARISC_1_0:
3201 strcpy (buf, ", PA-RISC 1.0");
3202 break;
3203 case EFA_PARISC_1_1:
3204 strcpy (buf, ", PA-RISC 1.1");
3205 break;
3206 case EFA_PARISC_2_0:
3207 strcpy (buf, ", PA-RISC 2.0");
3208 break;
3209 default:
3210 break;
3211 }
3212 if (e_flags & EF_PARISC_TRAPNIL)
3213 strcat (buf, ", trapnil");
3214 if (e_flags & EF_PARISC_EXT)
3215 strcat (buf, ", ext");
3216 if (e_flags & EF_PARISC_LSB)
3217 strcat (buf, ", lsb");
3218 if (e_flags & EF_PARISC_WIDE)
3219 strcat (buf, ", wide");
3220 if (e_flags & EF_PARISC_NO_KABP)
3221 strcat (buf, ", no kabp");
3222 if (e_flags & EF_PARISC_LAZYSWAP)
3223 strcat (buf, ", lazyswap");
30800947 3224 break;
76da6bbe 3225
7d466069 3226 case EM_PJ:
2b0337b0 3227 case EM_PJ_OLD:
7d466069
ILT		 3228 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3229 strcat (buf, ", new calling convention");
3230
3231 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3232 strcat (buf, ", gnu calling convention");
3233 break;
4d6ed7c8
NC		 3234
3235 case EM_IA_64:
3236 if ((e_flags & EF_IA_64_ABI64))
3237 strcat (buf, ", 64-bit");
3238 else
3239 strcat (buf, ", 32-bit");
3240 if ((e_flags & EF_IA_64_REDUCEDFP))
3241 strcat (buf, ", reduced fp model");
3242 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3243 strcat (buf, ", no function descriptors, constant gp");
3244 else if ((e_flags & EF_IA_64_CONS_GP))
3245 strcat (buf, ", constant gp");
3246 if ((e_flags & EF_IA_64_ABSOLUTE))
3247 strcat (buf, ", absolute");
28f997cf
TG		 3248 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3249 {
3250 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3251 strcat (buf, ", vms_linkages");
3252 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3253 {
3254 case EF_IA_64_VMS_COMCOD_SUCCESS:
3255 break;
3256 case EF_IA_64_VMS_COMCOD_WARNING:
3257 strcat (buf, ", warning");
3258 break;
3259 case EF_IA_64_VMS_COMCOD_ERROR:
3260 strcat (buf, ", error");
3261 break;
3262 case EF_IA_64_VMS_COMCOD_ABORT:
3263 strcat (buf, ", abort");
3264 break;
3265 default:
bee0ee85
NC		 3266 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3267 e_flags & EF_IA_64_VMS_COMCOD);
3268 strcat (buf, ", <unknown>");
28f997cf
TG		 3269 }
3270 }
4d6ed7c8 3271 break;
179d3252
JT		 3272
3273 case EM_VAX:
3274 if ((e_flags & EF_VAX_NONPIC))
3275 strcat (buf, ", non-PIC");
3276 if ((e_flags & EF_VAX_DFLOAT))
3277 strcat (buf, ", D-Float");
3278 if ((e_flags & EF_VAX_GFLOAT))
3279 strcat (buf, ", G-Float");
3280 break;
c7927a3c 3281
619ed720
EB		 3282 case EM_VISIUM:
3283 if (e_flags & EF_VISIUM_ARCH_MCM)
3284 strcat (buf, ", mcm");
3285 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3286 strcat (buf, ", mcm24");
3287 if (e_flags & EF_VISIUM_ARCH_GR6)
3288 strcat (buf, ", gr6");
3289 break;
3290
4046d87a 3291 case EM_RL78:
1740ba0c
NC		 3292 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3293 {
3294 case E_FLAG_RL78_ANY_CPU: break;
3295 case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3296 case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3297 case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3298 }
856ea05c
KP		 3299 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3300 strcat (buf, ", 64-bit doubles");
4046d87a 3301 break;
0b4362b0 3302
c7927a3c
NC		 3303 case EM_RX:
3304 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3305 strcat (buf, ", 64-bit doubles");
3306 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 3307 strcat (buf, ", dsp");
d4cb0ea0 3308 if (e_flags & E_FLAG_RX_PID)
0b4362b0 3309 strcat (buf, ", pid");
708e2187
NC		 3310 if (e_flags & E_FLAG_RX_ABI)
3311 strcat (buf, ", RX ABI");
3525236c
NC		 3312 if (e_flags & E_FLAG_RX_SINSNS_SET)
3313 strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3314 ? ", uses String instructions" : ", bans String instructions");
d4cb0ea0 3315 break;
55786da2
AK		 3316
3317 case EM_S390:
3318 if (e_flags & EF_S390_HIGH_GPRS)
3319 strcat (buf, ", highgprs");
d4cb0ea0 3320 break;
40b36596
JM		 3321
3322 case EM_TI_C6000:
3323 if ((e_flags & EF_C6000_REL))
3324 strcat (buf, ", relocatable module");
d4cb0ea0 3325 break;
13761a11
NC		 3326
3327 case EM_MSP430:
3328 strcat (buf, _(": architecture variant: "));
3329 switch (e_flags & EF_MSP430_MACH)
3330 {
3331 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3332 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3333 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3334 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3335 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3336 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3337 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3338 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3339 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3340 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3341 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3342 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3343 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3344 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3345 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3346 default:
3347 strcat (buf, _(": unknown")); break;
3348 }
3349
3350 if (e_flags & ~ EF_MSP430_MACH)
3351 strcat (buf, _(": unknown extra flag bits also present"));
252b5132
RH		 3352 }
3353 }
3354
3355 return buf;
3356}
3357
252b5132 3358static const char *
d3ba0551
AM		 3359get_osabi_name (unsigned int osabi)
3360{
3361 static char buff[32];
3362
3363 switch (osabi)
3364 {
3365 case ELFOSABI_NONE: return "UNIX - System V";
3366 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3367 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 3368 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 3369 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3370 case ELFOSABI_AIX: return "UNIX - AIX";
3371 case ELFOSABI_IRIX: return "UNIX - IRIX";
3372 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3373 case ELFOSABI_TRU64: return "UNIX - TRU64";
3374 case ELFOSABI_MODESTO: return "Novell - Modesto";
3375 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3376 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3377 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 3378 case ELFOSABI_AROS: return "AROS";
11636f9e 3379 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 3380 default:
40b36596
JM		 3381 if (osabi >= 64)
3382 switch (elf_header.e_machine)
3383 {
3384 case EM_ARM:
3385 switch (osabi)
3386 {
3387 case ELFOSABI_ARM: return "ARM";
3388 default:
3389 break;
3390 }
3391 break;
3392
3393 case EM_MSP430:
3394 case EM_MSP430_OLD:
619ed720 3395 case EM_VISIUM:
40b36596
JM		 3396 switch (osabi)
3397 {
3398 case ELFOSABI_STANDALONE: return _("Standalone App");
3399 default:
3400 break;
3401 }
3402 break;
3403
3404 case EM_TI_C6000:
3405 switch (osabi)
3406 {
3407 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3408 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3409 default:
3410 break;
3411 }
3412 break;
3413
3414 default:
3415 break;
3416 }
e9e44622 3417 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 3418 return buff;
3419 }
3420}
3421
a06ea964
NC		 3422static const char *
3423get_aarch64_segment_type (unsigned long type)
3424{
3425 switch (type)
3426 {
3427 case PT_AARCH64_ARCHEXT:
3428 return "AARCH64_ARCHEXT";
3429 default:
3430 break;
3431 }
3432
3433 return NULL;
3434}
3435
b294bdf8
MM		 3436static const char *
3437get_arm_segment_type (unsigned long type)
3438{
3439 switch (type)
3440 {
3441 case PT_ARM_EXIDX:
3442 return "EXIDX";
3443 default:
3444 break;
3445 }
3446
3447 return NULL;
3448}
3449
d3ba0551
AM		 3450static const char *
3451get_mips_segment_type (unsigned long type)
252b5132
RH		 3452{
3453 switch (type)
3454 {
3455 case PT_MIPS_REGINFO:
3456 return "REGINFO";
3457 case PT_MIPS_RTPROC:
3458 return "RTPROC";
3459 case PT_MIPS_OPTIONS:
3460 return "OPTIONS";
351cdf24
MF		 3461 case PT_MIPS_ABIFLAGS:
3462 return "ABIFLAGS";
252b5132
RH		 3463 default:
3464 break;
3465 }
3466
3467 return NULL;
3468}
3469
103f02d3 3470static const char *
d3ba0551 3471get_parisc_segment_type (unsigned long type)
103f02d3
UD		 3472{
3473 switch (type)
3474 {
3475 case PT_HP_TLS: return "HP_TLS";
3476 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3477 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3478 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3479 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3480 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3481 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3482 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3483 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3484 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3485 case PT_HP_PARALLEL: return "HP_PARALLEL";
3486 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 3487 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3488 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3489 case PT_HP_STACK: return "HP_STACK";
3490 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 3491 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3492 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 3493 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 3494 default:
3495 break;
3496 }
3497
3498 return NULL;
3499}
3500
4d6ed7c8 3501static const char *
d3ba0551 3502get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 3503{
3504 switch (type)
3505 {
3506 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3507 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 3508 case PT_HP_TLS: return "HP_TLS";
3509 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3510 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3511 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 3512 default:
3513 break;
3514 }
3515
3516 return NULL;
3517}
3518
40b36596
JM		 3519static const char *
3520get_tic6x_segment_type (unsigned long type)
3521{
3522 switch (type)
3523 {
3524 case PT_C6000_PHATTR: return "C6000_PHATTR";
3525 default:
3526 break;
3527 }
3528
3529 return NULL;
3530}
3531
252b5132 3532static const char *
d3ba0551 3533get_segment_type (unsigned long p_type)
252b5132 3534{
b34976b6 3535 static char buff[32];
252b5132
RH		 3536
3537 switch (p_type)
3538 {
b34976b6
AM		 3539 case PT_NULL: return "NULL";
3540 case PT_LOAD: return "LOAD";
252b5132 3541 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 3542 case PT_INTERP: return "INTERP";
3543 case PT_NOTE: return "NOTE";
3544 case PT_SHLIB: return "SHLIB";
3545 case PT_PHDR: return "PHDR";
13ae64f3 3546 case PT_TLS: return "TLS";
252b5132 3547
65765700
JJ		 3548 case PT_GNU_EH_FRAME:
3549 return "GNU_EH_FRAME";
2b05f1b7 3550 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 3551 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 3552
252b5132
RH		 3553 default:
3554 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3555 {
2cf0635d 3556 const char * result;
103f02d3 3557
252b5132
RH		 3558 switch (elf_header.e_machine)
3559 {
a06ea964
NC		 3560 case EM_AARCH64:
3561 result = get_aarch64_segment_type (p_type);
3562 break;
b294bdf8
MM		 3563 case EM_ARM:
3564 result = get_arm_segment_type (p_type);
3565 break;
252b5132 3566 case EM_MIPS:
4fe85591 3567 case EM_MIPS_RS3_LE:
252b5132
RH		 3568 result = get_mips_segment_type (p_type);
3569 break;
103f02d3
UD		 3570 case EM_PARISC:
3571 result = get_parisc_segment_type (p_type);
3572 break;
4d6ed7c8
NC		 3573 case EM_IA_64:
3574 result = get_ia64_segment_type (p_type);
3575 break;
40b36596
JM		 3576 case EM_TI_C6000:
3577 result = get_tic6x_segment_type (p_type);
3578 break;
252b5132
RH		 3579 default:
3580 result = NULL;
3581 break;
3582 }
103f02d3 3583
252b5132
RH		 3584 if (result != NULL)
3585 return result;
103f02d3 3586
252b5132
RH		 3587 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3588 }
3589 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3590 {
2cf0635d 3591 const char * result;
103f02d3
UD		 3592
3593 switch (elf_header.e_machine)
3594 {
3595 case EM_PARISC:
3596 result = get_parisc_segment_type (p_type);
3597 break;
00428cca
AM		 3598 case EM_IA_64:
3599 result = get_ia64_segment_type (p_type);
3600 break;
103f02d3
UD		 3601 default:
3602 result = NULL;
3603 break;
3604 }
3605
3606 if (result != NULL)
3607 return result;
3608
3609 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3610 }
252b5132 3611 else
e9e44622 3612 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3613
3614 return buff;
3615 }
3616}
3617
3618static const char *
d3ba0551 3619get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3620{
3621 switch (sh_type)
3622 {
b34976b6
AM		 3623 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3624 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3625 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3626 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3627 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3628 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3629 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3630 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3631 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3632 case SHT_MIPS_RELD: return "MIPS_RELD";
3633 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3634 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3635 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3636 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3637 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3638 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3639 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3640 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3641 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3642 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3643 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3644 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3645 case SHT_MIPS_LINE: return "MIPS_LINE";
3646 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3647 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3648 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3649 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3650 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3651 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3652 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3653 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3654 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3655 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3656 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3657 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3658 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3659 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3660 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132 3661 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
351cdf24 3662 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
252b5132
RH		 3663 default:
3664 break;
3665 }
3666 return NULL;
3667}
3668
103f02d3 3669static const char *
d3ba0551 3670get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3671{
3672 switch (sh_type)
3673 {
3674 case SHT_PARISC_EXT: return "PARISC_EXT";
3675 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3676 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3677 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3678 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3679 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3680 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3681 default:
3682 break;
3683 }
3684 return NULL;
3685}
3686
4d6ed7c8 3687static const char *
d3ba0551 3688get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3689{
18bd398b 3690 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3691 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3692 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3693
4d6ed7c8
NC		 3694 switch (sh_type)
3695 {
148b93f2
NC		 3696 case SHT_IA_64_EXT: return "IA_64_EXT";
3697 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3698 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3699 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3700 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3701 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3702 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3703 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3704 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3705 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3706 default:
3707 break;
3708 }
3709 return NULL;
3710}
3711
d2b2c203
DJ		 3712static const char *
3713get_x86_64_section_type_name (unsigned int sh_type)
3714{
3715 switch (sh_type)
3716 {
3717 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3718 default:
3719 break;
3720 }
3721 return NULL;
3722}
3723
a06ea964
NC		 3724static const char *
3725get_aarch64_section_type_name (unsigned int sh_type)
3726{
3727 switch (sh_type)
3728 {
3729 case SHT_AARCH64_ATTRIBUTES:
3730 return "AARCH64_ATTRIBUTES";
3731 default:
3732 break;
3733 }
3734 return NULL;
3735}
3736
40a18ebd
NC		 3737static const char *
3738get_arm_section_type_name (unsigned int sh_type)
3739{
3740 switch (sh_type)
3741 {
7f6fed87
NC		 3742 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3743 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3744 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3745 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3746 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3747 default:
3748 break;
3749 }
3750 return NULL;
3751}
3752
40b36596
JM		 3753static const char *
3754get_tic6x_section_type_name (unsigned int sh_type)
3755{
3756 switch (sh_type)
3757 {
3758 case SHT_C6000_UNWIND:
3759 return "C6000_UNWIND";
3760 case SHT_C6000_PREEMPTMAP:
3761 return "C6000_PREEMPTMAP";
3762 case SHT_C6000_ATTRIBUTES:
3763 return "C6000_ATTRIBUTES";
3764 case SHT_TI_ICODE:
3765 return "TI_ICODE";
3766 case SHT_TI_XREF:
3767 return "TI_XREF";
3768 case SHT_TI_HANDLER:
3769 return "TI_HANDLER";
3770 case SHT_TI_INITINFO:
3771 return "TI_INITINFO";
3772 case SHT_TI_PHATTRS:
3773 return "TI_PHATTRS";
3774 default:
3775 break;
3776 }
3777 return NULL;
3778}
3779
13761a11
NC		 3780static const char *
3781get_msp430x_section_type_name (unsigned int sh_type)
3782{
3783 switch (sh_type)
3784 {
3785 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3786 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3787 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3788 default: return NULL;
3789 }
3790}
3791
685080f2
NC		 3792static const char *
3793get_v850_section_type_name (unsigned int sh_type)
3794{
3795 switch (sh_type)
3796 {
3797 case SHT_V850_SCOMMON: return "V850 Small Common";
3798 case SHT_V850_TCOMMON: return "V850 Tiny Common";
3799 case SHT_V850_ZCOMMON: return "V850 Zero Common";
3800 case SHT_RENESAS_IOP: return "RENESAS IOP";
3801 case SHT_RENESAS_INFO: return "RENESAS INFO";
3802 default: return NULL;
3803 }
3804}
3805
252b5132 3806static const char *
d3ba0551 3807get_section_type_name (unsigned int sh_type)
252b5132 3808{
b34976b6 3809 static char buff[32];
252b5132
RH		 3810
3811 switch (sh_type)
3812 {
3813 case SHT_NULL: return "NULL";
3814 case SHT_PROGBITS: return "PROGBITS";
3815 case SHT_SYMTAB: return "SYMTAB";
3816 case SHT_STRTAB: return "STRTAB";
3817 case SHT_RELA: return "RELA";
3818 case SHT_HASH: return "HASH";
3819 case SHT_DYNAMIC: return "DYNAMIC";
3820 case SHT_NOTE: return "NOTE";
3821 case SHT_NOBITS: return "NOBITS";
3822 case SHT_REL: return "REL";
3823 case SHT_SHLIB: return "SHLIB";
3824 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3825 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3826 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3827 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3828 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3829 case SHT_GROUP: return "GROUP";
3830 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3831 case SHT_GNU_verdef: return "VERDEF";
3832 case SHT_GNU_verneed: return "VERNEED";
3833 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3834 case 0x6ffffff0: return "VERSYM";
3835 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3836 case 0x7ffffffd: return "AUXILIARY";
3837 case 0x7fffffff: return "FILTER";
047b2264 3838 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3839
3840 default:
3841 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3842 {
2cf0635d 3843 const char * result;
252b5132
RH		 3844
3845 switch (elf_header.e_machine)
3846 {
3847 case EM_MIPS:
4fe85591 3848 case EM_MIPS_RS3_LE:
252b5132
RH		 3849 result = get_mips_section_type_name (sh_type);
3850 break;
103f02d3
UD		 3851 case EM_PARISC:
3852 result = get_parisc_section_type_name (sh_type);
3853 break;
4d6ed7c8
NC		 3854 case EM_IA_64:
3855 result = get_ia64_section_type_name (sh_type);
3856 break;
d2b2c203 3857 case EM_X86_64:
8a9036a4 3858 case EM_L1OM:
7a9068fe 3859 case EM_K1OM:
d2b2c203
DJ		 3860 result = get_x86_64_section_type_name (sh_type);
3861 break;
a06ea964
NC		 3862 case EM_AARCH64:
3863 result = get_aarch64_section_type_name (sh_type);
3864 break;
40a18ebd
NC		 3865 case EM_ARM:
3866 result = get_arm_section_type_name (sh_type);
3867 break;
40b36596
JM		 3868 case EM_TI_C6000:
3869 result = get_tic6x_section_type_name (sh_type);
3870 break;
13761a11
NC		 3871 case EM_MSP430:
3872 result = get_msp430x_section_type_name (sh_type);
3873 break;
685080f2
NC		 3874 case EM_V800:
3875 case EM_V850:
3876 case EM_CYGNUS_V850:
3877 result = get_v850_section_type_name (sh_type);
3878 break;
252b5132
RH		 3879 default:
3880 result = NULL;
3881 break;
3882 }
3883
3884 if (result != NULL)
3885 return result;
3886
c91d0dfb 3887 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3888 }
3889 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3890 {
2cf0635d 3891 const char * result;
148b93f2
NC		 3892
3893 switch (elf_header.e_machine)
3894 {
3895 case EM_IA_64:
3896 result = get_ia64_section_type_name (sh_type);
3897 break;
3898 default:
3899 result = NULL;
3900 break;
3901 }
3902
3903 if (result != NULL)
3904 return result;
3905
3906 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3907 }
252b5132 3908 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
685080f2
NC		 3909 {
3910 switch (elf_header.e_machine)
3911 {
3912 case EM_V800:
3913 case EM_V850:
3914 case EM_CYGNUS_V850:
3915 return get_v850_section_type_name (sh_type);
3916 default:
3917 break;
3918 }
3919
3920 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3921 }
252b5132 3922 else
a7dbfd1c
NC		 3923 /* This message is probably going to be displayed in a 15
3924 character wide field, so put the hex value first. */
3925 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3926
252b5132
RH		 3927 return buff;
3928 }
3929}
3930
2979dc34 3931#define OPTION_DEBUG_DUMP 512
2c610e4b 3932#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3933#define OPTION_DWARF_DEPTH 514
3934#define OPTION_DWARF_START 515
4723351a 3935#define OPTION_DWARF_CHECK 516
2979dc34 3936
85b1c36d 3937static struct option options[] =
252b5132 3938{
b34976b6 3939 {"all", no_argument, 0, 'a'},
252b5132
RH		 3940 {"file-header", no_argument, 0, 'h'},
3941 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3942 {"headers", no_argument, 0, 'e'},
3943 {"histogram", no_argument, 0, 'I'},
3944 {"segments", no_argument, 0, 'l'},
3945 {"sections", no_argument, 0, 'S'},
252b5132 3946 {"section-headers", no_argument, 0, 'S'},
f5842774 3947 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3948 {"section-details", no_argument, 0, 't'},
595cf52e 3949 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3950 {"symbols", no_argument, 0, 's'},
3951 {"syms", no_argument, 0, 's'},
2c610e4b 3952 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3953 {"relocs", no_argument, 0, 'r'},
3954 {"notes", no_argument, 0, 'n'},
3955 {"dynamic", no_argument, 0, 'd'},
a952a375 3956 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3957 {"version-info", no_argument, 0, 'V'},
3958 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3959 {"unwind", no_argument, 0, 'u'},
4145f1d5 3960 {"archive-index", no_argument, 0, 'c'},
b34976b6 3961 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3962 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3963 {"string-dump", required_argument, 0, 'p'},
0e602686 3964 {"decompress", no_argument, 0, 'z'},
252b5132
RH		 3965#ifdef SUPPORT_DISASSEMBLY
3966 {"instruction-dump", required_argument, 0, 'i'},
3967#endif
cf13d699 3968 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3969
fd2f0033
TT		 3970 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3971 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 3972 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 3973
b34976b6
AM		 3974 {"version", no_argument, 0, 'v'},
3975 {"wide", no_argument, 0, 'W'},
3976 {"help", no_argument, 0, 'H'},
3977 {0, no_argument, 0, 0}
252b5132
RH		 3978};
3979
3980static void
2cf0635d 3981usage (FILE * stream)
252b5132 3982{
92f01d61
JM		 3983 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3984 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3985 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3986 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3987 -h --file-header Display the ELF file header\n\
3988 -l --program-headers Display the program headers\n\
3989 --segments An alias for --program-headers\n\
3990 -S --section-headers Display the sections' header\n\
3991 --sections An alias for --section-headers\n\
f5842774 3992 -g --section-groups Display the section groups\n\
5477e8a0 3993 -t --section-details Display the section details\n\
8b53311e
NC		 3994 -e --headers Equivalent to: -h -l -S\n\
3995 -s --syms Display the symbol table\n\
3f08eb35 3996 --symbols An alias for --syms\n\
2c610e4b 3997 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3998 -n --notes Display the core notes (if present)\n\
3999 -r --relocs Display the relocations (if present)\n\
4000 -u --unwind Display the unwind info (if present)\n\
b2d38a17 4001 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 4002 -V --version-info Display the version sections (if present)\n\
1b31d05e 4003 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 4004 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 4005 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 4006 -x --hex-dump=<number|name>\n\
4007 Dump the contents of section <number|name> as bytes\n\
4008 -p --string-dump=<number|name>\n\
4009 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 4010 -R --relocated-dump=<number|name>\n\
4011 Dump the contents of section <number|name> as relocated bytes\n\
0e602686 4012 -z --decompress Decompress section before dumping it\n\
f9f0e732 4013 -w[lLiaprmfFsoRt] or\n\
1ed06042 4014 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 4015 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 4016 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4017 =addr,=cu_index]\n\
8b53311e 4018 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 4019 fprintf (stream, _("\
4020 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4021 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4022 or deeper\n"));
252b5132 4023#ifdef SUPPORT_DISASSEMBLY
92f01d61 4024 fprintf (stream, _("\
09c11c86
NC		 4025 -i --instruction-dump=<number|name>\n\
4026 Disassemble the contents of section <number|name>\n"));
252b5132 4027#endif
92f01d61 4028 fprintf (stream, _("\
8b53311e
NC		 4029 -I --histogram Display histogram of bucket list lengths\n\
4030 -W --wide Allow output width to exceed 80 characters\n\
07012eee 4031 @<file> Read options from <file>\n\
8b53311e
NC		 4032 -H --help Display this information\n\
4033 -v --version Display the version number of readelf\n"));
1118d252 4034
92f01d61
JM		 4035 if (REPORT_BUGS_TO[0] && stream == stdout)
4036 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 4037
92f01d61 4038 exit (stream == stdout ? 0 : 1);
252b5132
RH		 4039}
4040
18bd398b
NC		 4041/* Record the fact that the user wants the contents of section number
4042 SECTION to be displayed using the method(s) encoded as flags bits
4043 in TYPE. Note, TYPE can be zero if we are creating the array for
4044 the first time. */
4045
252b5132 4046static void
09c11c86 4047request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 4048{
4049 if (section >= num_dump_sects)
4050 {
2cf0635d 4051 dump_type * new_dump_sects;
252b5132 4052
3f5e193b
NC		 4053 new_dump_sects = (dump_type *) calloc (section + 1,
4054 sizeof (* dump_sects));
252b5132
RH		 4055
4056 if (new_dump_sects == NULL)
591a748a 4057 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 4058 else
4059 {
4060 /* Copy current flag settings. */
09c11c86 4061 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 4062
4063 free (dump_sects);
4064
4065 dump_sects = new_dump_sects;
4066 num_dump_sects = section + 1;
4067 }
4068 }
4069
4070 if (dump_sects)
b34976b6 4071 dump_sects[section] |= type;
252b5132
RH		 4072
4073 return;
4074}
4075
aef1f6d0
DJ		 4076/* Request a dump by section name. */
4077
4078static void
2cf0635d 4079request_dump_byname (const char * section, dump_type type)
aef1f6d0 4080{
2cf0635d 4081 struct dump_list_entry * new_request;
aef1f6d0 4082
3f5e193b
NC		 4083 new_request = (struct dump_list_entry *)
4084 malloc (sizeof (struct dump_list_entry));
aef1f6d0 4085 if (!new_request)
591a748a 4086 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4087
4088 new_request->name = strdup (section);
4089 if (!new_request->name)
591a748a 4090 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4091
4092 new_request->type = type;
4093
4094 new_request->next = dump_sects_byname;
4095 dump_sects_byname = new_request;
4096}
4097
cf13d699
NC		 4098static inline void
4099request_dump (dump_type type)
4100{
4101 int section;
4102 char * cp;
4103
4104 do_dump++;
4105 section = strtoul (optarg, & cp, 0);
4106
4107 if (! *cp && section >= 0)
4108 request_dump_bynumber (section, type);
4109 else
4110 request_dump_byname (optarg, type);
4111}
4112
4113
252b5132 4114static void
2cf0635d 4115parse_args (int argc, char ** argv)
252b5132
RH		 4116{
4117 int c;
4118
4119 if (argc < 2)
92f01d61 4120 usage (stderr);
252b5132
RH		 4121
4122 while ((c = getopt_long
0e602686 4123 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
252b5132 4124 {
252b5132
RH		 4125 switch (c)
4126 {
4127 case 0:
4128 /* Long options. */
4129 break;
4130 case 'H':
92f01d61 4131 usage (stdout);
252b5132
RH		 4132 break;
4133
4134 case 'a':
b34976b6
AM		 4135 do_syms++;
4136 do_reloc++;
4137 do_unwind++;
4138 do_dynamic++;
4139 do_header++;
4140 do_sections++;
f5842774 4141 do_section_groups++;
b34976b6
AM		 4142 do_segments++;
4143 do_version++;
4144 do_histogram++;
4145 do_arch++;
4146 do_notes++;
252b5132 4147 break;
f5842774
L		 4148 case 'g':
4149 do_section_groups++;
4150 break;
5477e8a0 4151 case 't':
595cf52e 4152 case 'N':
5477e8a0
L		 4153 do_sections++;
4154 do_section_details++;
595cf52e 4155 break;
252b5132 4156 case 'e':
b34976b6
AM		 4157 do_header++;
4158 do_sections++;
4159 do_segments++;
252b5132 4160 break;
a952a375 4161 case 'A':
b34976b6 4162 do_arch++;
a952a375 4163 break;
252b5132 4164 case 'D':
b34976b6 4165 do_using_dynamic++;
252b5132
RH		 4166 break;
4167 case 'r':
b34976b6 4168 do_reloc++;
252b5132 4169 break;
4d6ed7c8 4170 case 'u':
b34976b6 4171 do_unwind++;
4d6ed7c8 4172 break;
252b5132 4173 case 'h':
b34976b6 4174 do_header++;
252b5132
RH		 4175 break;
4176 case 'l':
b34976b6 4177 do_segments++;
252b5132
RH		 4178 break;
4179 case 's':
b34976b6 4180 do_syms++;
252b5132
RH		 4181 break;
4182 case 'S':
b34976b6 4183 do_sections++;
252b5132
RH		 4184 break;
4185 case 'd':
b34976b6 4186 do_dynamic++;
252b5132 4187 break;
a952a375 4188 case 'I':
b34976b6 4189 do_histogram++;
a952a375 4190 break;
779fe533 4191 case 'n':
b34976b6 4192 do_notes++;
779fe533 4193 break;
4145f1d5
NC		 4194 case 'c':
4195 do_archive_index++;
4196 break;
252b5132 4197 case 'x':
cf13d699 4198 request_dump (HEX_DUMP);
aef1f6d0 4199 break;
09c11c86 4200 case 'p':
cf13d699
NC		 4201 request_dump (STRING_DUMP);
4202 break;
4203 case 'R':
4204 request_dump (RELOC_DUMP);
09c11c86 4205 break;
0e602686
NC		 4206 case 'z':
4207 decompress_dumps++;
4208 break;
252b5132 4209 case 'w':
b34976b6 4210 do_dump++;
252b5132 4211 if (optarg == 0)
613ff48b
CC		 4212 {
4213 do_debugging = 1;
4214 dwarf_select_sections_all ();
4215 }
252b5132
RH		 4216 else
4217 {
4218 do_debugging = 0;
4cb93e3b 4219 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 4220 }
4221 break;
2979dc34 4222 case OPTION_DEBUG_DUMP:
b34976b6 4223 do_dump++;
2979dc34
JJ		 4224 if (optarg == 0)
4225 do_debugging = 1;
4226 else
4227 {
2979dc34 4228 do_debugging = 0;
4cb93e3b 4229 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 4230 }
4231 break;
fd2f0033
TT		 4232 case OPTION_DWARF_DEPTH:
4233 {
4234 char *cp;
4235
4236 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4237 }
4238 break;
4239 case OPTION_DWARF_START:
4240 {
4241 char *cp;
4242
4243 dwarf_start_die = strtoul (optarg, & cp, 0);
4244 }
4245 break;
4723351a
CC		 4246 case OPTION_DWARF_CHECK:
4247 dwarf_check = 1;
4248 break;
2c610e4b
L		 4249 case OPTION_DYN_SYMS:
4250 do_dyn_syms++;
4251 break;
252b5132
RH		 4252#ifdef SUPPORT_DISASSEMBLY
4253 case 'i':
cf13d699
NC		 4254 request_dump (DISASS_DUMP);
4255 break;
252b5132
RH		 4256#endif
4257 case 'v':
4258 print_version (program_name);
4259 break;
4260 case 'V':
b34976b6 4261 do_version++;
252b5132 4262 break;
d974e256 4263 case 'W':
b34976b6 4264 do_wide++;
d974e256 4265 break;
252b5132 4266 default:
252b5132
RH		 4267 /* xgettext:c-format */
4268 error (_("Invalid option '-%c'\n"), c);
4269 /* Drop through. */
4270 case '?':
92f01d61 4271 usage (stderr);
252b5132
RH		 4272 }
4273 }
4274
4d6ed7c8 4275 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 4276 && !do_segments && !do_header && !do_dump && !do_version
f5842774 4277 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 4278 && !do_section_groups && !do_archive_index
4279 && !do_dyn_syms)
92f01d61 4280 usage (stderr);
252b5132
RH		 4281}
4282
4283static const char *
d3ba0551 4284get_elf_class (unsigned int elf_class)
252b5132 4285{
b34976b6 4286 static char buff[32];
103f02d3 4287
252b5132
RH		 4288 switch (elf_class)
4289 {
4290 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 4291 case ELFCLASS32: return "ELF32";
4292 case ELFCLASS64: return "ELF64";
ab5e7794 4293 default:
e9e44622 4294 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 4295 return buff;
252b5132
RH		 4296 }
4297}
4298
4299static const char *
d3ba0551 4300get_data_encoding (unsigned int encoding)
252b5132 4301{
b34976b6 4302 static char buff[32];
103f02d3 4303
252b5132
RH		 4304 switch (encoding)
4305 {
4306 case ELFDATANONE: return _("none");
33c63f9d
CM		 4307 case ELFDATA2LSB: return _("2's complement, little endian");
4308 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 4309 default:
e9e44622 4310 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 4311 return buff;
252b5132
RH		 4312 }
4313}
4314
252b5132 4315/* Decode the data held in 'elf_header'. */
ee42cf8c 4316
252b5132 4317static int
d3ba0551 4318process_file_header (void)
252b5132 4319{
b34976b6
AM		 4320 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4321 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4322 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4323 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 4324 {
4325 error
4326 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4327 return 0;
4328 }
4329
2dc4cec1
L		 4330 init_dwarf_regnames (elf_header.e_machine);
4331
252b5132
RH		 4332 if (do_header)
4333 {
4334 int i;
4335
4336 printf (_("ELF Header:\n"));
4337 printf (_(" Magic: "));
b34976b6
AM		 4338 for (i = 0; i < EI_NIDENT; i++)
4339 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 4340 printf ("\n");
4341 printf (_(" Class: %s\n"),
b34976b6 4342 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 4343 printf (_(" Data: %s\n"),
b34976b6 4344 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 4345 printf (_(" Version: %d %s\n"),
b34976b6
AM		 4346 elf_header.e_ident[EI_VERSION],
4347 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 4348 ? "(current)"
b34976b6 4349 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 4350 ? _("<unknown: %lx>")
789be9f7 4351 : "")));
252b5132 4352 printf (_(" OS/ABI: %s\n"),
b34976b6 4353 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 4354 printf (_(" ABI Version: %d\n"),
b34976b6 4355 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 4356 printf (_(" Type: %s\n"),
4357 get_file_type (elf_header.e_type));
4358 printf (_(" Machine: %s\n"),
4359 get_machine_name (elf_header.e_machine));
4360 printf (_(" Version: 0x%lx\n"),
4361 (unsigned long) elf_header.e_version);
76da6bbe 4362
f7a99963
NC		 4363 printf (_(" Entry point address: "));
4364 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4365 printf (_("\n Start of program headers: "));
4366 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4367 printf (_(" (bytes into file)\n Start of section headers: "));
4368 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4369 printf (_(" (bytes into file)\n"));
76da6bbe 4370
252b5132
RH		 4371 printf (_(" Flags: 0x%lx%s\n"),
4372 (unsigned long) elf_header.e_flags,
4373 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4374 printf (_(" Size of this header: %ld (bytes)\n"),
4375 (long) elf_header.e_ehsize);
4376 printf (_(" Size of program headers: %ld (bytes)\n"),
4377 (long) elf_header.e_phentsize);
2046a35d 4378 printf (_(" Number of program headers: %ld"),
252b5132 4379 (long) elf_header.e_phnum);
2046a35d
AM		 4380 if (section_headers != NULL
4381 && elf_header.e_phnum == PN_XNUM
4382 && section_headers[0].sh_info != 0)
cc5914eb 4383 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 4384 putc ('\n', stdout);
252b5132
RH		 4385 printf (_(" Size of section headers: %ld (bytes)\n"),
4386 (long) elf_header.e_shentsize);
560f3c1c 4387 printf (_(" Number of section headers: %ld"),
252b5132 4388 (long) elf_header.e_shnum);
4fbb74a6 4389 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 4390 printf (" (%ld)", (long) section_headers[0].sh_size);
4391 putc ('\n', stdout);
4392 printf (_(" Section header string table index: %ld"),
252b5132 4393 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 4394 if (section_headers != NULL
4395 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 4396 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 4397 else if (elf_header.e_shstrndx != SHN_UNDEF
4398 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 4399 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 4400 putc ('\n', stdout);
4401 }
4402
4403 if (section_headers != NULL)
4404 {
2046a35d
AM		 4405 if (elf_header.e_phnum == PN_XNUM
4406 && section_headers[0].sh_info != 0)
4407 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 4408 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 4409 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 4410 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 4411 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 4412 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 4413 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 4414 free (section_headers);
4415 section_headers = NULL;
252b5132 4416 }
103f02d3 4417
9ea033b2
NC		 4418 return 1;
4419}
4420
e0a31db1 4421static bfd_boolean
91d6fa6a 4422get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4423{
2cf0635d
NC		 4424 Elf32_External_Phdr * phdrs;
4425 Elf32_External_Phdr * external;
4426 Elf_Internal_Phdr * internal;
b34976b6 4427 unsigned int i;
e0a31db1
NC		 4428 unsigned int size = elf_header.e_phentsize;
4429 unsigned int num = elf_header.e_phnum;
4430
4431 /* PR binutils/17531: Cope with unexpected section header sizes. */
4432 if (size == 0 || num == 0)
4433 return FALSE;
4434 if (size < sizeof * phdrs)
4435 {
4436 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4437 return FALSE;
4438 }
4439 if (size > sizeof * phdrs)
4440 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4441
3f5e193b 4442 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1
NC		 4443 size, num, _("program headers"));
4444 if (phdrs == NULL)
4445 return FALSE;
9ea033b2 4446
91d6fa6a 4447 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4448 i < elf_header.e_phnum;
b34976b6 4449 i++, internal++, external++)
252b5132 4450 {
9ea033b2
NC		 4451 internal->p_type = BYTE_GET (external->p_type);
4452 internal->p_offset = BYTE_GET (external->p_offset);
4453 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4454 internal->p_paddr = BYTE_GET (external->p_paddr);
4455 internal->p_filesz = BYTE_GET (external->p_filesz);
4456 internal->p_memsz = BYTE_GET (external->p_memsz);
4457 internal->p_flags = BYTE_GET (external->p_flags);
4458 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 4459 }
4460
9ea033b2 4461 free (phdrs);
e0a31db1 4462 return TRUE;
252b5132
RH		 4463}
4464
e0a31db1 4465static bfd_boolean
91d6fa6a 4466get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4467{
2cf0635d
NC		 4468 Elf64_External_Phdr * phdrs;
4469 Elf64_External_Phdr * external;
4470 Elf_Internal_Phdr * internal;
b34976b6 4471 unsigned int i;
e0a31db1
NC		 4472 unsigned int size = elf_header.e_phentsize;
4473 unsigned int num = elf_header.e_phnum;
4474
4475 /* PR binutils/17531: Cope with unexpected section header sizes. */
4476 if (size == 0 || num == 0)
4477 return FALSE;
4478 if (size < sizeof * phdrs)
4479 {
4480 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4481 return FALSE;
4482 }
4483 if (size > sizeof * phdrs)
4484 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4485
3f5e193b 4486 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1 4487 size, num, _("program headers"));
a6e9f9df 4488 if (!phdrs)
e0a31db1 4489 return FALSE;
9ea033b2 4490
91d6fa6a 4491 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4492 i < elf_header.e_phnum;
b34976b6 4493 i++, internal++, external++)
9ea033b2
NC		 4494 {
4495 internal->p_type = BYTE_GET (external->p_type);
4496 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 4497 internal->p_offset = BYTE_GET (external->p_offset);
4498 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4499 internal->p_paddr = BYTE_GET (external->p_paddr);
4500 internal->p_filesz = BYTE_GET (external->p_filesz);
4501 internal->p_memsz = BYTE_GET (external->p_memsz);
4502 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 4503 }
4504
4505 free (phdrs);
e0a31db1 4506 return TRUE;
9ea033b2 4507}
252b5132 4508
d93f0186
NC		 4509/* Returns 1 if the program headers were read into `program_headers'. */
4510
4511static int
2cf0635d 4512get_program_headers (FILE * file)
d93f0186 4513{
2cf0635d 4514 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 4515
4516 /* Check cache of prior read. */
4517 if (program_headers != NULL)
4518 return 1;
4519
3f5e193b
NC		 4520 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4521 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 4522
4523 if (phdrs == NULL)
4524 {
8b73c356
NC		 4525 error (_("Out of memory reading %u program headers\n"),
4526 elf_header.e_phnum);
d93f0186
NC		 4527 return 0;
4528 }
4529
4530 if (is_32bit_elf
4531 ? get_32bit_program_headers (file, phdrs)
4532 : get_64bit_program_headers (file, phdrs))
4533 {
4534 program_headers = phdrs;
4535 return 1;
4536 }
4537
4538 free (phdrs);
4539 return 0;
4540}
4541
2f62977e
NC		 4542/* Returns 1 if the program headers were loaded. */
4543
252b5132 4544static int
2cf0635d 4545process_program_headers (FILE * file)
252b5132 4546{
2cf0635d 4547 Elf_Internal_Phdr * segment;
b34976b6 4548 unsigned int i;
252b5132
RH		 4549
4550 if (elf_header.e_phnum == 0)
4551 {
82f2dbf7
NC		 4552 /* PR binutils/12467. */
4553 if (elf_header.e_phoff != 0)
4554 warn (_("possibly corrupt ELF header - it has a non-zero program"
9035ed51 4555 " header offset, but no program headers\n"));
82f2dbf7 4556 else if (do_segments)
252b5132 4557 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 4558 return 0;
252b5132
RH		 4559 }
4560
4561 if (do_segments && !do_header)
4562 {
f7a99963
NC		 4563 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4564 printf (_("Entry point "));
4565 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4566 printf (_("\nThere are %d program headers, starting at offset "),
4567 elf_header.e_phnum);
4568 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4569 printf ("\n");
252b5132
RH		 4570 }
4571
d93f0186 4572 if (! get_program_headers (file))
252b5132 4573 return 0;
103f02d3 4574
252b5132
RH		 4575 if (do_segments)
4576 {
3a1a2036
NC		 4577 if (elf_header.e_phnum > 1)
4578 printf (_("\nProgram Headers:\n"));
4579 else
4580 printf (_("\nProgram Headers:\n"));
76da6bbe 4581
f7a99963
NC		 4582 if (is_32bit_elf)
4583 printf
4584 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 4585 else if (do_wide)
4586 printf
4587 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 4588 else
4589 {
4590 printf
4591 (_(" Type Offset VirtAddr PhysAddr\n"));
4592 printf
4593 (_(" FileSiz MemSiz Flags Align\n"));
4594 }
252b5132
RH		 4595 }
4596
252b5132 4597 dynamic_addr = 0;
1b228002 4598 dynamic_size = 0;
252b5132
RH		 4599
4600 for (i = 0, segment = program_headers;
4601 i < elf_header.e_phnum;
b34976b6 4602 i++, segment++)
252b5132
RH		 4603 {
4604 if (do_segments)
4605 {
103f02d3 4606 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 4607
4608 if (is_32bit_elf)
4609 {
4610 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4611 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4612 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4613 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4614 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4615 printf ("%c%c%c ",
4616 (segment->p_flags & PF_R ? 'R' : ' '),
4617 (segment->p_flags & PF_W ? 'W' : ' '),
4618 (segment->p_flags & PF_X ? 'E' : ' '));
4619 printf ("%#lx", (unsigned long) segment->p_align);
4620 }
d974e256
JJ		 4621 else if (do_wide)
4622 {
4623 if ((unsigned long) segment->p_offset == segment->p_offset)
4624 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4625 else
4626 {
4627 print_vma (segment->p_offset, FULL_HEX);
4628 putchar (' ');
4629 }
4630
4631 print_vma (segment->p_vaddr, FULL_HEX);
4632 putchar (' ');
4633 print_vma (segment->p_paddr, FULL_HEX);
4634 putchar (' ');
4635
4636 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4637 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4638 else
4639 {
4640 print_vma (segment->p_filesz, FULL_HEX);
4641 putchar (' ');
4642 }
4643
4644 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4645 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4646 else
4647 {
f48e6c45 4648 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 4649 }
4650
4651 printf (" %c%c%c ",
4652 (segment->p_flags & PF_R ? 'R' : ' '),
4653 (segment->p_flags & PF_W ? 'W' : ' '),
4654 (segment->p_flags & PF_X ? 'E' : ' '));
4655
4656 if ((unsigned long) segment->p_align == segment->p_align)
4657 printf ("%#lx", (unsigned long) segment->p_align);
4658 else
4659 {
4660 print_vma (segment->p_align, PREFIX_HEX);
4661 }
4662 }
f7a99963
NC		 4663 else
4664 {
4665 print_vma (segment->p_offset, FULL_HEX);
4666 putchar (' ');
4667 print_vma (segment->p_vaddr, FULL_HEX);
4668 putchar (' ');
4669 print_vma (segment->p_paddr, FULL_HEX);
4670 printf ("\n ");
4671 print_vma (segment->p_filesz, FULL_HEX);
4672 putchar (' ');
4673 print_vma (segment->p_memsz, FULL_HEX);
4674 printf (" %c%c%c ",
4675 (segment->p_flags & PF_R ? 'R' : ' '),
4676 (segment->p_flags & PF_W ? 'W' : ' '),
4677 (segment->p_flags & PF_X ? 'E' : ' '));
4678 print_vma (segment->p_align, HEX);
4679 }
252b5132
RH		 4680 }
4681
f54498b4
NC		 4682 if (do_segments)
4683 putc ('\n', stdout);
4684
252b5132
RH		 4685 switch (segment->p_type)
4686 {
252b5132
RH		 4687 case PT_DYNAMIC:
4688 if (dynamic_addr)
4689 error (_("more than one dynamic segment\n"));
4690
20737c13
AM		 4691 /* By default, assume that the .dynamic section is the first
4692 section in the DYNAMIC segment. */
4693 dynamic_addr = segment->p_offset;
4694 dynamic_size = segment->p_filesz;
f54498b4
NC		 4695 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4696 if (dynamic_addr + dynamic_size >= current_file_size)
4697 {
4698 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4699 dynamic_addr = dynamic_size = 0;
4700 }
20737c13 4701
b2d38a17
NC		 4702 /* Try to locate the .dynamic section. If there is
4703 a section header table, we can easily locate it. */
4704 if (section_headers != NULL)
4705 {
2cf0635d 4706 Elf_Internal_Shdr * sec;
b2d38a17 4707
89fac5e3
RS		 4708 sec = find_section (".dynamic");
4709 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4710 {
28f997cf
TG		 4711 /* A corresponding .dynamic section is expected, but on
4712 IA-64/OpenVMS it is OK for it to be missing. */
4713 if (!is_ia64_vms ())
4714 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 4715 break;
4716 }
4717
42bb2e33 4718 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 4719 {
4720 dynamic_size = 0;
4721 break;
4722 }
42bb2e33 4723
b2d38a17
NC		 4724 dynamic_addr = sec->sh_offset;
4725 dynamic_size = sec->sh_size;
4726
4727 if (dynamic_addr < segment->p_offset
4728 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 4729 warn (_("the .dynamic section is not contained"
4730 " within the dynamic segment\n"));
b2d38a17 4731 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 4732 warn (_("the .dynamic section is not the first section"
4733 " in the dynamic segment.\n"));
b2d38a17 4734 }
252b5132
RH		 4735 break;
4736
4737 case PT_INTERP:
fb52b2f4
NC		 4738 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4739 SEEK_SET))
252b5132
RH		 4740 error (_("Unable to find program interpreter name\n"));
4741 else
4742 {
f8eae8b2 4743 char fmt [32];
9495b2e6 4744 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
f8eae8b2
L		 4745
4746 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4747 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4748
252b5132 4749 program_interpreter[0] = 0;
7bd7b3ef
AM		 4750 if (fscanf (file, fmt, program_interpreter) <= 0)
4751 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 4752
4753 if (do_segments)
f54498b4 4754 printf (_(" [Requesting program interpreter: %s]\n"),
252b5132
RH		 4755 program_interpreter);
4756 }
4757 break;
4758 }
252b5132
RH		 4759 }
4760
c256ffe7 4761 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 4762 {
4763 printf (_("\n Section to Segment mapping:\n"));
4764 printf (_(" Segment Sections...\n"));
4765
252b5132
RH		 4766 for (i = 0; i < elf_header.e_phnum; i++)
4767 {
9ad5cbcf 4768 unsigned int j;
2cf0635d 4769 Elf_Internal_Shdr * section;
252b5132
RH		 4770
4771 segment = program_headers + i;
b391a3e3 4772 section = section_headers + 1;
252b5132
RH		 4773
4774 printf (" %2.2d ", i);
4775
b34976b6 4776 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4777 {
f4638467
AM		 4778 if (!ELF_TBSS_SPECIAL (section, segment)
4779 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
74e1a04b 4780 printf ("%s ", printable_section_name (section));
252b5132
RH		 4781 }
4782
4783 putc ('\n',stdout);
4784 }
4785 }
4786
252b5132
RH		 4787 return 1;
4788}
4789
4790
d93f0186
NC		 4791/* Find the file offset corresponding to VMA by using the program headers. */
4792
4793static long
2cf0635d 4794offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4795{
2cf0635d 4796 Elf_Internal_Phdr * seg;
d93f0186
NC		 4797
4798 if (! get_program_headers (file))
4799 {
4800 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4801 return (long) vma;
4802 }
4803
4804 for (seg = program_headers;
4805 seg < program_headers + elf_header.e_phnum;
4806 ++seg)
4807 {
4808 if (seg->p_type != PT_LOAD)
4809 continue;
4810
4811 if (vma >= (seg->p_vaddr & -seg->p_align)
4812 && vma + size <= seg->p_vaddr + seg->p_filesz)
4813 return vma - seg->p_vaddr + seg->p_offset;
4814 }
4815
4816 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4817 (unsigned long) vma);
d93f0186
NC		 4818 return (long) vma;
4819}
4820
4821
049b0c3a
NC		 4822/* Allocate memory and load the sections headers into the global pointer
4823 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4824 generate any error messages if the load fails. */
4825
4826static bfd_boolean
4827get_32bit_section_headers (FILE * file, bfd_boolean probe)
252b5132 4828{
2cf0635d
NC		 4829 Elf32_External_Shdr * shdrs;
4830 Elf_Internal_Shdr * internal;
b34976b6 4831 unsigned int i;
049b0c3a
NC		 4832 unsigned int size = elf_header.e_shentsize;
4833 unsigned int num = probe ? 1 : elf_header.e_shnum;
4834
4835 /* PR binutils/17531: Cope with unexpected section header sizes. */
4836 if (size == 0 || num == 0)
4837 return FALSE;
4838 if (size < sizeof * shdrs)
4839 {
4840 if (! probe)
4841 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4842 return FALSE;
4843 }
4844 if (!probe && size > sizeof * shdrs)
4845 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
252b5132 4846
3f5e193b 4847 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4848 size, num,
4849 probe ? NULL : _("section headers"));
4850 if (shdrs == NULL)
4851 return FALSE;
252b5132 4852
049b0c3a
NC		 4853 if (section_headers != NULL)
4854 free (section_headers);
3f5e193b
NC		 4855 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4856 sizeof (Elf_Internal_Shdr));
252b5132
RH		 4857 if (section_headers == NULL)
4858 {
049b0c3a 4859 if (!probe)
8b73c356 4860 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4861 return FALSE;
252b5132
RH		 4862 }
4863
4864 for (i = 0, internal = section_headers;
560f3c1c 4865 i < num;
b34976b6 4866 i++, internal++)
252b5132
RH		 4867 {
4868 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4869 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4870 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4871 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4872 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4873 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4874 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4875 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4876 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4877 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4878 }
4879
4880 free (shdrs);
049b0c3a 4881 return TRUE;
252b5132
RH		 4882}
4883
049b0c3a
NC		 4884static bfd_boolean
4885get_64bit_section_headers (FILE * file, bfd_boolean probe)
9ea033b2 4886{
2cf0635d
NC		 4887 Elf64_External_Shdr * shdrs;
4888 Elf_Internal_Shdr * internal;
b34976b6 4889 unsigned int i;
049b0c3a
NC		 4890 unsigned int size = elf_header.e_shentsize;
4891 unsigned int num = probe ? 1 : elf_header.e_shnum;
4892
4893 /* PR binutils/17531: Cope with unexpected section header sizes. */
4894 if (size == 0 || num == 0)
4895 return FALSE;
4896 if (size < sizeof * shdrs)
4897 {
4898 if (! probe)
4899 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4900 return FALSE;
4901 }
4902 if (! probe && size > sizeof * shdrs)
4903 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
9ea033b2 4904
3f5e193b 4905 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4906 size, num,
4907 probe ? NULL : _("section headers"));
4908 if (shdrs == NULL)
4909 return FALSE;
9ea033b2 4910
049b0c3a
NC		 4911 if (section_headers != NULL)
4912 free (section_headers);
3f5e193b
NC		 4913 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4914 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4915 if (section_headers == NULL)
4916 {
049b0c3a 4917 if (! probe)
8b73c356 4918 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4919 return FALSE;
9ea033b2
NC		 4920 }
4921
4922 for (i = 0, internal = section_headers;
560f3c1c 4923 i < num;
b34976b6 4924 i++, internal++)
9ea033b2
NC		 4925 {
4926 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4927 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4928 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4929 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4930 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4931 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4932 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4933 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4934 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4935 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4936 }
4937
4938 free (shdrs);
049b0c3a 4939 return TRUE;
9ea033b2
NC		 4940}
4941
252b5132 4942static Elf_Internal_Sym *
ba5cdace
NC		 4943get_32bit_elf_symbols (FILE * file,
4944 Elf_Internal_Shdr * section,
4945 unsigned long * num_syms_return)
252b5132 4946{
ba5cdace 4947 unsigned long number = 0;
dd24e3da 4948 Elf32_External_Sym * esyms = NULL;
ba5cdace 4949 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 4950 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4951 Elf_Internal_Sym * psym;
b34976b6 4952 unsigned int j;
252b5132 4953
c9c1d674
EG		 4954 if (section->sh_size == 0)
4955 {
4956 if (num_syms_return != NULL)
4957 * num_syms_return = 0;
4958 return NULL;
4959 }
4960
dd24e3da 4961 /* Run some sanity checks first. */
c9c1d674 4962 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 4963 {
c9c1d674
EG		 4964 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4965 printable_section_name (section), (unsigned long) section->sh_entsize);
ba5cdace 4966 goto exit_point;
dd24e3da
NC		 4967 }
4968
f54498b4
NC		 4969 if (section->sh_size > current_file_size)
4970 {
4971 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
74e1a04b 4972 printable_section_name (section), (unsigned long) section->sh_size);
f54498b4
NC		 4973 goto exit_point;
4974 }
4975
dd24e3da
NC		 4976 number = section->sh_size / section->sh_entsize;
4977
4978 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4979 {
c9c1d674 4980 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 4981 (unsigned long) section->sh_size,
4982 printable_section_name (section),
4983 (unsigned long) section->sh_entsize);
ba5cdace 4984 goto exit_point;
dd24e3da
NC		 4985 }
4986
3f5e193b
NC		 4987 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4988 section->sh_size, _("symbols"));
dd24e3da 4989 if (esyms == NULL)
ba5cdace 4990 goto exit_point;
252b5132 4991
9ad5cbcf
AM		 4992 shndx = NULL;
4993 if (symtab_shndx_hdr != NULL
4994 && (symtab_shndx_hdr->sh_link
4fbb74a6 4995 == (unsigned long) (section - section_headers)))
9ad5cbcf 4996 {
3f5e193b
NC		 4997 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4998 symtab_shndx_hdr->sh_offset,
4999 1, symtab_shndx_hdr->sh_size,
9cf03b7e 5000 _("symbol table section indicies"));
dd24e3da
NC		 5001 if (shndx == NULL)
5002 goto exit_point;
c9c1d674
EG		 5003 /* PR17531: file: heap-buffer-overflow */
5004 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5005 {
5006 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5007 printable_section_name (symtab_shndx_hdr),
5008 (unsigned long) symtab_shndx_hdr->sh_size,
5009 (unsigned long) section->sh_size);
5010 goto exit_point;
5011 }
9ad5cbcf
AM		 5012 }
5013
3f5e193b 5014 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 5015
5016 if (isyms == NULL)
5017 {
8b73c356
NC		 5018 error (_("Out of memory reading %lu symbols\n"),
5019 (unsigned long) number);
dd24e3da 5020 goto exit_point;
252b5132
RH		 5021 }
5022
dd24e3da 5023 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 5024 {
5025 psym->st_name = BYTE_GET (esyms[j].st_name);
5026 psym->st_value = BYTE_GET (esyms[j].st_value);
5027 psym->st_size = BYTE_GET (esyms[j].st_size);
5028 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 5029 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5030 psym->st_shndx
5031 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5032 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5033 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 5034 psym->st_info = BYTE_GET (esyms[j].st_info);
5035 psym->st_other = BYTE_GET (esyms[j].st_other);
5036 }
5037
dd24e3da 5038 exit_point:
ba5cdace 5039 if (shndx != NULL)
9ad5cbcf 5040 free (shndx);
ba5cdace 5041 if (esyms != NULL)
dd24e3da 5042 free (esyms);
252b5132 5043
ba5cdace
NC		 5044 if (num_syms_return != NULL)
5045 * num_syms_return = isyms == NULL ? 0 : number;
5046
252b5132
RH		 5047 return isyms;
5048}
5049
9ea033b2 5050static Elf_Internal_Sym *
ba5cdace
NC		 5051get_64bit_elf_symbols (FILE * file,
5052 Elf_Internal_Shdr * section,
5053 unsigned long * num_syms_return)
9ea033b2 5054{
ba5cdace
NC		 5055 unsigned long number = 0;
5056 Elf64_External_Sym * esyms = NULL;
5057 Elf_External_Sym_Shndx * shndx = NULL;
5058 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5059 Elf_Internal_Sym * psym;
b34976b6 5060 unsigned int j;
9ea033b2 5061
c9c1d674
EG		 5062 if (section->sh_size == 0)
5063 {
5064 if (num_syms_return != NULL)
5065 * num_syms_return = 0;
5066 return NULL;
5067 }
5068
dd24e3da 5069 /* Run some sanity checks first. */
c9c1d674 5070 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5071 {
c9c1d674 5072 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
8066deb1
AM		 5073 printable_section_name (section),
5074 (unsigned long) section->sh_entsize);
ba5cdace 5075 goto exit_point;
dd24e3da
NC		 5076 }
5077
f54498b4
NC		 5078 if (section->sh_size > current_file_size)
5079 {
5080 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
8066deb1
AM		 5081 printable_section_name (section),
5082 (unsigned long) section->sh_size);
f54498b4
NC		 5083 goto exit_point;
5084 }
5085
dd24e3da
NC		 5086 number = section->sh_size / section->sh_entsize;
5087
5088 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5089 {
c9c1d674 5090 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5091 (unsigned long) section->sh_size,
5092 printable_section_name (section),
5093 (unsigned long) section->sh_entsize);
ba5cdace 5094 goto exit_point;
dd24e3da
NC		 5095 }
5096
3f5e193b
NC		 5097 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5098 section->sh_size, _("symbols"));
a6e9f9df 5099 if (!esyms)
ba5cdace 5100 goto exit_point;
9ea033b2 5101
9ad5cbcf
AM		 5102 if (symtab_shndx_hdr != NULL
5103 && (symtab_shndx_hdr->sh_link
4fbb74a6 5104 == (unsigned long) (section - section_headers)))
9ad5cbcf 5105 {
3f5e193b
NC		 5106 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5107 symtab_shndx_hdr->sh_offset,
5108 1, symtab_shndx_hdr->sh_size,
9cf03b7e 5109 _("symbol table section indicies"));
ba5cdace
NC		 5110 if (shndx == NULL)
5111 goto exit_point;
c9c1d674
EG		 5112 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5113 {
5114 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5115 printable_section_name (symtab_shndx_hdr),
5116 (unsigned long) symtab_shndx_hdr->sh_size,
5117 (unsigned long) section->sh_size);
5118 goto exit_point;
5119 }
9ad5cbcf
AM		 5120 }
5121
3f5e193b 5122 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 5123
5124 if (isyms == NULL)
5125 {
8b73c356
NC		 5126 error (_("Out of memory reading %lu symbols\n"),
5127 (unsigned long) number);
ba5cdace 5128 goto exit_point;
9ea033b2
NC		 5129 }
5130
ba5cdace 5131 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 5132 {
5133 psym->st_name = BYTE_GET (esyms[j].st_name);
5134 psym->st_info = BYTE_GET (esyms[j].st_info);
5135 psym->st_other = BYTE_GET (esyms[j].st_other);
5136 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 5137
4fbb74a6 5138 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5139 psym->st_shndx
5140 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5141 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5142 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 5143
66543521
AM		 5144 psym->st_value = BYTE_GET (esyms[j].st_value);
5145 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 5146 }
5147
ba5cdace
NC		 5148 exit_point:
5149 if (shndx != NULL)
9ad5cbcf 5150 free (shndx);
ba5cdace
NC		 5151 if (esyms != NULL)
5152 free (esyms);
5153
5154 if (num_syms_return != NULL)
5155 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 5156
5157 return isyms;
5158}
5159
d1133906 5160static const char *
d3ba0551 5161get_elf_section_flags (bfd_vma sh_flags)
d1133906 5162{
5477e8a0 5163 static char buff[1024];
2cf0635d 5164 char * p = buff;
8d5ff12c 5165 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 5166 int sindex;
5167 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 5168 bfd_vma os_flags = 0;
5169 bfd_vma proc_flags = 0;
5170 bfd_vma unknown_flags = 0;
148b93f2 5171 static const struct
5477e8a0 5172 {
2cf0635d 5173 const char * str;
5477e8a0
L		 5174 int len;
5175 }
5176 flags [] =
5177 {
cfcac11d
NC		 5178 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5179 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5180 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5181 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5182 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5183 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5184 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5185 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5186 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5187 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5188 /* IA-64 specific. */
5189 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5190 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5191 /* IA-64 OpenVMS specific. */
5192 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5193 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5194 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5195 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5196 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5197 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 5198 /* Generic. */
cfcac11d 5199 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 5200 /* SPARC specific. */
77115a4a
L		 5201 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5202 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") }
5477e8a0
L		 5203 };
5204
5205 if (do_section_details)
5206 {
8d5ff12c
L		 5207 sprintf (buff, "[%*.*lx]: ",
5208 field_size, field_size, (unsigned long) sh_flags);
5209 p += field_size + 4;
5477e8a0 5210 }
76da6bbe 5211
d1133906
NC		 5212 while (sh_flags)
5213 {
5214 bfd_vma flag;
5215
5216 flag = sh_flags & - sh_flags;
5217 sh_flags &= ~ flag;
76da6bbe 5218
5477e8a0 5219 if (do_section_details)
d1133906 5220 {
5477e8a0
L		 5221 switch (flag)
5222 {
91d6fa6a
NC		 5223 case SHF_WRITE: sindex = 0; break;
5224 case SHF_ALLOC: sindex = 1; break;
5225 case SHF_EXECINSTR: sindex = 2; break;
5226 case SHF_MERGE: sindex = 3; break;
5227 case SHF_STRINGS: sindex = 4; break;
5228 case SHF_INFO_LINK: sindex = 5; break;
5229 case SHF_LINK_ORDER: sindex = 6; break;
5230 case SHF_OS_NONCONFORMING: sindex = 7; break;
5231 case SHF_GROUP: sindex = 8; break;
5232 case SHF_TLS: sindex = 9; break;
18ae9cc1 5233 case SHF_EXCLUDE: sindex = 18; break;
77115a4a 5234 case SHF_COMPRESSED: sindex = 20; break;
76da6bbe 5235
5477e8a0 5236 default:
91d6fa6a 5237 sindex = -1;
cfcac11d 5238 switch (elf_header.e_machine)
148b93f2 5239 {
cfcac11d 5240 case EM_IA_64:
148b93f2 5241 if (flag == SHF_IA_64_SHORT)
91d6fa6a 5242 sindex = 10;
148b93f2 5243 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 5244 sindex = 11;
148b93f2
NC		 5245#ifdef BFD64
5246 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5247 switch (flag)
5248 {
91d6fa6a
NC		 5249 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5250 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5251 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5252 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5253 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5254 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 5255 default: break;
5256 }
5257#endif
cfcac11d
NC		 5258 break;
5259
caa83f8b 5260 case EM_386:
22abe556 5261 case EM_IAMCU:
caa83f8b 5262 case EM_X86_64:
7f502d6c 5263 case EM_L1OM:
7a9068fe 5264 case EM_K1OM:
cfcac11d
NC		 5265 case EM_OLD_SPARCV9:
5266 case EM_SPARC32PLUS:
5267 case EM_SPARCV9:
5268 case EM_SPARC:
18ae9cc1 5269 if (flag == SHF_ORDERED)
91d6fa6a 5270 sindex = 19;
cfcac11d
NC		 5271 break;
5272 default:
5273 break;
148b93f2 5274 }
5477e8a0
L		 5275 }
5276
91d6fa6a 5277 if (sindex != -1)
5477e8a0 5278 {
8d5ff12c
L		 5279 if (p != buff + field_size + 4)
5280 {
5281 if (size < (10 + 2))
bee0ee85
NC		 5282 {
5283 warn (_("Internal error: not enough buffer room for section flag info"));
5284 return _("<unknown>");
5285 }
8d5ff12c
L		 5286 size -= 2;
5287 *p++ = ',';
5288 *p++ = ' ';
5289 }
5290
91d6fa6a
NC		 5291 size -= flags [sindex].len;
5292 p = stpcpy (p, flags [sindex].str);
5477e8a0 5293 }
3b22753a 5294 else if (flag & SHF_MASKOS)
8d5ff12c 5295 os_flags |= flag;
d1133906 5296 else if (flag & SHF_MASKPROC)
8d5ff12c 5297 proc_flags |= flag;
d1133906 5298 else
8d5ff12c 5299 unknown_flags |= flag;
5477e8a0
L		 5300 }
5301 else
5302 {
5303 switch (flag)
5304 {
5305 case SHF_WRITE: *p = 'W'; break;
5306 case SHF_ALLOC: *p = 'A'; break;
5307 case SHF_EXECINSTR: *p = 'X'; break;
5308 case SHF_MERGE: *p = 'M'; break;
5309 case SHF_STRINGS: *p = 'S'; break;
5310 case SHF_INFO_LINK: *p = 'I'; break;
5311 case SHF_LINK_ORDER: *p = 'L'; break;
5312 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5313 case SHF_GROUP: *p = 'G'; break;
5314 case SHF_TLS: *p = 'T'; break;
18ae9cc1 5315 case SHF_EXCLUDE: *p = 'E'; break;
77115a4a 5316 case SHF_COMPRESSED: *p = 'C'; break;
5477e8a0
L		 5317
5318 default:
8a9036a4 5319 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 5320 || elf_header.e_machine == EM_L1OM
5321 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 5322 && flag == SHF_X86_64_LARGE)
5323 *p = 'l';
5324 else if (flag & SHF_MASKOS)
5325 {
5326 *p = 'o';
5327 sh_flags &= ~ SHF_MASKOS;
5328 }
5329 else if (flag & SHF_MASKPROC)
5330 {
5331 *p = 'p';
5332 sh_flags &= ~ SHF_MASKPROC;
5333 }
5334 else
5335 *p = 'x';
5336 break;
5337 }
5338 p++;
d1133906
NC		 5339 }
5340 }
76da6bbe 5341
8d5ff12c
L		 5342 if (do_section_details)
5343 {
5344 if (os_flags)
5345 {
5346 size -= 5 + field_size;
5347 if (p != buff + field_size + 4)
5348 {
5349 if (size < (2 + 1))
bee0ee85
NC		 5350 {
5351 warn (_("Internal error: not enough buffer room for section flag info"));
5352 return _("<unknown>");
5353 }
8d5ff12c
L		 5354 size -= 2;
5355 *p++ = ',';
5356 *p++ = ' ';
5357 }
5358 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5359 (unsigned long) os_flags);
5360 p += 5 + field_size;
5361 }
5362 if (proc_flags)
5363 {
5364 size -= 7 + field_size;
5365 if (p != buff + field_size + 4)
5366 {
5367 if (size < (2 + 1))
bee0ee85
NC		 5368 {
5369 warn (_("Internal error: not enough buffer room for section flag info"));
5370 return _("<unknown>");
5371 }
8d5ff12c
L		 5372 size -= 2;
5373 *p++ = ',';
5374 *p++ = ' ';
5375 }
5376 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5377 (unsigned long) proc_flags);
5378 p += 7 + field_size;
5379 }
5380 if (unknown_flags)
5381 {
5382 size -= 10 + field_size;
5383 if (p != buff + field_size + 4)
5384 {
5385 if (size < (2 + 1))
bee0ee85
NC		 5386 {
5387 warn (_("Internal error: not enough buffer room for section flag info"));
5388 return _("<unknown>");
5389 }
8d5ff12c
L		 5390 size -= 2;
5391 *p++ = ',';
5392 *p++ = ' ';
5393 }
2b692964 5394 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 5395 (unsigned long) unknown_flags);
5396 p += 10 + field_size;
5397 }
5398 }
5399
e9e44622 5400 *p = '\0';
d1133906
NC		 5401 return buff;
5402}
5403
77115a4a
L		 5404static unsigned int
5405get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf)
5406{
5407 if (is_32bit_elf)
5408 {
5409 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5410 chdr->ch_type = BYTE_GET (echdr->ch_type);
5411 chdr->ch_size = BYTE_GET (echdr->ch_size);
5412 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5413 return sizeof (*echdr);
5414 }
5415 else
5416 {
5417 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5418 chdr->ch_type = BYTE_GET (echdr->ch_type);
5419 chdr->ch_size = BYTE_GET (echdr->ch_size);
5420 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5421 return sizeof (*echdr);
5422 }
5423}
5424
252b5132 5425static int
2cf0635d 5426process_section_headers (FILE * file)
252b5132 5427{
2cf0635d 5428 Elf_Internal_Shdr * section;
b34976b6 5429 unsigned int i;
252b5132
RH		 5430
5431 section_headers = NULL;
5432
5433 if (elf_header.e_shnum == 0)
5434 {
82f2dbf7
NC		 5435 /* PR binutils/12467. */
5436 if (elf_header.e_shoff != 0)
5437 warn (_("possibly corrupt ELF file header - it has a non-zero"
5438 " section header offset, but no section headers\n"));
5439 else if (do_sections)
252b5132
RH		 5440 printf (_("\nThere are no sections in this file.\n"));
5441
5442 return 1;
5443 }
5444
5445 if (do_sections && !do_header)
9ea033b2 5446 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 5447 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5448
9ea033b2
NC		 5449 if (is_32bit_elf)
5450 {
049b0c3a 5451 if (! get_32bit_section_headers (file, FALSE))
9ea033b2
NC		 5452 return 0;
5453 }
049b0c3a 5454 else if (! get_64bit_section_headers (file, FALSE))
252b5132
RH		 5455 return 0;
5456
5457 /* Read in the string table, so that we have names to display. */
0b49d371 5458 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 5459 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 5460 {
4fbb74a6 5461 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 5462
c256ffe7
JJ		 5463 if (section->sh_size != 0)
5464 {
3f5e193b
NC		 5465 string_table = (char *) get_data (NULL, file, section->sh_offset,
5466 1, section->sh_size,
5467 _("string table"));
0de14b54 5468
c256ffe7
JJ		 5469 string_table_length = string_table != NULL ? section->sh_size : 0;
5470 }
252b5132
RH		 5471 }
5472
5473 /* Scan the sections for the dynamic symbol table
e3c8793a 5474 and dynamic string table and debug sections. */
252b5132
RH		 5475 dynamic_symbols = NULL;
5476 dynamic_strings = NULL;
5477 dynamic_syminfo = NULL;
f1ef08cb 5478 symtab_shndx_hdr = NULL;
103f02d3 5479
89fac5e3
RS		 5480 eh_addr_size = is_32bit_elf ? 4 : 8;
5481 switch (elf_header.e_machine)
5482 {
5483 case EM_MIPS:
5484 case EM_MIPS_RS3_LE:
5485 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5486 FDE addresses. However, the ABI also has a semi-official ILP32
5487 variant for which the normal FDE address size rules apply.
5488
5489 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5490 section, where XX is the size of longs in bits. Unfortunately,
5491 earlier compilers provided no way of distinguishing ILP32 objects
5492 from LP64 objects, so if there's any doubt, we should assume that
5493 the official LP64 form is being used. */
5494 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5495 && find_section (".gcc_compiled_long32") == NULL)
5496 eh_addr_size = 8;
5497 break;
0f56a26a
DD		 5498
5499 case EM_H8_300:
5500 case EM_H8_300H:
5501 switch (elf_header.e_flags & EF_H8_MACH)
5502 {
5503 case E_H8_MACH_H8300:
5504 case E_H8_MACH_H8300HN:
5505 case E_H8_MACH_H8300SN:
5506 case E_H8_MACH_H8300SXN:
5507 eh_addr_size = 2;
5508 break;
5509 case E_H8_MACH_H8300H:
5510 case E_H8_MACH_H8300S:
5511 case E_H8_MACH_H8300SX:
5512 eh_addr_size = 4;
5513 break;
5514 }
f4236fe4
DD		 5515 break;
5516
ff7eeb89 5517 case EM_M32C_OLD:
f4236fe4
DD		 5518 case EM_M32C:
5519 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5520 {
5521 case EF_M32C_CPU_M16C:
5522 eh_addr_size = 2;
5523 break;
5524 }
5525 break;
89fac5e3
RS		 5526 }
5527
76ca31c0
NC		 5528#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5529 do \
5530 { \
5531 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5532 if (section->sh_entsize != expected_entsize) \
9dd3a467 5533 { \
76ca31c0
NC		 5534 char buf[40]; \
5535 sprintf_vma (buf, section->sh_entsize); \
5536 /* Note: coded this way so that there is a single string for \
5537 translation. */ \
5538 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5539 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5540 (unsigned) expected_entsize); \
9dd3a467 5541 section->sh_entsize = expected_entsize; \
76ca31c0
NC		 5542 } \
5543 } \
08d8fa11 5544 while (0)
9dd3a467
NC		 5545
5546#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 5547 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5548 sizeof (Elf64_External_##type))
5549
252b5132
RH		 5550 for (i = 0, section = section_headers;
5551 i < elf_header.e_shnum;
b34976b6 5552 i++, section++)
252b5132 5553 {
2cf0635d 5554 char * name = SECTION_NAME (section);
252b5132
RH		 5555
5556 if (section->sh_type == SHT_DYNSYM)
5557 {
5558 if (dynamic_symbols != NULL)
5559 {
5560 error (_("File contains multiple dynamic symbol tables\n"));
5561 continue;
5562 }
5563
08d8fa11 5564 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 5565 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 5566 }
5567 else if (section->sh_type == SHT_STRTAB
18bd398b 5568 && streq (name, ".dynstr"))
252b5132
RH		 5569 {
5570 if (dynamic_strings != NULL)
5571 {
5572 error (_("File contains multiple dynamic string tables\n"));
5573 continue;
5574 }
5575
3f5e193b
NC		 5576 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5577 1, section->sh_size,
5578 _("dynamic strings"));
59245841 5579 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 5580 }
9ad5cbcf
AM		 5581 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5582 {
5583 if (symtab_shndx_hdr != NULL)
5584 {
5585 error (_("File contains multiple symtab shndx tables\n"));
5586 continue;
5587 }
5588 symtab_shndx_hdr = section;
5589 }
08d8fa11
JJ		 5590 else if (section->sh_type == SHT_SYMTAB)
5591 CHECK_ENTSIZE (section, i, Sym);
5592 else if (section->sh_type == SHT_GROUP)
5593 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5594 else if (section->sh_type == SHT_REL)
5595 CHECK_ENTSIZE (section, i, Rel);
5596 else if (section->sh_type == SHT_RELA)
5597 CHECK_ENTSIZE (section, i, Rela);
252b5132 5598 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 5599 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 5600 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 5601 || do_debug_str || do_debug_loc || do_debug_ranges
5602 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 5603 && (const_strneq (name, ".debug_")
5604 || const_strneq (name, ".zdebug_")))
252b5132 5605 {
1b315056
CS		 5606 if (name[1] == 'z')
5607 name += sizeof (".zdebug_") - 1;
5608 else
5609 name += sizeof (".debug_") - 1;
252b5132
RH		 5610
5611 if (do_debugging
4723351a
CC		 5612 || (do_debug_info && const_strneq (name, "info"))
5613 || (do_debug_info && const_strneq (name, "types"))
5614 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 5615 || (do_debug_lines && strcmp (name, "line") == 0)
5616 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 5617 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5618 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
459d52c8
DE		 5619 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5620 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4723351a
CC		 5621 || (do_debug_aranges && const_strneq (name, "aranges"))
5622 || (do_debug_ranges && const_strneq (name, "ranges"))
5623 || (do_debug_frames && const_strneq (name, "frame"))
5624 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5625 || (do_debug_macinfo && const_strneq (name, "macro"))
5626 || (do_debug_str && const_strneq (name, "str"))
5627 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 5628 || (do_debug_addr && const_strneq (name, "addr"))
5629 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5630 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 5631 )
09c11c86 5632 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 5633 }
a262ae96 5634 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 5635 else if ((do_debugging || do_debug_info)
0112cd26 5636 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 5637 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 5638 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 5639 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 5640 else if (do_gdb_index && streq (name, ".gdb_index"))
5641 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 5642 /* Trace sections for Itanium VMS. */
5643 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5644 || do_trace_aranges)
5645 && const_strneq (name, ".trace_"))
5646 {
5647 name += sizeof (".trace_") - 1;
5648
5649 if (do_debugging
5650 || (do_trace_info && streq (name, "info"))
5651 || (do_trace_abbrevs && streq (name, "abbrev"))
5652 || (do_trace_aranges && streq (name, "aranges"))
5653 )
5654 request_dump_bynumber (i, DEBUG_DUMP);
5655 }
252b5132
RH		 5656 }
5657
5658 if (! do_sections)
5659 return 1;
5660
3a1a2036
NC		 5661 if (elf_header.e_shnum > 1)
5662 printf (_("\nSection Headers:\n"));
5663 else
5664 printf (_("\nSection Header:\n"));
76da6bbe 5665
f7a99963 5666 if (is_32bit_elf)
595cf52e 5667 {
5477e8a0 5668 if (do_section_details)
595cf52e
L		 5669 {
5670 printf (_(" [Nr] Name\n"));
5477e8a0 5671 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 5672 }
5673 else
5674 printf
5675 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5676 }
d974e256 5677 else if (do_wide)
595cf52e 5678 {
5477e8a0 5679 if (do_section_details)
595cf52e
L		 5680 {
5681 printf (_(" [Nr] Name\n"));
5477e8a0 5682 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 5683 }
5684 else
5685 printf
5686 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5687 }
f7a99963
NC		 5688 else
5689 {
5477e8a0 5690 if (do_section_details)
595cf52e
L		 5691 {
5692 printf (_(" [Nr] Name\n"));
5477e8a0
L		 5693 printf (_(" Type Address Offset Link\n"));
5694 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 5695 }
5696 else
5697 {
5698 printf (_(" [Nr] Name Type Address Offset\n"));
5699 printf (_(" Size EntSize Flags Link Info Align\n"));
5700 }
f7a99963 5701 }
252b5132 5702
5477e8a0
L		 5703 if (do_section_details)
5704 printf (_(" Flags\n"));
5705
252b5132
RH		 5706 for (i = 0, section = section_headers;
5707 i < elf_header.e_shnum;
b34976b6 5708 i++, section++)
252b5132 5709 {
7bfd842d 5710 printf (" [%2u] ", i);
5477e8a0 5711 if (do_section_details)
74e1a04b 5712 printf ("%s\n ", printable_section_name (section));
595cf52e 5713 else
74e1a04b 5714 print_symbol (-17, SECTION_NAME (section));
0b4362b0 5715
ea52a088
NC		 5716 printf (do_wide ? " %-15s " : " %-15.15s ",
5717 get_section_type_name (section->sh_type));
0b4362b0 5718
f7a99963
NC		 5719 if (is_32bit_elf)
5720 {
cfcac11d
NC		 5721 const char * link_too_big = NULL;
5722
f7a99963 5723 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 5724
f7a99963
NC		 5725 printf ( " %6.6lx %6.6lx %2.2lx",
5726 (unsigned long) section->sh_offset,
5727 (unsigned long) section->sh_size,
5728 (unsigned long) section->sh_entsize);
d1133906 5729
5477e8a0
L		 5730 if (do_section_details)
5731 fputs (" ", stdout);
5732 else
5733 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5734
cfcac11d
NC		 5735 if (section->sh_link >= elf_header.e_shnum)
5736 {
5737 link_too_big = "";
5738 /* The sh_link value is out of range. Normally this indicates
caa83f8b 5739 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 5740 switch (elf_header.e_machine)
5741 {
caa83f8b 5742 case EM_386:
22abe556 5743 case EM_IAMCU:
caa83f8b 5744 case EM_X86_64:
7f502d6c 5745 case EM_L1OM:
7a9068fe 5746 case EM_K1OM:
cfcac11d
NC		 5747 case EM_OLD_SPARCV9:
5748 case EM_SPARC32PLUS:
5749 case EM_SPARCV9:
5750 case EM_SPARC:
5751 if (section->sh_link == (SHN_BEFORE & 0xffff))
5752 link_too_big = "BEFORE";
5753 else if (section->sh_link == (SHN_AFTER & 0xffff))
5754 link_too_big = "AFTER";
5755 break;
5756 default:
5757 break;
5758 }
5759 }
5760
5761 if (do_section_details)
5762 {
5763 if (link_too_big != NULL && * link_too_big)
5764 printf ("<%s> ", link_too_big);
5765 else
5766 printf ("%2u ", section->sh_link);
5767 printf ("%3u %2lu\n", section->sh_info,
5768 (unsigned long) section->sh_addralign);
5769 }
5770 else
5771 printf ("%2u %3u %2lu\n",
5772 section->sh_link,
5773 section->sh_info,
5774 (unsigned long) section->sh_addralign);
5775
5776 if (link_too_big && ! * link_too_big)
5777 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5778 i, section->sh_link);
f7a99963 5779 }
d974e256
JJ		 5780 else if (do_wide)
5781 {
5782 print_vma (section->sh_addr, LONG_HEX);
5783
5784 if ((long) section->sh_offset == section->sh_offset)
5785 printf (" %6.6lx", (unsigned long) section->sh_offset);
5786 else
5787 {
5788 putchar (' ');
5789 print_vma (section->sh_offset, LONG_HEX);
5790 }
5791
5792 if ((unsigned long) section->sh_size == section->sh_size)
5793 printf (" %6.6lx", (unsigned long) section->sh_size);
5794 else
5795 {
5796 putchar (' ');
5797 print_vma (section->sh_size, LONG_HEX);
5798 }
5799
5800 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5801 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5802 else
5803 {
5804 putchar (' ');
5805 print_vma (section->sh_entsize, LONG_HEX);
5806 }
5807
5477e8a0
L		 5808 if (do_section_details)
5809 fputs (" ", stdout);
5810 else
5811 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 5812
72de5009 5813 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 5814
5815 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 5816 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 5817 else
5818 {
5819 print_vma (section->sh_addralign, DEC);
5820 putchar ('\n');
5821 }
5822 }
5477e8a0 5823 else if (do_section_details)
595cf52e 5824 {
5477e8a0 5825 printf (" %-15.15s ",
595cf52e 5826 get_section_type_name (section->sh_type));
595cf52e
L		 5827 print_vma (section->sh_addr, LONG_HEX);
5828 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 5829 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 5830 else
5831 {
5832 printf (" ");
5833 print_vma (section->sh_offset, LONG_HEX);
5834 }
72de5009 5835 printf (" %u\n ", section->sh_link);
595cf52e 5836 print_vma (section->sh_size, LONG_HEX);
5477e8a0 5837 putchar (' ');
595cf52e
L		 5838 print_vma (section->sh_entsize, LONG_HEX);
5839
72de5009
AM		 5840 printf (" %-16u %lu\n",
5841 section->sh_info,
595cf52e
L		 5842 (unsigned long) section->sh_addralign);
5843 }
f7a99963
NC		 5844 else
5845 {
5846 putchar (' ');
5847 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 5848 if ((long) section->sh_offset == section->sh_offset)
5849 printf (" %8.8lx", (unsigned long) section->sh_offset);
5850 else
5851 {
5852 printf (" ");
5853 print_vma (section->sh_offset, LONG_HEX);
5854 }
f7a99963
NC		 5855 printf ("\n ");
5856 print_vma (section->sh_size, LONG_HEX);
5857 printf (" ");
5858 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 5859
d1133906 5860 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5861
72de5009
AM		 5862 printf (" %2u %3u %lu\n",
5863 section->sh_link,
5864 section->sh_info,
f7a99963
NC		 5865 (unsigned long) section->sh_addralign);
5866 }
5477e8a0
L		 5867
5868 if (do_section_details)
77115a4a
L		 5869 {
5870 printf (" %s\n", get_elf_section_flags (section->sh_flags));
5871 if ((section->sh_flags & SHF_COMPRESSED) != 0)
5872 {
5873 /* Minimum section size is 12 bytes for 32-bit compression
5874 header + 12 bytes for compressed data header. */
5875 unsigned char buf[24];
5876 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
5877 if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
5878 sizeof (buf), _("compression header")))
5879 {
5880 Elf_Internal_Chdr chdr;
5881 get_compression_header (&chdr, buf);
5882 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
5883 printf (" ZLIB, ");
5884 else
5885 printf (_(" [<unknown>: 0x%x], "),
5886 chdr.ch_type);
5887 print_vma (chdr.ch_size, LONG_HEX);
5888 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
5889 }
5890 }
5891 }
252b5132
RH		 5892 }
5893
5477e8a0 5894 if (!do_section_details)
3dbcc61d
NC		 5895 {
5896 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 5897 || elf_header.e_machine == EM_L1OM
5898 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 5899 printf (_("Key to Flags:\n\
5900 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5901 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5902 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5903 else
5904 printf (_("Key to Flags:\n\
e3c8793a 5905 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 5906 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 5907 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
0b4362b0 5908 }
d1133906 5909
252b5132
RH		 5910 return 1;
5911}
5912
f5842774
L		 5913static const char *
5914get_group_flags (unsigned int flags)
5915{
5916 static char buff[32];
5917 switch (flags)
5918 {
220453ec
AM		 5919 case 0:
5920 return "";
5921
f5842774 5922 case GRP_COMDAT:
220453ec 5923 return "COMDAT ";
f5842774
L		 5924
5925 default:
220453ec 5926 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 5927 break;
5928 }
5929 return buff;
5930}
5931
5932static int
2cf0635d 5933process_section_groups (FILE * file)
f5842774 5934{
2cf0635d 5935 Elf_Internal_Shdr * section;
f5842774 5936 unsigned int i;
2cf0635d
NC		 5937 struct group * group;
5938 Elf_Internal_Shdr * symtab_sec;
5939 Elf_Internal_Shdr * strtab_sec;
5940 Elf_Internal_Sym * symtab;
ba5cdace 5941 unsigned long num_syms;
2cf0635d 5942 char * strtab;
c256ffe7 5943 size_t strtab_size;
d1f5c6e3
L		 5944
5945 /* Don't process section groups unless needed. */
5946 if (!do_unwind && !do_section_groups)
5947 return 1;
f5842774
L		 5948
5949 if (elf_header.e_shnum == 0)
5950 {
5951 if (do_section_groups)
82f2dbf7 5952 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 5953
5954 return 1;
5955 }
5956
5957 if (section_headers == NULL)
5958 {
5959 error (_("Section headers are not available!\n"));
fa1908fd
NC		 5960 /* PR 13622: This can happen with a corrupt ELF header. */
5961 return 0;
f5842774
L		 5962 }
5963
3f5e193b
NC		 5964 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5965 sizeof (struct group *));
e4b17d5c
L		 5966
5967 if (section_headers_groups == NULL)
5968 {
8b73c356
NC		 5969 error (_("Out of memory reading %u section group headers\n"),
5970 elf_header.e_shnum);
e4b17d5c
L		 5971 return 0;
5972 }
5973
f5842774 5974 /* Scan the sections for the group section. */
d1f5c6e3 5975 group_count = 0;
f5842774
L		 5976 for (i = 0, section = section_headers;
5977 i < elf_header.e_shnum;
5978 i++, section++)
e4b17d5c
L		 5979 if (section->sh_type == SHT_GROUP)
5980 group_count++;
5981
d1f5c6e3
L		 5982 if (group_count == 0)
5983 {
5984 if (do_section_groups)
5985 printf (_("\nThere are no section groups in this file.\n"));
5986
5987 return 1;
5988 }
5989
3f5e193b 5990 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 5991
5992 if (section_groups == NULL)
5993 {
8b73c356
NC		 5994 error (_("Out of memory reading %lu groups\n"),
5995 (unsigned long) group_count);
e4b17d5c
L		 5996 return 0;
5997 }
5998
d1f5c6e3
L		 5999 symtab_sec = NULL;
6000 strtab_sec = NULL;
6001 symtab = NULL;
ba5cdace 6002 num_syms = 0;
d1f5c6e3 6003 strtab = NULL;
c256ffe7 6004 strtab_size = 0;
e4b17d5c
L		 6005 for (i = 0, section = section_headers, group = section_groups;
6006 i < elf_header.e_shnum;
6007 i++, section++)
f5842774
L		 6008 {
6009 if (section->sh_type == SHT_GROUP)
6010 {
74e1a04b
NC		 6011 const char * name = printable_section_name (section);
6012 const char * group_name;
2cf0635d
NC		 6013 unsigned char * start;
6014 unsigned char * indices;
f5842774 6015 unsigned int entry, j, size;
2cf0635d
NC		 6016 Elf_Internal_Shdr * sec;
6017 Elf_Internal_Sym * sym;
f5842774
L		 6018
6019 /* Get the symbol table. */
4fbb74a6
AM		 6020 if (section->sh_link >= elf_header.e_shnum
6021 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 6022 != SHT_SYMTAB))
f5842774
L		 6023 {
6024 error (_("Bad sh_link in group section `%s'\n"), name);
6025 continue;
6026 }
d1f5c6e3
L		 6027
6028 if (symtab_sec != sec)
6029 {
6030 symtab_sec = sec;
6031 if (symtab)
6032 free (symtab);
ba5cdace 6033 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 6034 }
f5842774 6035
dd24e3da
NC		 6036 if (symtab == NULL)
6037 {
6038 error (_("Corrupt header in group section `%s'\n"), name);
6039 continue;
6040 }
6041
ba5cdace
NC		 6042 if (section->sh_info >= num_syms)
6043 {
6044 error (_("Bad sh_info in group section `%s'\n"), name);
6045 continue;
6046 }
6047
f5842774
L		 6048 sym = symtab + section->sh_info;
6049
6050 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6051 {
4fbb74a6
AM		 6052 if (sym->st_shndx == 0
6053 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 6054 {
6055 error (_("Bad sh_info in group section `%s'\n"), name);
6056 continue;
6057 }
ba2685cc 6058
4fbb74a6 6059 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 6060 strtab_sec = NULL;
6061 if (strtab)
6062 free (strtab);
f5842774 6063 strtab = NULL;
c256ffe7 6064 strtab_size = 0;
f5842774
L		 6065 }
6066 else
6067 {
6068 /* Get the string table. */
4fbb74a6 6069 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 6070 {
6071 strtab_sec = NULL;
6072 if (strtab)
6073 free (strtab);
6074 strtab = NULL;
6075 strtab_size = 0;
6076 }
6077 else if (strtab_sec
4fbb74a6 6078 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 6079 {
6080 strtab_sec = sec;
6081 if (strtab)
6082 free (strtab);
071436c6 6083
3f5e193b 6084 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
071436c6
NC		 6085 1, strtab_sec->sh_size,
6086 _("string table"));
c256ffe7 6087 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 6088 }
c256ffe7 6089 group_name = sym->st_name < strtab_size
2b692964 6090 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 6091 }
6092
c9c1d674
EG		 6093 /* PR 17531: file: loop. */
6094 if (section->sh_entsize > section->sh_size)
6095 {
6096 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6097 printable_section_name (section),
8066deb1
AM		 6098 (unsigned long) section->sh_entsize,
6099 (unsigned long) section->sh_size);
c9c1d674
EG		 6100 break;
6101 }
6102
3f5e193b
NC		 6103 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6104 1, section->sh_size,
6105 _("section data"));
59245841
NC		 6106 if (start == NULL)
6107 continue;
f5842774
L		 6108
6109 indices = start;
6110 size = (section->sh_size / section->sh_entsize) - 1;
6111 entry = byte_get (indices, 4);
6112 indices += 4;
e4b17d5c
L		 6113
6114 if (do_section_groups)
6115 {
2b692964 6116 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 6117 get_group_flags (entry), i, name, group_name, size);
ba2685cc 6118
e4b17d5c
L		 6119 printf (_(" [Index] Name\n"));
6120 }
6121
6122 group->group_index = i;
6123
f5842774
L		 6124 for (j = 0; j < size; j++)
6125 {
2cf0635d 6126 struct group_list * g;
e4b17d5c 6127
f5842774
L		 6128 entry = byte_get (indices, 4);
6129 indices += 4;
6130
4fbb74a6 6131 if (entry >= elf_header.e_shnum)
391cb864 6132 {
57028622
NC		 6133 static unsigned num_group_errors = 0;
6134
6135 if (num_group_errors ++ < 10)
6136 {
6137 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6138 entry, i, elf_header.e_shnum - 1);
6139 if (num_group_errors == 10)
6140 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6141 }
391cb864
L		 6142 continue;
6143 }
391cb864 6144
4fbb74a6 6145 if (section_headers_groups [entry] != NULL)
e4b17d5c 6146 {
d1f5c6e3
L		 6147 if (entry)
6148 {
57028622
NC		 6149 static unsigned num_errs = 0;
6150
6151 if (num_errs ++ < 10)
6152 {
6153 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6154 entry, i,
6155 section_headers_groups [entry]->group_index);
6156 if (num_errs == 10)
6157 warn (_("Further error messages about already contained group sections suppressed\n"));
6158 }
d1f5c6e3
L		 6159 continue;
6160 }
6161 else
6162 {
6163 /* Intel C/C++ compiler may put section 0 in a
6164 section group. We just warn it the first time
6165 and ignore it afterwards. */
6166 static int warned = 0;
6167 if (!warned)
6168 {
6169 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 6170 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 6171 warned++;
6172 }
6173 }
e4b17d5c
L		 6174 }
6175
4fbb74a6 6176 section_headers_groups [entry] = group;
e4b17d5c
L		 6177
6178 if (do_section_groups)
6179 {
4fbb74a6 6180 sec = section_headers + entry;
74e1a04b 6181 printf (" [%5u] %s\n", entry, printable_section_name (sec));
ba2685cc
AM		 6182 }
6183
3f5e193b 6184 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 6185 g->section_index = entry;
6186 g->next = group->root;
6187 group->root = g;
f5842774
L		 6188 }
6189
f5842774
L		 6190 if (start)
6191 free (start);
e4b17d5c
L		 6192
6193 group++;
f5842774
L		 6194 }
6195 }
6196
d1f5c6e3
L		 6197 if (symtab)
6198 free (symtab);
6199 if (strtab)
6200 free (strtab);
f5842774
L		 6201 return 1;
6202}
6203
28f997cf
TG		 6204/* Data used to display dynamic fixups. */
6205
6206struct ia64_vms_dynfixup
6207{
6208 bfd_vma needed_ident; /* Library ident number. */
6209 bfd_vma needed; /* Index in the dstrtab of the library name. */
6210 bfd_vma fixup_needed; /* Index of the library. */
6211 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6212 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6213};
6214
6215/* Data used to display dynamic relocations. */
6216
6217struct ia64_vms_dynimgrela
6218{
6219 bfd_vma img_rela_cnt; /* Number of relocations. */
6220 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6221};
6222
6223/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6224 library). */
6225
6226static void
6227dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6228 const char *strtab, unsigned int strtab_sz)
6229{
6230 Elf64_External_VMS_IMAGE_FIXUP *imfs;
6231 long i;
6232 const char *lib_name;
6233
6234 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6235 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6236 _("dynamic section image fixups"));
6237 if (!imfs)
6238 return;
6239
6240 if (fixup->needed < strtab_sz)
6241 lib_name = strtab + fixup->needed;
6242 else
6243 {
6244 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 6245 (unsigned long) fixup->needed);
28f997cf
TG		 6246 lib_name = "???";
6247 }
6248 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6249 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6250 printf
6251 (_("Seg Offset Type SymVec DataType\n"));
6252
6253 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6254 {
6255 unsigned int type;
6256 const char *rtype;
6257
6258 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6259 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6260 type = BYTE_GET (imfs [i].type);
6261 rtype = elf_ia64_reloc_type (type);
6262 if (rtype == NULL)
6263 printf (" 0x%08x ", type);
6264 else
6265 printf (" %-32s ", rtype);
6266 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6267 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6268 }
6269
6270 free (imfs);
6271}
6272
6273/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6274
6275static void
6276dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6277{
6278 Elf64_External_VMS_IMAGE_RELA *imrs;
6279 long i;
6280
6281 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6282 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 6283 _("dynamic section image relocations"));
28f997cf
TG		 6284 if (!imrs)
6285 return;
6286
6287 printf (_("\nImage relocs\n"));
6288 printf
6289 (_("Seg Offset Type Addend Seg Sym Off\n"));
6290
6291 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6292 {
6293 unsigned int type;
6294 const char *rtype;
6295
6296 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6297 printf ("%08" BFD_VMA_FMT "x ",
6298 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6299 type = BYTE_GET (imrs [i].type);
6300 rtype = elf_ia64_reloc_type (type);
6301 if (rtype == NULL)
6302 printf ("0x%08x ", type);
6303 else
6304 printf ("%-31s ", rtype);
6305 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6306 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6307 printf ("%08" BFD_VMA_FMT "x\n",
6308 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6309 }
6310
6311 free (imrs);
6312}
6313
6314/* Display IA-64 OpenVMS dynamic relocations and fixups. */
6315
6316static int
6317process_ia64_vms_dynamic_relocs (FILE *file)
6318{
6319 struct ia64_vms_dynfixup fixup;
6320 struct ia64_vms_dynimgrela imgrela;
6321 Elf_Internal_Dyn *entry;
6322 int res = 0;
6323 bfd_vma strtab_off = 0;
6324 bfd_vma strtab_sz = 0;
6325 char *strtab = NULL;
6326
6327 memset (&fixup, 0, sizeof (fixup));
6328 memset (&imgrela, 0, sizeof (imgrela));
6329
6330 /* Note: the order of the entries is specified by the OpenVMS specs. */
6331 for (entry = dynamic_section;
6332 entry < dynamic_section + dynamic_nent;
6333 entry++)
6334 {
6335 switch (entry->d_tag)
6336 {
6337 case DT_IA_64_VMS_STRTAB_OFFSET:
6338 strtab_off = entry->d_un.d_val;
6339 break;
6340 case DT_STRSZ:
6341 strtab_sz = entry->d_un.d_val;
6342 if (strtab == NULL)
6343 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6344 1, strtab_sz, _("dynamic string section"));
6345 break;
6346
6347 case DT_IA_64_VMS_NEEDED_IDENT:
6348 fixup.needed_ident = entry->d_un.d_val;
6349 break;
6350 case DT_NEEDED:
6351 fixup.needed = entry->d_un.d_val;
6352 break;
6353 case DT_IA_64_VMS_FIXUP_NEEDED:
6354 fixup.fixup_needed = entry->d_un.d_val;
6355 break;
6356 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6357 fixup.fixup_rela_cnt = entry->d_un.d_val;
6358 break;
6359 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6360 fixup.fixup_rela_off = entry->d_un.d_val;
6361 res++;
6362 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6363 break;
6364
6365 case DT_IA_64_VMS_IMG_RELA_CNT:
6366 imgrela.img_rela_cnt = entry->d_un.d_val;
6367 break;
6368 case DT_IA_64_VMS_IMG_RELA_OFF:
6369 imgrela.img_rela_off = entry->d_un.d_val;
6370 res++;
6371 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6372 break;
6373
6374 default:
6375 break;
6376 }
6377 }
6378
6379 if (strtab != NULL)
6380 free (strtab);
6381
6382 return res;
6383}
6384
85b1c36d 6385static struct
566b0d53 6386{
2cf0635d 6387 const char * name;
566b0d53
L		 6388 int reloc;
6389 int size;
6390 int rela;
6391} dynamic_relocations [] =
6392{
6393 { "REL", DT_REL, DT_RELSZ, FALSE },
6394 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6395 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6396};
6397
252b5132 6398/* Process the reloc section. */
18bd398b 6399
252b5132 6400static int
2cf0635d 6401process_relocs (FILE * file)
252b5132 6402{
b34976b6
AM		 6403 unsigned long rel_size;
6404 unsigned long rel_offset;
252b5132
RH		 6405
6406
6407 if (!do_reloc)
6408 return 1;
6409
6410 if (do_using_dynamic)
6411 {
566b0d53 6412 int is_rela;
2cf0635d 6413 const char * name;
566b0d53
L		 6414 int has_dynamic_reloc;
6415 unsigned int i;
0de14b54 6416
566b0d53 6417 has_dynamic_reloc = 0;
252b5132 6418
566b0d53 6419 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 6420 {
566b0d53
L		 6421 is_rela = dynamic_relocations [i].rela;
6422 name = dynamic_relocations [i].name;
6423 rel_size = dynamic_info [dynamic_relocations [i].size];
6424 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 6425
566b0d53
L		 6426 has_dynamic_reloc |= rel_size;
6427
6428 if (is_rela == UNKNOWN)
aa903cfb 6429 {
566b0d53
L		 6430 if (dynamic_relocations [i].reloc == DT_JMPREL)
6431 switch (dynamic_info[DT_PLTREL])
6432 {
6433 case DT_REL:
6434 is_rela = FALSE;
6435 break;
6436 case DT_RELA:
6437 is_rela = TRUE;
6438 break;
6439 }
aa903cfb 6440 }
252b5132 6441
566b0d53
L		 6442 if (rel_size)
6443 {
6444 printf
6445 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6446 name, rel_offset, rel_size);
252b5132 6447
d93f0186
NC		 6448 dump_relocations (file,
6449 offset_from_vma (file, rel_offset, rel_size),
6450 rel_size,
566b0d53 6451 dynamic_symbols, num_dynamic_syms,
bb4d2ac2
L		 6452 dynamic_strings, dynamic_strings_length,
6453 is_rela, 1);
566b0d53 6454 }
252b5132 6455 }
566b0d53 6456
28f997cf
TG		 6457 if (is_ia64_vms ())
6458 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6459
566b0d53 6460 if (! has_dynamic_reloc)
252b5132
RH		 6461 printf (_("\nThere are no dynamic relocations in this file.\n"));
6462 }
6463 else
6464 {
2cf0635d 6465 Elf_Internal_Shdr * section;
b34976b6
AM		 6466 unsigned long i;
6467 int found = 0;
252b5132
RH		 6468
6469 for (i = 0, section = section_headers;
6470 i < elf_header.e_shnum;
b34976b6 6471 i++, section++)
252b5132
RH		 6472 {
6473 if ( section->sh_type != SHT_RELA
6474 && section->sh_type != SHT_REL)
6475 continue;
6476
6477 rel_offset = section->sh_offset;
6478 rel_size = section->sh_size;
6479
6480 if (rel_size)
6481 {
2cf0635d 6482 Elf_Internal_Shdr * strsec;
b34976b6 6483 int is_rela;
103f02d3 6484
252b5132
RH		 6485 printf (_("\nRelocation section "));
6486
6487 if (string_table == NULL)
19936277 6488 printf ("%d", section->sh_name);
252b5132 6489 else
74e1a04b 6490 printf ("'%s'", printable_section_name (section));
252b5132
RH		 6491
6492 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6493 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6494
d79b3d50
NC		 6495 is_rela = section->sh_type == SHT_RELA;
6496
4fbb74a6
AM		 6497 if (section->sh_link != 0
6498 && section->sh_link < elf_header.e_shnum)
af3fc3bc 6499 {
2cf0635d
NC		 6500 Elf_Internal_Shdr * symsec;
6501 Elf_Internal_Sym * symtab;
d79b3d50 6502 unsigned long nsyms;
c256ffe7 6503 unsigned long strtablen = 0;
2cf0635d 6504 char * strtab = NULL;
57346661 6505
4fbb74a6 6506 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 6507 if (symsec->sh_type != SHT_SYMTAB
6508 && symsec->sh_type != SHT_DYNSYM)
6509 continue;
6510
ba5cdace 6511 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 6512
af3fc3bc
AM		 6513 if (symtab == NULL)
6514 continue;
252b5132 6515
4fbb74a6
AM		 6516 if (symsec->sh_link != 0
6517 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 6518 {
4fbb74a6 6519 strsec = section_headers + symsec->sh_link;
103f02d3 6520
3f5e193b 6521 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
071436c6
NC		 6522 1, strsec->sh_size,
6523 _("string table"));
c256ffe7
JJ		 6524 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6525 }
252b5132 6526
d79b3d50 6527 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2
L		 6528 symtab, nsyms, strtab, strtablen,
6529 is_rela,
6530 symsec->sh_type == SHT_DYNSYM);
d79b3d50
NC		 6531 if (strtab)
6532 free (strtab);
6533 free (symtab);
6534 }
6535 else
6536 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2 6537 NULL, 0, NULL, 0, is_rela, 0);
252b5132
RH		 6538
6539 found = 1;
6540 }
6541 }
6542
6543 if (! found)
6544 printf (_("\nThere are no relocations in this file.\n"));
6545 }
6546
6547 return 1;
6548}
6549
4d6ed7c8
NC		 6550/* An absolute address consists of a section and an offset. If the
6551 section is NULL, the offset itself is the address, otherwise, the
6552 address equals to LOAD_ADDRESS(section) + offset. */
6553
6554struct absaddr
948f632f
DA		 6555{
6556 unsigned short section;
6557 bfd_vma offset;
6558};
4d6ed7c8 6559
1949de15
L		 6560#define ABSADDR(a) \
6561 ((a).section \
6562 ? section_headers [(a).section].sh_addr + (a).offset \
6563 : (a).offset)
6564
948f632f
DA		 6565/* Find the nearest symbol at or below ADDR. Returns the symbol
6566 name, if found, and the offset from the symbol to ADDR. */
4d6ed7c8 6567
4d6ed7c8 6568static void
2cf0635d 6569find_symbol_for_address (Elf_Internal_Sym * symtab,
948f632f
DA		 6570 unsigned long nsyms,
6571 const char * strtab,
6572 unsigned long strtab_size,
6573 struct absaddr addr,
6574 const char ** symname,
6575 bfd_vma * offset)
4d6ed7c8 6576{
d3ba0551 6577 bfd_vma dist = 0x100000;
2cf0635d 6578 Elf_Internal_Sym * sym;
948f632f
DA		 6579 Elf_Internal_Sym * beg;
6580 Elf_Internal_Sym * end;
2cf0635d 6581 Elf_Internal_Sym * best = NULL;
4d6ed7c8 6582
0b6ae522 6583 REMOVE_ARCH_BITS (addr.offset);
948f632f
DA		 6584 beg = symtab;
6585 end = symtab + nsyms;
0b6ae522 6586
948f632f 6587 while (beg < end)
4d6ed7c8 6588 {
948f632f
DA		 6589 bfd_vma value;
6590
6591 sym = beg + (end - beg) / 2;
0b6ae522 6592
948f632f 6593 value = sym->st_value;
0b6ae522
DJ		 6594 REMOVE_ARCH_BITS (value);
6595
948f632f 6596 if (sym->st_name != 0
4d6ed7c8 6597 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 6598 && addr.offset >= value
6599 && addr.offset - value < dist)
4d6ed7c8
NC		 6600 {
6601 best = sym;
0b6ae522 6602 dist = addr.offset - value;
4d6ed7c8
NC		 6603 if (!dist)
6604 break;
6605 }
948f632f
DA		 6606
6607 if (addr.offset < value)
6608 end = sym;
6609 else
6610 beg = sym + 1;
4d6ed7c8 6611 }
1b31d05e 6612
4d6ed7c8
NC		 6613 if (best)
6614 {
57346661 6615 *symname = (best->st_name >= strtab_size
2b692964 6616 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 6617 *offset = dist;
6618 return;
6619 }
1b31d05e 6620
4d6ed7c8
NC		 6621 *symname = NULL;
6622 *offset = addr.offset;
6623}
6624
948f632f
DA		 6625static int
6626symcmp (const void *p, const void *q)
6627{
6628 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
6629 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
6630
6631 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
6632}
6633
6634/* Process the unwind section. */
6635
6636#include "unwind-ia64.h"
6637
6638struct ia64_unw_table_entry
6639{
6640 struct absaddr start;
6641 struct absaddr end;
6642 struct absaddr info;
6643};
6644
6645struct ia64_unw_aux_info
6646{
6647 struct ia64_unw_table_entry *table; /* Unwind table. */
6648 unsigned long table_len; /* Length of unwind table. */
6649 unsigned char * info; /* Unwind info. */
6650 unsigned long info_size; /* Size of unwind info. */
6651 bfd_vma info_addr; /* Starting address of unwind info. */
6652 bfd_vma seg_base; /* Starting address of segment. */
6653 Elf_Internal_Sym * symtab; /* The symbol table. */
6654 unsigned long nsyms; /* Number of symbols. */
6655 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
6656 unsigned long nfuns; /* Number of entries in funtab. */
6657 char * strtab; /* The string table. */
6658 unsigned long strtab_size; /* Size of string table. */
6659};
6660
4d6ed7c8 6661static void
2cf0635d 6662dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 6663{
2cf0635d 6664 struct ia64_unw_table_entry * tp;
948f632f 6665 unsigned long j, nfuns;
4d6ed7c8 6666 int in_body;
7036c0e1 6667
948f632f
DA		 6668 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
6669 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
6670 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
6671 aux->funtab[nfuns++] = aux->symtab[j];
6672 aux->nfuns = nfuns;
6673 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
6674
4d6ed7c8
NC		 6675 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6676 {
6677 bfd_vma stamp;
6678 bfd_vma offset;
2cf0635d
NC		 6679 const unsigned char * dp;
6680 const unsigned char * head;
53774b7e 6681 const unsigned char * end;
2cf0635d 6682 const char * procname;
4d6ed7c8 6683
948f632f 6684 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661 6685 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 6686
6687 fputs ("\n<", stdout);
6688
6689 if (procname)
6690 {
6691 fputs (procname, stdout);
6692
6693 if (offset)
6694 printf ("+%lx", (unsigned long) offset);
6695 }
6696
6697 fputs (">: [", stdout);
6698 print_vma (tp->start.offset, PREFIX_HEX);
6699 fputc ('-', stdout);
6700 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 6701 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 6702 (unsigned long) (tp->info.offset - aux->seg_base));
6703
53774b7e
NC		 6704 /* PR 17531: file: 86232b32. */
6705 if (aux->info == NULL)
6706 continue;
6707
6708 /* PR 17531: file: 0997b4d1. */
6709 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6710 {
6711 warn (_("Invalid offset %lx in table entry %ld\n"),
6712 (long) tp->info.offset, (long) (tp - aux->table));
6713 continue;
6714 }
6715
1949de15 6716 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 6717 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 6718
86f55779 6719 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 6720 (unsigned) UNW_VER (stamp),
6721 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6722 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6723 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 6724 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 6725
6726 if (UNW_VER (stamp) != 1)
6727 {
2b692964 6728 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 6729 continue;
6730 }
6731
6732 in_body = 0;
53774b7e
NC		 6733 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6734 /* PR 17531: file: 16ceda89. */
6735 if (end > aux->info + aux->info_size)
6736 end = aux->info + aux->info_size;
6737 for (dp = head + 8; dp < end;)
4d6ed7c8
NC		 6738 dp = unw_decode (dp, in_body, & in_body);
6739 }
948f632f
DA		 6740
6741 free (aux->funtab);
4d6ed7c8
NC		 6742}
6743
53774b7e 6744static bfd_boolean
2cf0635d
NC		 6745slurp_ia64_unwind_table (FILE * file,
6746 struct ia64_unw_aux_info * aux,
6747 Elf_Internal_Shdr * sec)
4d6ed7c8 6748{
89fac5e3 6749 unsigned long size, nrelas, i;
2cf0635d
NC		 6750 Elf_Internal_Phdr * seg;
6751 struct ia64_unw_table_entry * tep;
6752 Elf_Internal_Shdr * relsec;
6753 Elf_Internal_Rela * rela;
6754 Elf_Internal_Rela * rp;
6755 unsigned char * table;
6756 unsigned char * tp;
6757 Elf_Internal_Sym * sym;
6758 const char * relname;
4d6ed7c8 6759
53774b7e
NC		 6760 aux->table_len = 0;
6761
4d6ed7c8
NC		 6762 /* First, find the starting address of the segment that includes
6763 this section: */
6764
6765 if (elf_header.e_phnum)
6766 {
d93f0186 6767 if (! get_program_headers (file))
53774b7e 6768 return FALSE;
4d6ed7c8 6769
d93f0186
NC		 6770 for (seg = program_headers;
6771 seg < program_headers + elf_header.e_phnum;
6772 ++seg)
4d6ed7c8
NC		 6773 {
6774 if (seg->p_type != PT_LOAD)
6775 continue;
6776
6777 if (sec->sh_addr >= seg->p_vaddr
6778 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6779 {
6780 aux->seg_base = seg->p_vaddr;
6781 break;
6782 }
6783 }
4d6ed7c8
NC		 6784 }
6785
6786 /* Second, build the unwind table from the contents of the unwind section: */
6787 size = sec->sh_size;
3f5e193b
NC		 6788 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6789 _("unwind table"));
a6e9f9df 6790 if (!table)
53774b7e 6791 return FALSE;
4d6ed7c8 6792
53774b7e 6793 aux->table_len = size / (3 * eh_addr_size);
3f5e193b 6794 aux->table = (struct ia64_unw_table_entry *)
53774b7e 6795 xcmalloc (aux->table_len, sizeof (aux->table[0]));
89fac5e3 6796 tep = aux->table;
53774b7e
NC		 6797
6798 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
4d6ed7c8
NC		 6799 {
6800 tep->start.section = SHN_UNDEF;
6801 tep->end.section = SHN_UNDEF;
6802 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 6803 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6804 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6805 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 6806 tep->start.offset += aux->seg_base;
6807 tep->end.offset += aux->seg_base;
6808 tep->info.offset += aux->seg_base;
6809 }
6810 free (table);
6811
41e92641 6812 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 6813 for (relsec = section_headers;
6814 relsec < section_headers + elf_header.e_shnum;
6815 ++relsec)
6816 {
6817 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6818 || relsec->sh_info >= elf_header.e_shnum
6819 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 6820 continue;
6821
6822 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6823 & rela, & nrelas))
53774b7e
NC		 6824 {
6825 free (aux->table);
6826 aux->table = NULL;
6827 aux->table_len = 0;
6828 return FALSE;
6829 }
4d6ed7c8
NC		 6830
6831 for (rp = rela; rp < rela + nrelas; ++rp)
6832 {
aca88567
NC		 6833 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6834 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 6835
82b1b41b
NC		 6836 /* PR 17531: file: 9fa67536. */
6837 if (relname == NULL)
6838 {
6839 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
6840 continue;
6841 }
948f632f 6842
0112cd26 6843 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 6844 {
82b1b41b 6845 warn (_("Skipping unexpected relocation type: %s\n"), relname);
4d6ed7c8
NC		 6846 continue;
6847 }
6848
89fac5e3 6849 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 6850
53774b7e
NC		 6851 /* PR 17531: file: 5bc8d9bf. */
6852 if (i >= aux->table_len)
6853 {
6854 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
6855 continue;
6856 }
6857
6858 switch (rp->r_offset / eh_addr_size % 3)
4d6ed7c8
NC		 6859 {
6860 case 0:
6861 aux->table[i].start.section = sym->st_shndx;
e466bc6e 6862 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6863 break;
6864 case 1:
6865 aux->table[i].end.section = sym->st_shndx;
e466bc6e 6866 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6867 break;
6868 case 2:
6869 aux->table[i].info.section = sym->st_shndx;
e466bc6e 6870 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6871 break;
6872 default:
6873 break;
6874 }
6875 }
6876
6877 free (rela);
6878 }
6879
53774b7e 6880 return TRUE;
4d6ed7c8
NC		 6881}
6882
1b31d05e 6883static void
2cf0635d 6884ia64_process_unwind (FILE * file)
4d6ed7c8 6885{
2cf0635d
NC		 6886 Elf_Internal_Shdr * sec;
6887 Elf_Internal_Shdr * unwsec = NULL;
6888 Elf_Internal_Shdr * strsec;
89fac5e3 6889 unsigned long i, unwcount = 0, unwstart = 0;
57346661 6890 struct ia64_unw_aux_info aux;
f1467e33 6891
4d6ed7c8
NC		 6892 memset (& aux, 0, sizeof (aux));
6893
4d6ed7c8
NC		 6894 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6895 {
c256ffe7 6896 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6897 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 6898 {
ba5cdace 6899 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 6900
4fbb74a6 6901 strsec = section_headers + sec->sh_link;
4082ef84
NC		 6902 if (aux.strtab != NULL)
6903 {
6904 error (_("Multiple auxillary string tables encountered\n"));
6905 free (aux.strtab);
6906 }
3f5e193b
NC		 6907 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6908 1, strsec->sh_size,
6909 _("string table"));
c256ffe7 6910 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 6911 }
6912 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 6913 unwcount++;
6914 }
6915
6916 if (!unwcount)
6917 printf (_("\nThere are no unwind sections in this file.\n"));
6918
6919 while (unwcount-- > 0)
6920 {
2cf0635d 6921 char * suffix;
579f31ac
JJ		 6922 size_t len, len2;
6923
4082ef84 6924 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
579f31ac
JJ		 6925 i < elf_header.e_shnum; ++i, ++sec)
6926 if (sec->sh_type == SHT_IA_64_UNWIND)
6927 {
6928 unwsec = sec;
6929 break;
6930 }
4082ef84
NC		 6931 /* We have already counted the number of SHT_IA64_UNWIND
6932 sections so the loop above should never fail. */
6933 assert (unwsec != NULL);
579f31ac
JJ		 6934
6935 unwstart = i + 1;
6936 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6937
e4b17d5c
L		 6938 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6939 {
6940 /* We need to find which section group it is in. */
4082ef84 6941 struct group_list * g;
e4b17d5c 6942
4082ef84
NC		 6943 if (section_headers_groups == NULL
6944 || section_headers_groups [i] == NULL)
6945 i = elf_header.e_shnum;
6946 else
e4b17d5c 6947 {
4082ef84 6948 g = section_headers_groups [i]->root;
18bd398b 6949
4082ef84
NC		 6950 for (; g != NULL; g = g->next)
6951 {
6952 sec = section_headers + g->section_index;
e4b17d5c 6953
4082ef84
NC		 6954 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6955 break;
6956 }
6957
6958 if (g == NULL)
6959 i = elf_header.e_shnum;
6960 }
e4b17d5c 6961 }
18bd398b 6962 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 6963 {
18bd398b 6964 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 6965 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6966 suffix = SECTION_NAME (unwsec) + len;
6967 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6968 ++i, ++sec)
18bd398b
NC		 6969 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6970 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6971 break;
6972 }
6973 else
6974 {
6975 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 6976 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 6977 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6978 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6979 suffix = "";
18bd398b 6980 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 6981 suffix = SECTION_NAME (unwsec) + len;
6982 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6983 ++i, ++sec)
18bd398b
NC		 6984 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6985 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6986 break;
6987 }
6988
6989 if (i == elf_header.e_shnum)
6990 {
6991 printf (_("\nCould not find unwind info section for "));
6992
6993 if (string_table == NULL)
6994 printf ("%d", unwsec->sh_name);
6995 else
74e1a04b 6996 printf ("'%s'", printable_section_name (unwsec));
579f31ac
JJ		 6997 }
6998 else
4d6ed7c8 6999 {
4d6ed7c8 7000 aux.info_addr = sec->sh_addr;
3f5e193b 7001 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
4082ef84
NC		 7002 sec->sh_size,
7003 _("unwind info"));
59245841 7004 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 7005
579f31ac 7006 printf (_("\nUnwind section "));
4d6ed7c8 7007
579f31ac
JJ		 7008 if (string_table == NULL)
7009 printf ("%d", unwsec->sh_name);
7010 else
74e1a04b 7011 printf ("'%s'", printable_section_name (unwsec));
4d6ed7c8 7012
579f31ac 7013 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 7014 (unsigned long) unwsec->sh_offset,
89fac5e3 7015 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 7016
53774b7e
NC		 7017 if (slurp_ia64_unwind_table (file, & aux, unwsec)
7018 && aux.table_len > 0)
579f31ac
JJ		 7019 dump_ia64_unwind (& aux);
7020
7021 if (aux.table)
7022 free ((char *) aux.table);
7023 if (aux.info)
7024 free ((char *) aux.info);
7025 aux.table = NULL;
7026 aux.info = NULL;
7027 }
4d6ed7c8 7028 }
4d6ed7c8 7029
4d6ed7c8
NC		 7030 if (aux.symtab)
7031 free (aux.symtab);
7032 if (aux.strtab)
7033 free ((char *) aux.strtab);
4d6ed7c8
NC		 7034}
7035
3f5e193b
NC		 7036struct hppa_unw_table_entry
7037 {
7038 struct absaddr start;
7039 struct absaddr end;
948f632f 7040 unsigned int Cannot_unwind:1; /* 0 */
3f5e193b
NC		 7041 unsigned int Millicode:1; /* 1 */
7042 unsigned int Millicode_save_sr0:1; /* 2 */
7043 unsigned int Region_description:2; /* 3..4 */
7044 unsigned int reserved1:1; /* 5 */
7045 unsigned int Entry_SR:1; /* 6 */
7046 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
7047 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
7048 unsigned int Args_stored:1; /* 16 */
948f632f
DA		 7049 unsigned int Variable_Frame:1; /* 17 */
7050 unsigned int Separate_Package_Body:1; /* 18 */
3f5e193b 7051 unsigned int Frame_Extension_Millicode:1; /* 19 */
948f632f
DA		 7052 unsigned int Stack_Overflow_Check:1; /* 20 */
7053 unsigned int Two_Instruction_SP_Increment:1;/* 21 */
3f5e193b
NC		 7054 unsigned int Ada_Region:1; /* 22 */
7055 unsigned int cxx_info:1; /* 23 */
948f632f
DA		 7056 unsigned int cxx_try_catch:1; /* 24 */
7057 unsigned int sched_entry_seq:1; /* 25 */
3f5e193b 7058 unsigned int reserved2:1; /* 26 */
948f632f
DA		 7059 unsigned int Save_SP:1; /* 27 */
7060 unsigned int Save_RP:1; /* 28 */
3f5e193b
NC		 7061 unsigned int Save_MRP_in_frame:1; /* 29 */
7062 unsigned int extn_ptr_defined:1; /* 30 */
948f632f 7063 unsigned int Cleanup_defined:1; /* 31 */
3f5e193b 7064
948f632f
DA		 7065 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7066 unsigned int HP_UX_interrupt_marker:1; /* 1 */
3f5e193b 7067 unsigned int Large_frame:1; /* 2 */
948f632f 7068 unsigned int Pseudo_SP_Set:1; /* 3 */
3f5e193b
NC		 7069 unsigned int reserved4:1; /* 4 */
7070 unsigned int Total_frame_size:27; /* 5..31 */
7071 };
7072
57346661 7073struct hppa_unw_aux_info
948f632f
DA		 7074{
7075 struct hppa_unw_table_entry * table; /* Unwind table. */
7076 unsigned long table_len; /* Length of unwind table. */
7077 bfd_vma seg_base; /* Starting address of segment. */
7078 Elf_Internal_Sym * symtab; /* The symbol table. */
7079 unsigned long nsyms; /* Number of symbols. */
7080 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7081 unsigned long nfuns; /* Number of entries in funtab. */
7082 char * strtab; /* The string table. */
7083 unsigned long strtab_size; /* Size of string table. */
7084};
57346661
AM		 7085
7086static void
2cf0635d 7087dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 7088{
2cf0635d 7089 struct hppa_unw_table_entry * tp;
948f632f
DA		 7090 unsigned long j, nfuns;
7091
7092 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7093 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7094 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7095 aux->funtab[nfuns++] = aux->symtab[j];
7096 aux->nfuns = nfuns;
7097 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
57346661 7098
57346661
AM		 7099 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7100 {
7101 bfd_vma offset;
2cf0635d 7102 const char * procname;
57346661 7103
948f632f 7104 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661
AM		 7105 aux->strtab_size, tp->start, &procname,
7106 &offset);
7107
7108 fputs ("\n<", stdout);
7109
7110 if (procname)
7111 {
7112 fputs (procname, stdout);
7113
7114 if (offset)
7115 printf ("+%lx", (unsigned long) offset);
7116 }
7117
7118 fputs (">: [", stdout);
7119 print_vma (tp->start.offset, PREFIX_HEX);
7120 fputc ('-', stdout);
7121 print_vma (tp->end.offset, PREFIX_HEX);
7122 printf ("]\n\t");
7123
18bd398b
NC		 7124#define PF(_m) if (tp->_m) printf (#_m " ");
7125#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 7126 PF(Cannot_unwind);
7127 PF(Millicode);
7128 PF(Millicode_save_sr0);
18bd398b 7129 /* PV(Region_description); */
57346661
AM		 7130 PF(Entry_SR);
7131 PV(Entry_FR);
7132 PV(Entry_GR);
7133 PF(Args_stored);
7134 PF(Variable_Frame);
7135 PF(Separate_Package_Body);
7136 PF(Frame_Extension_Millicode);
7137 PF(Stack_Overflow_Check);
7138 PF(Two_Instruction_SP_Increment);
7139 PF(Ada_Region);
7140 PF(cxx_info);
7141 PF(cxx_try_catch);
7142 PF(sched_entry_seq);
7143 PF(Save_SP);
7144 PF(Save_RP);
7145 PF(Save_MRP_in_frame);
7146 PF(extn_ptr_defined);
7147 PF(Cleanup_defined);
7148 PF(MPE_XL_interrupt_marker);
7149 PF(HP_UX_interrupt_marker);
7150 PF(Large_frame);
7151 PF(Pseudo_SP_Set);
7152 PV(Total_frame_size);
7153#undef PF
7154#undef PV
7155 }
7156
18bd398b 7157 printf ("\n");
948f632f
DA		 7158
7159 free (aux->funtab);
57346661
AM		 7160}
7161
7162static int
2cf0635d
NC		 7163slurp_hppa_unwind_table (FILE * file,
7164 struct hppa_unw_aux_info * aux,
7165 Elf_Internal_Shdr * sec)
57346661 7166{
1c0751b2 7167 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 7168 Elf_Internal_Phdr * seg;
7169 struct hppa_unw_table_entry * tep;
7170 Elf_Internal_Shdr * relsec;
7171 Elf_Internal_Rela * rela;
7172 Elf_Internal_Rela * rp;
7173 unsigned char * table;
7174 unsigned char * tp;
7175 Elf_Internal_Sym * sym;
7176 const char * relname;
57346661 7177
57346661
AM		 7178 /* First, find the starting address of the segment that includes
7179 this section. */
7180
7181 if (elf_header.e_phnum)
7182 {
7183 if (! get_program_headers (file))
7184 return 0;
7185
7186 for (seg = program_headers;
7187 seg < program_headers + elf_header.e_phnum;
7188 ++seg)
7189 {
7190 if (seg->p_type != PT_LOAD)
7191 continue;
7192
7193 if (sec->sh_addr >= seg->p_vaddr
7194 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7195 {
7196 aux->seg_base = seg->p_vaddr;
7197 break;
7198 }
7199 }
7200 }
7201
7202 /* Second, build the unwind table from the contents of the unwind
7203 section. */
7204 size = sec->sh_size;
3f5e193b
NC		 7205 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7206 _("unwind table"));
57346661
AM		 7207 if (!table)
7208 return 0;
7209
1c0751b2
DA		 7210 unw_ent_size = 16;
7211 nentries = size / unw_ent_size;
7212 size = unw_ent_size * nentries;
57346661 7213
3f5e193b
NC		 7214 tep = aux->table = (struct hppa_unw_table_entry *)
7215 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 7216
1c0751b2 7217 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 7218 {
7219 unsigned int tmp1, tmp2;
7220
7221 tep->start.section = SHN_UNDEF;
7222 tep->end.section = SHN_UNDEF;
7223
1c0751b2
DA		 7224 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7225 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7226 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7227 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7228
7229 tep->start.offset += aux->seg_base;
7230 tep->end.offset += aux->seg_base;
57346661
AM		 7231
7232 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7233 tep->Millicode = (tmp1 >> 30) & 0x1;
7234 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7235 tep->Region_description = (tmp1 >> 27) & 0x3;
7236 tep->reserved1 = (tmp1 >> 26) & 0x1;
7237 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7238 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7239 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7240 tep->Args_stored = (tmp1 >> 15) & 0x1;
7241 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7242 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7243 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7244 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7245 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7246 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7247 tep->cxx_info = (tmp1 >> 8) & 0x1;
7248 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7249 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7250 tep->reserved2 = (tmp1 >> 5) & 0x1;
7251 tep->Save_SP = (tmp1 >> 4) & 0x1;
7252 tep->Save_RP = (tmp1 >> 3) & 0x1;
7253 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7254 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7255 tep->Cleanup_defined = tmp1 & 0x1;
7256
7257 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7258 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7259 tep->Large_frame = (tmp2 >> 29) & 0x1;
7260 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7261 tep->reserved4 = (tmp2 >> 27) & 0x1;
7262 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 7263 }
7264 free (table);
7265
7266 /* Third, apply any relocations to the unwind table. */
57346661
AM		 7267 for (relsec = section_headers;
7268 relsec < section_headers + elf_header.e_shnum;
7269 ++relsec)
7270 {
7271 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7272 || relsec->sh_info >= elf_header.e_shnum
7273 || section_headers + relsec->sh_info != sec)
57346661
AM		 7274 continue;
7275
7276 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7277 & rela, & nrelas))
7278 return 0;
7279
7280 for (rp = rela; rp < rela + nrelas; ++rp)
7281 {
aca88567
NC		 7282 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7283 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 7284
7285 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 7286 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 7287 {
7288 warn (_("Skipping unexpected relocation type %s\n"), relname);
7289 continue;
7290 }
7291
7292 i = rp->r_offset / unw_ent_size;
7293
89fac5e3 7294 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 7295 {
7296 case 0:
7297 aux->table[i].start.section = sym->st_shndx;
1e456d54 7298 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 7299 break;
7300 case 1:
7301 aux->table[i].end.section = sym->st_shndx;
1e456d54 7302 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 7303 break;
7304 default:
7305 break;
7306 }
7307 }
7308
7309 free (rela);
7310 }
7311
1c0751b2 7312 aux->table_len = nentries;
57346661
AM		 7313
7314 return 1;
7315}
7316
1b31d05e 7317static void
2cf0635d 7318hppa_process_unwind (FILE * file)
57346661 7319{
57346661 7320 struct hppa_unw_aux_info aux;
2cf0635d
NC		 7321 Elf_Internal_Shdr * unwsec = NULL;
7322 Elf_Internal_Shdr * strsec;
7323 Elf_Internal_Shdr * sec;
18bd398b 7324 unsigned long i;
57346661 7325
c256ffe7 7326 if (string_table == NULL)
1b31d05e
NC		 7327 return;
7328
7329 memset (& aux, 0, sizeof (aux));
57346661
AM		 7330
7331 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7332 {
c256ffe7 7333 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7334 && sec->sh_link < elf_header.e_shnum)
57346661 7335 {
ba5cdace 7336 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 7337
4fbb74a6 7338 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7339 if (aux.strtab != NULL)
7340 {
7341 error (_("Multiple auxillary string tables encountered\n"));
7342 free (aux.strtab);
7343 }
3f5e193b
NC		 7344 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7345 1, strsec->sh_size,
7346 _("string table"));
c256ffe7 7347 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 7348 }
18bd398b 7349 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 7350 unwsec = sec;
7351 }
7352
7353 if (!unwsec)
7354 printf (_("\nThere are no unwind sections in this file.\n"));
7355
7356 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7357 {
18bd398b 7358 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 7359 {
74e1a04b
NC		 7360 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7361 printable_section_name (sec),
57346661 7362 (unsigned long) sec->sh_offset,
89fac5e3 7363 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 7364
7365 slurp_hppa_unwind_table (file, &aux, sec);
7366 if (aux.table_len > 0)
7367 dump_hppa_unwind (&aux);
7368
7369 if (aux.table)
7370 free ((char *) aux.table);
7371 aux.table = NULL;
7372 }
7373 }
7374
7375 if (aux.symtab)
7376 free (aux.symtab);
7377 if (aux.strtab)
7378 free ((char *) aux.strtab);
57346661
AM		 7379}
7380
0b6ae522
DJ		 7381struct arm_section
7382{
a734115a
NC		 7383 unsigned char * data; /* The unwind data. */
7384 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7385 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7386 unsigned long nrelas; /* The number of relocations. */
7387 unsigned int rel_type; /* REL or RELA ? */
7388 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 7389};
7390
7391struct arm_unw_aux_info
7392{
a734115a
NC		 7393 FILE * file; /* The file containing the unwind sections. */
7394 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7395 unsigned long nsyms; /* Number of symbols. */
948f632f
DA		 7396 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7397 unsigned long nfuns; /* Number of these symbols. */
a734115a
NC		 7398 char * strtab; /* The file's string table. */
7399 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 7400};
7401
7402static const char *
7403arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7404 bfd_vma fn, struct absaddr addr)
7405{
7406 const char *procname;
7407 bfd_vma sym_offset;
7408
7409 if (addr.section == SHN_UNDEF)
7410 addr.offset = fn;
7411
948f632f 7412 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
0b6ae522
DJ		 7413 aux->strtab_size, addr, &procname,
7414 &sym_offset);
7415
7416 print_vma (fn, PREFIX_HEX);
7417
7418 if (procname)
7419 {
7420 fputs (" <", stdout);
7421 fputs (procname, stdout);
7422
7423 if (sym_offset)
7424 printf ("+0x%lx", (unsigned long) sym_offset);
7425 fputc ('>', stdout);
7426 }
7427
7428 return procname;
7429}
7430
7431static void
7432arm_free_section (struct arm_section *arm_sec)
7433{
7434 if (arm_sec->data != NULL)
7435 free (arm_sec->data);
7436
7437 if (arm_sec->rela != NULL)
7438 free (arm_sec->rela);
7439}
7440
a734115a
NC		 7441/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7442 cached section and install SEC instead.
7443 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7444 and return its valued in * WORDP, relocating if necessary.
1b31d05e 7445 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 7446 relocation's offset in ADDR.
1b31d05e
NC		 7447 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7448 into the string table of the symbol associated with the reloc. If no
7449 reloc was applied store -1 there.
7450 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 7451
7452static bfd_boolean
1b31d05e
NC		 7453get_unwind_section_word (struct arm_unw_aux_info * aux,
7454 struct arm_section * arm_sec,
7455 Elf_Internal_Shdr * sec,
7456 bfd_vma word_offset,
7457 unsigned int * wordp,
7458 struct absaddr * addr,
7459 bfd_vma * sym_name)
0b6ae522
DJ		 7460{
7461 Elf_Internal_Rela *rp;
7462 Elf_Internal_Sym *sym;
7463 const char * relname;
7464 unsigned int word;
7465 bfd_boolean wrapped;
7466
e0a31db1
NC		 7467 if (sec == NULL || arm_sec == NULL)
7468 return FALSE;
7469
0b6ae522
DJ		 7470 addr->section = SHN_UNDEF;
7471 addr->offset = 0;
7472
1b31d05e
NC		 7473 if (sym_name != NULL)
7474 *sym_name = (bfd_vma) -1;
7475
a734115a 7476 /* If necessary, update the section cache. */
0b6ae522
DJ		 7477 if (sec != arm_sec->sec)
7478 {
7479 Elf_Internal_Shdr *relsec;
7480
7481 arm_free_section (arm_sec);
7482
7483 arm_sec->sec = sec;
7484 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7485 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 7486 arm_sec->rela = NULL;
7487 arm_sec->nrelas = 0;
7488
7489 for (relsec = section_headers;
7490 relsec < section_headers + elf_header.e_shnum;
7491 ++relsec)
7492 {
7493 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 7494 || section_headers + relsec->sh_info != sec
7495 /* PR 15745: Check the section type as well. */
7496 || (relsec->sh_type != SHT_REL
7497 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 7498 continue;
7499
a734115a 7500 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 7501 if (relsec->sh_type == SHT_REL)
7502 {
7503 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7504 relsec->sh_size,
7505 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7506 return FALSE;
0b6ae522 7507 }
1ae40aa4 7508 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 7509 {
7510 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7511 relsec->sh_size,
7512 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7513 return FALSE;
0b6ae522 7514 }
1ae40aa4 7515 break;
0b6ae522
DJ		 7516 }
7517
7518 arm_sec->next_rela = arm_sec->rela;
7519 }
7520
a734115a 7521 /* If there is no unwind data we can do nothing. */
0b6ae522 7522 if (arm_sec->data == NULL)
a734115a 7523 return FALSE;
0b6ae522 7524
e0a31db1
NC		 7525 /* If the offset is invalid then fail. */
7526 if (word_offset > sec->sh_size - 4)
7527 return FALSE;
7528
a734115a 7529 /* Get the word at the required offset. */
0b6ae522
DJ		 7530 word = byte_get (arm_sec->data + word_offset, 4);
7531
0eff7165
NC		 7532 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7533 if (arm_sec->rela == NULL)
7534 {
7535 * wordp = word;
7536 return TRUE;
7537 }
7538
a734115a 7539 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 7540 wrapped = FALSE;
7541 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7542 {
7543 bfd_vma prelval, offset;
7544
7545 if (rp->r_offset > word_offset && !wrapped)
7546 {
7547 rp = arm_sec->rela;
7548 wrapped = TRUE;
7549 }
7550 if (rp->r_offset > word_offset)
7551 break;
7552
7553 if (rp->r_offset & 3)
7554 {
7555 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7556 (unsigned long) rp->r_offset);
7557 continue;
7558 }
7559
7560 if (rp->r_offset < word_offset)
7561 continue;
7562
74e1a04b
NC		 7563 /* PR 17531: file: 027-161405-0.004 */
7564 if (aux->symtab == NULL)
7565 continue;
7566
0b6ae522
DJ		 7567 if (arm_sec->rel_type == SHT_REL)
7568 {
7569 offset = word & 0x7fffffff;
7570 if (offset & 0x40000000)
7571 offset |= ~ (bfd_vma) 0x7fffffff;
7572 }
a734115a 7573 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 7574 offset = rp->r_addend;
a734115a 7575 else
74e1a04b
NC		 7576 {
7577 error (_("Unknown section relocation type %d encountered\n"),
7578 arm_sec->rel_type);
7579 break;
7580 }
0b6ae522 7581
071436c6
NC		 7582 /* PR 17531 file: 027-1241568-0.004. */
7583 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7584 {
7585 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7586 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7587 break;
7588 }
7589
7590 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
0b6ae522
DJ		 7591 offset += sym->st_value;
7592 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7593
a734115a
NC		 7594 /* Check that we are processing the expected reloc type. */
7595 if (elf_header.e_machine == EM_ARM)
7596 {
7597 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7598 if (relname == NULL)
7599 {
7600 warn (_("Skipping unknown ARM relocation type: %d\n"),
7601 (int) ELF32_R_TYPE (rp->r_info));
7602 continue;
7603 }
a734115a
NC		 7604
7605 if (streq (relname, "R_ARM_NONE"))
7606 continue;
0b4362b0 7607
a734115a
NC		 7608 if (! streq (relname, "R_ARM_PREL31"))
7609 {
071436c6 7610 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
a734115a
NC		 7611 continue;
7612 }
7613 }
7614 else if (elf_header.e_machine == EM_TI_C6000)
7615 {
7616 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7617 if (relname == NULL)
7618 {
7619 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7620 (int) ELF32_R_TYPE (rp->r_info));
7621 continue;
7622 }
0b4362b0 7623
a734115a
NC		 7624 if (streq (relname, "R_C6000_NONE"))
7625 continue;
7626
7627 if (! streq (relname, "R_C6000_PREL31"))
7628 {
071436c6 7629 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
a734115a
NC		 7630 continue;
7631 }
7632
7633 prelval >>= 1;
7634 }
7635 else
74e1a04b
NC		 7636 {
7637 /* This function currently only supports ARM and TI unwinders. */
7638 warn (_("Only TI and ARM unwinders are currently supported\n"));
7639 break;
7640 }
fa197c1c 7641
0b6ae522
DJ		 7642 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7643 addr->section = sym->st_shndx;
7644 addr->offset = offset;
74e1a04b 7645
1b31d05e
NC		 7646 if (sym_name)
7647 * sym_name = sym->st_name;
0b6ae522
DJ		 7648 break;
7649 }
7650
7651 *wordp = word;
7652 arm_sec->next_rela = rp;
7653
a734115a 7654 return TRUE;
0b6ae522
DJ		 7655}
7656
a734115a
NC		 7657static const char *tic6x_unwind_regnames[16] =
7658{
0b4362b0
RM		 7659 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7660 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 7661 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7662};
fa197c1c 7663
0b6ae522 7664static void
fa197c1c 7665decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 7666{
fa197c1c
PB		 7667 int i;
7668
7669 for (i = 12; mask; mask >>= 1, i--)
7670 {
7671 if (mask & 1)
7672 {
7673 fputs (tic6x_unwind_regnames[i], stdout);
7674 if (mask > 1)
7675 fputs (", ", stdout);
7676 }
7677 }
7678}
0b6ae522
DJ		 7679
7680#define ADVANCE \
7681 if (remaining == 0 && more_words) \
7682 { \
7683 data_offset += 4; \
1b31d05e
NC		 7684 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7685 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 7686 return; \
7687 remaining = 4; \
7688 more_words--; \
7689 } \
7690
7691#define GET_OP(OP) \
7692 ADVANCE; \
7693 if (remaining) \
7694 { \
7695 remaining--; \
7696 (OP) = word >> 24; \
7697 word <<= 8; \
7698 } \
7699 else \
7700 { \
2b692964 7701 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 7702 return; \
7703 } \
cc5914eb 7704 printf ("0x%02x ", OP)
0b6ae522 7705
fa197c1c 7706static void
948f632f
DA		 7707decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
7708 unsigned int word,
7709 unsigned int remaining,
7710 unsigned int more_words,
7711 bfd_vma data_offset,
7712 Elf_Internal_Shdr * data_sec,
7713 struct arm_section * data_arm_sec)
fa197c1c
PB		 7714{
7715 struct absaddr addr;
0b6ae522
DJ		 7716
7717 /* Decode the unwinding instructions. */
7718 while (1)
7719 {
7720 unsigned int op, op2;
7721
7722 ADVANCE;
7723 if (remaining == 0)
7724 break;
7725 remaining--;
7726 op = word >> 24;
7727 word <<= 8;
7728
cc5914eb 7729 printf (" 0x%02x ", op);
0b6ae522
DJ		 7730
7731 if ((op & 0xc0) == 0x00)
7732 {
7733 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7734
cc5914eb 7735 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 7736 }
7737 else if ((op & 0xc0) == 0x40)
7738 {
7739 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7740
cc5914eb 7741 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 7742 }
7743 else if ((op & 0xf0) == 0x80)
7744 {
7745 GET_OP (op2);
7746 if (op == 0x80 && op2 == 0)
7747 printf (_("Refuse to unwind"));
7748 else
7749 {
7750 unsigned int mask = ((op & 0x0f) << 8) | op2;
7751 int first = 1;
7752 int i;
2b692964 7753
0b6ae522
DJ		 7754 printf ("pop {");
7755 for (i = 0; i < 12; i++)
7756 if (mask & (1 << i))
7757 {
7758 if (first)
7759 first = 0;
7760 else
7761 printf (", ");
7762 printf ("r%d", 4 + i);
7763 }
7764 printf ("}");
7765 }
7766 }
7767 else if ((op & 0xf0) == 0x90)
7768 {
7769 if (op == 0x9d || op == 0x9f)
7770 printf (_(" [Reserved]"));
7771 else
cc5914eb 7772 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 7773 }
7774 else if ((op & 0xf0) == 0xa0)
7775 {
7776 int end = 4 + (op & 0x07);
7777 int first = 1;
7778 int i;
61865e30 7779
0b6ae522
DJ		 7780 printf (" pop {");
7781 for (i = 4; i <= end; i++)
7782 {
7783 if (first)
7784 first = 0;
7785 else
7786 printf (", ");
7787 printf ("r%d", i);
7788 }
7789 if (op & 0x08)
7790 {
1b31d05e 7791 if (!first)
0b6ae522
DJ		 7792 printf (", ");
7793 printf ("r14");
7794 }
7795 printf ("}");
7796 }
7797 else if (op == 0xb0)
7798 printf (_(" finish"));
7799 else if (op == 0xb1)
7800 {
7801 GET_OP (op2);
7802 if (op2 == 0 || (op2 & 0xf0) != 0)
7803 printf (_("[Spare]"));
7804 else
7805 {
7806 unsigned int mask = op2 & 0x0f;
7807 int first = 1;
7808 int i;
61865e30 7809
0b6ae522
DJ		 7810 printf ("pop {");
7811 for (i = 0; i < 12; i++)
7812 if (mask & (1 << i))
7813 {
7814 if (first)
7815 first = 0;
7816 else
7817 printf (", ");
7818 printf ("r%d", i);
7819 }
7820 printf ("}");
7821 }
7822 }
7823 else if (op == 0xb2)
7824 {
b115cf96 7825 unsigned char buf[9];
0b6ae522
DJ		 7826 unsigned int i, len;
7827 unsigned long offset;
61865e30 7828
b115cf96 7829 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 7830 {
7831 GET_OP (buf[i]);
7832 if ((buf[i] & 0x80) == 0)
7833 break;
7834 }
4082ef84
NC		 7835 if (i == sizeof (buf))
7836 printf (_("corrupt change to vsp"));
7837 else
7838 {
7839 offset = read_uleb128 (buf, &len, buf + i + 1);
7840 assert (len == i + 1);
7841 offset = offset * 4 + 0x204;
7842 printf ("vsp = vsp + %ld", offset);
7843 }
0b6ae522 7844 }
61865e30 7845 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 7846 {
61865e30
NC		 7847 unsigned int first, last;
7848
7849 GET_OP (op2);
7850 first = op2 >> 4;
7851 last = op2 & 0x0f;
7852 if (op == 0xc8)
7853 first = first + 16;
7854 printf ("pop {D%d", first);
7855 if (last)
7856 printf ("-D%d", first + last);
7857 printf ("}");
7858 }
7859 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7860 {
7861 unsigned int count = op & 0x07;
7862
7863 printf ("pop {D8");
7864 if (count)
7865 printf ("-D%d", 8 + count);
7866 printf ("}");
7867 }
7868 else if (op >= 0xc0 && op <= 0xc5)
7869 {
7870 unsigned int count = op & 0x07;
7871
7872 printf (" pop {wR10");
7873 if (count)
7874 printf ("-wR%d", 10 + count);
7875 printf ("}");
7876 }
7877 else if (op == 0xc6)
7878 {
7879 unsigned int first, last;
7880
7881 GET_OP (op2);
7882 first = op2 >> 4;
7883 last = op2 & 0x0f;
7884 printf ("pop {wR%d", first);
7885 if (last)
7886 printf ("-wR%d", first + last);
7887 printf ("}");
7888 }
7889 else if (op == 0xc7)
7890 {
7891 GET_OP (op2);
7892 if (op2 == 0 || (op2 & 0xf0) != 0)
7893 printf (_("[Spare]"));
0b6ae522
DJ		 7894 else
7895 {
61865e30
NC		 7896 unsigned int mask = op2 & 0x0f;
7897 int first = 1;
7898 int i;
7899
7900 printf ("pop {");
7901 for (i = 0; i < 4; i++)
7902 if (mask & (1 << i))
7903 {
7904 if (first)
7905 first = 0;
7906 else
7907 printf (", ");
7908 printf ("wCGR%d", i);
7909 }
7910 printf ("}");
0b6ae522
DJ		 7911 }
7912 }
61865e30
NC		 7913 else
7914 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 7915 printf ("\n");
7916 }
fa197c1c
PB		 7917}
7918
7919static void
948f632f
DA		 7920decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
7921 unsigned int word,
7922 unsigned int remaining,
7923 unsigned int more_words,
7924 bfd_vma data_offset,
7925 Elf_Internal_Shdr * data_sec,
7926 struct arm_section * data_arm_sec)
fa197c1c
PB		 7927{
7928 struct absaddr addr;
7929
7930 /* Decode the unwinding instructions. */
7931 while (1)
7932 {
7933 unsigned int op, op2;
7934
7935 ADVANCE;
7936 if (remaining == 0)
7937 break;
7938 remaining--;
7939 op = word >> 24;
7940 word <<= 8;
7941
9cf03b7e 7942 printf (" 0x%02x ", op);
fa197c1c
PB		 7943
7944 if ((op & 0xc0) == 0x00)
7945 {
7946 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 7947 printf (" sp = sp + %d", offset);
fa197c1c
PB		 7948 }
7949 else if ((op & 0xc0) == 0x80)
7950 {
7951 GET_OP (op2);
7952 if (op == 0x80 && op2 == 0)
7953 printf (_("Refuse to unwind"));
7954 else
7955 {
7956 unsigned int mask = ((op & 0x1f) << 8) | op2;
7957 if (op & 0x20)
7958 printf ("pop compact {");
7959 else
7960 printf ("pop {");
7961
7962 decode_tic6x_unwind_regmask (mask);
7963 printf("}");
7964 }
7965 }
7966 else if ((op & 0xf0) == 0xc0)
7967 {
7968 unsigned int reg;
7969 unsigned int nregs;
7970 unsigned int i;
7971 const char *name;
a734115a
NC		 7972 struct
7973 {
fa197c1c
PB		 7974 unsigned int offset;
7975 unsigned int reg;
7976 } regpos[16];
7977
7978 /* Scan entire instruction first so that GET_OP output is not
7979 interleaved with disassembly. */
7980 nregs = 0;
7981 for (i = 0; nregs < (op & 0xf); i++)
7982 {
7983 GET_OP (op2);
7984 reg = op2 >> 4;
7985 if (reg != 0xf)
7986 {
7987 regpos[nregs].offset = i * 2;
7988 regpos[nregs].reg = reg;
7989 nregs++;
7990 }
7991
7992 reg = op2 & 0xf;
7993 if (reg != 0xf)
7994 {
7995 regpos[nregs].offset = i * 2 + 1;
7996 regpos[nregs].reg = reg;
7997 nregs++;
7998 }
7999 }
8000
8001 printf (_("pop frame {"));
8002 reg = nregs - 1;
8003 for (i = i * 2; i > 0; i--)
8004 {
8005 if (regpos[reg].offset == i - 1)
8006 {
8007 name = tic6x_unwind_regnames[regpos[reg].reg];
8008 if (reg > 0)
8009 reg--;
8010 }
8011 else
8012 name = _("[pad]");
8013
8014 fputs (name, stdout);
8015 if (i > 1)
8016 printf (", ");
8017 }
8018
8019 printf ("}");
8020 }
8021 else if (op == 0xd0)
8022 printf (" MOV FP, SP");
8023 else if (op == 0xd1)
8024 printf (" __c6xabi_pop_rts");
8025 else if (op == 0xd2)
8026 {
8027 unsigned char buf[9];
8028 unsigned int i, len;
8029 unsigned long offset;
a734115a 8030
fa197c1c
PB		 8031 for (i = 0; i < sizeof (buf); i++)
8032 {
8033 GET_OP (buf[i]);
8034 if ((buf[i] & 0x80) == 0)
8035 break;
8036 }
0eff7165
NC		 8037 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8038 if (i == sizeof (buf))
8039 {
8040 printf ("<corrupt sp adjust>\n");
8041 warn (_("Corrupt stack pointer adjustment detected\n"));
8042 return;
8043 }
948f632f 8044
f6f0e17b 8045 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 8046 assert (len == i + 1);
8047 offset = offset * 8 + 0x408;
8048 printf (_("sp = sp + %ld"), offset);
8049 }
8050 else if ((op & 0xf0) == 0xe0)
8051 {
8052 if ((op & 0x0f) == 7)
8053 printf (" RETURN");
8054 else
8055 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8056 }
8057 else
8058 {
8059 printf (_(" [unsupported opcode]"));
8060 }
8061 putchar ('\n');
8062 }
8063}
8064
8065static bfd_vma
a734115a 8066arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 8067{
8068 bfd_vma offset;
8069
8070 offset = word & 0x7fffffff;
8071 if (offset & 0x40000000)
8072 offset |= ~ (bfd_vma) 0x7fffffff;
8073
8074 if (elf_header.e_machine == EM_TI_C6000)
8075 offset <<= 1;
8076
8077 return offset + where;
8078}
8079
8080static void
1b31d05e
NC		 8081decode_arm_unwind (struct arm_unw_aux_info * aux,
8082 unsigned int word,
8083 unsigned int remaining,
8084 bfd_vma data_offset,
8085 Elf_Internal_Shdr * data_sec,
8086 struct arm_section * data_arm_sec)
fa197c1c
PB		 8087{
8088 int per_index;
8089 unsigned int more_words = 0;
37e14bc3 8090 struct absaddr addr;
1b31d05e 8091 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 8092
8093 if (remaining == 0)
8094 {
1b31d05e
NC		 8095 /* Fetch the first word.
8096 Note - when decoding an object file the address extracted
8097 here will always be 0. So we also pass in the sym_name
8098 parameter so that we can find the symbol associated with
8099 the personality routine. */
8100 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8101 & word, & addr, & sym_name))
fa197c1c 8102 return;
1b31d05e 8103
fa197c1c
PB		 8104 remaining = 4;
8105 }
8106
8107 if ((word & 0x80000000) == 0)
8108 {
8109 /* Expand prel31 for personality routine. */
8110 bfd_vma fn;
8111 const char *procname;
8112
a734115a 8113 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 8114 printf (_(" Personality routine: "));
1b31d05e
NC		 8115 if (fn == 0
8116 && addr.section == SHN_UNDEF && addr.offset == 0
8117 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8118 {
8119 procname = aux->strtab + sym_name;
8120 print_vma (fn, PREFIX_HEX);
8121 if (procname)
8122 {
8123 fputs (" <", stdout);
8124 fputs (procname, stdout);
8125 fputc ('>', stdout);
8126 }
8127 }
8128 else
8129 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 8130 fputc ('\n', stdout);
8131
8132 /* The GCC personality routines use the standard compact
8133 encoding, starting with one byte giving the number of
8134 words. */
8135 if (procname != NULL
8136 && (const_strneq (procname, "__gcc_personality_v0")
8137 || const_strneq (procname, "__gxx_personality_v0")
8138 || const_strneq (procname, "__gcj_personality_v0")
8139 || const_strneq (procname, "__gnu_objc_personality_v0")))
8140 {
8141 remaining = 0;
8142 more_words = 1;
8143 ADVANCE;
8144 if (!remaining)
8145 {
8146 printf (_(" [Truncated data]\n"));
8147 return;
8148 }
8149 more_words = word >> 24;
8150 word <<= 8;
8151 remaining--;
8152 per_index = -1;
8153 }
8154 else
8155 return;
8156 }
8157 else
8158 {
1b31d05e 8159 /* ARM EHABI Section 6.3:
0b4362b0 8160
1b31d05e 8161 An exception-handling table entry for the compact model looks like:
0b4362b0 8162
1b31d05e
NC		 8163 31 30-28 27-24 23-0
8164 -- ----- ----- ----
8165 1 0 index Data for personalityRoutine[index] */
8166
8167 if (elf_header.e_machine == EM_ARM
8168 && (word & 0x70000000))
83c257ca 8169 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 8170
fa197c1c 8171 per_index = (word >> 24) & 0x7f;
1b31d05e 8172 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 8173 if (per_index == 0)
8174 {
8175 more_words = 0;
8176 word <<= 8;
8177 remaining--;
8178 }
8179 else if (per_index < 3)
8180 {
8181 more_words = (word >> 16) & 0xff;
8182 word <<= 16;
8183 remaining -= 2;
8184 }
8185 }
8186
8187 switch (elf_header.e_machine)
8188 {
8189 case EM_ARM:
8190 if (per_index < 3)
8191 {
8192 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8193 data_offset, data_sec, data_arm_sec);
8194 }
8195 else
1b31d05e
NC		 8196 {
8197 warn (_("Unknown ARM compact model index encountered\n"));
8198 printf (_(" [reserved]\n"));
8199 }
fa197c1c
PB		 8200 break;
8201
8202 case EM_TI_C6000:
8203 if (per_index < 3)
8204 {
8205 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 8206 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 8207 }
8208 else if (per_index < 5)
8209 {
8210 if (((word >> 17) & 0x7f) == 0x7f)
8211 printf (_(" Restore stack from frame pointer\n"));
8212 else
8213 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8214 printf (_(" Registers restored: "));
8215 if (per_index == 4)
8216 printf (" (compact) ");
8217 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8218 putchar ('\n');
8219 printf (_(" Return register: %s\n"),
8220 tic6x_unwind_regnames[word & 0xf]);
8221 }
8222 else
1b31d05e 8223 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 8224 break;
8225
8226 default:
74e1a04b 8227 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
1b31d05e 8228 elf_header.e_machine);
fa197c1c 8229 }
0b6ae522
DJ		 8230
8231 /* Decode the descriptors. Not implemented. */
8232}
8233
8234static void
8235dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8236{
8237 struct arm_section exidx_arm_sec, extab_arm_sec;
8238 unsigned int i, exidx_len;
948f632f 8239 unsigned long j, nfuns;
0b6ae522
DJ		 8240
8241 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8242 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8243 exidx_len = exidx_sec->sh_size / 8;
8244
948f632f
DA		 8245 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8246 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8247 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8248 aux->funtab[nfuns++] = aux->symtab[j];
8249 aux->nfuns = nfuns;
8250 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8251
0b6ae522
DJ		 8252 for (i = 0; i < exidx_len; i++)
8253 {
8254 unsigned int exidx_fn, exidx_entry;
8255 struct absaddr fn_addr, entry_addr;
8256 bfd_vma fn;
8257
8258 fputc ('\n', stdout);
8259
1b31d05e
NC		 8260 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8261 8 * i, & exidx_fn, & fn_addr, NULL)
8262 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8263 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 8264 {
948f632f 8265 free (aux->funtab);
1b31d05e
NC		 8266 arm_free_section (& exidx_arm_sec);
8267 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 8268 return;
8269 }
8270
83c257ca
NC		 8271 /* ARM EHABI, Section 5:
8272 An index table entry consists of 2 words.
8273 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8274 if (exidx_fn & 0x80000000)
8275 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8276
a734115a 8277 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 8278
a734115a 8279 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 8280 fputs (": ", stdout);
8281
8282 if (exidx_entry == 1)
8283 {
8284 print_vma (exidx_entry, PREFIX_HEX);
8285 fputs (" [cantunwind]\n", stdout);
8286 }
8287 else if (exidx_entry & 0x80000000)
8288 {
8289 print_vma (exidx_entry, PREFIX_HEX);
8290 fputc ('\n', stdout);
8291 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8292 }
8293 else
8294 {
8f73510c 8295 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 8296 Elf_Internal_Shdr *table_sec;
8297
8298 fputs ("@", stdout);
a734115a 8299 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 8300 print_vma (table, PREFIX_HEX);
8301 printf ("\n");
8302
8303 /* Locate the matching .ARM.extab. */
8304 if (entry_addr.section != SHN_UNDEF
8305 && entry_addr.section < elf_header.e_shnum)
8306 {
8307 table_sec = section_headers + entry_addr.section;
8308 table_offset = entry_addr.offset;
8309 }
8310 else
8311 {
8312 table_sec = find_section_by_address (table);
8313 if (table_sec != NULL)
8314 table_offset = table - table_sec->sh_addr;
8315 }
8316 if (table_sec == NULL)
8317 {
8318 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8319 (unsigned long) table);
8320 continue;
8321 }
8322 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8323 &extab_arm_sec);
8324 }
8325 }
8326
8327 printf ("\n");
8328
948f632f 8329 free (aux->funtab);
0b6ae522
DJ		 8330 arm_free_section (&exidx_arm_sec);
8331 arm_free_section (&extab_arm_sec);
8332}
8333
fa197c1c 8334/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 8335
8336static void
0b6ae522
DJ		 8337arm_process_unwind (FILE *file)
8338{
8339 struct arm_unw_aux_info aux;
8340 Elf_Internal_Shdr *unwsec = NULL;
8341 Elf_Internal_Shdr *strsec;
8342 Elf_Internal_Shdr *sec;
8343 unsigned long i;
fa197c1c 8344 unsigned int sec_type;
0b6ae522 8345
fa197c1c
PB		 8346 switch (elf_header.e_machine)
8347 {
8348 case EM_ARM:
8349 sec_type = SHT_ARM_EXIDX;
8350 break;
8351
8352 case EM_TI_C6000:
8353 sec_type = SHT_C6000_UNWIND;
8354 break;
8355
0b4362b0 8356 default:
74e1a04b 8357 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
1b31d05e
NC		 8358 elf_header.e_machine);
8359 return;
fa197c1c
PB		 8360 }
8361
0b6ae522 8362 if (string_table == NULL)
1b31d05e
NC		 8363 return;
8364
8365 memset (& aux, 0, sizeof (aux));
8366 aux.file = file;
0b6ae522
DJ		 8367
8368 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8369 {
8370 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8371 {
ba5cdace 8372 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 8373
8374 strsec = section_headers + sec->sh_link;
74e1a04b
NC		 8375
8376 /* PR binutils/17531 file: 011-12666-0.004. */
8377 if (aux.strtab != NULL)
8378 {
4082ef84 8379 error (_("Multiple string tables found in file.\n"));
74e1a04b
NC		 8380 free (aux.strtab);
8381 }
0b6ae522
DJ		 8382 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8383 1, strsec->sh_size, _("string table"));
8384 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8385 }
fa197c1c 8386 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 8387 unwsec = sec;
8388 }
8389
1b31d05e 8390 if (unwsec == NULL)
0b6ae522 8391 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 8392 else
8393 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8394 {
8395 if (sec->sh_type == sec_type)
8396 {
8397 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
74e1a04b 8398 printable_section_name (sec),
1b31d05e
NC		 8399 (unsigned long) sec->sh_offset,
8400 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 8401
1b31d05e
NC		 8402 dump_arm_unwind (&aux, sec);
8403 }
8404 }
0b6ae522
DJ		 8405
8406 if (aux.symtab)
8407 free (aux.symtab);
8408 if (aux.strtab)
8409 free ((char *) aux.strtab);
0b6ae522
DJ		 8410}
8411
1b31d05e 8412static void
2cf0635d 8413process_unwind (FILE * file)
57346661 8414{
2cf0635d
NC		 8415 struct unwind_handler
8416 {
57346661 8417 int machtype;
1b31d05e 8418 void (* handler)(FILE *);
2cf0635d
NC		 8419 } handlers[] =
8420 {
0b6ae522 8421 { EM_ARM, arm_process_unwind },
57346661
AM		 8422 { EM_IA_64, ia64_process_unwind },
8423 { EM_PARISC, hppa_process_unwind },
fa197c1c 8424 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 8425 { 0, 0 }
8426 };
8427 int i;
8428
8429 if (!do_unwind)
1b31d05e 8430 return;
57346661
AM		 8431
8432 for (i = 0; handlers[i].handler != NULL; i++)
8433 if (elf_header.e_machine == handlers[i].machtype)
9f758fdc
NC		 8434 {
8435 handlers[i].handler (file);
8436 return;
8437 }
57346661 8438
1b31d05e
NC		 8439 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8440 get_machine_name (elf_header.e_machine));
57346661
AM		 8441}
8442
252b5132 8443static void
2cf0635d 8444dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 8445{
8446 switch (entry->d_tag)
8447 {
8448 case DT_MIPS_FLAGS:
8449 if (entry->d_un.d_val == 0)
4b68bca3 8450 printf (_("NONE"));
252b5132
RH		 8451 else
8452 {
8453 static const char * opts[] =
8454 {
8455 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8456 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8457 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8458 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8459 "RLD_ORDER_SAFE"
8460 };
8461 unsigned int cnt;
8462 int first = 1;
2b692964 8463
60bca95a 8464 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 8465 if (entry->d_un.d_val & (1 << cnt))
8466 {
8467 printf ("%s%s", first ? "" : " ", opts[cnt]);
8468 first = 0;
8469 }
252b5132
RH		 8470 }
8471 break;
103f02d3 8472
252b5132 8473 case DT_MIPS_IVERSION:
d79b3d50 8474 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 8475 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8476 else
76ca31c0
NC		 8477 {
8478 char buf[40];
8479 sprintf_vma (buf, entry->d_un.d_ptr);
8480 /* Note: coded this way so that there is a single string for translation. */
8481 printf (_("<corrupt: %s>"), buf);
8482 }
252b5132 8483 break;
103f02d3 8484
252b5132
RH		 8485 case DT_MIPS_TIME_STAMP:
8486 {
8487 char timebuf[20];
2cf0635d 8488 struct tm * tmp;
91d6fa6a 8489 time_t atime = entry->d_un.d_val;
82b1b41b 8490
91d6fa6a 8491 tmp = gmtime (&atime);
82b1b41b
NC		 8492 /* PR 17531: file: 6accc532. */
8493 if (tmp == NULL)
8494 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8495 else
8496 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8497 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8498 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 8499 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 8500 }
8501 break;
103f02d3 8502
252b5132
RH		 8503 case DT_MIPS_RLD_VERSION:
8504 case DT_MIPS_LOCAL_GOTNO:
8505 case DT_MIPS_CONFLICTNO:
8506 case DT_MIPS_LIBLISTNO:
8507 case DT_MIPS_SYMTABNO:
8508 case DT_MIPS_UNREFEXTNO:
8509 case DT_MIPS_HIPAGENO:
8510 case DT_MIPS_DELTA_CLASS_NO:
8511 case DT_MIPS_DELTA_INSTANCE_NO:
8512 case DT_MIPS_DELTA_RELOC_NO:
8513 case DT_MIPS_DELTA_SYM_NO:
8514 case DT_MIPS_DELTA_CLASSSYM_NO:
8515 case DT_MIPS_COMPACT_SIZE:
4b68bca3 8516 print_vma (entry->d_un.d_ptr, DEC);
252b5132 8517 break;
103f02d3
UD		 8518
8519 default:
4b68bca3 8520 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 8521 }
4b68bca3 8522 putchar ('\n');
103f02d3
UD		 8523}
8524
103f02d3 8525static void
2cf0635d 8526dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 8527{
8528 switch (entry->d_tag)
8529 {
8530 case DT_HP_DLD_FLAGS:
8531 {
8532 static struct
8533 {
8534 long int bit;
2cf0635d 8535 const char * str;
5e220199
NC		 8536 }
8537 flags[] =
8538 {
8539 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8540 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8541 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8542 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8543 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8544 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8545 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8546 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8547 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8548 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 8549 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8550 { DT_HP_GST, "HP_GST" },
8551 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8552 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8553 { DT_HP_NODELETE, "HP_NODELETE" },
8554 { DT_HP_GROUP, "HP_GROUP" },
8555 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 8556 };
103f02d3 8557 int first = 1;
5e220199 8558 size_t cnt;
f7a99963 8559 bfd_vma val = entry->d_un.d_val;
103f02d3 8560
60bca95a 8561 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 8562 if (val & flags[cnt].bit)
30800947
NC		 8563 {
8564 if (! first)
8565 putchar (' ');
8566 fputs (flags[cnt].str, stdout);
8567 first = 0;
8568 val ^= flags[cnt].bit;
8569 }
76da6bbe 8570
103f02d3 8571 if (val != 0 || first)
f7a99963
NC		 8572 {
8573 if (! first)
8574 putchar (' ');
8575 print_vma (val, HEX);
8576 }
103f02d3
UD		 8577 }
8578 break;
76da6bbe 8579
252b5132 8580 default:
f7a99963
NC		 8581 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8582 break;
252b5132 8583 }
35b1837e 8584 putchar ('\n');
252b5132
RH		 8585}
8586
28f997cf
TG		 8587#ifdef BFD64
8588
8589/* VMS vs Unix time offset and factor. */
8590
8591#define VMS_EPOCH_OFFSET 35067168000000000LL
8592#define VMS_GRANULARITY_FACTOR 10000000
8593
8594/* Display a VMS time in a human readable format. */
8595
8596static void
8597print_vms_time (bfd_int64_t vmstime)
8598{
8599 struct tm *tm;
8600 time_t unxtime;
8601
8602 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8603 tm = gmtime (&unxtime);
8604 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8605 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8606 tm->tm_hour, tm->tm_min, tm->tm_sec);
8607}
8608#endif /* BFD64 */
8609
ecc51f48 8610static void
2cf0635d 8611dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 8612{
8613 switch (entry->d_tag)
8614 {
0de14b54 8615 case DT_IA_64_PLT_RESERVE:
bdf4d63a 8616 /* First 3 slots reserved. */
ecc51f48
NC		 8617 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8618 printf (" -- ");
8619 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 8620 break;
8621
28f997cf
TG		 8622 case DT_IA_64_VMS_LINKTIME:
8623#ifdef BFD64
8624 print_vms_time (entry->d_un.d_val);
8625#endif
8626 break;
8627
8628 case DT_IA_64_VMS_LNKFLAGS:
8629 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8630 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8631 printf (" CALL_DEBUG");
8632 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8633 printf (" NOP0BUFS");
8634 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8635 printf (" P0IMAGE");
8636 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8637 printf (" MKTHREADS");
8638 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8639 printf (" UPCALLS");
8640 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8641 printf (" IMGSTA");
8642 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8643 printf (" INITIALIZE");
8644 if (entry->d_un.d_val & VMS_LF_MAIN)
8645 printf (" MAIN");
8646 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8647 printf (" EXE_INIT");
8648 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8649 printf (" TBK_IN_IMG");
8650 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8651 printf (" DBG_IN_IMG");
8652 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8653 printf (" TBK_IN_DSF");
8654 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8655 printf (" DBG_IN_DSF");
8656 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8657 printf (" SIGNATURES");
8658 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8659 printf (" REL_SEG_OFF");
8660 break;
8661
bdf4d63a
JJ		 8662 default:
8663 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8664 break;
ecc51f48 8665 }
bdf4d63a 8666 putchar ('\n');
ecc51f48
NC		 8667}
8668
252b5132 8669static int
2cf0635d 8670get_32bit_dynamic_section (FILE * file)
252b5132 8671{
2cf0635d
NC		 8672 Elf32_External_Dyn * edyn;
8673 Elf32_External_Dyn * ext;
8674 Elf_Internal_Dyn * entry;
103f02d3 8675
3f5e193b
NC		 8676 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8677 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8678 if (!edyn)
8679 return 0;
103f02d3 8680
071436c6
NC		 8681 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8682 might not have the luxury of section headers. Look for the DT_NULL
8683 terminator to determine the number of entries. */
ba2685cc 8684 for (ext = edyn, dynamic_nent = 0;
071436c6 8685 (char *) ext < (char *) edyn + dynamic_size - sizeof (* entry);
ba2685cc
AM		 8686 ext++)
8687 {
8688 dynamic_nent++;
8689 if (BYTE_GET (ext->d_tag) == DT_NULL)
8690 break;
8691 }
252b5132 8692
3f5e193b
NC		 8693 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8694 sizeof (* entry));
b2d38a17 8695 if (dynamic_section == NULL)
252b5132 8696 {
8b73c356
NC		 8697 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8698 (unsigned long) dynamic_nent);
9ea033b2
NC		 8699 free (edyn);
8700 return 0;
8701 }
252b5132 8702
fb514b26 8703 for (ext = edyn, entry = dynamic_section;
ba2685cc 8704 entry < dynamic_section + dynamic_nent;
fb514b26 8705 ext++, entry++)
9ea033b2 8706 {
fb514b26
AM		 8707 entry->d_tag = BYTE_GET (ext->d_tag);
8708 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8709 }
8710
9ea033b2
NC		 8711 free (edyn);
8712
8713 return 1;
8714}
8715
8716static int
2cf0635d 8717get_64bit_dynamic_section (FILE * file)
9ea033b2 8718{
2cf0635d
NC		 8719 Elf64_External_Dyn * edyn;
8720 Elf64_External_Dyn * ext;
8721 Elf_Internal_Dyn * entry;
103f02d3 8722
071436c6 8723 /* Read in the data. */
3f5e193b
NC		 8724 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8725 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8726 if (!edyn)
8727 return 0;
103f02d3 8728
071436c6
NC		 8729 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8730 might not have the luxury of section headers. Look for the DT_NULL
8731 terminator to determine the number of entries. */
ba2685cc 8732 for (ext = edyn, dynamic_nent = 0;
071436c6
NC		 8733 /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer. */
8734 (char *) ext < ((char *) edyn) + dynamic_size - sizeof (* ext);
ba2685cc
AM		 8735 ext++)
8736 {
8737 dynamic_nent++;
66543521 8738 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 8739 break;
8740 }
252b5132 8741
3f5e193b
NC		 8742 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8743 sizeof (* entry));
b2d38a17 8744 if (dynamic_section == NULL)
252b5132 8745 {
8b73c356
NC		 8746 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8747 (unsigned long) dynamic_nent);
252b5132
RH		 8748 free (edyn);
8749 return 0;
8750 }
8751
071436c6 8752 /* Convert from external to internal formats. */
fb514b26 8753 for (ext = edyn, entry = dynamic_section;
ba2685cc 8754 entry < dynamic_section + dynamic_nent;
fb514b26 8755 ext++, entry++)
252b5132 8756 {
66543521
AM		 8757 entry->d_tag = BYTE_GET (ext->d_tag);
8758 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8759 }
8760
8761 free (edyn);
8762
9ea033b2
NC		 8763 return 1;
8764}
8765
e9e44622
JJ		 8766static void
8767print_dynamic_flags (bfd_vma flags)
d1133906 8768{
e9e44622 8769 int first = 1;
13ae64f3 8770
d1133906
NC		 8771 while (flags)
8772 {
8773 bfd_vma flag;
8774
8775 flag = flags & - flags;
8776 flags &= ~ flag;
8777
e9e44622
JJ		 8778 if (first)
8779 first = 0;
8780 else
8781 putc (' ', stdout);
13ae64f3 8782
d1133906
NC		 8783 switch (flag)
8784 {
e9e44622
JJ		 8785 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
8786 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
8787 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
8788 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
8789 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 8790 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 8791 }
8792 }
e9e44622 8793 puts ("");
d1133906
NC		 8794}
8795
b2d38a17
NC		 8796/* Parse and display the contents of the dynamic section. */
8797
9ea033b2 8798static int
2cf0635d 8799process_dynamic_section (FILE * file)
9ea033b2 8800{
2cf0635d 8801 Elf_Internal_Dyn * entry;
9ea033b2
NC		 8802
8803 if (dynamic_size == 0)
8804 {
8805 if (do_dynamic)
b2d38a17 8806 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 8807
8808 return 1;
8809 }
8810
8811 if (is_32bit_elf)
8812 {
b2d38a17 8813 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 8814 return 0;
8815 }
b2d38a17 8816 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 8817 return 0;
8818
252b5132
RH		 8819 /* Find the appropriate symbol table. */
8820 if (dynamic_symbols == NULL)
8821 {
86dba8ee
AM		 8822 for (entry = dynamic_section;
8823 entry < dynamic_section + dynamic_nent;
8824 ++entry)
252b5132 8825 {
c8286bd1 8826 Elf_Internal_Shdr section;
252b5132
RH		 8827
8828 if (entry->d_tag != DT_SYMTAB)
8829 continue;
8830
8831 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8832
8833 /* Since we do not know how big the symbol table is,
8834 we default to reading in the entire file (!) and
8835 processing that. This is overkill, I know, but it
e3c8793a 8836 should work. */
d93f0186 8837 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 8838
fb52b2f4
NC		 8839 if (archive_file_offset != 0)
8840 section.sh_size = archive_file_size - section.sh_offset;
8841 else
8842 {
8843 if (fseek (file, 0, SEEK_END))
591a748a 8844 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 8845
8846 section.sh_size = ftell (file) - section.sh_offset;
8847 }
252b5132 8848
9ea033b2 8849 if (is_32bit_elf)
9ad5cbcf 8850 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 8851 else
9ad5cbcf 8852 section.sh_entsize = sizeof (Elf64_External_Sym);
071436c6 8853 section.sh_name = string_table_length;
252b5132 8854
ba5cdace 8855 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 8856 if (num_dynamic_syms < 1)
252b5132
RH		 8857 {
8858 error (_("Unable to determine the number of symbols to load\n"));
8859 continue;
8860 }
252b5132
RH		 8861 }
8862 }
8863
8864 /* Similarly find a string table. */
8865 if (dynamic_strings == NULL)
8866 {
86dba8ee
AM		 8867 for (entry = dynamic_section;
8868 entry < dynamic_section + dynamic_nent;
8869 ++entry)
252b5132
RH		 8870 {
8871 unsigned long offset;
b34976b6 8872 long str_tab_len;
252b5132
RH		 8873
8874 if (entry->d_tag != DT_STRTAB)
8875 continue;
8876
8877 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8878
8879 /* Since we do not know how big the string table is,
8880 we default to reading in the entire file (!) and
8881 processing that. This is overkill, I know, but it
e3c8793a 8882 should work. */
252b5132 8883
d93f0186 8884 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 8885
8886 if (archive_file_offset != 0)
8887 str_tab_len = archive_file_size - offset;
8888 else
8889 {
8890 if (fseek (file, 0, SEEK_END))
8891 error (_("Unable to seek to end of file\n"));
8892 str_tab_len = ftell (file) - offset;
8893 }
252b5132
RH		 8894
8895 if (str_tab_len < 1)
8896 {
8897 error
8898 (_("Unable to determine the length of the dynamic string table\n"));
8899 continue;
8900 }
8901
3f5e193b
NC		 8902 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8903 str_tab_len,
8904 _("dynamic string table"));
59245841 8905 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 8906 break;
8907 }
8908 }
8909
8910 /* And find the syminfo section if available. */
8911 if (dynamic_syminfo == NULL)
8912 {
3e8bba36 8913 unsigned long syminsz = 0;
252b5132 8914
86dba8ee
AM		 8915 for (entry = dynamic_section;
8916 entry < dynamic_section + dynamic_nent;
8917 ++entry)
252b5132
RH		 8918 {
8919 if (entry->d_tag == DT_SYMINENT)
8920 {
8921 /* Note: these braces are necessary to avoid a syntax
8922 error from the SunOS4 C compiler. */
049b0c3a
NC		 8923 /* PR binutils/17531: A corrupt file can trigger this test.
8924 So do not use an assert, instead generate an error message. */
8925 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
071436c6 8926 error (_("Bad value (%d) for SYMINENT entry\n"),
049b0c3a 8927 (int) entry->d_un.d_val);
252b5132
RH		 8928 }
8929 else if (entry->d_tag == DT_SYMINSZ)
8930 syminsz = entry->d_un.d_val;
8931 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 8932 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8933 syminsz);
252b5132
RH		 8934 }
8935
8936 if (dynamic_syminfo_offset != 0 && syminsz != 0)
8937 {
2cf0635d
NC		 8938 Elf_External_Syminfo * extsyminfo;
8939 Elf_External_Syminfo * extsym;
8940 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 8941
8942 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 8943 extsyminfo = (Elf_External_Syminfo *)
8944 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8945 _("symbol information"));
a6e9f9df
AM		 8946 if (!extsyminfo)
8947 return 0;
252b5132 8948
3f5e193b 8949 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 8950 if (dynamic_syminfo == NULL)
8951 {
8b73c356
NC		 8952 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8953 (unsigned long) syminsz);
252b5132
RH		 8954 return 0;
8955 }
8956
8957 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 8958 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8959 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8960 ++syminfo, ++extsym)
252b5132 8961 {
86dba8ee
AM		 8962 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8963 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 8964 }
8965
8966 free (extsyminfo);
8967 }
8968 }
8969
8970 if (do_dynamic && dynamic_addr)
8b73c356
NC		 8971 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8972 dynamic_addr, (unsigned long) dynamic_nent);
252b5132
RH		 8973 if (do_dynamic)
8974 printf (_(" Tag Type Name/Value\n"));
8975
86dba8ee
AM		 8976 for (entry = dynamic_section;
8977 entry < dynamic_section + dynamic_nent;
8978 entry++)
252b5132
RH		 8979 {
8980 if (do_dynamic)
f7a99963 8981 {
2cf0635d 8982 const char * dtype;
e699b9ff 8983
f7a99963
NC		 8984 putchar (' ');
8985 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 8986 dtype = get_dynamic_type (entry->d_tag);
8987 printf (" (%s)%*s", dtype,
8988 ((is_32bit_elf ? 27 : 19)
8989 - (int) strlen (dtype)),
f7a99963
NC		 8990 " ");
8991 }
252b5132
RH		 8992
8993 switch (entry->d_tag)
8994 {
d1133906
NC		 8995 case DT_FLAGS:
8996 if (do_dynamic)
e9e44622 8997 print_dynamic_flags (entry->d_un.d_val);
d1133906 8998 break;
76da6bbe 8999
252b5132
RH		 9000 case DT_AUXILIARY:
9001 case DT_FILTER:
019148e4
L		 9002 case DT_CONFIG:
9003 case DT_DEPAUDIT:
9004 case DT_AUDIT:
252b5132
RH		 9005 if (do_dynamic)
9006 {
019148e4 9007 switch (entry->d_tag)
b34976b6 9008 {
019148e4
L		 9009 case DT_AUXILIARY:
9010 printf (_("Auxiliary library"));
9011 break;
9012
9013 case DT_FILTER:
9014 printf (_("Filter library"));
9015 break;
9016
b34976b6 9017 case DT_CONFIG:
019148e4
L		 9018 printf (_("Configuration file"));
9019 break;
9020
9021 case DT_DEPAUDIT:
9022 printf (_("Dependency audit library"));
9023 break;
9024
9025 case DT_AUDIT:
9026 printf (_("Audit library"));
9027 break;
9028 }
252b5132 9029
d79b3d50
NC		 9030 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9031 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 9032 else
f7a99963
NC		 9033 {
9034 printf (": ");
9035 print_vma (entry->d_un.d_val, PREFIX_HEX);
9036 putchar ('\n');
9037 }
252b5132
RH		 9038 }
9039 break;
9040
dcefbbbd 9041 case DT_FEATURE:
252b5132
RH		 9042 if (do_dynamic)
9043 {
9044 printf (_("Flags:"));
86f55779 9045
252b5132
RH		 9046 if (entry->d_un.d_val == 0)
9047 printf (_(" None\n"));
9048 else
9049 {
9050 unsigned long int val = entry->d_un.d_val;
86f55779 9051
252b5132
RH		 9052 if (val & DTF_1_PARINIT)
9053 {
9054 printf (" PARINIT");
9055 val ^= DTF_1_PARINIT;
9056 }
dcefbbbd
L		 9057 if (val & DTF_1_CONFEXP)
9058 {
9059 printf (" CONFEXP");
9060 val ^= DTF_1_CONFEXP;
9061 }
252b5132
RH		 9062 if (val != 0)
9063 printf (" %lx", val);
9064 puts ("");
9065 }
9066 }
9067 break;
9068
9069 case DT_POSFLAG_1:
9070 if (do_dynamic)
9071 {
9072 printf (_("Flags:"));
86f55779 9073
252b5132
RH		 9074 if (entry->d_un.d_val == 0)
9075 printf (_(" None\n"));
9076 else
9077 {
9078 unsigned long int val = entry->d_un.d_val;
86f55779 9079
252b5132
RH		 9080 if (val & DF_P1_LAZYLOAD)
9081 {
9082 printf (" LAZYLOAD");
9083 val ^= DF_P1_LAZYLOAD;
9084 }
9085 if (val & DF_P1_GROUPPERM)
9086 {
9087 printf (" GROUPPERM");
9088 val ^= DF_P1_GROUPPERM;
9089 }
9090 if (val != 0)
9091 printf (" %lx", val);
9092 puts ("");
9093 }
9094 }
9095 break;
9096
9097 case DT_FLAGS_1:
9098 if (do_dynamic)
9099 {
9100 printf (_("Flags:"));
9101 if (entry->d_un.d_val == 0)
9102 printf (_(" None\n"));
9103 else
9104 {
9105 unsigned long int val = entry->d_un.d_val;
86f55779 9106
252b5132
RH		 9107 if (val & DF_1_NOW)
9108 {
9109 printf (" NOW");
9110 val ^= DF_1_NOW;
9111 }
9112 if (val & DF_1_GLOBAL)
9113 {
9114 printf (" GLOBAL");
9115 val ^= DF_1_GLOBAL;
9116 }
9117 if (val & DF_1_GROUP)
9118 {
9119 printf (" GROUP");
9120 val ^= DF_1_GROUP;
9121 }
9122 if (val & DF_1_NODELETE)
9123 {
9124 printf (" NODELETE");
9125 val ^= DF_1_NODELETE;
9126 }
9127 if (val & DF_1_LOADFLTR)
9128 {
9129 printf (" LOADFLTR");
9130 val ^= DF_1_LOADFLTR;
9131 }
9132 if (val & DF_1_INITFIRST)
9133 {
9134 printf (" INITFIRST");
9135 val ^= DF_1_INITFIRST;
9136 }
9137 if (val & DF_1_NOOPEN)
9138 {
9139 printf (" NOOPEN");
9140 val ^= DF_1_NOOPEN;
9141 }
9142 if (val & DF_1_ORIGIN)
9143 {
9144 printf (" ORIGIN");
9145 val ^= DF_1_ORIGIN;
9146 }
9147 if (val & DF_1_DIRECT)
9148 {
9149 printf (" DIRECT");
9150 val ^= DF_1_DIRECT;
9151 }
9152 if (val & DF_1_TRANS)
9153 {
9154 printf (" TRANS");
9155 val ^= DF_1_TRANS;
9156 }
9157 if (val & DF_1_INTERPOSE)
9158 {
9159 printf (" INTERPOSE");
9160 val ^= DF_1_INTERPOSE;
9161 }
f7db6139 9162 if (val & DF_1_NODEFLIB)
dcefbbbd 9163 {
f7db6139
L		 9164 printf (" NODEFLIB");
9165 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 9166 }
9167 if (val & DF_1_NODUMP)
9168 {
9169 printf (" NODUMP");
9170 val ^= DF_1_NODUMP;
9171 }
34b60028 9172 if (val & DF_1_CONFALT)
dcefbbbd 9173 {
34b60028
L		 9174 printf (" CONFALT");
9175 val ^= DF_1_CONFALT;
9176 }
9177 if (val & DF_1_ENDFILTEE)
9178 {
9179 printf (" ENDFILTEE");
9180 val ^= DF_1_ENDFILTEE;
9181 }
9182 if (val & DF_1_DISPRELDNE)
9183 {
9184 printf (" DISPRELDNE");
9185 val ^= DF_1_DISPRELDNE;
9186 }
9187 if (val & DF_1_DISPRELPND)
9188 {
9189 printf (" DISPRELPND");
9190 val ^= DF_1_DISPRELPND;
9191 }
9192 if (val & DF_1_NODIRECT)
9193 {
9194 printf (" NODIRECT");
9195 val ^= DF_1_NODIRECT;
9196 }
9197 if (val & DF_1_IGNMULDEF)
9198 {
9199 printf (" IGNMULDEF");
9200 val ^= DF_1_IGNMULDEF;
9201 }
9202 if (val & DF_1_NOKSYMS)
9203 {
9204 printf (" NOKSYMS");
9205 val ^= DF_1_NOKSYMS;
9206 }
9207 if (val & DF_1_NOHDR)
9208 {
9209 printf (" NOHDR");
9210 val ^= DF_1_NOHDR;
9211 }
9212 if (val & DF_1_EDITED)
9213 {
9214 printf (" EDITED");
9215 val ^= DF_1_EDITED;
9216 }
9217 if (val & DF_1_NORELOC)
9218 {
9219 printf (" NORELOC");
9220 val ^= DF_1_NORELOC;
9221 }
9222 if (val & DF_1_SYMINTPOSE)
9223 {
9224 printf (" SYMINTPOSE");
9225 val ^= DF_1_SYMINTPOSE;
9226 }
9227 if (val & DF_1_GLOBAUDIT)
9228 {
9229 printf (" GLOBAUDIT");
9230 val ^= DF_1_GLOBAUDIT;
9231 }
9232 if (val & DF_1_SINGLETON)
9233 {
9234 printf (" SINGLETON");
9235 val ^= DF_1_SINGLETON;
dcefbbbd 9236 }
252b5132
RH		 9237 if (val != 0)
9238 printf (" %lx", val);
9239 puts ("");
9240 }
9241 }
9242 break;
9243
9244 case DT_PLTREL:
566b0d53 9245 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9246 if (do_dynamic)
9247 puts (get_dynamic_type (entry->d_un.d_val));
9248 break;
9249
9250 case DT_NULL :
9251 case DT_NEEDED :
9252 case DT_PLTGOT :
9253 case DT_HASH :
9254 case DT_STRTAB :
9255 case DT_SYMTAB :
9256 case DT_RELA :
9257 case DT_INIT :
9258 case DT_FINI :
9259 case DT_SONAME :
9260 case DT_RPATH :
9261 case DT_SYMBOLIC:
9262 case DT_REL :
9263 case DT_DEBUG :
9264 case DT_TEXTREL :
9265 case DT_JMPREL :
019148e4 9266 case DT_RUNPATH :
252b5132
RH		 9267 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9268
9269 if (do_dynamic)
9270 {
2cf0635d 9271 char * name;
252b5132 9272
d79b3d50
NC		 9273 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9274 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9275 else
d79b3d50 9276 name = NULL;
252b5132
RH		 9277
9278 if (name)
9279 {
9280 switch (entry->d_tag)
9281 {
9282 case DT_NEEDED:
9283 printf (_("Shared library: [%s]"), name);
9284
18bd398b 9285 if (streq (name, program_interpreter))
f7a99963 9286 printf (_(" program interpreter"));
252b5132
RH		 9287 break;
9288
9289 case DT_SONAME:
f7a99963 9290 printf (_("Library soname: [%s]"), name);
252b5132
RH		 9291 break;
9292
9293 case DT_RPATH:
f7a99963 9294 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 9295 break;
9296
019148e4
L		 9297 case DT_RUNPATH:
9298 printf (_("Library runpath: [%s]"), name);
9299 break;
9300
252b5132 9301 default:
f7a99963
NC		 9302 print_vma (entry->d_un.d_val, PREFIX_HEX);
9303 break;
252b5132
RH		 9304 }
9305 }
9306 else
f7a99963
NC		 9307 print_vma (entry->d_un.d_val, PREFIX_HEX);
9308
9309 putchar ('\n');
252b5132
RH		 9310 }
9311 break;
9312
9313 case DT_PLTRELSZ:
9314 case DT_RELASZ :
9315 case DT_STRSZ :
9316 case DT_RELSZ :
9317 case DT_RELAENT :
9318 case DT_SYMENT :
9319 case DT_RELENT :
566b0d53 9320 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9321 case DT_PLTPADSZ:
9322 case DT_MOVEENT :
9323 case DT_MOVESZ :
9324 case DT_INIT_ARRAYSZ:
9325 case DT_FINI_ARRAYSZ:
047b2264
JJ		 9326 case DT_GNU_CONFLICTSZ:
9327 case DT_GNU_LIBLISTSZ:
252b5132 9328 if (do_dynamic)
f7a99963
NC		 9329 {
9330 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 9331 printf (_(" (bytes)\n"));
f7a99963 9332 }
252b5132
RH		 9333 break;
9334
9335 case DT_VERDEFNUM:
9336 case DT_VERNEEDNUM:
9337 case DT_RELACOUNT:
9338 case DT_RELCOUNT:
9339 if (do_dynamic)
f7a99963
NC		 9340 {
9341 print_vma (entry->d_un.d_val, UNSIGNED);
9342 putchar ('\n');
9343 }
252b5132
RH		 9344 break;
9345
9346 case DT_SYMINSZ:
9347 case DT_SYMINENT:
9348 case DT_SYMINFO:
9349 case DT_USED:
9350 case DT_INIT_ARRAY:
9351 case DT_FINI_ARRAY:
9352 if (do_dynamic)
9353 {
d79b3d50
NC		 9354 if (entry->d_tag == DT_USED
9355 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 9356 {
2cf0635d 9357 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9358
b34976b6 9359 if (*name)
252b5132
RH		 9360 {
9361 printf (_("Not needed object: [%s]\n"), name);
9362 break;
9363 }
9364 }
103f02d3 9365
f7a99963
NC		 9366 print_vma (entry->d_un.d_val, PREFIX_HEX);
9367 putchar ('\n');
252b5132
RH		 9368 }
9369 break;
9370
9371 case DT_BIND_NOW:
9372 /* The value of this entry is ignored. */
35b1837e
AM		 9373 if (do_dynamic)
9374 putchar ('\n');
252b5132 9375 break;
103f02d3 9376
047b2264
JJ		 9377 case DT_GNU_PRELINKED:
9378 if (do_dynamic)
9379 {
2cf0635d 9380 struct tm * tmp;
91d6fa6a 9381 time_t atime = entry->d_un.d_val;
047b2264 9382
91d6fa6a 9383 tmp = gmtime (&atime);
071436c6
NC		 9384 /* PR 17533 file: 041-1244816-0.004. */
9385 if (tmp == NULL)
5a2cbcf4
L		 9386 printf (_("<corrupt time val: %lx"),
9387 (unsigned long) atime);
071436c6
NC		 9388 else
9389 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9390 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9391 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 9392
9393 }
9394 break;
9395
fdc90cb4
JJ		 9396 case DT_GNU_HASH:
9397 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9398 if (do_dynamic)
9399 {
9400 print_vma (entry->d_un.d_val, PREFIX_HEX);
9401 putchar ('\n');
9402 }
9403 break;
9404
252b5132
RH		 9405 default:
9406 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 9407 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 9408 entry->d_un.d_val;
9409
9410 if (do_dynamic)
9411 {
9412 switch (elf_header.e_machine)
9413 {
9414 case EM_MIPS:
4fe85591 9415 case EM_MIPS_RS3_LE:
b2d38a17 9416 dynamic_section_mips_val (entry);
252b5132 9417 break;
103f02d3 9418 case EM_PARISC:
b2d38a17 9419 dynamic_section_parisc_val (entry);
103f02d3 9420 break;
ecc51f48 9421 case EM_IA_64:
b2d38a17 9422 dynamic_section_ia64_val (entry);
ecc51f48 9423 break;
252b5132 9424 default:
f7a99963
NC		 9425 print_vma (entry->d_un.d_val, PREFIX_HEX);
9426 putchar ('\n');
252b5132
RH		 9427 }
9428 }
9429 break;
9430 }
9431 }
9432
9433 return 1;
9434}
9435
9436static char *
d3ba0551 9437get_ver_flags (unsigned int flags)
252b5132 9438{
b34976b6 9439 static char buff[32];
252b5132
RH		 9440
9441 buff[0] = 0;
9442
9443 if (flags == 0)
9444 return _("none");
9445
9446 if (flags & VER_FLG_BASE)
9447 strcat (buff, "BASE ");
9448
9449 if (flags & VER_FLG_WEAK)
9450 {
9451 if (flags & VER_FLG_BASE)
9452 strcat (buff, "| ");
9453
9454 strcat (buff, "WEAK ");
9455 }
9456
44ec90b9
RO		 9457 if (flags & VER_FLG_INFO)
9458 {
9459 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9460 strcat (buff, "| ");
9461
9462 strcat (buff, "INFO ");
9463 }
9464
9465 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 9466 strcat (buff, _("| <unknown>"));
252b5132
RH		 9467
9468 return buff;
9469}
9470
9471/* Display the contents of the version sections. */
98fb390a 9472
252b5132 9473static int
2cf0635d 9474process_version_sections (FILE * file)
252b5132 9475{
2cf0635d 9476 Elf_Internal_Shdr * section;
b34976b6
AM		 9477 unsigned i;
9478 int found = 0;
252b5132
RH		 9479
9480 if (! do_version)
9481 return 1;
9482
9483 for (i = 0, section = section_headers;
9484 i < elf_header.e_shnum;
b34976b6 9485 i++, section++)
252b5132
RH		 9486 {
9487 switch (section->sh_type)
9488 {
9489 case SHT_GNU_verdef:
9490 {
2cf0635d 9491 Elf_External_Verdef * edefs;
b34976b6
AM		 9492 unsigned int idx;
9493 unsigned int cnt;
2cf0635d 9494 char * endbuf;
252b5132
RH		 9495
9496 found = 1;
9497
74e1a04b
NC		 9498 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9499 printable_section_name (section),
9500 section->sh_info);
252b5132
RH		 9501
9502 printf (_(" Addr: 0x"));
9503 printf_vma (section->sh_addr);
74e1a04b 9504 printf (_(" Offset: %#08lx Link: %u (%s)"),
1b228002 9505 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9506 printable_section_name_from_index (section->sh_link));
252b5132 9507
3f5e193b
NC		 9508 edefs = (Elf_External_Verdef *)
9509 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9510 _("version definition section"));
a6e9f9df
AM		 9511 if (!edefs)
9512 break;
59245841 9513 endbuf = (char *) edefs + section->sh_size;
252b5132 9514
b34976b6 9515 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 9516 {
2cf0635d
NC		 9517 char * vstart;
9518 Elf_External_Verdef * edef;
b34976b6 9519 Elf_Internal_Verdef ent;
2cf0635d 9520 Elf_External_Verdaux * eaux;
b34976b6
AM		 9521 Elf_Internal_Verdaux aux;
9522 int j;
9523 int isum;
103f02d3 9524
7e26601c
NC		 9525 /* Check for very large indicies. */
9526 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 9527 break;
9528
252b5132 9529 vstart = ((char *) edefs) + idx;
54806181
AM		 9530 if (vstart + sizeof (*edef) > endbuf)
9531 break;
252b5132
RH		 9532
9533 edef = (Elf_External_Verdef *) vstart;
9534
9535 ent.vd_version = BYTE_GET (edef->vd_version);
9536 ent.vd_flags = BYTE_GET (edef->vd_flags);
9537 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9538 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9539 ent.vd_hash = BYTE_GET (edef->vd_hash);
9540 ent.vd_aux = BYTE_GET (edef->vd_aux);
9541 ent.vd_next = BYTE_GET (edef->vd_next);
9542
9543 printf (_(" %#06x: Rev: %d Flags: %s"),
9544 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9545
9546 printf (_(" Index: %d Cnt: %d "),
9547 ent.vd_ndx, ent.vd_cnt);
9548
dd24e3da 9549 /* Check for overflow. */
7e26601c 9550 if (ent.vd_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 9551 break;
9552
252b5132
RH		 9553 vstart += ent.vd_aux;
9554
9555 eaux = (Elf_External_Verdaux *) vstart;
9556
9557 aux.vda_name = BYTE_GET (eaux->vda_name);
9558 aux.vda_next = BYTE_GET (eaux->vda_next);
9559
d79b3d50
NC		 9560 if (VALID_DYNAMIC_NAME (aux.vda_name))
9561 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9562 else
9563 printf (_("Name index: %ld\n"), aux.vda_name);
9564
9565 isum = idx + ent.vd_aux;
9566
b34976b6 9567 for (j = 1; j < ent.vd_cnt; j++)
252b5132 9568 {
dd24e3da 9569 /* Check for overflow. */
7e26601c 9570 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 9571 break;
9572
252b5132
RH		 9573 isum += aux.vda_next;
9574 vstart += aux.vda_next;
9575
9576 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 9577 if (vstart + sizeof (*eaux) > endbuf)
9578 break;
252b5132
RH		 9579
9580 aux.vda_name = BYTE_GET (eaux->vda_name);
9581 aux.vda_next = BYTE_GET (eaux->vda_next);
9582
d79b3d50 9583 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 9584 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 9585 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9586 else
9587 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9588 isum, j, aux.vda_name);
9589 }
dd24e3da 9590
54806181
AM		 9591 if (j < ent.vd_cnt)
9592 printf (_(" Version def aux past end of section\n"));
252b5132 9593
5d921cbd
NC		 9594 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9595 if (idx + ent.vd_next <= idx)
9596 break;
9597
252b5132
RH		 9598 idx += ent.vd_next;
9599 }
dd24e3da 9600
54806181
AM		 9601 if (cnt < section->sh_info)
9602 printf (_(" Version definition past end of section\n"));
252b5132
RH		 9603
9604 free (edefs);
9605 }
9606 break;
103f02d3 9607
252b5132
RH		 9608 case SHT_GNU_verneed:
9609 {
2cf0635d 9610 Elf_External_Verneed * eneed;
b34976b6
AM		 9611 unsigned int idx;
9612 unsigned int cnt;
2cf0635d 9613 char * endbuf;
252b5132
RH		 9614
9615 found = 1;
9616
72de5009 9617 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
74e1a04b 9618 printable_section_name (section), section->sh_info);
252b5132
RH		 9619
9620 printf (_(" Addr: 0x"));
9621 printf_vma (section->sh_addr);
72de5009 9622 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9623 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9624 printable_section_name_from_index (section->sh_link));
252b5132 9625
3f5e193b
NC		 9626 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9627 section->sh_offset, 1,
9628 section->sh_size,
9cf03b7e 9629 _("Version Needs section"));
a6e9f9df
AM		 9630 if (!eneed)
9631 break;
59245841 9632 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 9633
9634 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9635 {
2cf0635d 9636 Elf_External_Verneed * entry;
b34976b6
AM		 9637 Elf_Internal_Verneed ent;
9638 int j;
9639 int isum;
2cf0635d 9640 char * vstart;
252b5132 9641
7e26601c 9642 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 9643 break;
9644
252b5132 9645 vstart = ((char *) eneed) + idx;
54806181
AM		 9646 if (vstart + sizeof (*entry) > endbuf)
9647 break;
252b5132
RH		 9648
9649 entry = (Elf_External_Verneed *) vstart;
9650
9651 ent.vn_version = BYTE_GET (entry->vn_version);
9652 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
9653 ent.vn_file = BYTE_GET (entry->vn_file);
9654 ent.vn_aux = BYTE_GET (entry->vn_aux);
9655 ent.vn_next = BYTE_GET (entry->vn_next);
9656
9657 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
9658
d79b3d50
NC		 9659 if (VALID_DYNAMIC_NAME (ent.vn_file))
9660 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 9661 else
9662 printf (_(" File: %lx"), ent.vn_file);
9663
9664 printf (_(" Cnt: %d\n"), ent.vn_cnt);
9665
dd24e3da 9666 /* Check for overflow. */
7e26601c 9667 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da 9668 break;
252b5132
RH		 9669 vstart += ent.vn_aux;
9670
9671 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9672 {
2cf0635d 9673 Elf_External_Vernaux * eaux;
b34976b6 9674 Elf_Internal_Vernaux aux;
252b5132 9675
54806181
AM		 9676 if (vstart + sizeof (*eaux) > endbuf)
9677 break;
252b5132
RH		 9678 eaux = (Elf_External_Vernaux *) vstart;
9679
9680 aux.vna_hash = BYTE_GET (eaux->vna_hash);
9681 aux.vna_flags = BYTE_GET (eaux->vna_flags);
9682 aux.vna_other = BYTE_GET (eaux->vna_other);
9683 aux.vna_name = BYTE_GET (eaux->vna_name);
9684 aux.vna_next = BYTE_GET (eaux->vna_next);
9685
d79b3d50 9686 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 9687 printf (_(" %#06x: Name: %s"),
d79b3d50 9688 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 9689 else
ecc2063b 9690 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 9691 isum, aux.vna_name);
9692
9693 printf (_(" Flags: %s Version: %d\n"),
9694 get_ver_flags (aux.vna_flags), aux.vna_other);
9695
dd24e3da 9696 /* Check for overflow. */
53774b7e
NC		 9697 if (aux.vna_next > (size_t) (endbuf - vstart)
9698 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9699 {
9700 warn (_("Invalid vna_next field of %lx\n"),
9701 aux.vna_next);
9702 j = ent.vn_cnt;
9703 break;
9704 }
252b5132
RH		 9705 isum += aux.vna_next;
9706 vstart += aux.vna_next;
9707 }
9cf03b7e 9708
54806181 9709 if (j < ent.vn_cnt)
9cf03b7e 9710 warn (_("Missing Version Needs auxillary information\n"));
252b5132 9711
bcf83b2a 9712 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
c24cf8b6
NC		 9713 {
9714 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9715 cnt = section->sh_info;
9716 break;
9717 }
252b5132
RH		 9718 idx += ent.vn_next;
9719 }
9cf03b7e 9720
54806181 9721 if (cnt < section->sh_info)
9cf03b7e 9722 warn (_("Missing Version Needs information\n"));
103f02d3 9723
252b5132
RH		 9724 free (eneed);
9725 }
9726 break;
9727
9728 case SHT_GNU_versym:
9729 {
2cf0635d 9730 Elf_Internal_Shdr * link_section;
8b73c356
NC		 9731 size_t total;
9732 unsigned int cnt;
2cf0635d
NC		 9733 unsigned char * edata;
9734 unsigned short * data;
9735 char * strtab;
9736 Elf_Internal_Sym * symbols;
9737 Elf_Internal_Shdr * string_sec;
ba5cdace 9738 unsigned long num_syms;
d3ba0551 9739 long off;
252b5132 9740
4fbb74a6 9741 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9742 break;
9743
4fbb74a6 9744 link_section = section_headers + section->sh_link;
08d8fa11 9745 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 9746
4fbb74a6 9747 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9748 break;
9749
252b5132
RH		 9750 found = 1;
9751
ba5cdace 9752 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 9753 if (symbols == NULL)
9754 break;
252b5132 9755
4fbb74a6 9756 string_sec = section_headers + link_section->sh_link;
252b5132 9757
3f5e193b
NC		 9758 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9759 string_sec->sh_size,
9760 _("version string table"));
a6e9f9df 9761 if (!strtab)
0429c154
MS		 9762 {
9763 free (symbols);
9764 break;
9765 }
252b5132 9766
8b73c356
NC		 9767 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9768 printable_section_name (section), (unsigned long) total);
252b5132
RH		 9769
9770 printf (_(" Addr: "));
9771 printf_vma (section->sh_addr);
72de5009 9772 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9773 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9774 printable_section_name (link_section));
252b5132 9775
d3ba0551
AM		 9776 off = offset_from_vma (file,
9777 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9778 total * sizeof (short));
3f5e193b
NC		 9779 edata = (unsigned char *) get_data (NULL, file, off, total,
9780 sizeof (short),
9781 _("version symbol data"));
a6e9f9df
AM		 9782 if (!edata)
9783 {
9784 free (strtab);
0429c154 9785 free (symbols);
a6e9f9df
AM		 9786 break;
9787 }
252b5132 9788
3f5e193b 9789 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 9790
9791 for (cnt = total; cnt --;)
b34976b6
AM		 9792 data[cnt] = byte_get (edata + cnt * sizeof (short),
9793 sizeof (short));
252b5132
RH		 9794
9795 free (edata);
9796
9797 for (cnt = 0; cnt < total; cnt += 4)
9798 {
9799 int j, nn;
00d93f34 9800 int check_def, check_need;
2cf0635d 9801 char * name;
252b5132
RH		 9802
9803 printf (" %03x:", cnt);
9804
9805 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 9806 switch (data[cnt + j])
252b5132
RH		 9807 {
9808 case 0:
9809 fputs (_(" 0 (*local*) "), stdout);
9810 break;
9811
9812 case 1:
9813 fputs (_(" 1 (*global*) "), stdout);
9814 break;
9815
9816 default:
c244d050
NC		 9817 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9818 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 9819
dd24e3da 9820 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 9821 array, break to avoid an out-of-bounds read. */
9822 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 9823 {
9824 warn (_("invalid index into symbol array\n"));
9825 break;
9826 }
9827
00d93f34
JJ		 9828 check_def = 1;
9829 check_need = 1;
4fbb74a6
AM		 9830 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9831 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 9832 != SHT_NOBITS)
252b5132 9833 {
b34976b6 9834 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 9835 check_def = 0;
9836 else
9837 check_need = 0;
252b5132 9838 }
00d93f34
JJ		 9839
9840 if (check_need
b34976b6 9841 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 9842 {
b34976b6
AM		 9843 Elf_Internal_Verneed ivn;
9844 unsigned long offset;
252b5132 9845
d93f0186
NC		 9846 offset = offset_from_vma
9847 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9848 sizeof (Elf_External_Verneed));
252b5132 9849
b34976b6 9850 do
252b5132 9851 {
b34976b6
AM		 9852 Elf_Internal_Vernaux ivna;
9853 Elf_External_Verneed evn;
9854 Elf_External_Vernaux evna;
9855 unsigned long a_off;
252b5132 9856
59245841
NC		 9857 if (get_data (&evn, file, offset, sizeof (evn), 1,
9858 _("version need")) == NULL)
9859 break;
0b4362b0 9860
252b5132
RH		 9861 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9862 ivn.vn_next = BYTE_GET (evn.vn_next);
9863
9864 a_off = offset + ivn.vn_aux;
9865
9866 do
9867 {
59245841
NC		 9868 if (get_data (&evna, file, a_off, sizeof (evna),
9869 1, _("version need aux (2)")) == NULL)
9870 {
9871 ivna.vna_next = 0;
9872 ivna.vna_other = 0;
9873 }
9874 else
9875 {
9876 ivna.vna_next = BYTE_GET (evna.vna_next);
9877 ivna.vna_other = BYTE_GET (evna.vna_other);
9878 }
252b5132
RH		 9879
9880 a_off += ivna.vna_next;
9881 }
b34976b6 9882 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 9883 && ivna.vna_next != 0);
9884
b34976b6 9885 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 9886 {
9887 ivna.vna_name = BYTE_GET (evna.vna_name);
9888
54806181
AM		 9889 if (ivna.vna_name >= string_sec->sh_size)
9890 name = _("*invalid*");
9891 else
9892 name = strtab + ivna.vna_name;
252b5132 9893 nn += printf ("(%s%-*s",
16062207
ILT		 9894 name,
9895 12 - (int) strlen (name),
252b5132 9896 ")");
00d93f34 9897 check_def = 0;
252b5132
RH		 9898 break;
9899 }
9900
9901 offset += ivn.vn_next;
9902 }
9903 while (ivn.vn_next);
9904 }
00d93f34 9905
b34976b6
AM		 9906 if (check_def && data[cnt + j] != 0x8001
9907 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9908 {
b34976b6
AM		 9909 Elf_Internal_Verdef ivd;
9910 Elf_External_Verdef evd;
9911 unsigned long offset;
252b5132 9912
d93f0186
NC		 9913 offset = offset_from_vma
9914 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9915 sizeof evd);
252b5132
RH		 9916
9917 do
9918 {
59245841
NC		 9919 if (get_data (&evd, file, offset, sizeof (evd), 1,
9920 _("version def")) == NULL)
9921 {
9922 ivd.vd_next = 0;
948f632f 9923 /* PR 17531: file: 046-1082287-0.004. */
3102e897
NC		 9924 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
9925 break;
59245841
NC		 9926 }
9927 else
9928 {
9929 ivd.vd_next = BYTE_GET (evd.vd_next);
9930 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9931 }
252b5132
RH		 9932
9933 offset += ivd.vd_next;
9934 }
c244d050 9935 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 9936 && ivd.vd_next != 0);
9937
c244d050 9938 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 9939 {
b34976b6
AM		 9940 Elf_External_Verdaux evda;
9941 Elf_Internal_Verdaux ivda;
252b5132
RH		 9942
9943 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9944
59245841
NC		 9945 if (get_data (&evda, file,
9946 offset - ivd.vd_next + ivd.vd_aux,
9947 sizeof (evda), 1,
9948 _("version def aux")) == NULL)
9949 break;
252b5132
RH		 9950
9951 ivda.vda_name = BYTE_GET (evda.vda_name);
9952
54806181
AM		 9953 if (ivda.vda_name >= string_sec->sh_size)
9954 name = _("*invalid*");
9955 else
9956 name = strtab + ivda.vda_name;
252b5132 9957 nn += printf ("(%s%-*s",
16062207
ILT		 9958 name,
9959 12 - (int) strlen (name),
252b5132
RH		 9960 ")");
9961 }
9962 }
9963
9964 if (nn < 18)
9965 printf ("%*c", 18 - nn, ' ');
9966 }
9967
9968 putchar ('\n');
9969 }
9970
9971 free (data);
9972 free (strtab);
9973 free (symbols);
9974 }
9975 break;
103f02d3 9976
252b5132
RH		 9977 default:
9978 break;
9979 }
9980 }
9981
9982 if (! found)
9983 printf (_("\nNo version information found in this file.\n"));
9984
9985 return 1;
9986}
9987
d1133906 9988static const char *
d3ba0551 9989get_symbol_binding (unsigned int binding)
252b5132 9990{
b34976b6 9991 static char buff[32];
252b5132
RH		 9992
9993 switch (binding)
9994 {
b34976b6
AM		 9995 case STB_LOCAL: return "LOCAL";
9996 case STB_GLOBAL: return "GLOBAL";
9997 case STB_WEAK: return "WEAK";
252b5132
RH		 9998 default:
9999 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 10000 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10001 binding);
252b5132 10002 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 10003 {
10004 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 10005 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10006 /* GNU is still using the default value 0. */
3e7a7d11
NC		 10007 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10008 return "UNIQUE";
10009 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10010 }
252b5132 10011 else
e9e44622 10012 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 10013 return buff;
10014 }
10015}
10016
d1133906 10017static const char *
d3ba0551 10018get_symbol_type (unsigned int type)
252b5132 10019{
b34976b6 10020 static char buff[32];
252b5132
RH		 10021
10022 switch (type)
10023 {
b34976b6
AM		 10024 case STT_NOTYPE: return "NOTYPE";
10025 case STT_OBJECT: return "OBJECT";
10026 case STT_FUNC: return "FUNC";
10027 case STT_SECTION: return "SECTION";
10028 case STT_FILE: return "FILE";
10029 case STT_COMMON: return "COMMON";
10030 case STT_TLS: return "TLS";
15ab5209
DB		 10031 case STT_RELC: return "RELC";
10032 case STT_SRELC: return "SRELC";
252b5132
RH		 10033 default:
10034 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 10035 {
3510a7b8
NC		 10036 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10037 return "THUMB_FUNC";
103f02d3 10038
351b4b40 10039 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 10040 return "REGISTER";
10041
10042 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10043 return "PARISC_MILLI";
10044
e9e44622 10045 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 10046 }
252b5132 10047 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 10048 {
10049 if (elf_header.e_machine == EM_PARISC)
10050 {
10051 if (type == STT_HP_OPAQUE)
10052 return "HP_OPAQUE";
10053 if (type == STT_HP_STUB)
10054 return "HP_STUB";
10055 }
10056
d8045f23 10057 if (type == STT_GNU_IFUNC
9c55345c 10058 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 10059 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 10060 /* GNU is still using the default value 0. */
d8045f23
NC		 10061 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10062 return "IFUNC";
10063
e9e44622 10064 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 10065 }
252b5132 10066 else
e9e44622 10067 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 10068 return buff;
10069 }
10070}
10071
d1133906 10072static const char *
d3ba0551 10073get_symbol_visibility (unsigned int visibility)
d1133906
NC		 10074{
10075 switch (visibility)
10076 {
b34976b6
AM		 10077 case STV_DEFAULT: return "DEFAULT";
10078 case STV_INTERNAL: return "INTERNAL";
10079 case STV_HIDDEN: return "HIDDEN";
d1133906 10080 case STV_PROTECTED: return "PROTECTED";
bee0ee85
NC		 10081 default:
10082 error (_("Unrecognized visibility value: %u"), visibility);
10083 return _("<unknown>");
d1133906
NC		 10084 }
10085}
10086
5e2b0d47
NC		 10087static const char *
10088get_mips_symbol_other (unsigned int other)
10089{
10090 switch (other)
10091 {
df58fc94
RS		 10092 case STO_OPTIONAL:
10093 return "OPTIONAL";
10094 case STO_MIPS_PLT:
10095 return "MIPS PLT";
10096 case STO_MIPS_PIC:
10097 return "MIPS PIC";
10098 case STO_MICROMIPS:
10099 return "MICROMIPS";
10100 case STO_MICROMIPS | STO_MIPS_PIC:
10101 return "MICROMIPS, MIPS PIC";
10102 case STO_MIPS16:
10103 return "MIPS16";
10104 default:
10105 return NULL;
5e2b0d47
NC		 10106 }
10107}
10108
28f997cf
TG		 10109static const char *
10110get_ia64_symbol_other (unsigned int other)
10111{
10112 if (is_ia64_vms ())
10113 {
10114 static char res[32];
10115
10116 res[0] = 0;
10117
10118 /* Function types is for images and .STB files only. */
10119 switch (elf_header.e_type)
10120 {
10121 case ET_DYN:
10122 case ET_EXEC:
10123 switch (VMS_ST_FUNC_TYPE (other))
10124 {
10125 case VMS_SFT_CODE_ADDR:
10126 strcat (res, " CA");
10127 break;
10128 case VMS_SFT_SYMV_IDX:
10129 strcat (res, " VEC");
10130 break;
10131 case VMS_SFT_FD:
10132 strcat (res, " FD");
10133 break;
10134 case VMS_SFT_RESERVE:
10135 strcat (res, " RSV");
10136 break;
10137 default:
bee0ee85
NC		 10138 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10139 VMS_ST_FUNC_TYPE (other));
10140 strcat (res, " <unknown>");
10141 break;
28f997cf
TG		 10142 }
10143 break;
10144 default:
10145 break;
10146 }
10147 switch (VMS_ST_LINKAGE (other))
10148 {
10149 case VMS_STL_IGNORE:
10150 strcat (res, " IGN");
10151 break;
10152 case VMS_STL_RESERVE:
10153 strcat (res, " RSV");
10154 break;
10155 case VMS_STL_STD:
10156 strcat (res, " STD");
10157 break;
10158 case VMS_STL_LNK:
10159 strcat (res, " LNK");
10160 break;
10161 default:
bee0ee85
NC		 10162 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10163 VMS_ST_LINKAGE (other));
10164 strcat (res, " <unknown>");
10165 break;
28f997cf
TG		 10166 }
10167
10168 if (res[0] != 0)
10169 return res + 1;
10170 else
10171 return res;
10172 }
10173 return NULL;
10174}
10175
6911b7dc
AM		 10176static const char *
10177get_ppc64_symbol_other (unsigned int other)
10178{
10179 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10180 {
10181 static char buf[32];
10182 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10183 PPC64_LOCAL_ENTRY_OFFSET (other));
10184 return buf;
10185 }
10186 return NULL;
10187}
10188
5e2b0d47
NC		 10189static const char *
10190get_symbol_other (unsigned int other)
10191{
10192 const char * result = NULL;
10193 static char buff [32];
10194
10195 if (other == 0)
10196 return "";
10197
10198 switch (elf_header.e_machine)
10199 {
10200 case EM_MIPS:
10201 result = get_mips_symbol_other (other);
28f997cf
TG		 10202 break;
10203 case EM_IA_64:
10204 result = get_ia64_symbol_other (other);
10205 break;
6911b7dc
AM		 10206 case EM_PPC64:
10207 result = get_ppc64_symbol_other (other);
10208 break;
5e2b0d47
NC		 10209 default:
10210 break;
10211 }
10212
10213 if (result)
10214 return result;
10215
10216 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10217 return buff;
10218}
10219
d1133906 10220static const char *
d3ba0551 10221get_symbol_index_type (unsigned int type)
252b5132 10222{
b34976b6 10223 static char buff[32];
5cf1065c 10224
252b5132
RH		 10225 switch (type)
10226 {
b34976b6
AM		 10227 case SHN_UNDEF: return "UND";
10228 case SHN_ABS: return "ABS";
10229 case SHN_COMMON: return "COM";
252b5132 10230 default:
9ce701e2
L		 10231 if (type == SHN_IA_64_ANSI_COMMON
10232 && elf_header.e_machine == EM_IA_64
10233 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10234 return "ANSI_COM";
8a9036a4 10235 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 10236 || elf_header.e_machine == EM_L1OM
10237 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 10238 && type == SHN_X86_64_LCOMMON)
10239 return "LARGE_COM";
ac145307
BS		 10240 else if ((type == SHN_MIPS_SCOMMON
10241 && elf_header.e_machine == EM_MIPS)
10242 || (type == SHN_TIC6X_SCOMMON
10243 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 10244 return "SCOM";
10245 else if (type == SHN_MIPS_SUNDEFINED
10246 && elf_header.e_machine == EM_MIPS)
10247 return "SUND";
9ce701e2 10248 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 10249 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 10250 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 10251 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10252 else if (type >= SHN_LORESERVE)
10253 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4 10254 else if (type >= elf_header.e_shnum)
e0a31db1 10255 sprintf (buff, _("bad section index[%3d]"), type);
252b5132 10256 else
232e7cb8 10257 sprintf (buff, "%3d", type);
5cf1065c 10258 break;
252b5132 10259 }
5cf1065c
NC		 10260
10261 return buff;
252b5132
RH		 10262}
10263
66543521 10264static bfd_vma *
57028622 10265get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
252b5132 10266{
2cf0635d
NC		 10267 unsigned char * e_data;
10268 bfd_vma * i_data;
252b5132 10269
57028622
NC		 10270 /* If the size_t type is smaller than the bfd_size_type, eg because
10271 you are building a 32-bit tool on a 64-bit host, then make sure
10272 that when (number) is cast to (size_t) no information is lost. */
10273 if (sizeof (size_t) < sizeof (bfd_size_type)
10274 && (bfd_size_type) ((size_t) number) != number)
10275 {
10276 error (_("Size truncation prevents reading %llu elements of size %u\n"),
10277 (unsigned long long) number, ent_size);
10278 return NULL;
10279 }
948f632f 10280
3102e897
NC		 10281 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10282 attempting to allocate memory when the read is bound to fail. */
10283 if (ent_size * number > current_file_size)
10284 {
57028622
NC		 10285 error (_("Invalid number of dynamic entries: %llu\n"),
10286 (unsigned long long) number);
3102e897
NC		 10287 return NULL;
10288 }
10289
57028622 10290 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
252b5132
RH		 10291 if (e_data == NULL)
10292 {
57028622
NC		 10293 error (_("Out of memory reading %llu dynamic entries\n"),
10294 (unsigned long long) number);
252b5132
RH		 10295 return NULL;
10296 }
10297
57028622 10298 if (fread (e_data, ent_size, (size_t) number, file) != number)
252b5132 10299 {
57028622
NC		 10300 error (_("Unable to read in %llu bytes of dynamic data\n"),
10301 (unsigned long long) (number * ent_size));
3102e897 10302 free (e_data);
252b5132
RH		 10303 return NULL;
10304 }
10305
57028622 10306 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
252b5132
RH		 10307 if (i_data == NULL)
10308 {
57028622
NC		 10309 error (_("Out of memory allocating space for %llu dynamic entries\n"),
10310 (unsigned long long) number);
252b5132
RH		 10311 free (e_data);
10312 return NULL;
10313 }
10314
10315 while (number--)
66543521 10316 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 10317
10318 free (e_data);
10319
10320 return i_data;
10321}
10322
6bd1a22c
L		 10323static void
10324print_dynamic_symbol (bfd_vma si, unsigned long hn)
10325{
2cf0635d 10326 Elf_Internal_Sym * psym;
6bd1a22c
L		 10327 int n;
10328
6bd1a22c
L		 10329 n = print_vma (si, DEC_5);
10330 if (n < 5)
0b4362b0 10331 fputs (&" "[n], stdout);
6bd1a22c 10332 printf (" %3lu: ", hn);
e0a31db1
NC		 10333
10334 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10335 {
3102e897
NC		 10336 printf (_("<No info available for dynamic symbol number %lu>\n"),
10337 (unsigned long) si);
e0a31db1
NC		 10338 return;
10339 }
10340
10341 psym = dynamic_symbols + si;
6bd1a22c
L		 10342 print_vma (psym->st_value, LONG_HEX);
10343 putchar (' ');
10344 print_vma (psym->st_size, DEC_5);
10345
f4be36b3
AM		 10346 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10347 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10348 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 10349 /* Check to see if any other bits in the st_other field are set.
10350 Note - displaying this information disrupts the layout of the
10351 table being generated, but for the moment this case is very
10352 rare. */
10353 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10354 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10355 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10356 if (VALID_DYNAMIC_NAME (psym->st_name))
10357 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10358 else
2b692964 10359 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 10360 putchar ('\n');
10361}
10362
bb4d2ac2
L		 10363static const char *
10364get_symbol_version_string (FILE *file, int is_dynsym,
10365 const char *strtab,
10366 unsigned long int strtab_size,
10367 unsigned int si, Elf_Internal_Sym *psym,
10368 enum versioned_symbol_info *sym_info,
10369 unsigned short *vna_other)
10370{
10371 const char *version_string = NULL;
10372
10373 if (is_dynsym
10374 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
10375 {
10376 unsigned char data[2];
10377 unsigned short vers_data;
10378 unsigned long offset;
10379 int is_nobits;
10380 int check_def;
10381
10382 offset = offset_from_vma
10383 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10384 sizeof data + si * sizeof (vers_data));
10385
10386 if (get_data (&data, file, offset + si * sizeof (vers_data),
10387 sizeof (data), 1, _("version data")) == NULL)
10388 return NULL;
10389
10390 vers_data = byte_get (data, 2);
10391
53774b7e
NC		 10392 is_nobits = (section_headers != NULL
10393 && psym->st_shndx < elf_header.e_shnum
bb4d2ac2
L		 10394 && section_headers[psym->st_shndx].sh_type
10395 == SHT_NOBITS);
10396
10397 check_def = (psym->st_shndx != SHN_UNDEF);
10398
10399 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
10400 {
10401 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
10402 && (is_nobits || ! check_def))
10403 {
10404 Elf_External_Verneed evn;
10405 Elf_Internal_Verneed ivn;
10406 Elf_Internal_Vernaux ivna;
10407
10408 /* We must test both. */
10409 offset = offset_from_vma
10410 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10411 sizeof evn);
10412
10413 do
10414 {
10415 unsigned long vna_off;
10416
10417 if (get_data (&evn, file, offset, sizeof (evn), 1,
10418 _("version need")) == NULL)
10419 {
10420 ivna.vna_next = 0;
10421 ivna.vna_other = 0;
10422 ivna.vna_name = 0;
10423 break;
10424 }
10425
10426 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10427 ivn.vn_next = BYTE_GET (evn.vn_next);
10428
10429 vna_off = offset + ivn.vn_aux;
10430
10431 do
10432 {
10433 Elf_External_Vernaux evna;
10434
10435 if (get_data (&evna, file, vna_off,
10436 sizeof (evna), 1,
10437 _("version need aux (3)")) == NULL)
10438 {
10439 ivna.vna_next = 0;
10440 ivna.vna_other = 0;
10441 ivna.vna_name = 0;
10442 }
10443 else
10444 {
10445 ivna.vna_other = BYTE_GET (evna.vna_other);
10446 ivna.vna_next = BYTE_GET (evna.vna_next);
10447 ivna.vna_name = BYTE_GET (evna.vna_name);
10448 }
10449
10450 vna_off += ivna.vna_next;
10451 }
10452 while (ivna.vna_other != vers_data
10453 && ivna.vna_next != 0);
10454
10455 if (ivna.vna_other == vers_data)
10456 break;
10457
10458 offset += ivn.vn_next;
10459 }
10460 while (ivn.vn_next != 0);
10461
10462 if (ivna.vna_other == vers_data)
10463 {
10464 *sym_info = symbol_undefined;
10465 *vna_other = ivna.vna_other;
10466 version_string = (ivna.vna_name < strtab_size
10467 ? strtab + ivna.vna_name
10468 : _("<corrupt>"));
10469 check_def = 0;
10470 }
10471 else if (! is_nobits)
10472 error (_("bad dynamic symbol\n"));
10473 else
10474 check_def = 1;
10475 }
10476
10477 if (check_def)
10478 {
10479 if (vers_data != 0x8001
10480 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10481 {
10482 Elf_Internal_Verdef ivd;
10483 Elf_Internal_Verdaux ivda;
10484 Elf_External_Verdaux evda;
10485 unsigned long off;
10486
10487 off = offset_from_vma
10488 (file,
10489 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10490 sizeof (Elf_External_Verdef));
10491
10492 do
10493 {
10494 Elf_External_Verdef evd;
10495
10496 if (get_data (&evd, file, off, sizeof (evd),
10497 1, _("version def")) == NULL)
10498 {
10499 ivd.vd_ndx = 0;
10500 ivd.vd_aux = 0;
10501 ivd.vd_next = 0;
10502 }
10503 else
10504 {
10505 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10506 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10507 ivd.vd_next = BYTE_GET (evd.vd_next);
10508 }
10509
10510 off += ivd.vd_next;
10511 }
10512 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10513 && ivd.vd_next != 0);
10514
10515 off -= ivd.vd_next;
10516 off += ivd.vd_aux;
10517
10518 if (get_data (&evda, file, off, sizeof (evda),
10519 1, _("version def aux")) == NULL)
10520 return version_string;
10521
10522 ivda.vda_name = BYTE_GET (evda.vda_name);
10523
10524 if (psym->st_name != ivda.vda_name)
10525 {
10526 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10527 ? symbol_hidden : symbol_public);
10528 version_string = (ivda.vda_name < strtab_size
10529 ? strtab + ivda.vda_name
10530 : _("<corrupt>"));
10531 }
10532 }
10533 }
10534 }
10535 }
10536 return version_string;
10537}
10538
e3c8793a 10539/* Dump the symbol table. */
252b5132 10540static int
2cf0635d 10541process_symbol_table (FILE * file)
252b5132 10542{
2cf0635d 10543 Elf_Internal_Shdr * section;
8b73c356
NC		 10544 bfd_size_type nbuckets = 0;
10545 bfd_size_type nchains = 0;
2cf0635d
NC		 10546 bfd_vma * buckets = NULL;
10547 bfd_vma * chains = NULL;
fdc90cb4 10548 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 10549 bfd_vma * gnubuckets = NULL;
10550 bfd_vma * gnuchains = NULL;
6bd1a22c 10551 bfd_vma gnusymidx = 0;
071436c6 10552 bfd_size_type ngnuchains = 0;
252b5132 10553
2c610e4b 10554 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 10555 return 1;
10556
6bd1a22c
L		 10557 if (dynamic_info[DT_HASH]
10558 && (do_histogram
2c610e4b
L		 10559 || (do_using_dynamic
10560 && !do_dyn_syms
10561 && dynamic_strings != NULL)))
252b5132 10562 {
66543521
AM		 10563 unsigned char nb[8];
10564 unsigned char nc[8];
8b73c356 10565 unsigned int hash_ent_size = 4;
66543521
AM		 10566
10567 if ((elf_header.e_machine == EM_ALPHA
10568 || elf_header.e_machine == EM_S390
10569 || elf_header.e_machine == EM_S390_OLD)
10570 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10571 hash_ent_size = 8;
10572
fb52b2f4
NC		 10573 if (fseek (file,
10574 (archive_file_offset
10575 + offset_from_vma (file, dynamic_info[DT_HASH],
10576 sizeof nb + sizeof nc)),
d93f0186 10577 SEEK_SET))
252b5132 10578 {
591a748a 10579 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10580 goto no_hash;
252b5132
RH		 10581 }
10582
66543521 10583 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 10584 {
10585 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10586 goto no_hash;
252b5132
RH		 10587 }
10588
66543521 10589 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 10590 {
10591 error (_("Failed to read in number of chains\n"));
d3a44ec6 10592 goto no_hash;
252b5132
RH		 10593 }
10594
66543521
AM		 10595 nbuckets = byte_get (nb, hash_ent_size);
10596 nchains = byte_get (nc, hash_ent_size);
252b5132 10597
66543521
AM		 10598 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10599 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 10600
d3a44ec6 10601 no_hash:
252b5132 10602 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 10603 {
10604 if (do_using_dynamic)
10605 return 0;
10606 free (buckets);
10607 free (chains);
10608 buckets = NULL;
10609 chains = NULL;
10610 nbuckets = 0;
10611 nchains = 0;
10612 }
252b5132
RH		 10613 }
10614
6bd1a22c
L		 10615 if (dynamic_info_DT_GNU_HASH
10616 && (do_histogram
2c610e4b
L		 10617 || (do_using_dynamic
10618 && !do_dyn_syms
10619 && dynamic_strings != NULL)))
252b5132 10620 {
6bd1a22c
L		 10621 unsigned char nb[16];
10622 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10623 bfd_vma buckets_vma;
10624
10625 if (fseek (file,
10626 (archive_file_offset
10627 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10628 sizeof nb)),
10629 SEEK_SET))
10630 {
10631 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10632 goto no_gnu_hash;
6bd1a22c 10633 }
252b5132 10634
6bd1a22c
L		 10635 if (fread (nb, 16, 1, file) != 1)
10636 {
10637 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10638 goto no_gnu_hash;
6bd1a22c
L		 10639 }
10640
10641 ngnubuckets = byte_get (nb, 4);
10642 gnusymidx = byte_get (nb + 4, 4);
10643 bitmaskwords = byte_get (nb + 8, 4);
10644 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 10645 if (is_32bit_elf)
6bd1a22c 10646 buckets_vma += bitmaskwords * 4;
f7a99963 10647 else
6bd1a22c 10648 buckets_vma += bitmaskwords * 8;
252b5132 10649
6bd1a22c
L		 10650 if (fseek (file,
10651 (archive_file_offset
10652 + offset_from_vma (file, buckets_vma, 4)),
10653 SEEK_SET))
252b5132 10654 {
6bd1a22c 10655 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10656 goto no_gnu_hash;
6bd1a22c
L		 10657 }
10658
10659 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 10660
6bd1a22c 10661 if (gnubuckets == NULL)
d3a44ec6 10662 goto no_gnu_hash;
6bd1a22c
L		 10663
10664 for (i = 0; i < ngnubuckets; i++)
10665 if (gnubuckets[i] != 0)
10666 {
10667 if (gnubuckets[i] < gnusymidx)
10668 return 0;
10669
10670 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10671 maxchain = gnubuckets[i];
10672 }
10673
10674 if (maxchain == 0xffffffff)
d3a44ec6 10675 goto no_gnu_hash;
6bd1a22c
L		 10676
10677 maxchain -= gnusymidx;
10678
10679 if (fseek (file,
10680 (archive_file_offset
10681 + offset_from_vma (file, buckets_vma
10682 + 4 * (ngnubuckets + maxchain), 4)),
10683 SEEK_SET))
10684 {
10685 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10686 goto no_gnu_hash;
6bd1a22c
L		 10687 }
10688
10689 do
10690 {
10691 if (fread (nb, 4, 1, file) != 1)
252b5132 10692 {
6bd1a22c 10693 error (_("Failed to determine last chain length\n"));
d3a44ec6 10694 goto no_gnu_hash;
6bd1a22c 10695 }
252b5132 10696
6bd1a22c 10697 if (maxchain + 1 == 0)
d3a44ec6 10698 goto no_gnu_hash;
252b5132 10699
6bd1a22c
L		 10700 ++maxchain;
10701 }
10702 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 10703
6bd1a22c
L		 10704 if (fseek (file,
10705 (archive_file_offset
10706 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10707 SEEK_SET))
10708 {
10709 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10710 goto no_gnu_hash;
6bd1a22c
L		 10711 }
10712
10713 gnuchains = get_dynamic_data (file, maxchain, 4);
071436c6 10714 ngnuchains = maxchain;
6bd1a22c 10715
d3a44ec6 10716 no_gnu_hash:
6bd1a22c 10717 if (gnuchains == NULL)
d3a44ec6
JJ		 10718 {
10719 free (gnubuckets);
d3a44ec6
JJ		 10720 gnubuckets = NULL;
10721 ngnubuckets = 0;
f64fddf1
NC		 10722 if (do_using_dynamic)
10723 return 0;
d3a44ec6 10724 }
6bd1a22c
L		 10725 }
10726
10727 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10728 && do_syms
10729 && do_using_dynamic
3102e897
NC		 10730 && dynamic_strings != NULL
10731 && dynamic_symbols != NULL)
6bd1a22c
L		 10732 {
10733 unsigned long hn;
10734
10735 if (dynamic_info[DT_HASH])
10736 {
10737 bfd_vma si;
10738
10739 printf (_("\nSymbol table for image:\n"));
10740 if (is_32bit_elf)
10741 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10742 else
10743 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10744
10745 for (hn = 0; hn < nbuckets; hn++)
10746 {
10747 if (! buckets[hn])
10748 continue;
10749
10750 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10751 print_dynamic_symbol (si, hn);
252b5132
RH		 10752 }
10753 }
6bd1a22c
L		 10754
10755 if (dynamic_info_DT_GNU_HASH)
10756 {
10757 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10758 if (is_32bit_elf)
10759 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10760 else
10761 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10762
10763 for (hn = 0; hn < ngnubuckets; ++hn)
10764 if (gnubuckets[hn] != 0)
10765 {
10766 bfd_vma si = gnubuckets[hn];
10767 bfd_vma off = si - gnusymidx;
10768
10769 do
10770 {
10771 print_dynamic_symbol (si, hn);
10772 si++;
10773 }
071436c6 10774 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
6bd1a22c
L		 10775 }
10776 }
252b5132 10777 }
8b73c356
NC		 10778 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10779 && section_headers != NULL)
252b5132 10780 {
b34976b6 10781 unsigned int i;
252b5132
RH		 10782
10783 for (i = 0, section = section_headers;
10784 i < elf_header.e_shnum;
10785 i++, section++)
10786 {
b34976b6 10787 unsigned int si;
2cf0635d 10788 char * strtab = NULL;
c256ffe7 10789 unsigned long int strtab_size = 0;
2cf0635d
NC		 10790 Elf_Internal_Sym * symtab;
10791 Elf_Internal_Sym * psym;
ba5cdace 10792 unsigned long num_syms;
252b5132 10793
2c610e4b
L		 10794 if ((section->sh_type != SHT_SYMTAB
10795 && section->sh_type != SHT_DYNSYM)
10796 || (!do_syms
10797 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 10798 continue;
10799
dd24e3da
NC		 10800 if (section->sh_entsize == 0)
10801 {
10802 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
74e1a04b 10803 printable_section_name (section));
dd24e3da
NC		 10804 continue;
10805 }
10806
252b5132 10807 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
74e1a04b 10808 printable_section_name (section),
252b5132 10809 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 10810
f7a99963 10811 if (is_32bit_elf)
ca47b30c 10812 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 10813 else
ca47b30c 10814 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 10815
ba5cdace 10816 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 10817 if (symtab == NULL)
10818 continue;
10819
10820 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 10821 {
10822 strtab = string_table;
10823 strtab_size = string_table_length;
10824 }
4fbb74a6 10825 else if (section->sh_link < elf_header.e_shnum)
252b5132 10826 {
2cf0635d 10827 Elf_Internal_Shdr * string_sec;
252b5132 10828
4fbb74a6 10829 string_sec = section_headers + section->sh_link;
252b5132 10830
3f5e193b
NC		 10831 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10832 1, string_sec->sh_size,
10833 _("string table"));
c256ffe7 10834 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 10835 }
10836
ba5cdace 10837 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 10838 {
bb4d2ac2
L		 10839 const char *version_string;
10840 enum versioned_symbol_info sym_info;
10841 unsigned short vna_other;
10842
5e220199 10843 printf ("%6d: ", si);
f7a99963
NC		 10844 print_vma (psym->st_value, LONG_HEX);
10845 putchar (' ');
10846 print_vma (psym->st_size, DEC_5);
d1133906
NC		 10847 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10848 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 10849 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 10850 /* Check to see if any other bits in the st_other field are set.
10851 Note - displaying this information disrupts the layout of the
10852 table being generated, but for the moment this case is very rare. */
10853 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10854 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 10855 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 10856 print_symbol (25, psym->st_name < strtab_size
2b692964 10857 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 10858
bb4d2ac2
L		 10859 version_string
10860 = get_symbol_version_string (file,
10861 section->sh_type == SHT_DYNSYM,
10862 strtab, strtab_size, si,
10863 psym, &sym_info, &vna_other);
10864 if (version_string)
252b5132 10865 {
bb4d2ac2
L		 10866 if (sym_info == symbol_undefined)
10867 printf ("@%s (%d)", version_string, vna_other);
10868 else
10869 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10870 version_string);
252b5132
RH		 10871 }
10872
10873 putchar ('\n');
10874 }
10875
10876 free (symtab);
10877 if (strtab != string_table)
10878 free (strtab);
10879 }
10880 }
10881 else if (do_syms)
10882 printf
10883 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10884
10885 if (do_histogram && buckets != NULL)
10886 {
2cf0635d
NC		 10887 unsigned long * lengths;
10888 unsigned long * counts;
66543521
AM		 10889 unsigned long hn;
10890 bfd_vma si;
10891 unsigned long maxlength = 0;
10892 unsigned long nzero_counts = 0;
10893 unsigned long nsyms = 0;
94d15024 10894 unsigned long chained;
252b5132 10895
66543521
AM		 10896 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10897 (unsigned long) nbuckets);
252b5132 10898
3f5e193b 10899 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 10900 if (lengths == NULL)
10901 {
8b73c356 10902 error (_("Out of memory allocating space for histogram buckets\n"));
252b5132
RH		 10903 return 0;
10904 }
8b73c356
NC		 10905
10906 printf (_(" Length Number %% of total Coverage\n"));
252b5132
RH		 10907 for (hn = 0; hn < nbuckets; ++hn)
10908 {
94d15024
MF		 10909 for (si = buckets[hn], chained = 0;
10910 si > 0 && si < nchains && si < nbuckets && chained <= nchains;
10911 si = chains[si], ++chained)
252b5132 10912 {
b34976b6 10913 ++nsyms;
252b5132 10914 if (maxlength < ++lengths[hn])
b34976b6 10915 ++maxlength;
252b5132 10916 }
94d15024
MF		 10917
10918 /* PR binutils/17531: A corrupt binary could contain broken
10919 histogram data. Do not go into an infinite loop trying
10920 to process it. */
10921 if (chained > nchains)
10922 {
10923 error (_("histogram chain is corrupt\n"));
10924 break;
10925 }
252b5132
RH		 10926 }
10927
3f5e193b 10928 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 10929 if (counts == NULL)
10930 {
b2e951ec 10931 free (lengths);
8b73c356 10932 error (_("Out of memory allocating space for histogram counts\n"));
252b5132
RH		 10933 return 0;
10934 }
10935
10936 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 10937 ++counts[lengths[hn]];
252b5132 10938
103f02d3 10939 if (nbuckets > 0)
252b5132 10940 {
66543521
AM		 10941 unsigned long i;
10942 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 10943 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 10944 for (i = 1; i <= maxlength; ++i)
103f02d3 10945 {
66543521
AM		 10946 nzero_counts += counts[i] * i;
10947 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10948 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 10949 (nzero_counts * 100.0) / nsyms);
10950 }
252b5132
RH		 10951 }
10952
10953 free (counts);
10954 free (lengths);
10955 }
10956
10957 if (buckets != NULL)
10958 {
10959 free (buckets);
10960 free (chains);
10961 }
10962
d3a44ec6 10963 if (do_histogram && gnubuckets != NULL)
fdc90cb4 10964 {
2cf0635d
NC		 10965 unsigned long * lengths;
10966 unsigned long * counts;
fdc90cb4
JJ		 10967 unsigned long hn;
10968 unsigned long maxlength = 0;
10969 unsigned long nzero_counts = 0;
10970 unsigned long nsyms = 0;
fdc90cb4 10971
8b73c356
NC		 10972 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10973 (unsigned long) ngnubuckets);
10974
3f5e193b 10975 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 10976 if (lengths == NULL)
10977 {
8b73c356 10978 error (_("Out of memory allocating space for gnu histogram buckets\n"));
fdc90cb4
JJ		 10979 return 0;
10980 }
10981
fdc90cb4
JJ		 10982 printf (_(" Length Number %% of total Coverage\n"));
10983
10984 for (hn = 0; hn < ngnubuckets; ++hn)
10985 if (gnubuckets[hn] != 0)
10986 {
10987 bfd_vma off, length = 1;
10988
6bd1a22c 10989 for (off = gnubuckets[hn] - gnusymidx;
071436c6
NC		 10990 /* PR 17531 file: 010-77222-0.004. */
10991 off < ngnuchains && (gnuchains[off] & 1) == 0;
10992 ++off)
fdc90cb4
JJ		 10993 ++length;
10994 lengths[hn] = length;
10995 if (length > maxlength)
10996 maxlength = length;
10997 nsyms += length;
10998 }
10999
3f5e193b 11000 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 11001 if (counts == NULL)
11002 {
b2e951ec 11003 free (lengths);
8b73c356 11004 error (_("Out of memory allocating space for gnu histogram counts\n"));
fdc90cb4
JJ		 11005 return 0;
11006 }
11007
11008 for (hn = 0; hn < ngnubuckets; ++hn)
11009 ++counts[lengths[hn]];
11010
11011 if (ngnubuckets > 0)
11012 {
11013 unsigned long j;
11014 printf (" 0 %-10lu (%5.1f%%)\n",
11015 counts[0], (counts[0] * 100.0) / ngnubuckets);
11016 for (j = 1; j <= maxlength; ++j)
11017 {
11018 nzero_counts += counts[j] * j;
11019 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11020 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11021 (nzero_counts * 100.0) / nsyms);
11022 }
11023 }
11024
11025 free (counts);
11026 free (lengths);
11027 free (gnubuckets);
11028 free (gnuchains);
11029 }
11030
252b5132
RH		 11031 return 1;
11032}
11033
11034static int
2cf0635d 11035process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 11036{
b4c96d0d 11037 unsigned int i;
252b5132
RH		 11038
11039 if (dynamic_syminfo == NULL
11040 || !do_dynamic)
11041 /* No syminfo, this is ok. */
11042 return 1;
11043
11044 /* There better should be a dynamic symbol section. */
11045 if (dynamic_symbols == NULL || dynamic_strings == NULL)
11046 return 0;
11047
11048 if (dynamic_addr)
11049 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11050 dynamic_syminfo_offset, dynamic_syminfo_nent);
11051
11052 printf (_(" Num: Name BoundTo Flags\n"));
11053 for (i = 0; i < dynamic_syminfo_nent; ++i)
11054 {
11055 unsigned short int flags = dynamic_syminfo[i].si_flags;
11056
31104126 11057 printf ("%4d: ", i);
4082ef84
NC		 11058 if (i >= num_dynamic_syms)
11059 printf (_("<corrupt index>"));
11060 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
d79b3d50
NC		 11061 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11062 else
2b692964 11063 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 11064 putchar (' ');
252b5132
RH		 11065
11066 switch (dynamic_syminfo[i].si_boundto)
11067 {
11068 case SYMINFO_BT_SELF:
11069 fputs ("SELF ", stdout);
11070 break;
11071 case SYMINFO_BT_PARENT:
11072 fputs ("PARENT ", stdout);
11073 break;
11074 default:
11075 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 11076 && dynamic_syminfo[i].si_boundto < dynamic_nent
11077 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 11078 {
d79b3d50 11079 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 11080 putchar (' ' );
11081 }
252b5132
RH		 11082 else
11083 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11084 break;
11085 }
11086
11087 if (flags & SYMINFO_FLG_DIRECT)
11088 printf (" DIRECT");
11089 if (flags & SYMINFO_FLG_PASSTHRU)
11090 printf (" PASSTHRU");
11091 if (flags & SYMINFO_FLG_COPY)
11092 printf (" COPY");
11093 if (flags & SYMINFO_FLG_LAZYLOAD)
11094 printf (" LAZYLOAD");
11095
11096 puts ("");
11097 }
11098
11099 return 1;
11100}
11101
cf13d699
NC		 11102/* Check to see if the given reloc needs to be handled in a target specific
11103 manner. If so then process the reloc and return TRUE otherwise return
11104 FALSE. */
09c11c86 11105
cf13d699
NC		 11106static bfd_boolean
11107target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11108 unsigned char * start,
11109 Elf_Internal_Sym * symtab)
252b5132 11110{
cf13d699 11111 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 11112
cf13d699 11113 switch (elf_header.e_machine)
252b5132 11114 {
13761a11
NC		 11115 case EM_MSP430:
11116 case EM_MSP430_OLD:
11117 {
11118 static Elf_Internal_Sym * saved_sym = NULL;
11119
11120 switch (reloc_type)
11121 {
11122 case 10: /* R_MSP430_SYM_DIFF */
11123 if (uses_msp430x_relocs ())
11124 break;
11125 case 21: /* R_MSP430X_SYM_DIFF */
11126 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11127 return TRUE;
11128
11129 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11130 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11131 goto handle_sym_diff;
0b4362b0 11132
13761a11
NC		 11133 case 5: /* R_MSP430_16_BYTE */
11134 case 9: /* R_MSP430_8 */
11135 if (uses_msp430x_relocs ())
11136 break;
11137 goto handle_sym_diff;
11138
11139 case 2: /* R_MSP430_ABS16 */
11140 case 15: /* R_MSP430X_ABS16 */
11141 if (! uses_msp430x_relocs ())
11142 break;
11143 goto handle_sym_diff;
0b4362b0 11144
13761a11
NC		 11145 handle_sym_diff:
11146 if (saved_sym != NULL)
11147 {
11148 bfd_vma value;
11149
11150 value = reloc->r_addend
11151 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11152 - saved_sym->st_value);
11153
11154 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11155
11156 saved_sym = NULL;
11157 return TRUE;
11158 }
11159 break;
11160
11161 default:
11162 if (saved_sym != NULL)
071436c6 11163 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13761a11
NC		 11164 break;
11165 }
11166 break;
11167 }
11168
cf13d699
NC		 11169 case EM_MN10300:
11170 case EM_CYGNUS_MN10300:
11171 {
11172 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 11173
cf13d699
NC		 11174 switch (reloc_type)
11175 {
11176 case 34: /* R_MN10300_ALIGN */
11177 return TRUE;
11178 case 33: /* R_MN10300_SYM_DIFF */
11179 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11180 return TRUE;
11181 case 1: /* R_MN10300_32 */
11182 case 2: /* R_MN10300_16 */
11183 if (saved_sym != NULL)
11184 {
11185 bfd_vma value;
252b5132 11186
cf13d699
NC		 11187 value = reloc->r_addend
11188 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11189 - saved_sym->st_value);
252b5132 11190
cf13d699 11191 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 11192
cf13d699
NC		 11193 saved_sym = NULL;
11194 return TRUE;
11195 }
11196 break;
11197 default:
11198 if (saved_sym != NULL)
071436c6 11199 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
cf13d699
NC		 11200 break;
11201 }
11202 break;
11203 }
6ff71e76
NC		 11204
11205 case EM_RL78:
11206 {
11207 static bfd_vma saved_sym1 = 0;
11208 static bfd_vma saved_sym2 = 0;
11209 static bfd_vma value;
11210
11211 switch (reloc_type)
11212 {
11213 case 0x80: /* R_RL78_SYM. */
11214 saved_sym1 = saved_sym2;
11215 saved_sym2 = symtab[get_reloc_symindex (reloc->r_info)].st_value;
11216 saved_sym2 += reloc->r_addend;
11217 return TRUE;
11218
11219 case 0x83: /* R_RL78_OPsub. */
11220 value = saved_sym1 - saved_sym2;
11221 saved_sym2 = saved_sym1 = 0;
11222 return TRUE;
11223 break;
11224
11225 case 0x41: /* R_RL78_ABS32. */
11226 byte_put (start + reloc->r_offset, value, 4);
11227 value = 0;
11228 return TRUE;
11229
11230 case 0x43: /* R_RL78_ABS16. */
11231 byte_put (start + reloc->r_offset, value, 2);
11232 value = 0;
11233 return TRUE;
11234
11235 default:
11236 break;
11237 }
11238 break;
11239 }
252b5132
RH		 11240 }
11241
cf13d699 11242 return FALSE;
252b5132
RH		 11243}
11244
aca88567
NC		 11245/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11246 DWARF debug sections. This is a target specific test. Note - we do not
11247 go through the whole including-target-headers-multiple-times route, (as
11248 we have already done with <elf/h8.h>) because this would become very
11249 messy and even then this function would have to contain target specific
11250 information (the names of the relocs instead of their numeric values).
11251 FIXME: This is not the correct way to solve this problem. The proper way
11252 is to have target specific reloc sizing and typing functions created by
11253 the reloc-macros.h header, in the same way that it already creates the
11254 reloc naming functions. */
11255
11256static bfd_boolean
11257is_32bit_abs_reloc (unsigned int reloc_type)
11258{
11259 switch (elf_header.e_machine)
11260 {
41e92641 11261 case EM_386:
22abe556 11262 case EM_IAMCU:
41e92641 11263 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 11264 case EM_68K:
11265 return reloc_type == 1; /* R_68K_32. */
11266 case EM_860:
11267 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 11268 case EM_960:
11269 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 11270 case EM_AARCH64:
11271 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 11272 case EM_ALPHA:
137b6b5f 11273 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 11274 case EM_ARC:
11275 return reloc_type == 1; /* R_ARC_32. */
11276 case EM_ARM:
11277 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 11278 case EM_AVR_OLD:
aca88567
NC		 11279 case EM_AVR:
11280 return reloc_type == 1;
cfb8c092
NC		 11281 case EM_ADAPTEVA_EPIPHANY:
11282 return reloc_type == 3;
aca88567
NC		 11283 case EM_BLACKFIN:
11284 return reloc_type == 0x12; /* R_byte4_data. */
11285 case EM_CRIS:
11286 return reloc_type == 3; /* R_CRIS_32. */
11287 case EM_CR16:
11288 return reloc_type == 3; /* R_CR16_NUM32. */
11289 case EM_CRX:
11290 return reloc_type == 15; /* R_CRX_NUM32. */
11291 case EM_CYGNUS_FRV:
11292 return reloc_type == 1;
41e92641
NC		 11293 case EM_CYGNUS_D10V:
11294 case EM_D10V:
11295 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 11296 case EM_CYGNUS_D30V:
11297 case EM_D30V:
11298 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 11299 case EM_DLX:
11300 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 11301 case EM_CYGNUS_FR30:
11302 case EM_FR30:
11303 return reloc_type == 3; /* R_FR30_32. */
3f8107ab
AM		 11304 case EM_FT32:
11305 return reloc_type == 1; /* R_FT32_32. */
aca88567
NC		 11306 case EM_H8S:
11307 case EM_H8_300:
11308 case EM_H8_300H:
11309 return reloc_type == 1; /* R_H8_DIR32. */
3730236a 11310 case EM_IA_64:
d1c4b12b
NC		 11311 return reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
11312 || reloc_type == 0x25; /* R_IA64_DIR32LSB. */
aca88567
NC		 11313 case EM_IP2K_OLD:
11314 case EM_IP2K:
11315 return reloc_type == 2; /* R_IP2K_32. */
11316 case EM_IQ2000:
11317 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 11318 case EM_LATTICEMICO32:
11319 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 11320 case EM_M32C_OLD:
aca88567
NC		 11321 case EM_M32C:
11322 return reloc_type == 3; /* R_M32C_32. */
11323 case EM_M32R:
11324 return reloc_type == 34; /* R_M32R_32_RELA. */
11325 case EM_MCORE:
11326 return reloc_type == 1; /* R_MCORE_ADDR32. */
11327 case EM_CYGNUS_MEP:
11328 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 11329 case EM_METAG:
11330 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 11331 case EM_MICROBLAZE:
11332 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 11333 case EM_MIPS:
11334 return reloc_type == 2; /* R_MIPS_32. */
11335 case EM_MMIX:
11336 return reloc_type == 4; /* R_MMIX_32. */
11337 case EM_CYGNUS_MN10200:
11338 case EM_MN10200:
11339 return reloc_type == 1; /* R_MN10200_32. */
11340 case EM_CYGNUS_MN10300:
11341 case EM_MN10300:
11342 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 11343 case EM_MOXIE:
11344 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 11345 case EM_MSP430_OLD:
11346 case EM_MSP430:
13761a11 11347 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 11348 case EM_MT:
11349 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 11350 case EM_NDS32:
11351 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 11352 case EM_ALTERA_NIOS2:
36591ba1 11353 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 11354 case EM_NIOS32:
11355 return reloc_type == 1; /* R_NIOS_32. */
73589c9d
CS		 11356 case EM_OR1K:
11357 return reloc_type == 1; /* R_OR1K_32. */
aca88567 11358 case EM_PARISC:
5fda8eca
NC		 11359 return (reloc_type == 1 /* R_PARISC_DIR32. */
11360 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 11361 case EM_PJ:
11362 case EM_PJ_OLD:
11363 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
11364 case EM_PPC64:
11365 return reloc_type == 1; /* R_PPC64_ADDR32. */
11366 case EM_PPC:
11367 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 11368 case EM_RL78:
11369 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 11370 case EM_RX:
11371 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 11372 case EM_S370:
11373 return reloc_type == 1; /* R_I370_ADDR31. */
11374 case EM_S390_OLD:
11375 case EM_S390:
11376 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 11377 case EM_SCORE:
11378 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 11379 case EM_SH:
11380 return reloc_type == 1; /* R_SH_DIR32. */
11381 case EM_SPARC32PLUS:
11382 case EM_SPARCV9:
11383 case EM_SPARC:
11384 return reloc_type == 3 /* R_SPARC_32. */
11385 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 11386 case EM_SPU:
11387 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 11388 case EM_TI_C6000:
11389 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 11390 case EM_TILEGX:
11391 return reloc_type == 2; /* R_TILEGX_32. */
11392 case EM_TILEPRO:
11393 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 11394 case EM_CYGNUS_V850:
11395 case EM_V850:
11396 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 11397 case EM_V800:
11398 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 11399 case EM_VAX:
11400 return reloc_type == 1; /* R_VAX_32. */
619ed720
EB		 11401 case EM_VISIUM:
11402 return reloc_type == 3; /* R_VISIUM_32. */
aca88567 11403 case EM_X86_64:
8a9036a4 11404 case EM_L1OM:
7a9068fe 11405 case EM_K1OM:
aca88567 11406 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 11407 case EM_XC16X:
11408 case EM_C166:
11409 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 11410 case EM_XGATE:
11411 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 11412 case EM_XSTORMY16:
11413 return reloc_type == 1; /* R_XSTROMY16_32. */
11414 case EM_XTENSA_OLD:
11415 case EM_XTENSA:
11416 return reloc_type == 1; /* R_XTENSA_32. */
aca88567 11417 default:
bee0ee85
NC		 11418 {
11419 static unsigned int prev_warn = 0;
11420
11421 /* Avoid repeating the same warning multiple times. */
11422 if (prev_warn != elf_header.e_machine)
11423 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11424 elf_header.e_machine);
11425 prev_warn = elf_header.e_machine;
11426 return FALSE;
11427 }
aca88567
NC		 11428 }
11429}
11430
11431/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11432 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11433
11434static bfd_boolean
11435is_32bit_pcrel_reloc (unsigned int reloc_type)
11436{
11437 switch (elf_header.e_machine)
11438 {
41e92641 11439 case EM_386:
22abe556 11440 case EM_IAMCU:
3e0873ac 11441 return reloc_type == 2; /* R_386_PC32. */
aca88567 11442 case EM_68K:
3e0873ac 11443 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 11444 case EM_AARCH64:
11445 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 11446 case EM_ADAPTEVA_EPIPHANY:
11447 return reloc_type == 6;
aca88567
NC		 11448 case EM_ALPHA:
11449 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 11450 case EM_ARM:
3e0873ac 11451 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 11452 case EM_MICROBLAZE:
11453 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
73589c9d
CS		 11454 case EM_OR1K:
11455 return reloc_type == 9; /* R_OR1K_32_PCREL. */
aca88567 11456 case EM_PARISC:
85acf597 11457 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 11458 case EM_PPC:
11459 return reloc_type == 26; /* R_PPC_REL32. */
11460 case EM_PPC64:
3e0873ac 11461 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 11462 case EM_S390_OLD:
11463 case EM_S390:
3e0873ac 11464 return reloc_type == 5; /* R_390_PC32. */
aca88567 11465 case EM_SH:
3e0873ac 11466 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 11467 case EM_SPARC32PLUS:
11468 case EM_SPARCV9:
11469 case EM_SPARC:
3e0873ac 11470 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 11471 case EM_SPU:
11472 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 11473 case EM_TILEGX:
11474 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
11475 case EM_TILEPRO:
11476 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
619ed720
EB		 11477 case EM_VISIUM:
11478 return reloc_type == 6; /* R_VISIUM_32_PCREL */
aca88567 11479 case EM_X86_64:
8a9036a4 11480 case EM_L1OM:
7a9068fe 11481 case EM_K1OM:
3e0873ac 11482 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 11483 case EM_XTENSA_OLD:
11484 case EM_XTENSA:
11485 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 11486 default:
11487 /* Do not abort or issue an error message here. Not all targets use
11488 pc-relative 32-bit relocs in their DWARF debug information and we
11489 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 11490 more helpful warning message will be generated by apply_relocations
11491 anyway, so just return. */
aca88567
NC		 11492 return FALSE;
11493 }
11494}
11495
11496/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11497 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11498
11499static bfd_boolean
11500is_64bit_abs_reloc (unsigned int reloc_type)
11501{
11502 switch (elf_header.e_machine)
11503 {
a06ea964
NC		 11504 case EM_AARCH64:
11505 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 11506 case EM_ALPHA:
11507 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 11508 case EM_IA_64:
11509 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 11510 case EM_PARISC:
11511 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 11512 case EM_PPC64:
11513 return reloc_type == 38; /* R_PPC64_ADDR64. */
11514 case EM_SPARC32PLUS:
11515 case EM_SPARCV9:
11516 case EM_SPARC:
11517 return reloc_type == 54; /* R_SPARC_UA64. */
11518 case EM_X86_64:
8a9036a4 11519 case EM_L1OM:
7a9068fe 11520 case EM_K1OM:
aca88567 11521 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 11522 case EM_S390_OLD:
11523 case EM_S390:
aa137e4d
NC		 11524 return reloc_type == 22; /* R_S390_64. */
11525 case EM_TILEGX:
11526 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 11527 case EM_MIPS:
aa137e4d 11528 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 11529 default:
11530 return FALSE;
11531 }
11532}
11533
85acf597
RH		 11534/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11535 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11536
11537static bfd_boolean
11538is_64bit_pcrel_reloc (unsigned int reloc_type)
11539{
11540 switch (elf_header.e_machine)
11541 {
a06ea964
NC		 11542 case EM_AARCH64:
11543 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 11544 case EM_ALPHA:
aa137e4d 11545 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 11546 case EM_IA_64:
aa137e4d 11547 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 11548 case EM_PARISC:
aa137e4d 11549 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 11550 case EM_PPC64:
aa137e4d 11551 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 11552 case EM_SPARC32PLUS:
11553 case EM_SPARCV9:
11554 case EM_SPARC:
aa137e4d 11555 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 11556 case EM_X86_64:
8a9036a4 11557 case EM_L1OM:
7a9068fe 11558 case EM_K1OM:
aa137e4d 11559 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 11560 case EM_S390_OLD:
11561 case EM_S390:
aa137e4d
NC		 11562 return reloc_type == 23; /* R_S390_PC64. */
11563 case EM_TILEGX:
11564 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 11565 default:
11566 return FALSE;
11567 }
11568}
11569
4dc3c23d
AM		 11570/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11571 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11572
11573static bfd_boolean
11574is_24bit_abs_reloc (unsigned int reloc_type)
11575{
11576 switch (elf_header.e_machine)
11577 {
11578 case EM_CYGNUS_MN10200:
11579 case EM_MN10200:
11580 return reloc_type == 4; /* R_MN10200_24. */
11581 default:
11582 return FALSE;
11583 }
11584}
11585
aca88567
NC		 11586/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11587 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11588
11589static bfd_boolean
11590is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 11591{
11592 switch (elf_header.e_machine)
11593 {
aca88567
NC		 11594 case EM_AVR_OLD:
11595 case EM_AVR:
11596 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 11597 case EM_ADAPTEVA_EPIPHANY:
11598 return reloc_type == 5;
41e92641
NC		 11599 case EM_CYGNUS_D10V:
11600 case EM_D10V:
11601 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 11602 case EM_H8S:
11603 case EM_H8_300:
11604 case EM_H8_300H:
aca88567
NC		 11605 return reloc_type == R_H8_DIR16;
11606 case EM_IP2K_OLD:
11607 case EM_IP2K:
11608 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 11609 case EM_M32C_OLD:
f4236fe4
DD		 11610 case EM_M32C:
11611 return reloc_type == 1; /* R_M32C_16 */
aca88567 11612 case EM_MSP430:
13761a11
NC		 11613 if (uses_msp430x_relocs ())
11614 return reloc_type == 2; /* R_MSP430_ABS16. */
78c8d46c 11615 case EM_MSP430_OLD:
aca88567 11616 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 11617 case EM_NDS32:
11618 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 11619 case EM_ALTERA_NIOS2:
36591ba1 11620 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 11621 case EM_NIOS32:
11622 return reloc_type == 9; /* R_NIOS_16. */
73589c9d
CS		 11623 case EM_OR1K:
11624 return reloc_type == 2; /* R_OR1K_16. */
40b36596
JM		 11625 case EM_TI_C6000:
11626 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 11627 case EM_XC16X:
11628 case EM_C166:
11629 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 11630 case EM_CYGNUS_MN10200:
11631 case EM_MN10200:
11632 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 11633 case EM_CYGNUS_MN10300:
11634 case EM_MN10300:
11635 return reloc_type == 2; /* R_MN10300_16. */
619ed720
EB		 11636 case EM_VISIUM:
11637 return reloc_type == 2; /* R_VISIUM_16. */
f6c1a2d5
NC		 11638 case EM_XGATE:
11639 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 11640 default:
aca88567 11641 return FALSE;
4b78141a
NC		 11642 }
11643}
11644
2a7b2e88
JK		 11645/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11646 relocation entries (possibly formerly used for SHT_GROUP sections). */
11647
11648static bfd_boolean
11649is_none_reloc (unsigned int reloc_type)
11650{
11651 switch (elf_header.e_machine)
11652 {
cb8f3167
NC		 11653 case EM_68K: /* R_68K_NONE. */
11654 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 11655 case EM_SPARC32PLUS:
11656 case EM_SPARCV9:
cb8f3167
NC		 11657 case EM_SPARC: /* R_SPARC_NONE. */
11658 case EM_MIPS: /* R_MIPS_NONE. */
11659 case EM_PARISC: /* R_PARISC_NONE. */
11660 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 11661 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 11662 case EM_PPC: /* R_PPC_NONE. */
11663 case EM_PPC64: /* R_PPC64_NONE. */
11664 case EM_ARM: /* R_ARM_NONE. */
11665 case EM_IA_64: /* R_IA64_NONE. */
11666 case EM_SH: /* R_SH_NONE. */
2a7b2e88 11667 case EM_S390_OLD:
cb8f3167
NC		 11668 case EM_S390: /* R_390_NONE. */
11669 case EM_CRIS: /* R_CRIS_NONE. */
11670 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 11671 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 11672 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 11673 case EM_MN10300: /* R_MN10300_NONE. */
3f8107ab 11674 case EM_FT32: /* R_FT32_NONE. */
5506d11a 11675 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 11676 case EM_M32R: /* R_M32R_NONE. */
40b36596 11677 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 11678 case EM_TILEGX: /* R_TILEGX_NONE. */
11679 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 11680 case EM_XC16X:
11681 case EM_C166: /* R_XC16X_NONE. */
36591ba1
SL		 11682 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
11683 case EM_NIOS32: /* R_NIOS_NONE. */
73589c9d 11684 case EM_OR1K: /* R_OR1K_NONE. */
cb8f3167 11685 return reloc_type == 0;
a06ea964
NC		 11686 case EM_AARCH64:
11687 return reloc_type == 0 || reloc_type == 256;
35c08157
KLC		 11688 case EM_NDS32:
11689 return (reloc_type == 0 /* R_XTENSA_NONE. */
11690 || reloc_type == 204 /* R_NDS32_DIFF8. */
11691 || reloc_type == 205 /* R_NDS32_DIFF16. */
11692 || reloc_type == 206 /* R_NDS32_DIFF32. */
11693 || reloc_type == 207 /* R_NDS32_ULEB128. */);
58332dda
JK		 11694 case EM_XTENSA_OLD:
11695 case EM_XTENSA:
4dc3c23d
AM		 11696 return (reloc_type == 0 /* R_XTENSA_NONE. */
11697 || reloc_type == 17 /* R_XTENSA_DIFF8. */
11698 || reloc_type == 18 /* R_XTENSA_DIFF16. */
11699 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
a3c62988
NC		 11700 case EM_METAG:
11701 return reloc_type == 3; /* R_METAG_NONE. */
2a7b2e88
JK		 11702 }
11703 return FALSE;
11704}
11705
d1c4b12b
NC		 11706/* Returns TRUE if there is a relocation against
11707 section NAME at OFFSET bytes. */
11708
11709bfd_boolean
11710reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
11711{
11712 Elf_Internal_Rela * relocs;
11713 Elf_Internal_Rela * rp;
11714
11715 if (dsec == NULL || dsec->reloc_info == NULL)
11716 return FALSE;
11717
11718 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
11719
11720 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
11721 if (rp->r_offset == offset)
11722 return TRUE;
11723
11724 return FALSE;
11725}
11726
cf13d699
NC		 11727/* Apply relocations to a section.
11728 Note: So far support has been added only for those relocations
11729 which can be found in debug sections.
d1c4b12b
NC		 11730 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
11731 loaded relocs. It is then the caller's responsibility to free them.
cf13d699 11732 FIXME: Add support for more relocations ? */
1b315056 11733
cf13d699 11734static void
d1c4b12b
NC		 11735apply_relocations (void * file,
11736 const Elf_Internal_Shdr * section,
11737 unsigned char * start,
11738 bfd_size_type size,
11739 void ** relocs_return,
11740 unsigned long * num_relocs_return)
1b315056 11741{
cf13d699 11742 Elf_Internal_Shdr * relsec;
0d2a7a93 11743 unsigned char * end = start + size;
cb8f3167 11744
d1c4b12b
NC		 11745 if (relocs_return != NULL)
11746 {
11747 * (Elf_Internal_Rela **) relocs_return = NULL;
11748 * num_relocs_return = 0;
11749 }
11750
cf13d699
NC		 11751 if (elf_header.e_type != ET_REL)
11752 return;
1b315056 11753
cf13d699 11754 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 11755 for (relsec = section_headers;
11756 relsec < section_headers + elf_header.e_shnum;
11757 ++relsec)
252b5132 11758 {
41e92641
NC		 11759 bfd_boolean is_rela;
11760 unsigned long num_relocs;
2cf0635d
NC		 11761 Elf_Internal_Rela * relocs;
11762 Elf_Internal_Rela * rp;
11763 Elf_Internal_Shdr * symsec;
11764 Elf_Internal_Sym * symtab;
ba5cdace 11765 unsigned long num_syms;
2cf0635d 11766 Elf_Internal_Sym * sym;
252b5132 11767
41e92641 11768 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 11769 || relsec->sh_info >= elf_header.e_shnum
11770 || section_headers + relsec->sh_info != section
c256ffe7 11771 || relsec->sh_size == 0
4fbb74a6 11772 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 11773 continue;
428409d5 11774
41e92641
NC		 11775 is_rela = relsec->sh_type == SHT_RELA;
11776
11777 if (is_rela)
11778 {
3f5e193b
NC		 11779 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11780 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11781 return;
11782 }
11783 else
11784 {
3f5e193b
NC		 11785 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11786 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11787 return;
11788 }
11789
11790 /* SH uses RELA but uses in place value instead of the addend field. */
11791 if (elf_header.e_machine == EM_SH)
11792 is_rela = FALSE;
428409d5 11793
4fbb74a6 11794 symsec = section_headers + relsec->sh_link;
ba5cdace 11795 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 11796
41e92641 11797 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 11798 {
41e92641
NC		 11799 bfd_vma addend;
11800 unsigned int reloc_type;
11801 unsigned int reloc_size;
91d6fa6a 11802 unsigned char * rloc;
ba5cdace 11803 unsigned long sym_index;
4b78141a 11804
aca88567 11805 reloc_type = get_reloc_type (rp->r_info);
41e92641 11806
98fb390a 11807 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 11808 continue;
98fb390a
NC		 11809 else if (is_none_reloc (reloc_type))
11810 continue;
11811 else if (is_32bit_abs_reloc (reloc_type)
11812 || is_32bit_pcrel_reloc (reloc_type))
aca88567 11813 reloc_size = 4;
85acf597
RH		 11814 else if (is_64bit_abs_reloc (reloc_type)
11815 || is_64bit_pcrel_reloc (reloc_type))
aca88567 11816 reloc_size = 8;
4dc3c23d
AM		 11817 else if (is_24bit_abs_reloc (reloc_type))
11818 reloc_size = 3;
aca88567
NC		 11819 else if (is_16bit_abs_reloc (reloc_type))
11820 reloc_size = 2;
11821 else
4b78141a 11822 {
bee0ee85
NC		 11823 static unsigned int prev_reloc = 0;
11824 if (reloc_type != prev_reloc)
11825 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11826 reloc_type, printable_section_name (section));
11827 prev_reloc = reloc_type;
4b78141a
NC		 11828 continue;
11829 }
103f02d3 11830
91d6fa6a 11831 rloc = start + rp->r_offset;
c8da6823 11832 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 11833 {
11834 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11835 (unsigned long) rp->r_offset,
74e1a04b 11836 printable_section_name (section));
700dd8b7
L		 11837 continue;
11838 }
103f02d3 11839
ba5cdace
NC		 11840 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11841 if (sym_index >= num_syms)
11842 {
11843 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
74e1a04b 11844 sym_index, printable_section_name (section));
ba5cdace
NC		 11845 continue;
11846 }
11847 sym = symtab + sym_index;
41e92641
NC		 11848
11849 /* If the reloc has a symbol associated with it,
55f25fc3
L		 11850 make sure that it is of an appropriate type.
11851
11852 Relocations against symbols without type can happen.
11853 Gcc -feliminate-dwarf2-dups may generate symbols
11854 without type for debug info.
11855
11856 Icc generates relocations against function symbols
11857 instead of local labels.
11858
11859 Relocations against object symbols can happen, eg when
11860 referencing a global array. For an example of this see
11861 the _clz.o binary in libgcc.a. */
aca88567 11862 if (sym != symtab
55f25fc3 11863 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 11864 {
41e92641 11865 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 11866 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 11867 (long int)(rp - relocs),
74e1a04b 11868 printable_section_name (relsec));
aca88567 11869 continue;
5b18a4bc 11870 }
252b5132 11871
4dc3c23d
AM		 11872 addend = 0;
11873 if (is_rela)
11874 addend += rp->r_addend;
c47320c3
AM		 11875 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11876 partial_inplace. */
4dc3c23d
AM		 11877 if (!is_rela
11878 || (elf_header.e_machine == EM_XTENSA
11879 && reloc_type == 1)
11880 || ((elf_header.e_machine == EM_PJ
11881 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 11882 && reloc_type == 1)
11883 || ((elf_header.e_machine == EM_D30V
11884 || elf_header.e_machine == EM_CYGNUS_D30V)
11885 && reloc_type == 12))
91d6fa6a 11886 addend += byte_get (rloc, reloc_size);
cb8f3167 11887
85acf597
RH		 11888 if (is_32bit_pcrel_reloc (reloc_type)
11889 || is_64bit_pcrel_reloc (reloc_type))
11890 {
11891 /* On HPPA, all pc-relative relocations are biased by 8. */
11892 if (elf_header.e_machine == EM_PARISC)
11893 addend -= 8;
91d6fa6a 11894 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 11895 reloc_size);
11896 }
41e92641 11897 else
91d6fa6a 11898 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 11899 }
252b5132 11900
5b18a4bc 11901 free (symtab);
d1c4b12b
NC		 11902
11903 if (relocs_return)
11904 {
11905 * (Elf_Internal_Rela **) relocs_return = relocs;
11906 * num_relocs_return = num_relocs;
11907 }
11908 else
11909 free (relocs);
11910
5b18a4bc
NC		 11911 break;
11912 }
5b18a4bc 11913}
103f02d3 11914
cf13d699
NC		 11915#ifdef SUPPORT_DISASSEMBLY
11916static int
11917disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11918{
74e1a04b 11919 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
cf13d699 11920
74e1a04b 11921 /* FIXME: XXX -- to be done --- XXX */
cf13d699
NC		 11922
11923 return 1;
11924}
11925#endif
11926
11927/* Reads in the contents of SECTION from FILE, returning a pointer
11928 to a malloc'ed buffer or NULL if something went wrong. */
11929
11930static char *
11931get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11932{
11933 bfd_size_type num_bytes;
11934
11935 num_bytes = section->sh_size;
11936
11937 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11938 {
11939 printf (_("\nSection '%s' has no data to dump.\n"),
74e1a04b 11940 printable_section_name (section));
cf13d699
NC		 11941 return NULL;
11942 }
11943
3f5e193b
NC		 11944 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11945 _("section contents"));
cf13d699
NC		 11946}
11947
0e602686
NC		 11948/* Uncompresses a section that was compressed using zlib, in place. */
11949
11950static bfd_boolean
11951uncompress_section_contents (unsigned char **buffer,
11952 dwarf_size_type uncompressed_size,
11953 dwarf_size_type *size)
11954{
11955 dwarf_size_type compressed_size = *size;
11956 unsigned char * compressed_buffer = *buffer;
11957 unsigned char * uncompressed_buffer;
11958 z_stream strm;
11959 int rc;
11960
11961 /* It is possible the section consists of several compressed
11962 buffers concatenated together, so we uncompress in a loop. */
11963 /* PR 18313: The state field in the z_stream structure is supposed
11964 to be invisible to the user (ie us), but some compilers will
11965 still complain about it being used without initialisation. So
11966 we first zero the entire z_stream structure and then set the fields
11967 that we need. */
11968 memset (& strm, 0, sizeof strm);
11969 strm.avail_in = compressed_size;
11970 strm.next_in = (Bytef *) compressed_buffer;
11971 strm.avail_out = uncompressed_size;
11972 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
11973
11974 rc = inflateInit (& strm);
11975 while (strm.avail_in > 0)
11976 {
11977 if (rc != Z_OK)
11978 goto fail;
11979 strm.next_out = ((Bytef *) uncompressed_buffer
11980 + (uncompressed_size - strm.avail_out));
11981 rc = inflate (&strm, Z_FINISH);
11982 if (rc != Z_STREAM_END)
11983 goto fail;
11984 rc = inflateReset (& strm);
11985 }
11986 rc = inflateEnd (& strm);
11987 if (rc != Z_OK
11988 || strm.avail_out != 0)
11989 goto fail;
11990
11991 *buffer = uncompressed_buffer;
11992 *size = uncompressed_size;
11993 return TRUE;
11994
11995 fail:
11996 free (uncompressed_buffer);
11997 /* Indicate decompression failure. */
11998 *buffer = NULL;
11999 return FALSE;
12000}
dd24e3da 12001
cf13d699
NC		 12002static void
12003dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12004{
0e602686
NC		 12005 Elf_Internal_Shdr * relsec;
12006 bfd_size_type num_bytes;
12007 char * data;
12008 char * end;
12009 char * real_start;
12010 char * start;
12011 bfd_boolean some_strings_shown;
cf13d699 12012
0e602686 12013 real_start = start = get_section_contents (section, file);
cf13d699
NC		 12014 if (start == NULL)
12015 return;
0e602686 12016 num_bytes = section->sh_size;
cf13d699 12017
74e1a04b 12018 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
cf13d699 12019
0e602686
NC		 12020 if (decompress_dumps)
12021 {
12022 dwarf_size_type new_size = num_bytes;
12023 dwarf_size_type uncompressed_size = 0;
12024
12025 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12026 {
12027 Elf_Internal_Chdr chdr;
12028 unsigned int compression_header_size
12029 = get_compression_header (& chdr, (unsigned char *) start);
12030
12031 if (chdr.ch_type == ELFCOMPRESS_ZLIB
12032 && chdr.ch_addralign == section->sh_addralign)
12033 {
12034 uncompressed_size = chdr.ch_size;
12035 start += compression_header_size;
12036 new_size -= compression_header_size;
12037 }
12038 }
12039 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12040 {
12041 /* Read the zlib header. In this case, it should be "ZLIB"
12042 followed by the uncompressed section size, 8 bytes in
12043 big-endian order. */
12044 uncompressed_size = start[4]; uncompressed_size <<= 8;
12045 uncompressed_size += start[5]; uncompressed_size <<= 8;
12046 uncompressed_size += start[6]; uncompressed_size <<= 8;
12047 uncompressed_size += start[7]; uncompressed_size <<= 8;
12048 uncompressed_size += start[8]; uncompressed_size <<= 8;
12049 uncompressed_size += start[9]; uncompressed_size <<= 8;
12050 uncompressed_size += start[10]; uncompressed_size <<= 8;
12051 uncompressed_size += start[11];
12052 start += 12;
12053 new_size -= 12;
12054 }
12055
12056 if (uncompressed_size
12057 && uncompress_section_contents ((unsigned char **) & start,
12058 uncompressed_size, & new_size))
12059 num_bytes = new_size;
12060 }
12061
cf13d699
NC		 12062 /* If the section being dumped has relocations against it the user might
12063 be expecting these relocations to have been applied. Check for this
12064 case and issue a warning message in order to avoid confusion.
12065 FIXME: Maybe we ought to have an option that dumps a section with
12066 relocs applied ? */
12067 for (relsec = section_headers;
12068 relsec < section_headers + elf_header.e_shnum;
12069 ++relsec)
12070 {
12071 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12072 || relsec->sh_info >= elf_header.e_shnum
12073 || section_headers + relsec->sh_info != section
12074 || relsec->sh_size == 0
12075 || relsec->sh_link >= elf_header.e_shnum)
12076 continue;
12077
12078 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12079 break;
12080 }
12081
cf13d699
NC		 12082 data = start;
12083 end = start + num_bytes;
12084 some_strings_shown = FALSE;
12085
12086 while (data < end)
12087 {
12088 while (!ISPRINT (* data))
12089 if (++ data >= end)
12090 break;
12091
12092 if (data < end)
12093 {
071436c6
NC		 12094 size_t maxlen = end - data;
12095
cf13d699 12096#ifndef __MSVCRT__
c975cc98
NC		 12097 /* PR 11128: Use two separate invocations in order to work
12098 around bugs in the Solaris 8 implementation of printf. */
12099 printf (" [%6tx] ", data - start);
cf13d699 12100#else
071436c6 12101 printf (" [%6Ix] ", (size_t) (data - start));
cf13d699 12102#endif
4082ef84
NC		 12103 if (maxlen > 0)
12104 {
12105 print_symbol ((int) maxlen, data);
12106 putchar ('\n');
12107 data += strnlen (data, maxlen);
12108 }
12109 else
12110 {
12111 printf (_("<corrupt>\n"));
12112 data = end;
12113 }
cf13d699
NC		 12114 some_strings_shown = TRUE;
12115 }
12116 }
12117
12118 if (! some_strings_shown)
12119 printf (_(" No strings found in this section."));
12120
0e602686 12121 free (real_start);
cf13d699
NC		 12122
12123 putchar ('\n');
12124}
12125
12126static void
12127dump_section_as_bytes (Elf_Internal_Shdr * section,
12128 FILE * file,
12129 bfd_boolean relocate)
12130{
12131 Elf_Internal_Shdr * relsec;
0e602686
NC		 12132 bfd_size_type bytes;
12133 bfd_size_type section_size;
12134 bfd_vma addr;
12135 unsigned char * data;
12136 unsigned char * real_start;
12137 unsigned char * start;
12138
12139 real_start = start = (unsigned char *) get_section_contents (section, file);
cf13d699
NC		 12140 if (start == NULL)
12141 return;
0e602686 12142 section_size = section->sh_size;
cf13d699 12143
74e1a04b 12144 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
cf13d699 12145
0e602686
NC		 12146 if (decompress_dumps)
12147 {
12148 dwarf_size_type new_size = section_size;
12149 dwarf_size_type uncompressed_size = 0;
12150
12151 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12152 {
12153 Elf_Internal_Chdr chdr;
12154 unsigned int compression_header_size
12155 = get_compression_header (& chdr, start);
12156
12157 if (chdr.ch_type == ELFCOMPRESS_ZLIB
12158 && chdr.ch_addralign == section->sh_addralign)
12159 {
12160 uncompressed_size = chdr.ch_size;
12161 start += compression_header_size;
12162 new_size -= compression_header_size;
12163 }
12164 }
12165 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12166 {
12167 /* Read the zlib header. In this case, it should be "ZLIB"
12168 followed by the uncompressed section size, 8 bytes in
12169 big-endian order. */
12170 uncompressed_size = start[4]; uncompressed_size <<= 8;
12171 uncompressed_size += start[5]; uncompressed_size <<= 8;
12172 uncompressed_size += start[6]; uncompressed_size <<= 8;
12173 uncompressed_size += start[7]; uncompressed_size <<= 8;
12174 uncompressed_size += start[8]; uncompressed_size <<= 8;
12175 uncompressed_size += start[9]; uncompressed_size <<= 8;
12176 uncompressed_size += start[10]; uncompressed_size <<= 8;
12177 uncompressed_size += start[11];
12178 start += 12;
12179 new_size -= 12;
12180 }
12181
12182 if (uncompressed_size
12183 && uncompress_section_contents (& start, uncompressed_size,
12184 & new_size))
12185 section_size = new_size;
12186 }
12187
cf13d699
NC		 12188 if (relocate)
12189 {
0e602686 12190 apply_relocations (file, section, start, section_size, NULL, NULL);
cf13d699
NC		 12191 }
12192 else
12193 {
12194 /* If the section being dumped has relocations against it the user might
12195 be expecting these relocations to have been applied. Check for this
12196 case and issue a warning message in order to avoid confusion.
12197 FIXME: Maybe we ought to have an option that dumps a section with
12198 relocs applied ? */
12199 for (relsec = section_headers;
12200 relsec < section_headers + elf_header.e_shnum;
12201 ++relsec)
12202 {
12203 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12204 || relsec->sh_info >= elf_header.e_shnum
12205 || section_headers + relsec->sh_info != section
12206 || relsec->sh_size == 0
12207 || relsec->sh_link >= elf_header.e_shnum)
12208 continue;
12209
12210 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12211 break;
12212 }
12213 }
12214
12215 addr = section->sh_addr;
0e602686 12216 bytes = section_size;
cf13d699
NC		 12217 data = start;
12218
12219 while (bytes)
12220 {
12221 int j;
12222 int k;
12223 int lbytes;
12224
12225 lbytes = (bytes > 16 ? 16 : bytes);
12226
12227 printf (" 0x%8.8lx ", (unsigned long) addr);
12228
12229 for (j = 0; j < 16; j++)
12230 {
12231 if (j < lbytes)
12232 printf ("%2.2x", data[j]);
12233 else
12234 printf (" ");
12235
12236 if ((j & 3) == 3)
12237 printf (" ");
12238 }
12239
12240 for (j = 0; j < lbytes; j++)
12241 {
12242 k = data[j];
12243 if (k >= ' ' && k < 0x7f)
12244 printf ("%c", k);
12245 else
12246 printf (".");
12247 }
12248
12249 putchar ('\n');
12250
12251 data += lbytes;
12252 addr += lbytes;
12253 bytes -= lbytes;
12254 }
12255
0e602686 12256 free (real_start);
cf13d699
NC		 12257
12258 putchar ('\n');
12259}
12260
d966045b
DJ		 12261static int
12262load_specific_debug_section (enum dwarf_section_display_enum debug,
0d2a7a93 12263 const Elf_Internal_Shdr * sec, void * file)
1007acb3 12264{
2cf0635d 12265 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 12266 char buf [64];
1007acb3 12267
19e6b90e
L		 12268 /* If it is already loaded, do nothing. */
12269 if (section->start != NULL)
12270 return 1;
1007acb3 12271
19e6b90e
L		 12272 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12273 section->address = sec->sh_addr;
06614111 12274 section->user_data = NULL;
3f5e193b
NC		 12275 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12276 sec->sh_offset, 1,
12277 sec->sh_size, buf);
59245841
NC		 12278 if (section->start == NULL)
12279 section->size = 0;
12280 else
12281 {
77115a4a
L		 12282 unsigned char *start = section->start;
12283 dwarf_size_type size = sec->sh_size;
dab394de 12284 dwarf_size_type uncompressed_size = 0;
77115a4a
L		 12285
12286 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12287 {
12288 Elf_Internal_Chdr chdr;
12289 unsigned int compression_header_size
12290 = get_compression_header (&chdr, start);
12291 if (chdr.ch_type != ELFCOMPRESS_ZLIB
12292 || chdr.ch_addralign != sec->sh_addralign)
12293 return 0;
dab394de 12294 uncompressed_size = chdr.ch_size;
77115a4a
L		 12295 start += compression_header_size;
12296 size -= compression_header_size;
12297 }
dab394de
L		 12298 else if (size > 12 && streq ((char *) start, "ZLIB"))
12299 {
12300 /* Read the zlib header. In this case, it should be "ZLIB"
12301 followed by the uncompressed section size, 8 bytes in
12302 big-endian order. */
12303 uncompressed_size = start[4]; uncompressed_size <<= 8;
12304 uncompressed_size += start[5]; uncompressed_size <<= 8;
12305 uncompressed_size += start[6]; uncompressed_size <<= 8;
12306 uncompressed_size += start[7]; uncompressed_size <<= 8;
12307 uncompressed_size += start[8]; uncompressed_size <<= 8;
12308 uncompressed_size += start[9]; uncompressed_size <<= 8;
12309 uncompressed_size += start[10]; uncompressed_size <<= 8;
12310 uncompressed_size += start[11];
12311 start += 12;
12312 size -= 12;
12313 }
12314
12315 if (uncompressed_size
12316 && uncompress_section_contents (&start, uncompressed_size,
12317 &size))
77115a4a
L		 12318 {
12319 /* Free the compressed buffer, update the section buffer
12320 and the section size if uncompress is successful. */
12321 free (section->start);
12322 section->start = start;
77115a4a
L		 12323 }
12324 section->size = size;
59245841 12325 }
4a114e3e 12326
1b315056
CS		 12327 if (section->start == NULL)
12328 return 0;
12329
19e6b90e 12330 if (debug_displays [debug].relocate)
d1c4b12b
NC		 12331 apply_relocations ((FILE *) file, sec, section->start, section->size,
12332 & section->reloc_info, & section->num_relocs);
12333 else
12334 {
12335 section->reloc_info = NULL;
12336 section->num_relocs = 0;
12337 }
1007acb3 12338
1b315056 12339 return 1;
1007acb3
L		 12340}
12341
657d0d47
CC		 12342/* If this is not NULL, load_debug_section will only look for sections
12343 within the list of sections given here. */
12344unsigned int *section_subset = NULL;
12345
d966045b 12346int
2cf0635d 12347load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 12348{
2cf0635d
NC		 12349 struct dwarf_section * section = &debug_displays [debug].section;
12350 Elf_Internal_Shdr * sec;
d966045b
DJ		 12351
12352 /* Locate the debug section. */
657d0d47 12353 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 12354 if (sec != NULL)
12355 section->name = section->uncompressed_name;
12356 else
12357 {
657d0d47 12358 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 12359 if (sec != NULL)
12360 section->name = section->compressed_name;
12361 }
12362 if (sec == NULL)
12363 return 0;
12364
657d0d47
CC		 12365 /* If we're loading from a subset of sections, and we've loaded
12366 a section matching this name before, it's likely that it's a
12367 different one. */
12368 if (section_subset != NULL)
12369 free_debug_section (debug);
12370
3f5e193b 12371 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 12372}
12373
19e6b90e
L		 12374void
12375free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 12376{
2cf0635d 12377 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 12378
19e6b90e
L		 12379 if (section->start == NULL)
12380 return;
1007acb3 12381
19e6b90e
L		 12382 free ((char *) section->start);
12383 section->start = NULL;
12384 section->address = 0;
12385 section->size = 0;
1007acb3
L		 12386}
12387
1007acb3 12388static int
657d0d47 12389display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 12390{
2cf0635d 12391 char * name = SECTION_NAME (section);
74e1a04b 12392 const char * print_name = printable_section_name (section);
19e6b90e
L		 12393 bfd_size_type length;
12394 int result = 1;
3f5e193b 12395 int i;
1007acb3 12396
19e6b90e
L		 12397 length = section->sh_size;
12398 if (length == 0)
1007acb3 12399 {
74e1a04b 12400 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
19e6b90e 12401 return 0;
1007acb3 12402 }
5dff79d8
NC		 12403 if (section->sh_type == SHT_NOBITS)
12404 {
12405 /* There is no point in dumping the contents of a debugging section
12406 which has the NOBITS type - the bits in the file will be random.
12407 This can happen when a file containing a .eh_frame section is
12408 stripped with the --only-keep-debug command line option. */
74e1a04b
NC		 12409 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12410 print_name);
5dff79d8
NC		 12411 return 0;
12412 }
1007acb3 12413
0112cd26 12414 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 12415 name = ".debug_info";
1007acb3 12416
19e6b90e
L		 12417 /* See if we know how to display the contents of this section. */
12418 for (i = 0; i < max; i++)
1b315056 12419 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 12420 || (i == line && const_strneq (name, ".debug_line."))
1b315056 12421 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 12422 {
2cf0635d 12423 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 12424 int secondary = (section != find_section (name));
12425
12426 if (secondary)
3f5e193b 12427 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 12428
b40bf0a2
NC		 12429 if (i == line && const_strneq (name, ".debug_line."))
12430 sec->name = name;
12431 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 12432 sec->name = sec->uncompressed_name;
12433 else
12434 sec->name = sec->compressed_name;
3f5e193b
NC		 12435 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12436 section, file))
19e6b90e 12437 {
657d0d47
CC		 12438 /* If this debug section is part of a CU/TU set in a .dwp file,
12439 restrict load_debug_section to the sections in that set. */
12440 section_subset = find_cu_tu_set (file, shndx);
12441
19e6b90e 12442 result &= debug_displays[i].display (sec, file);
1007acb3 12443
657d0d47
CC		 12444 section_subset = NULL;
12445
d966045b 12446 if (secondary || (i != info && i != abbrev))
3f5e193b 12447 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 12448 }
1007acb3 12449
19e6b90e
L		 12450 break;
12451 }
1007acb3 12452
19e6b90e 12453 if (i == max)
1007acb3 12454 {
74e1a04b 12455 printf (_("Unrecognized debug section: %s\n"), print_name);
19e6b90e 12456 result = 0;
1007acb3
L		 12457 }
12458
19e6b90e 12459 return result;
5b18a4bc 12460}
103f02d3 12461
aef1f6d0
DJ		 12462/* Set DUMP_SECTS for all sections where dumps were requested
12463 based on section name. */
12464
12465static void
12466initialise_dumps_byname (void)
12467{
2cf0635d 12468 struct dump_list_entry * cur;
aef1f6d0
DJ		 12469
12470 for (cur = dump_sects_byname; cur; cur = cur->next)
12471 {
12472 unsigned int i;
12473 int any;
12474
12475 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12476 if (streq (SECTION_NAME (section_headers + i), cur->name))
12477 {
09c11c86 12478 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 12479 any = 1;
12480 }
12481
12482 if (!any)
12483 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12484 cur->name);
12485 }
12486}
12487
5b18a4bc 12488static void
2cf0635d 12489process_section_contents (FILE * file)
5b18a4bc 12490{
2cf0635d 12491 Elf_Internal_Shdr * section;
19e6b90e 12492 unsigned int i;
103f02d3 12493
19e6b90e
L		 12494 if (! do_dump)
12495 return;
103f02d3 12496
aef1f6d0
DJ		 12497 initialise_dumps_byname ();
12498
19e6b90e
L		 12499 for (i = 0, section = section_headers;
12500 i < elf_header.e_shnum && i < num_dump_sects;
12501 i++, section++)
12502 {
12503#ifdef SUPPORT_DISASSEMBLY
12504 if (dump_sects[i] & DISASS_DUMP)
12505 disassemble_section (section, file);
12506#endif
12507 if (dump_sects[i] & HEX_DUMP)
cf13d699 12508 dump_section_as_bytes (section, file, FALSE);
103f02d3 12509
cf13d699
NC		 12510 if (dump_sects[i] & RELOC_DUMP)
12511 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 12512
12513 if (dump_sects[i] & STRING_DUMP)
12514 dump_section_as_strings (section, file);
cf13d699
NC		 12515
12516 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 12517 display_debug_section (i, section, file);
5b18a4bc 12518 }
103f02d3 12519
19e6b90e
L		 12520 /* Check to see if the user requested a
12521 dump of a section that does not exist. */
12522 while (i++ < num_dump_sects)
12523 if (dump_sects[i])
12524 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 12525}
103f02d3 12526
5b18a4bc 12527static void
19e6b90e 12528process_mips_fpe_exception (int mask)
5b18a4bc 12529{
19e6b90e
L		 12530 if (mask)
12531 {
12532 int first = 1;
12533 if (mask & OEX_FPU_INEX)
12534 fputs ("INEX", stdout), first = 0;
12535 if (mask & OEX_FPU_UFLO)
12536 printf ("%sUFLO", first ? "" : "|"), first = 0;
12537 if (mask & OEX_FPU_OFLO)
12538 printf ("%sOFLO", first ? "" : "|"), first = 0;
12539 if (mask & OEX_FPU_DIV0)
12540 printf ("%sDIV0", first ? "" : "|"), first = 0;
12541 if (mask & OEX_FPU_INVAL)
12542 printf ("%sINVAL", first ? "" : "|");
12543 }
5b18a4bc 12544 else
19e6b90e 12545 fputs ("0", stdout);
5b18a4bc 12546}
103f02d3 12547
f6f0e17b
NC		 12548/* Display's the value of TAG at location P. If TAG is
12549 greater than 0 it is assumed to be an unknown tag, and
12550 a message is printed to this effect. Otherwise it is
12551 assumed that a message has already been printed.
12552
12553 If the bottom bit of TAG is set it assumed to have a
12554 string value, otherwise it is assumed to have an integer
12555 value.
12556
12557 Returns an updated P pointing to the first unread byte
12558 beyond the end of TAG's value.
12559
12560 Reads at or beyond END will not be made. */
12561
12562static unsigned char *
12563display_tag_value (int tag,
12564 unsigned char * p,
12565 const unsigned char * const end)
12566{
12567 unsigned long val;
12568
12569 if (tag > 0)
12570 printf (" Tag_unknown_%d: ", tag);
12571
12572 if (p >= end)
12573 {
4082ef84 12574 warn (_("<corrupt tag>\n"));
f6f0e17b
NC		 12575 }
12576 else if (tag & 1)
12577 {
071436c6
NC		 12578 /* PR 17531 file: 027-19978-0.004. */
12579 size_t maxlen = (end - p) - 1;
12580
12581 putchar ('"');
4082ef84
NC		 12582 if (maxlen > 0)
12583 {
12584 print_symbol ((int) maxlen, (const char *) p);
12585 p += strnlen ((char *) p, maxlen) + 1;
12586 }
12587 else
12588 {
12589 printf (_("<corrupt string tag>"));
12590 p = (unsigned char *) end;
12591 }
071436c6 12592 printf ("\"\n");
f6f0e17b
NC		 12593 }
12594 else
12595 {
12596 unsigned int len;
12597
12598 val = read_uleb128 (p, &len, end);
12599 p += len;
12600 printf ("%ld (0x%lx)\n", val, val);
12601 }
12602
4082ef84 12603 assert (p <= end);
f6f0e17b
NC		 12604 return p;
12605}
12606
11c1ff18
PB		 12607/* ARM EABI attributes section. */
12608typedef struct
12609{
70e99720 12610 unsigned int tag;
2cf0635d 12611 const char * name;
11c1ff18 12612 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 12613 unsigned int type;
2cf0635d 12614 const char ** table;
11c1ff18
PB		 12615} arm_attr_public_tag;
12616
2cf0635d 12617static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 12618 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 12619 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 12620static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12621static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 12622 {"No", "Thumb-1", "Thumb-2"};
75375b3e 12623static const char * arm_attr_tag_FP_arch[] =
bca38921 12624 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
a715796b 12625 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
2cf0635d 12626static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 12627static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 12628 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 12629static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 12630 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12631 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 12632static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 12633 {"V6", "SB", "TLS", "Unused"};
2cf0635d 12634static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 12635 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 12636static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 12637 {"Absolute", "PC-relative", "None"};
2cf0635d 12638static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 12639 {"None", "direct", "GOT-indirect"};
2cf0635d 12640static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 12641 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 12642static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12643static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 12644 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 12645static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12646static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12647static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 12648 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 12649static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 12650 {"Unused", "small", "int", "forced to int"};
2cf0635d 12651static const char * arm_attr_tag_ABI_HardFP_use[] =
99654aaf 12652 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
2cf0635d 12653static const char * arm_attr_tag_ABI_VFP_args[] =
5c294fee 12654 {"AAPCS", "VFP registers", "custom", "compatible"};
2cf0635d 12655static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 12656 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 12657static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 12658 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12659 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 12660static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 12661 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12662 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 12663static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 12664static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 12665 {"Not Allowed", "Allowed"};
2cf0635d 12666static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 12667 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 12668static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 12669 {"Not Allowed", "Allowed"};
12670static const char * arm_attr_tag_DIV_use[] =
dd24e3da 12671 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 12672 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 12673static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12674static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 12675 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 12676 "TrustZone and Virtualization Extensions"};
dd24e3da 12677static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 12678 {"Not Allowed", "Allowed"};
11c1ff18
PB		 12679
12680#define LOOKUP(id, name) \
12681 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 12682static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 12683{
12684 {4, "CPU_raw_name", 1, NULL},
12685 {5, "CPU_name", 1, NULL},
12686 LOOKUP(6, CPU_arch),
12687 {7, "CPU_arch_profile", 0, NULL},
12688 LOOKUP(8, ARM_ISA_use),
12689 LOOKUP(9, THUMB_ISA_use),
75375b3e 12690 LOOKUP(10, FP_arch),
11c1ff18 12691 LOOKUP(11, WMMX_arch),
f5f53991
AS		 12692 LOOKUP(12, Advanced_SIMD_arch),
12693 LOOKUP(13, PCS_config),
11c1ff18
PB		 12694 LOOKUP(14, ABI_PCS_R9_use),
12695 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 12696 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 12697 LOOKUP(17, ABI_PCS_GOT_use),
12698 LOOKUP(18, ABI_PCS_wchar_t),
12699 LOOKUP(19, ABI_FP_rounding),
12700 LOOKUP(20, ABI_FP_denormal),
12701 LOOKUP(21, ABI_FP_exceptions),
12702 LOOKUP(22, ABI_FP_user_exceptions),
12703 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 12704 {24, "ABI_align_needed", 0, NULL},
12705 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 12706 LOOKUP(26, ABI_enum_size),
12707 LOOKUP(27, ABI_HardFP_use),
12708 LOOKUP(28, ABI_VFP_args),
12709 LOOKUP(29, ABI_WMMX_args),
12710 LOOKUP(30, ABI_optimization_goals),
12711 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 12712 {32, "compatibility", 0, NULL},
f5f53991 12713 LOOKUP(34, CPU_unaligned_access),
75375b3e 12714 LOOKUP(36, FP_HP_extension),
8e79c3df 12715 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 12716 LOOKUP(42, MPextension_use),
12717 LOOKUP(44, DIV_use),
f5f53991
AS		 12718 {64, "nodefaults", 0, NULL},
12719 {65, "also_compatible_with", 0, NULL},
12720 LOOKUP(66, T2EE_use),
12721 {67, "conformance", 1, NULL},
12722 LOOKUP(68, Virtualization_use),
cd21e546 12723 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 12724};
12725#undef LOOKUP
12726
11c1ff18 12727static unsigned char *
f6f0e17b
NC		 12728display_arm_attribute (unsigned char * p,
12729 const unsigned char * const end)
11c1ff18 12730{
70e99720 12731 unsigned int tag;
11c1ff18 12732 unsigned int len;
70e99720 12733 unsigned int val;
2cf0635d 12734 arm_attr_public_tag * attr;
11c1ff18 12735 unsigned i;
70e99720 12736 unsigned int type;
11c1ff18 12737
f6f0e17b 12738 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 12739 p += len;
12740 attr = NULL;
2cf0635d 12741 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 12742 {
12743 if (arm_attr_public_tags[i].tag == tag)
12744 {
12745 attr = &arm_attr_public_tags[i];
12746 break;
12747 }
12748 }
12749
12750 if (attr)
12751 {
12752 printf (" Tag_%s: ", attr->name);
12753 switch (attr->type)
12754 {
12755 case 0:
12756 switch (tag)
12757 {
12758 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 12759 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12760 p += len;
12761 switch (val)
12762 {
2b692964
NC		 12763 case 0: printf (_("None\n")); break;
12764 case 'A': printf (_("Application\n")); break;
12765 case 'R': printf (_("Realtime\n")); break;
12766 case 'M': printf (_("Microcontroller\n")); break;
12767 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 12768 default: printf ("??? (%d)\n", val); break;
12769 }
12770 break;
12771
75375b3e 12772 case 24: /* Tag_align_needed. */
f6f0e17b 12773 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12774 p += len;
12775 switch (val)
12776 {
2b692964
NC		 12777 case 0: printf (_("None\n")); break;
12778 case 1: printf (_("8-byte\n")); break;
12779 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 12780 case 3: printf ("??? 3\n"); break;
12781 default:
12782 if (val <= 12)
dd24e3da 12783 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12784 1 << val);
12785 else
12786 printf ("??? (%d)\n", val);
12787 break;
12788 }
12789 break;
12790
12791 case 25: /* Tag_align_preserved. */
f6f0e17b 12792 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12793 p += len;
12794 switch (val)
12795 {
2b692964
NC		 12796 case 0: printf (_("None\n")); break;
12797 case 1: printf (_("8-byte, except leaf SP\n")); break;
12798 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 12799 case 3: printf ("??? 3\n"); break;
12800 default:
12801 if (val <= 12)
dd24e3da 12802 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12803 1 << val);
12804 else
12805 printf ("??? (%d)\n", val);
12806 break;
12807 }
12808 break;
12809
11c1ff18 12810 case 32: /* Tag_compatibility. */
071436c6 12811 {
071436c6
NC		 12812 val = read_uleb128 (p, &len, end);
12813 p += len;
071436c6 12814 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 12815 if (p < end - 1)
12816 {
12817 size_t maxlen = (end - p) - 1;
12818
12819 print_symbol ((int) maxlen, (const char *) p);
12820 p += strnlen ((char *) p, maxlen) + 1;
12821 }
12822 else
12823 {
12824 printf (_("<corrupt>"));
12825 p = (unsigned char *) end;
12826 }
071436c6 12827 putchar ('\n');
071436c6 12828 }
11c1ff18
PB		 12829 break;
12830
f5f53991 12831 case 64: /* Tag_nodefaults. */
541a3cbd
NC		 12832 /* PR 17531: file: 001-505008-0.01. */
12833 if (p < end)
12834 p++;
2b692964 12835 printf (_("True\n"));
f5f53991
AS		 12836 break;
12837
12838 case 65: /* Tag_also_compatible_with. */
f6f0e17b 12839 val = read_uleb128 (p, &len, end);
f5f53991
AS		 12840 p += len;
12841 if (val == 6 /* Tag_CPU_arch. */)
12842 {
f6f0e17b 12843 val = read_uleb128 (p, &len, end);
f5f53991 12844 p += len;
071436c6 12845 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 12846 printf ("??? (%d)\n", val);
12847 else
12848 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12849 }
12850 else
12851 printf ("???\n");
071436c6
NC		 12852 while (p < end && *(p++) != '\0' /* NUL terminator. */)
12853 ;
f5f53991
AS		 12854 break;
12855
11c1ff18 12856 default:
bee0ee85
NC		 12857 printf (_("<unknown: %d>\n"), tag);
12858 break;
11c1ff18
PB		 12859 }
12860 return p;
12861
12862 case 1:
f6f0e17b 12863 return display_tag_value (-1, p, end);
11c1ff18 12864 case 2:
f6f0e17b 12865 return display_tag_value (0, p, end);
11c1ff18
PB		 12866
12867 default:
12868 assert (attr->type & 0x80);
f6f0e17b 12869 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12870 p += len;
12871 type = attr->type & 0x7f;
12872 if (val >= type)
12873 printf ("??? (%d)\n", val);
12874 else
12875 printf ("%s\n", attr->table[val]);
12876 return p;
12877 }
12878 }
11c1ff18 12879
f6f0e17b 12880 return display_tag_value (tag, p, end);
11c1ff18
PB		 12881}
12882
104d59d1 12883static unsigned char *
60bca95a 12884display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 12885 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12886 const unsigned char * const end)
104d59d1
JM		 12887{
12888 int tag;
12889 unsigned int len;
12890 int val;
104d59d1 12891
f6f0e17b 12892 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 12893 p += len;
12894
12895 /* Tag_compatibility is the only generic GNU attribute defined at
12896 present. */
12897 if (tag == 32)
12898 {
f6f0e17b 12899 val = read_uleb128 (p, &len, end);
104d59d1 12900 p += len;
071436c6
NC		 12901
12902 printf (_("flag = %d, vendor = "), val);
f6f0e17b
NC		 12903 if (p == end)
12904 {
071436c6 12905 printf (_("<corrupt>\n"));
f6f0e17b
NC		 12906 warn (_("corrupt vendor attribute\n"));
12907 }
12908 else
12909 {
4082ef84
NC		 12910 if (p < end - 1)
12911 {
12912 size_t maxlen = (end - p) - 1;
071436c6 12913
4082ef84
NC		 12914 print_symbol ((int) maxlen, (const char *) p);
12915 p += strnlen ((char *) p, maxlen) + 1;
12916 }
12917 else
12918 {
12919 printf (_("<corrupt>"));
12920 p = (unsigned char *) end;
12921 }
071436c6 12922 putchar ('\n');
f6f0e17b 12923 }
104d59d1
JM		 12924 return p;
12925 }
12926
12927 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 12928 return display_proc_gnu_attribute (p, tag, end);
104d59d1 12929
f6f0e17b 12930 return display_tag_value (tag, p, end);
104d59d1
JM		 12931}
12932
34c8bcba 12933static unsigned char *
f6f0e17b
NC		 12934display_power_gnu_attribute (unsigned char * p,
12935 int tag,
12936 const unsigned char * const end)
34c8bcba 12937{
34c8bcba
JM		 12938 unsigned int len;
12939 int val;
12940
12941 if (tag == Tag_GNU_Power_ABI_FP)
12942 {
f6f0e17b 12943 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 12944 p += len;
12945 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 12946
34c8bcba
JM		 12947 switch (val)
12948 {
12949 case 0:
2b692964 12950 printf (_("Hard or soft float\n"));
34c8bcba
JM		 12951 break;
12952 case 1:
2b692964 12953 printf (_("Hard float\n"));
34c8bcba
JM		 12954 break;
12955 case 2:
2b692964 12956 printf (_("Soft float\n"));
34c8bcba 12957 break;
3c7b9897 12958 case 3:
2b692964 12959 printf (_("Single-precision hard float\n"));
3c7b9897 12960 break;
34c8bcba
JM		 12961 default:
12962 printf ("??? (%d)\n", val);
12963 break;
12964 }
12965 return p;
12966 }
12967
c6e65352
DJ		 12968 if (tag == Tag_GNU_Power_ABI_Vector)
12969 {
f6f0e17b 12970 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 12971 p += len;
12972 printf (" Tag_GNU_Power_ABI_Vector: ");
12973 switch (val)
12974 {
12975 case 0:
2b692964 12976 printf (_("Any\n"));
c6e65352
DJ		 12977 break;
12978 case 1:
2b692964 12979 printf (_("Generic\n"));
c6e65352
DJ		 12980 break;
12981 case 2:
12982 printf ("AltiVec\n");
12983 break;
12984 case 3:
12985 printf ("SPE\n");
12986 break;
12987 default:
12988 printf ("??? (%d)\n", val);
12989 break;
12990 }
12991 return p;
12992 }
12993
f82e0623
NF		 12994 if (tag == Tag_GNU_Power_ABI_Struct_Return)
12995 {
f6f0e17b
NC		 12996 if (p == end)
12997 {
071436c6 12998 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
f6f0e17b
NC		 12999 return p;
13000 }
0b4362b0 13001
f6f0e17b 13002 val = read_uleb128 (p, &len, end);
f82e0623
NF		 13003 p += len;
13004 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13005 switch (val)
13006 {
13007 case 0:
2b692964 13008 printf (_("Any\n"));
f82e0623
NF		 13009 break;
13010 case 1:
13011 printf ("r3/r4\n");
13012 break;
13013 case 2:
2b692964 13014 printf (_("Memory\n"));
f82e0623
NF		 13015 break;
13016 default:
13017 printf ("??? (%d)\n", val);
13018 break;
13019 }
13020 return p;
13021 }
13022
f6f0e17b 13023 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 13024}
13025
643f7afb
AK		 13026static unsigned char *
13027display_s390_gnu_attribute (unsigned char * p,
13028 int tag,
13029 const unsigned char * const end)
13030{
13031 unsigned int len;
13032 int val;
13033
13034 if (tag == Tag_GNU_S390_ABI_Vector)
13035 {
13036 val = read_uleb128 (p, &len, end);
13037 p += len;
13038 printf (" Tag_GNU_S390_ABI_Vector: ");
13039
13040 switch (val)
13041 {
13042 case 0:
13043 printf (_("any\n"));
13044 break;
13045 case 1:
13046 printf (_("software\n"));
13047 break;
13048 case 2:
13049 printf (_("hardware\n"));
13050 break;
13051 default:
13052 printf ("??? (%d)\n", val);
13053 break;
13054 }
13055 return p;
13056 }
13057
13058 return display_tag_value (tag & 1, p, end);
13059}
13060
9e8c70f9
DM		 13061static void
13062display_sparc_hwcaps (int mask)
13063{
13064 if (mask)
13065 {
13066 int first = 1;
071436c6 13067
9e8c70f9
DM		 13068 if (mask & ELF_SPARC_HWCAP_MUL32)
13069 fputs ("mul32", stdout), first = 0;
13070 if (mask & ELF_SPARC_HWCAP_DIV32)
13071 printf ("%sdiv32", first ? "" : "|"), first = 0;
13072 if (mask & ELF_SPARC_HWCAP_FSMULD)
13073 printf ("%sfsmuld", first ? "" : "|"), first = 0;
13074 if (mask & ELF_SPARC_HWCAP_V8PLUS)
13075 printf ("%sv8plus", first ? "" : "|"), first = 0;
13076 if (mask & ELF_SPARC_HWCAP_POPC)
13077 printf ("%spopc", first ? "" : "|"), first = 0;
13078 if (mask & ELF_SPARC_HWCAP_VIS)
13079 printf ("%svis", first ? "" : "|"), first = 0;
13080 if (mask & ELF_SPARC_HWCAP_VIS2)
13081 printf ("%svis2", first ? "" : "|"), first = 0;
13082 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
13083 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
13084 if (mask & ELF_SPARC_HWCAP_FMAF)
13085 printf ("%sfmaf", first ? "" : "|"), first = 0;
13086 if (mask & ELF_SPARC_HWCAP_VIS3)
13087 printf ("%svis3", first ? "" : "|"), first = 0;
13088 if (mask & ELF_SPARC_HWCAP_HPC)
13089 printf ("%shpc", first ? "" : "|"), first = 0;
13090 if (mask & ELF_SPARC_HWCAP_RANDOM)
13091 printf ("%srandom", first ? "" : "|"), first = 0;
13092 if (mask & ELF_SPARC_HWCAP_TRANS)
13093 printf ("%strans", first ? "" : "|"), first = 0;
13094 if (mask & ELF_SPARC_HWCAP_FJFMAU)
13095 printf ("%sfjfmau", first ? "" : "|"), first = 0;
13096 if (mask & ELF_SPARC_HWCAP_IMA)
13097 printf ("%sima", first ? "" : "|"), first = 0;
13098 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
13099 printf ("%scspare", first ? "" : "|"), first = 0;
13100 }
13101 else
071436c6
NC		 13102 fputc ('0', stdout);
13103 fputc ('\n', stdout);
9e8c70f9
DM		 13104}
13105
3d68f91c
JM		 13106static void
13107display_sparc_hwcaps2 (int mask)
13108{
13109 if (mask)
13110 {
13111 int first = 1;
071436c6 13112
3d68f91c
JM		 13113 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
13114 fputs ("fjathplus", stdout), first = 0;
13115 if (mask & ELF_SPARC_HWCAP2_VIS3B)
13116 printf ("%svis3b", first ? "" : "|"), first = 0;
13117 if (mask & ELF_SPARC_HWCAP2_ADP)
13118 printf ("%sadp", first ? "" : "|"), first = 0;
13119 if (mask & ELF_SPARC_HWCAP2_SPARC5)
13120 printf ("%ssparc5", first ? "" : "|"), first = 0;
13121 if (mask & ELF_SPARC_HWCAP2_MWAIT)
13122 printf ("%smwait", first ? "" : "|"), first = 0;
13123 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
13124 printf ("%sxmpmul", first ? "" : "|"), first = 0;
13125 if (mask & ELF_SPARC_HWCAP2_XMONT)
13126 printf ("%sxmont2", first ? "" : "|"), first = 0;
13127 if (mask & ELF_SPARC_HWCAP2_NSEC)
13128 printf ("%snsec", first ? "" : "|"), first = 0;
13129 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
13130 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
13131 if (mask & ELF_SPARC_HWCAP2_FJDES)
13132 printf ("%sfjdes", first ? "" : "|"), first = 0;
13133 if (mask & ELF_SPARC_HWCAP2_FJAES)
13134 printf ("%sfjaes", first ? "" : "|"), first = 0;
13135 }
13136 else
071436c6
NC		 13137 fputc ('0', stdout);
13138 fputc ('\n', stdout);
3d68f91c
JM		 13139}
13140
9e8c70f9 13141static unsigned char *
f6f0e17b
NC		 13142display_sparc_gnu_attribute (unsigned char * p,
13143 int tag,
13144 const unsigned char * const end)
9e8c70f9 13145{
3d68f91c
JM		 13146 unsigned int len;
13147 int val;
13148
9e8c70f9
DM		 13149 if (tag == Tag_GNU_Sparc_HWCAPS)
13150 {
f6f0e17b 13151 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 13152 p += len;
13153 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 13154 display_sparc_hwcaps (val);
13155 return p;
3d68f91c
JM		 13156 }
13157 if (tag == Tag_GNU_Sparc_HWCAPS2)
13158 {
13159 val = read_uleb128 (p, &len, end);
13160 p += len;
13161 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13162 display_sparc_hwcaps2 (val);
13163 return p;
13164 }
9e8c70f9 13165
f6f0e17b 13166 return display_tag_value (tag, p, end);
9e8c70f9
DM		 13167}
13168
351cdf24
MF		 13169static void
13170print_mips_fp_abi_value (int val)
13171{
13172 switch (val)
13173 {
13174 case Val_GNU_MIPS_ABI_FP_ANY:
13175 printf (_("Hard or soft float\n"));
13176 break;
13177 case Val_GNU_MIPS_ABI_FP_DOUBLE:
13178 printf (_("Hard float (double precision)\n"));
13179 break;
13180 case Val_GNU_MIPS_ABI_FP_SINGLE:
13181 printf (_("Hard float (single precision)\n"));
13182 break;
13183 case Val_GNU_MIPS_ABI_FP_SOFT:
13184 printf (_("Soft float\n"));
13185 break;
13186 case Val_GNU_MIPS_ABI_FP_OLD_64:
13187 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13188 break;
13189 case Val_GNU_MIPS_ABI_FP_XX:
13190 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13191 break;
13192 case Val_GNU_MIPS_ABI_FP_64:
13193 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13194 break;
13195 case Val_GNU_MIPS_ABI_FP_64A:
13196 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13197 break;
13198 default:
13199 printf ("??? (%d)\n", val);
13200 break;
13201 }
13202}
13203
2cf19d5c 13204static unsigned char *
f6f0e17b
NC		 13205display_mips_gnu_attribute (unsigned char * p,
13206 int tag,
13207 const unsigned char * const end)
2cf19d5c 13208{
2cf19d5c
JM		 13209 if (tag == Tag_GNU_MIPS_ABI_FP)
13210 {
f6f0e17b
NC		 13211 unsigned int len;
13212 int val;
13213
13214 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 13215 p += len;
13216 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 13217
351cdf24
MF		 13218 print_mips_fp_abi_value (val);
13219
2cf19d5c
JM		 13220 return p;
13221 }
13222
a9f58168
CF		 13223 if (tag == Tag_GNU_MIPS_ABI_MSA)
13224 {
13225 unsigned int len;
13226 int val;
13227
13228 val = read_uleb128 (p, &len, end);
13229 p += len;
13230 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13231
13232 switch (val)
13233 {
13234 case Val_GNU_MIPS_ABI_MSA_ANY:
13235 printf (_("Any MSA or not\n"));
13236 break;
13237 case Val_GNU_MIPS_ABI_MSA_128:
13238 printf (_("128-bit MSA\n"));
13239 break;
13240 default:
13241 printf ("??? (%d)\n", val);
13242 break;
13243 }
13244 return p;
13245 }
13246
f6f0e17b 13247 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 13248}
13249
59e6276b 13250static unsigned char *
f6f0e17b
NC		 13251display_tic6x_attribute (unsigned char * p,
13252 const unsigned char * const end)
59e6276b
JM		 13253{
13254 int tag;
13255 unsigned int len;
13256 int val;
13257
f6f0e17b 13258 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 13259 p += len;
13260
13261 switch (tag)
13262 {
75fa6dc1 13263 case Tag_ISA:
f6f0e17b 13264 val = read_uleb128 (p, &len, end);
59e6276b 13265 p += len;
75fa6dc1 13266 printf (" Tag_ISA: ");
59e6276b
JM		 13267
13268 switch (val)
13269 {
75fa6dc1 13270 case C6XABI_Tag_ISA_none:
59e6276b
JM		 13271 printf (_("None\n"));
13272 break;
75fa6dc1 13273 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 13274 printf ("C62x\n");
13275 break;
75fa6dc1 13276 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 13277 printf ("C67x\n");
13278 break;
75fa6dc1 13279 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 13280 printf ("C67x+\n");
13281 break;
75fa6dc1 13282 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 13283 printf ("C64x\n");
13284 break;
75fa6dc1 13285 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 13286 printf ("C64x+\n");
13287 break;
75fa6dc1 13288 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 13289 printf ("C674x\n");
13290 break;
13291 default:
13292 printf ("??? (%d)\n", val);
13293 break;
13294 }
13295 return p;
13296
87779176 13297 case Tag_ABI_wchar_t:
f6f0e17b 13298 val = read_uleb128 (p, &len, end);
87779176
JM		 13299 p += len;
13300 printf (" Tag_ABI_wchar_t: ");
13301 switch (val)
13302 {
13303 case 0:
13304 printf (_("Not used\n"));
13305 break;
13306 case 1:
13307 printf (_("2 bytes\n"));
13308 break;
13309 case 2:
13310 printf (_("4 bytes\n"));
13311 break;
13312 default:
13313 printf ("??? (%d)\n", val);
13314 break;
13315 }
13316 return p;
13317
13318 case Tag_ABI_stack_align_needed:
f6f0e17b 13319 val = read_uleb128 (p, &len, end);
87779176
JM		 13320 p += len;
13321 printf (" Tag_ABI_stack_align_needed: ");
13322 switch (val)
13323 {
13324 case 0:
13325 printf (_("8-byte\n"));
13326 break;
13327 case 1:
13328 printf (_("16-byte\n"));
13329 break;
13330 default:
13331 printf ("??? (%d)\n", val);
13332 break;
13333 }
13334 return p;
13335
13336 case Tag_ABI_stack_align_preserved:
f6f0e17b 13337 val = read_uleb128 (p, &len, end);
87779176
JM		 13338 p += len;
13339 printf (" Tag_ABI_stack_align_preserved: ");
13340 switch (val)
13341 {
13342 case 0:
13343 printf (_("8-byte\n"));
13344 break;
13345 case 1:
13346 printf (_("16-byte\n"));
13347 break;
13348 default:
13349 printf ("??? (%d)\n", val);
13350 break;
13351 }
13352 return p;
13353
b5593623 13354 case Tag_ABI_DSBT:
f6f0e17b 13355 val = read_uleb128 (p, &len, end);
b5593623
JM		 13356 p += len;
13357 printf (" Tag_ABI_DSBT: ");
13358 switch (val)
13359 {
13360 case 0:
13361 printf (_("DSBT addressing not used\n"));
13362 break;
13363 case 1:
13364 printf (_("DSBT addressing used\n"));
13365 break;
13366 default:
13367 printf ("??? (%d)\n", val);
13368 break;
13369 }
13370 return p;
13371
87779176 13372 case Tag_ABI_PID:
f6f0e17b 13373 val = read_uleb128 (p, &len, end);
87779176
JM		 13374 p += len;
13375 printf (" Tag_ABI_PID: ");
13376 switch (val)
13377 {
13378 case 0:
13379 printf (_("Data addressing position-dependent\n"));
13380 break;
13381 case 1:
13382 printf (_("Data addressing position-independent, GOT near DP\n"));
13383 break;
13384 case 2:
13385 printf (_("Data addressing position-independent, GOT far from DP\n"));
13386 break;
13387 default:
13388 printf ("??? (%d)\n", val);
13389 break;
13390 }
13391 return p;
13392
13393 case Tag_ABI_PIC:
f6f0e17b 13394 val = read_uleb128 (p, &len, end);
87779176
JM		 13395 p += len;
13396 printf (" Tag_ABI_PIC: ");
13397 switch (val)
13398 {
13399 case 0:
13400 printf (_("Code addressing position-dependent\n"));
13401 break;
13402 case 1:
13403 printf (_("Code addressing position-independent\n"));
13404 break;
13405 default:
13406 printf ("??? (%d)\n", val);
13407 break;
13408 }
13409 return p;
13410
13411 case Tag_ABI_array_object_alignment:
f6f0e17b 13412 val = read_uleb128 (p, &len, end);
87779176
JM		 13413 p += len;
13414 printf (" Tag_ABI_array_object_alignment: ");
13415 switch (val)
13416 {
13417 case 0:
13418 printf (_("8-byte\n"));
13419 break;
13420 case 1:
13421 printf (_("4-byte\n"));
13422 break;
13423 case 2:
13424 printf (_("16-byte\n"));
13425 break;
13426 default:
13427 printf ("??? (%d)\n", val);
13428 break;
13429 }
13430 return p;
13431
13432 case Tag_ABI_array_object_align_expected:
f6f0e17b 13433 val = read_uleb128 (p, &len, end);
87779176
JM		 13434 p += len;
13435 printf (" Tag_ABI_array_object_align_expected: ");
13436 switch (val)
13437 {
13438 case 0:
13439 printf (_("8-byte\n"));
13440 break;
13441 case 1:
13442 printf (_("4-byte\n"));
13443 break;
13444 case 2:
13445 printf (_("16-byte\n"));
13446 break;
13447 default:
13448 printf ("??? (%d)\n", val);
13449 break;
13450 }
13451 return p;
13452
3cbd1c06 13453 case Tag_ABI_compatibility:
071436c6 13454 {
071436c6
NC		 13455 val = read_uleb128 (p, &len, end);
13456 p += len;
13457 printf (" Tag_ABI_compatibility: ");
071436c6 13458 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13459 if (p < end - 1)
13460 {
13461 size_t maxlen = (end - p) - 1;
13462
13463 print_symbol ((int) maxlen, (const char *) p);
13464 p += strnlen ((char *) p, maxlen) + 1;
13465 }
13466 else
13467 {
13468 printf (_("<corrupt>"));
13469 p = (unsigned char *) end;
13470 }
071436c6 13471 putchar ('\n');
071436c6
NC		 13472 return p;
13473 }
87779176
JM		 13474
13475 case Tag_ABI_conformance:
071436c6 13476 {
4082ef84
NC		 13477 printf (" Tag_ABI_conformance: \"");
13478 if (p < end - 1)
13479 {
13480 size_t maxlen = (end - p) - 1;
071436c6 13481
4082ef84
NC		 13482 print_symbol ((int) maxlen, (const char *) p);
13483 p += strnlen ((char *) p, maxlen) + 1;
13484 }
13485 else
13486 {
13487 printf (_("<corrupt>"));
13488 p = (unsigned char *) end;
13489 }
071436c6 13490 printf ("\"\n");
071436c6
NC		 13491 return p;
13492 }
59e6276b
JM		 13493 }
13494
f6f0e17b
NC		 13495 return display_tag_value (tag, p, end);
13496}
59e6276b 13497
f6f0e17b
NC		 13498static void
13499display_raw_attribute (unsigned char * p, unsigned char * end)
13500{
13501 unsigned long addr = 0;
13502 size_t bytes = end - p;
13503
e0a31db1 13504 assert (end > p);
f6f0e17b 13505 while (bytes)
87779176 13506 {
f6f0e17b
NC		 13507 int j;
13508 int k;
13509 int lbytes = (bytes > 16 ? 16 : bytes);
13510
13511 printf (" 0x%8.8lx ", addr);
13512
13513 for (j = 0; j < 16; j++)
13514 {
13515 if (j < lbytes)
13516 printf ("%2.2x", p[j]);
13517 else
13518 printf (" ");
13519
13520 if ((j & 3) == 3)
13521 printf (" ");
13522 }
13523
13524 for (j = 0; j < lbytes; j++)
13525 {
13526 k = p[j];
13527 if (k >= ' ' && k < 0x7f)
13528 printf ("%c", k);
13529 else
13530 printf (".");
13531 }
13532
13533 putchar ('\n');
13534
13535 p += lbytes;
13536 bytes -= lbytes;
13537 addr += lbytes;
87779176 13538 }
59e6276b 13539
f6f0e17b 13540 putchar ('\n');
59e6276b
JM		 13541}
13542
13761a11
NC		 13543static unsigned char *
13544display_msp430x_attribute (unsigned char * p,
13545 const unsigned char * const end)
13546{
13547 unsigned int len;
13548 int val;
13549 int tag;
13550
13551 tag = read_uleb128 (p, & len, end);
13552 p += len;
0b4362b0 13553
13761a11
NC		 13554 switch (tag)
13555 {
13556 case OFBA_MSPABI_Tag_ISA:
13557 val = read_uleb128 (p, &len, end);
13558 p += len;
13559 printf (" Tag_ISA: ");
13560 switch (val)
13561 {
13562 case 0: printf (_("None\n")); break;
13563 case 1: printf (_("MSP430\n")); break;
13564 case 2: printf (_("MSP430X\n")); break;
13565 default: printf ("??? (%d)\n", val); break;
13566 }
13567 break;
13568
13569 case OFBA_MSPABI_Tag_Code_Model:
13570 val = read_uleb128 (p, &len, end);
13571 p += len;
13572 printf (" Tag_Code_Model: ");
13573 switch (val)
13574 {
13575 case 0: printf (_("None\n")); break;
13576 case 1: printf (_("Small\n")); break;
13577 case 2: printf (_("Large\n")); break;
13578 default: printf ("??? (%d)\n", val); break;
13579 }
13580 break;
13581
13582 case OFBA_MSPABI_Tag_Data_Model:
13583 val = read_uleb128 (p, &len, end);
13584 p += len;
13585 printf (" Tag_Data_Model: ");
13586 switch (val)
13587 {
13588 case 0: printf (_("None\n")); break;
13589 case 1: printf (_("Small\n")); break;
13590 case 2: printf (_("Large\n")); break;
13591 case 3: printf (_("Restricted Large\n")); break;
13592 default: printf ("??? (%d)\n", val); break;
13593 }
13594 break;
13595
13596 default:
13597 printf (_(" <unknown tag %d>: "), tag);
13598
13599 if (tag & 1)
13600 {
071436c6 13601 putchar ('"');
4082ef84
NC		 13602 if (p < end - 1)
13603 {
13604 size_t maxlen = (end - p) - 1;
13605
13606 print_symbol ((int) maxlen, (const char *) p);
13607 p += strnlen ((char *) p, maxlen) + 1;
13608 }
13609 else
13610 {
13611 printf (_("<corrupt>"));
13612 p = (unsigned char *) end;
13613 }
071436c6 13614 printf ("\"\n");
13761a11
NC		 13615 }
13616 else
13617 {
13618 val = read_uleb128 (p, &len, end);
13619 p += len;
13620 printf ("%d (0x%x)\n", val, val);
13621 }
13622 break;
13623 }
13624
4082ef84 13625 assert (p <= end);
13761a11
NC		 13626 return p;
13627}
13628
11c1ff18 13629static int
60bca95a
NC		 13630process_attributes (FILE * file,
13631 const char * public_name,
104d59d1 13632 unsigned int proc_type,
f6f0e17b
NC		 13633 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13634 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 13635{
2cf0635d 13636 Elf_Internal_Shdr * sect;
11c1ff18
PB		 13637 unsigned i;
13638
13639 /* Find the section header so that we get the size. */
13640 for (i = 0, sect = section_headers;
13641 i < elf_header.e_shnum;
13642 i++, sect++)
13643 {
071436c6
NC		 13644 unsigned char * contents;
13645 unsigned char * p;
13646
104d59d1 13647 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 13648 continue;
13649
3f5e193b
NC		 13650 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13651 sect->sh_size, _("attributes"));
60bca95a 13652 if (contents == NULL)
11c1ff18 13653 continue;
60bca95a 13654
11c1ff18
PB		 13655 p = contents;
13656 if (*p == 'A')
13657 {
071436c6
NC		 13658 bfd_vma section_len;
13659
13660 section_len = sect->sh_size - 1;
11c1ff18 13661 p++;
60bca95a 13662
071436c6 13663 while (section_len > 0)
11c1ff18 13664 {
071436c6 13665 bfd_vma attr_len;
e9847026 13666 unsigned int namelen;
11c1ff18 13667 bfd_boolean public_section;
104d59d1 13668 bfd_boolean gnu_section;
11c1ff18 13669
071436c6 13670 if (section_len <= 4)
e0a31db1
NC		 13671 {
13672 error (_("Tag section ends prematurely\n"));
13673 break;
13674 }
071436c6 13675 attr_len = byte_get (p, 4);
11c1ff18 13676 p += 4;
60bca95a 13677
071436c6 13678 if (attr_len > section_len)
11c1ff18 13679 {
071436c6
NC		 13680 error (_("Bad attribute length (%u > %u)\n"),
13681 (unsigned) attr_len, (unsigned) section_len);
13682 attr_len = section_len;
11c1ff18 13683 }
74e1a04b 13684 /* PR 17531: file: 001-101425-0.004 */
071436c6 13685 else if (attr_len < 5)
74e1a04b 13686 {
071436c6 13687 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
74e1a04b
NC		 13688 break;
13689 }
e9847026 13690
071436c6
NC		 13691 section_len -= attr_len;
13692 attr_len -= 4;
13693
13694 namelen = strnlen ((char *) p, attr_len) + 1;
13695 if (namelen == 0 || namelen >= attr_len)
e9847026
NC		 13696 {
13697 error (_("Corrupt attribute section name\n"));
13698 break;
13699 }
13700
071436c6
NC		 13701 printf (_("Attribute Section: "));
13702 print_symbol (INT_MAX, (const char *) p);
13703 putchar ('\n');
60bca95a
NC		 13704
13705 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 13706 public_section = TRUE;
13707 else
13708 public_section = FALSE;
60bca95a
NC		 13709
13710 if (streq ((char *) p, "gnu"))
104d59d1
JM		 13711 gnu_section = TRUE;
13712 else
13713 gnu_section = FALSE;
60bca95a 13714
11c1ff18 13715 p += namelen;
071436c6 13716 attr_len -= namelen;
e0a31db1 13717
071436c6 13718 while (attr_len > 0 && p < contents + sect->sh_size)
11c1ff18 13719 {
e0a31db1 13720 int tag;
11c1ff18
PB		 13721 int val;
13722 bfd_vma size;
071436c6 13723 unsigned char * end;
60bca95a 13724
e0a31db1 13725 /* PR binutils/17531: Safe handling of corrupt files. */
071436c6 13726 if (attr_len < 6)
e0a31db1
NC		 13727 {
13728 error (_("Unused bytes at end of section\n"));
13729 section_len = 0;
13730 break;
13731 }
13732
13733 tag = *(p++);
11c1ff18 13734 size = byte_get (p, 4);
071436c6 13735 if (size > attr_len)
11c1ff18 13736 {
e9847026 13737 error (_("Bad subsection length (%u > %u)\n"),
071436c6
NC		 13738 (unsigned) size, (unsigned) attr_len);
13739 size = attr_len;
11c1ff18 13740 }
e0a31db1
NC		 13741 /* PR binutils/17531: Safe handling of corrupt files. */
13742 if (size < 6)
13743 {
13744 error (_("Bad subsection length (%u < 6)\n"),
13745 (unsigned) size);
13746 section_len = 0;
13747 break;
13748 }
60bca95a 13749
071436c6 13750 attr_len -= size;
11c1ff18 13751 end = p + size - 1;
071436c6 13752 assert (end <= contents + sect->sh_size);
11c1ff18 13753 p += 4;
60bca95a 13754
11c1ff18
PB		 13755 switch (tag)
13756 {
13757 case 1:
2b692964 13758 printf (_("File Attributes\n"));
11c1ff18
PB		 13759 break;
13760 case 2:
2b692964 13761 printf (_("Section Attributes:"));
11c1ff18
PB		 13762 goto do_numlist;
13763 case 3:
2b692964 13764 printf (_("Symbol Attributes:"));
11c1ff18
PB		 13765 do_numlist:
13766 for (;;)
13767 {
91d6fa6a 13768 unsigned int j;
60bca95a 13769
f6f0e17b 13770 val = read_uleb128 (p, &j, end);
91d6fa6a 13771 p += j;
11c1ff18
PB		 13772 if (val == 0)
13773 break;
13774 printf (" %d", val);
13775 }
13776 printf ("\n");
13777 break;
13778 default:
2b692964 13779 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 13780 public_section = FALSE;
13781 break;
13782 }
60bca95a 13783
071436c6 13784 if (public_section && display_pub_attribute != NULL)
11c1ff18
PB		 13785 {
13786 while (p < end)
f6f0e17b 13787 p = display_pub_attribute (p, end);
071436c6 13788 assert (p <= end);
104d59d1 13789 }
071436c6 13790 else if (gnu_section && display_proc_gnu_attribute != NULL)
104d59d1
JM		 13791 {
13792 while (p < end)
13793 p = display_gnu_attribute (p,
f6f0e17b
NC		 13794 display_proc_gnu_attribute,
13795 end);
071436c6 13796 assert (p <= end);
11c1ff18 13797 }
071436c6 13798 else if (p < end)
11c1ff18 13799 {
071436c6 13800 printf (_(" Unknown attribute:\n"));
f6f0e17b 13801 display_raw_attribute (p, end);
11c1ff18
PB		 13802 p = end;
13803 }
071436c6
NC		 13804 else
13805 attr_len = 0;
11c1ff18
PB		 13806 }
13807 }
13808 }
13809 else
e9847026 13810 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
d70c5fc7 13811
60bca95a 13812 free (contents);
11c1ff18
PB		 13813 }
13814 return 1;
13815}
13816
104d59d1 13817static int
2cf0635d 13818process_arm_specific (FILE * file)
104d59d1
JM		 13819{
13820 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13821 display_arm_attribute, NULL);
13822}
13823
34c8bcba 13824static int
2cf0635d 13825process_power_specific (FILE * file)
34c8bcba
JM		 13826{
13827 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13828 display_power_gnu_attribute);
13829}
13830
643f7afb
AK		 13831static int
13832process_s390_specific (FILE * file)
13833{
13834 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13835 display_s390_gnu_attribute);
13836}
13837
9e8c70f9
DM		 13838static int
13839process_sparc_specific (FILE * file)
13840{
13841 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13842 display_sparc_gnu_attribute);
13843}
13844
59e6276b
JM		 13845static int
13846process_tic6x_specific (FILE * file)
13847{
13848 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13849 display_tic6x_attribute, NULL);
13850}
13851
13761a11
NC		 13852static int
13853process_msp430x_specific (FILE * file)
13854{
13855 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13856 display_msp430x_attribute, NULL);
13857}
13858
ccb4c951
RS		 13859/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13860 Print the Address, Access and Initial fields of an entry at VMA ADDR
82b1b41b
NC		 13861 and return the VMA of the next entry, or -1 if there was a problem.
13862 Does not read from DATA_END or beyond. */
ccb4c951
RS		 13863
13864static bfd_vma
82b1b41b
NC		 13865print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
13866 unsigned char * data_end)
ccb4c951
RS		 13867{
13868 printf (" ");
13869 print_vma (addr, LONG_HEX);
13870 printf (" ");
13871 if (addr < pltgot + 0xfff0)
13872 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13873 else
13874 printf ("%10s", "");
13875 printf (" ");
13876 if (data == NULL)
2b692964 13877 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 13878 else
13879 {
13880 bfd_vma entry;
82b1b41b 13881 unsigned char * from = data + addr - pltgot;
ccb4c951 13882
82b1b41b
NC		 13883 if (from + (is_32bit_elf ? 4 : 8) > data_end)
13884 {
13885 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13886 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
13887 return (bfd_vma) -1;
13888 }
13889 else
13890 {
13891 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13892 print_vma (entry, LONG_HEX);
13893 }
ccb4c951
RS		 13894 }
13895 return addr + (is_32bit_elf ? 4 : 8);
13896}
13897
861fb55a
DJ		 13898/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13899 PLTGOT. Print the Address and Initial fields of an entry at VMA
13900 ADDR and return the VMA of the next entry. */
13901
13902static bfd_vma
2cf0635d 13903print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 13904{
13905 printf (" ");
13906 print_vma (addr, LONG_HEX);
13907 printf (" ");
13908 if (data == NULL)
2b692964 13909 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 13910 else
13911 {
13912 bfd_vma entry;
13913
13914 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13915 print_vma (entry, LONG_HEX);
13916 }
13917 return addr + (is_32bit_elf ? 4 : 8);
13918}
13919
351cdf24
MF		 13920static void
13921print_mips_ases (unsigned int mask)
13922{
13923 if (mask & AFL_ASE_DSP)
13924 fputs ("\n\tDSP ASE", stdout);
13925 if (mask & AFL_ASE_DSPR2)
13926 fputs ("\n\tDSP R2 ASE", stdout);
13927 if (mask & AFL_ASE_EVA)
13928 fputs ("\n\tEnhanced VA Scheme", stdout);
13929 if (mask & AFL_ASE_MCU)
13930 fputs ("\n\tMCU (MicroController) ASE", stdout);
13931 if (mask & AFL_ASE_MDMX)
13932 fputs ("\n\tMDMX ASE", stdout);
13933 if (mask & AFL_ASE_MIPS3D)
13934 fputs ("\n\tMIPS-3D ASE", stdout);
13935 if (mask & AFL_ASE_MT)
13936 fputs ("\n\tMT ASE", stdout);
13937 if (mask & AFL_ASE_SMARTMIPS)
13938 fputs ("\n\tSmartMIPS ASE", stdout);
13939 if (mask & AFL_ASE_VIRT)
13940 fputs ("\n\tVZ ASE", stdout);
13941 if (mask & AFL_ASE_MSA)
13942 fputs ("\n\tMSA ASE", stdout);
13943 if (mask & AFL_ASE_MIPS16)
13944 fputs ("\n\tMIPS16 ASE", stdout);
13945 if (mask & AFL_ASE_MICROMIPS)
13946 fputs ("\n\tMICROMIPS ASE", stdout);
13947 if (mask & AFL_ASE_XPA)
13948 fputs ("\n\tXPA ASE", stdout);
13949 if (mask == 0)
13950 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 13951 else if ((mask & ~AFL_ASE_MASK) != 0)
13952 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 13953}
13954
13955static void
13956print_mips_isa_ext (unsigned int isa_ext)
13957{
13958 switch (isa_ext)
13959 {
13960 case 0:
13961 fputs (_("None"), stdout);
13962 break;
13963 case AFL_EXT_XLR:
13964 fputs ("RMI XLR", stdout);
13965 break;
2c629856
N		 13966 case AFL_EXT_OCTEON3:
13967 fputs ("Cavium Networks Octeon3", stdout);
13968 break;
351cdf24
MF		 13969 case AFL_EXT_OCTEON2:
13970 fputs ("Cavium Networks Octeon2", stdout);
13971 break;
13972 case AFL_EXT_OCTEONP:
13973 fputs ("Cavium Networks OcteonP", stdout);
13974 break;
13975 case AFL_EXT_LOONGSON_3A:
13976 fputs ("Loongson 3A", stdout);
13977 break;
13978 case AFL_EXT_OCTEON:
13979 fputs ("Cavium Networks Octeon", stdout);
13980 break;
13981 case AFL_EXT_5900:
13982 fputs ("Toshiba R5900", stdout);
13983 break;
13984 case AFL_EXT_4650:
13985 fputs ("MIPS R4650", stdout);
13986 break;
13987 case AFL_EXT_4010:
13988 fputs ("LSI R4010", stdout);
13989 break;
13990 case AFL_EXT_4100:
13991 fputs ("NEC VR4100", stdout);
13992 break;
13993 case AFL_EXT_3900:
13994 fputs ("Toshiba R3900", stdout);
13995 break;
13996 case AFL_EXT_10000:
13997 fputs ("MIPS R10000", stdout);
13998 break;
13999 case AFL_EXT_SB1:
14000 fputs ("Broadcom SB-1", stdout);
14001 break;
14002 case AFL_EXT_4111:
14003 fputs ("NEC VR4111/VR4181", stdout);
14004 break;
14005 case AFL_EXT_4120:
14006 fputs ("NEC VR4120", stdout);
14007 break;
14008 case AFL_EXT_5400:
14009 fputs ("NEC VR5400", stdout);
14010 break;
14011 case AFL_EXT_5500:
14012 fputs ("NEC VR5500", stdout);
14013 break;
14014 case AFL_EXT_LOONGSON_2E:
14015 fputs ("ST Microelectronics Loongson 2E", stdout);
14016 break;
14017 case AFL_EXT_LOONGSON_2F:
14018 fputs ("ST Microelectronics Loongson 2F", stdout);
14019 break;
14020 default:
00ac7aa0 14021 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 14022 }
14023}
14024
14025static int
14026get_mips_reg_size (int reg_size)
14027{
14028 return (reg_size == AFL_REG_NONE) ? 0
14029 : (reg_size == AFL_REG_32) ? 32
14030 : (reg_size == AFL_REG_64) ? 64
14031 : (reg_size == AFL_REG_128) ? 128
14032 : -1;
14033}
14034
19e6b90e 14035static int
2cf0635d 14036process_mips_specific (FILE * file)
5b18a4bc 14037{
2cf0635d 14038 Elf_Internal_Dyn * entry;
351cdf24 14039 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 14040 size_t liblist_offset = 0;
14041 size_t liblistno = 0;
14042 size_t conflictsno = 0;
14043 size_t options_offset = 0;
14044 size_t conflicts_offset = 0;
861fb55a
DJ		 14045 size_t pltrelsz = 0;
14046 size_t pltrel = 0;
ccb4c951 14047 bfd_vma pltgot = 0;
861fb55a
DJ		 14048 bfd_vma mips_pltgot = 0;
14049 bfd_vma jmprel = 0;
ccb4c951
RS		 14050 bfd_vma local_gotno = 0;
14051 bfd_vma gotsym = 0;
14052 bfd_vma symtabno = 0;
103f02d3 14053
2cf19d5c
JM		 14054 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14055 display_mips_gnu_attribute);
14056
351cdf24
MF		 14057 sect = find_section (".MIPS.abiflags");
14058
14059 if (sect != NULL)
14060 {
14061 Elf_External_ABIFlags_v0 *abiflags_ext;
14062 Elf_Internal_ABIFlags_v0 abiflags_in;
14063
14064 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
14065 fputs ("\nCorrupt ABI Flags section.\n", stdout);
14066 else
14067 {
14068 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
14069 sect->sh_size, _("MIPS ABI Flags section"));
14070 if (abiflags_ext)
14071 {
14072 abiflags_in.version = BYTE_GET (abiflags_ext->version);
14073 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
14074 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
14075 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
14076 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
14077 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
14078 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
14079 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
14080 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
14081 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
14082 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
14083
14084 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
14085 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
14086 if (abiflags_in.isa_rev > 1)
14087 printf ("r%d", abiflags_in.isa_rev);
14088 printf ("\nGPR size: %d",
14089 get_mips_reg_size (abiflags_in.gpr_size));
14090 printf ("\nCPR1 size: %d",
14091 get_mips_reg_size (abiflags_in.cpr1_size));
14092 printf ("\nCPR2 size: %d",
14093 get_mips_reg_size (abiflags_in.cpr2_size));
14094 fputs ("\nFP ABI: ", stdout);
14095 print_mips_fp_abi_value (abiflags_in.fp_abi);
14096 fputs ("ISA Extension: ", stdout);
14097 print_mips_isa_ext (abiflags_in.isa_ext);
14098 fputs ("\nASEs:", stdout);
14099 print_mips_ases (abiflags_in.ases);
14100 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
14101 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
14102 fputc ('\n', stdout);
14103 free (abiflags_ext);
14104 }
14105 }
14106 }
14107
19e6b90e
L		 14108 /* We have a lot of special sections. Thanks SGI! */
14109 if (dynamic_section == NULL)
14110 /* No information available. */
14111 return 0;
252b5132 14112
071436c6
NC		 14113 for (entry = dynamic_section;
14114 /* PR 17531 file: 012-50589-0.004. */
14115 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
14116 ++entry)
252b5132
RH		 14117 switch (entry->d_tag)
14118 {
14119 case DT_MIPS_LIBLIST:
d93f0186
NC		 14120 liblist_offset
14121 = offset_from_vma (file, entry->d_un.d_val,
14122 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 14123 break;
14124 case DT_MIPS_LIBLISTNO:
14125 liblistno = entry->d_un.d_val;
14126 break;
14127 case DT_MIPS_OPTIONS:
d93f0186 14128 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 14129 break;
14130 case DT_MIPS_CONFLICT:
d93f0186
NC		 14131 conflicts_offset
14132 = offset_from_vma (file, entry->d_un.d_val,
14133 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 14134 break;
14135 case DT_MIPS_CONFLICTNO:
14136 conflictsno = entry->d_un.d_val;
14137 break;
ccb4c951 14138 case DT_PLTGOT:
861fb55a
DJ		 14139 pltgot = entry->d_un.d_ptr;
14140 break;
ccb4c951
RS		 14141 case DT_MIPS_LOCAL_GOTNO:
14142 local_gotno = entry->d_un.d_val;
14143 break;
14144 case DT_MIPS_GOTSYM:
14145 gotsym = entry->d_un.d_val;
14146 break;
14147 case DT_MIPS_SYMTABNO:
14148 symtabno = entry->d_un.d_val;
14149 break;
861fb55a
DJ		 14150 case DT_MIPS_PLTGOT:
14151 mips_pltgot = entry->d_un.d_ptr;
14152 break;
14153 case DT_PLTREL:
14154 pltrel = entry->d_un.d_val;
14155 break;
14156 case DT_PLTRELSZ:
14157 pltrelsz = entry->d_un.d_val;
14158 break;
14159 case DT_JMPREL:
14160 jmprel = entry->d_un.d_ptr;
14161 break;
252b5132
RH		 14162 default:
14163 break;
14164 }
14165
14166 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
14167 {
2cf0635d 14168 Elf32_External_Lib * elib;
252b5132
RH		 14169 size_t cnt;
14170
3f5e193b
NC		 14171 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
14172 liblistno,
14173 sizeof (Elf32_External_Lib),
9cf03b7e 14174 _("liblist section data"));
a6e9f9df 14175 if (elib)
252b5132 14176 {
2b692964 14177 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 14178 (unsigned long) liblistno);
2b692964 14179 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 14180 stdout);
14181
14182 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 14183 {
a6e9f9df 14184 Elf32_Lib liblist;
91d6fa6a 14185 time_t atime;
a6e9f9df 14186 char timebuf[20];
2cf0635d 14187 struct tm * tmp;
a6e9f9df
AM		 14188
14189 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14190 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 14191 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14192 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14193 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14194
91d6fa6a 14195 tmp = gmtime (&atime);
e9e44622
JJ		 14196 snprintf (timebuf, sizeof (timebuf),
14197 "%04u-%02u-%02uT%02u:%02u:%02u",
14198 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14199 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 14200
31104126 14201 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 14202 if (VALID_DYNAMIC_NAME (liblist.l_name))
14203 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
14204 else
2b692964 14205 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 14206 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
14207 liblist.l_version);
a6e9f9df
AM		 14208
14209 if (liblist.l_flags == 0)
2b692964 14210 puts (_(" NONE"));
a6e9f9df
AM		 14211 else
14212 {
14213 static const struct
252b5132 14214 {
2cf0635d 14215 const char * name;
a6e9f9df 14216 int bit;
252b5132 14217 }
a6e9f9df
AM		 14218 l_flags_vals[] =
14219 {
14220 { " EXACT_MATCH", LL_EXACT_MATCH },
14221 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
14222 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
14223 { " EXPORTS", LL_EXPORTS },
14224 { " DELAY_LOAD", LL_DELAY_LOAD },
14225 { " DELTA", LL_DELTA }
14226 };
14227 int flags = liblist.l_flags;
14228 size_t fcnt;
14229
60bca95a 14230 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 14231 if ((flags & l_flags_vals[fcnt].bit) != 0)
14232 {
14233 fputs (l_flags_vals[fcnt].name, stdout);
14234 flags ^= l_flags_vals[fcnt].bit;
14235 }
14236 if (flags != 0)
14237 printf (" %#x", (unsigned int) flags);
252b5132 14238
a6e9f9df
AM		 14239 puts ("");
14240 }
252b5132 14241 }
252b5132 14242
a6e9f9df
AM		 14243 free (elib);
14244 }
252b5132
RH		 14245 }
14246
14247 if (options_offset != 0)
14248 {
2cf0635d 14249 Elf_External_Options * eopt;
2cf0635d
NC		 14250 Elf_Internal_Options * iopt;
14251 Elf_Internal_Options * option;
252b5132
RH		 14252 size_t offset;
14253 int cnt;
351cdf24 14254 sect = section_headers;
252b5132
RH		 14255
14256 /* Find the section header so that we get the size. */
071436c6 14257 sect = find_section_by_type (SHT_MIPS_OPTIONS);
948f632f 14258 /* PR 17533 file: 012-277276-0.004. */
071436c6
NC		 14259 if (sect == NULL)
14260 {
14261 error (_("No MIPS_OPTIONS header found\n"));
14262 return 0;
14263 }
252b5132 14264
3f5e193b
NC		 14265 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14266 sect->sh_size, _("options"));
a6e9f9df 14267 if (eopt)
252b5132 14268 {
3f5e193b
NC		 14269 iopt = (Elf_Internal_Options *)
14270 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 14271 if (iopt == NULL)
14272 {
8b73c356 14273 error (_("Out of memory allocatinf space for MIPS options\n"));
a6e9f9df
AM		 14274 return 0;
14275 }
76da6bbe 14276
a6e9f9df
AM		 14277 offset = cnt = 0;
14278 option = iopt;
252b5132 14279
82b1b41b 14280 while (offset <= sect->sh_size - sizeof (* eopt))
a6e9f9df 14281 {
2cf0635d 14282 Elf_External_Options * eoption;
252b5132 14283
a6e9f9df 14284 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 14285
a6e9f9df
AM		 14286 option->kind = BYTE_GET (eoption->kind);
14287 option->size = BYTE_GET (eoption->size);
14288 option->section = BYTE_GET (eoption->section);
14289 option->info = BYTE_GET (eoption->info);
76da6bbe 14290
82b1b41b
NC		 14291 /* PR 17531: file: ffa0fa3b. */
14292 if (option->size < sizeof (* eopt)
14293 || offset + option->size > sect->sh_size)
14294 {
55325047
NC		 14295 error (_("Invalid size (%u) for MIPS option\n"), option->size);
14296 return 0;
82b1b41b 14297 }
a6e9f9df 14298 offset += option->size;
82b1b41b 14299
a6e9f9df
AM		 14300 ++option;
14301 ++cnt;
14302 }
252b5132 14303
a6e9f9df 14304 printf (_("\nSection '%s' contains %d entries:\n"),
74e1a04b 14305 printable_section_name (sect), cnt);
76da6bbe 14306
a6e9f9df 14307 option = iopt;
82b1b41b 14308 offset = 0;
252b5132 14309
a6e9f9df 14310 while (cnt-- > 0)
252b5132 14311 {
a6e9f9df
AM		 14312 size_t len;
14313
14314 switch (option->kind)
252b5132 14315 {
a6e9f9df
AM		 14316 case ODK_NULL:
14317 /* This shouldn't happen. */
14318 printf (" NULL %d %lx", option->section, option->info);
14319 break;
14320 case ODK_REGINFO:
14321 printf (" REGINFO ");
14322 if (elf_header.e_machine == EM_MIPS)
14323 {
14324 /* 32bit form. */
2cf0635d 14325 Elf32_External_RegInfo * ereg;
b34976b6 14326 Elf32_RegInfo reginfo;
a6e9f9df
AM		 14327
14328 ereg = (Elf32_External_RegInfo *) (option + 1);
14329 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14330 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14331 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14332 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14333 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14334 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14335
14336 printf ("GPR %08lx GP 0x%lx\n",
14337 reginfo.ri_gprmask,
14338 (unsigned long) reginfo.ri_gp_value);
14339 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14340 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14341 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14342 }
14343 else
14344 {
14345 /* 64 bit form. */
2cf0635d 14346 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 14347 Elf64_Internal_RegInfo reginfo;
14348
14349 ereg = (Elf64_External_RegInfo *) (option + 1);
14350 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14351 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14352 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14353 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14354 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 14355 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 14356
14357 printf ("GPR %08lx GP 0x",
14358 reginfo.ri_gprmask);
14359 printf_vma (reginfo.ri_gp_value);
14360 printf ("\n");
14361
14362 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14363 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14364 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14365 }
14366 ++option;
14367 continue;
14368 case ODK_EXCEPTIONS:
14369 fputs (" EXCEPTIONS fpe_min(", stdout);
14370 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14371 fputs (") fpe_max(", stdout);
14372 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14373 fputs (")", stdout);
14374
14375 if (option->info & OEX_PAGE0)
14376 fputs (" PAGE0", stdout);
14377 if (option->info & OEX_SMM)
14378 fputs (" SMM", stdout);
14379 if (option->info & OEX_FPDBUG)
14380 fputs (" FPDBUG", stdout);
14381 if (option->info & OEX_DISMISS)
14382 fputs (" DISMISS", stdout);
14383 break;
14384 case ODK_PAD:
14385 fputs (" PAD ", stdout);
14386 if (option->info & OPAD_PREFIX)
14387 fputs (" PREFIX", stdout);
14388 if (option->info & OPAD_POSTFIX)
14389 fputs (" POSTFIX", stdout);
14390 if (option->info & OPAD_SYMBOL)
14391 fputs (" SYMBOL", stdout);
14392 break;
14393 case ODK_HWPATCH:
14394 fputs (" HWPATCH ", stdout);
14395 if (option->info & OHW_R4KEOP)
14396 fputs (" R4KEOP", stdout);
14397 if (option->info & OHW_R8KPFETCH)
14398 fputs (" R8KPFETCH", stdout);
14399 if (option->info & OHW_R5KEOP)
14400 fputs (" R5KEOP", stdout);
14401 if (option->info & OHW_R5KCVTL)
14402 fputs (" R5KCVTL", stdout);
14403 break;
14404 case ODK_FILL:
14405 fputs (" FILL ", stdout);
14406 /* XXX Print content of info word? */
14407 break;
14408 case ODK_TAGS:
14409 fputs (" TAGS ", stdout);
14410 /* XXX Print content of info word? */
14411 break;
14412 case ODK_HWAND:
14413 fputs (" HWAND ", stdout);
14414 if (option->info & OHWA0_R4KEOP_CHECKED)
14415 fputs (" R4KEOP_CHECKED", stdout);
14416 if (option->info & OHWA0_R4KEOP_CLEAN)
14417 fputs (" R4KEOP_CLEAN", stdout);
14418 break;
14419 case ODK_HWOR:
14420 fputs (" HWOR ", stdout);
14421 if (option->info & OHWA0_R4KEOP_CHECKED)
14422 fputs (" R4KEOP_CHECKED", stdout);
14423 if (option->info & OHWA0_R4KEOP_CLEAN)
14424 fputs (" R4KEOP_CLEAN", stdout);
14425 break;
14426 case ODK_GP_GROUP:
14427 printf (" GP_GROUP %#06lx self-contained %#06lx",
14428 option->info & OGP_GROUP,
14429 (option->info & OGP_SELF) >> 16);
14430 break;
14431 case ODK_IDENT:
14432 printf (" IDENT %#06lx self-contained %#06lx",
14433 option->info & OGP_GROUP,
14434 (option->info & OGP_SELF) >> 16);
14435 break;
14436 default:
14437 /* This shouldn't happen. */
14438 printf (" %3d ??? %d %lx",
14439 option->kind, option->section, option->info);
14440 break;
252b5132 14441 }
a6e9f9df 14442
2cf0635d 14443 len = sizeof (* eopt);
a6e9f9df 14444 while (len < option->size)
82b1b41b
NC		 14445 {
14446 char datum = * ((char *) eopt + offset + len);
a6e9f9df 14447
82b1b41b
NC		 14448 if (ISPRINT (datum))
14449 printf ("%c", datum);
14450 else
14451 printf ("\\%03o", datum);
14452 len ++;
14453 }
a6e9f9df 14454 fputs ("\n", stdout);
82b1b41b
NC		 14455
14456 offset += option->size;
252b5132 14457 ++option;
252b5132
RH		 14458 }
14459
a6e9f9df 14460 free (eopt);
252b5132 14461 }
252b5132
RH		 14462 }
14463
14464 if (conflicts_offset != 0 && conflictsno != 0)
14465 {
2cf0635d 14466 Elf32_Conflict * iconf;
252b5132
RH		 14467 size_t cnt;
14468
14469 if (dynamic_symbols == NULL)
14470 {
591a748a 14471 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 14472 return 0;
14473 }
14474
3f5e193b 14475 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 14476 if (iconf == NULL)
14477 {
8b73c356 14478 error (_("Out of memory allocating space for dynamic conflicts\n"));
252b5132
RH		 14479 return 0;
14480 }
14481
9ea033b2 14482 if (is_32bit_elf)
252b5132 14483 {
2cf0635d 14484 Elf32_External_Conflict * econf32;
a6e9f9df 14485
3f5e193b
NC		 14486 econf32 = (Elf32_External_Conflict *)
14487 get_data (NULL, file, conflicts_offset, conflictsno,
14488 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 14489 if (!econf32)
14490 return 0;
252b5132
RH		 14491
14492 for (cnt = 0; cnt < conflictsno; ++cnt)
14493 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 14494
14495 free (econf32);
252b5132
RH		 14496 }
14497 else
14498 {
2cf0635d 14499 Elf64_External_Conflict * econf64;
a6e9f9df 14500
3f5e193b
NC		 14501 econf64 = (Elf64_External_Conflict *)
14502 get_data (NULL, file, conflicts_offset, conflictsno,
14503 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 14504 if (!econf64)
14505 return 0;
252b5132
RH		 14506
14507 for (cnt = 0; cnt < conflictsno; ++cnt)
14508 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 14509
14510 free (econf64);
252b5132
RH		 14511 }
14512
c7e7ca54
NC		 14513 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14514 (unsigned long) conflictsno);
252b5132
RH		 14515 puts (_(" Num: Index Value Name"));
14516
14517 for (cnt = 0; cnt < conflictsno; ++cnt)
14518 {
b34976b6 14519 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 14520
14521 if (iconf[cnt] >= num_dynamic_syms)
14522 printf (_("<corrupt symbol index>"));
d79b3d50 14523 else
e0a31db1
NC		 14524 {
14525 Elf_Internal_Sym * psym;
14526
14527 psym = & dynamic_symbols[iconf[cnt]];
14528 print_vma (psym->st_value, FULL_HEX);
14529 putchar (' ');
14530 if (VALID_DYNAMIC_NAME (psym->st_name))
14531 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14532 else
14533 printf (_("<corrupt: %14ld>"), psym->st_name);
14534 }
31104126 14535 putchar ('\n');
252b5132
RH		 14536 }
14537
252b5132
RH		 14538 free (iconf);
14539 }
14540
ccb4c951
RS		 14541 if (pltgot != 0 && local_gotno != 0)
14542 {
91d6fa6a 14543 bfd_vma ent, local_end, global_end;
bbeee7ea 14544 size_t i, offset;
2cf0635d 14545 unsigned char * data;
82b1b41b 14546 unsigned char * data_end;
bbeee7ea 14547 int addr_size;
ccb4c951 14548
91d6fa6a 14549 ent = pltgot;
ccb4c951
RS		 14550 addr_size = (is_32bit_elf ? 4 : 8);
14551 local_end = pltgot + local_gotno * addr_size;
ccb4c951 14552
74e1a04b
NC		 14553 /* PR binutils/17533 file: 012-111227-0.004 */
14554 if (symtabno < gotsym)
14555 {
14556 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
82b1b41b 14557 (unsigned long) gotsym, (unsigned long) symtabno);
74e1a04b
NC		 14558 return 0;
14559 }
82b1b41b 14560
74e1a04b 14561 global_end = local_end + (symtabno - gotsym) * addr_size;
82b1b41b
NC		 14562 /* PR 17531: file: 54c91a34. */
14563 if (global_end < local_end)
14564 {
14565 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14566 return 0;
14567 }
948f632f 14568
ccb4c951 14569 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 14570 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 14571 global_end - pltgot, 1,
14572 _("Global Offset Table data"));
59245841
NC		 14573 if (data == NULL)
14574 return 0;
82b1b41b 14575 data_end = data + (global_end - pltgot);
59245841 14576
ccb4c951
RS		 14577 printf (_("\nPrimary GOT:\n"));
14578 printf (_(" Canonical gp value: "));
14579 print_vma (pltgot + 0x7ff0, LONG_HEX);
14580 printf ("\n\n");
14581
14582 printf (_(" Reserved entries:\n"));
14583 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 14584 addr_size * 2, _("Address"), _("Access"),
14585 addr_size * 2, _("Initial"));
82b1b41b 14586 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14587 printf (_(" Lazy resolver\n"));
82b1b41b
NC		 14588 if (ent == (bfd_vma) -1)
14589 goto got_print_fail;
ccb4c951 14590 if (data
91d6fa6a 14591 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 14592 >> (addr_size * 8 - 1)) != 0)
14593 {
82b1b41b 14594 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14595 printf (_(" Module pointer (GNU extension)\n"));
82b1b41b
NC		 14596 if (ent == (bfd_vma) -1)
14597 goto got_print_fail;
ccb4c951
RS		 14598 }
14599 printf ("\n");
14600
91d6fa6a 14601 if (ent < local_end)
ccb4c951
RS		 14602 {
14603 printf (_(" Local entries:\n"));
cc5914eb 14604 printf (" %*s %10s %*s\n",
2b692964
NC		 14605 addr_size * 2, _("Address"), _("Access"),
14606 addr_size * 2, _("Initial"));
91d6fa6a 14607 while (ent < local_end)
ccb4c951 14608 {
82b1b41b 14609 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14610 printf ("\n");
82b1b41b
NC		 14611 if (ent == (bfd_vma) -1)
14612 goto got_print_fail;
ccb4c951
RS		 14613 }
14614 printf ("\n");
14615 }
14616
14617 if (gotsym < symtabno)
14618 {
14619 int sym_width;
14620
14621 printf (_(" Global entries:\n"));
cc5914eb 14622 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 14623 addr_size * 2, _("Address"),
14624 _("Access"),
2b692964 14625 addr_size * 2, _("Initial"),
9cf03b7e
NC		 14626 addr_size * 2, _("Sym.Val."),
14627 _("Type"),
14628 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14629 _("Ndx"), _("Name"));
0b4362b0 14630
ccb4c951 14631 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 14632
ccb4c951
RS		 14633 for (i = gotsym; i < symtabno; i++)
14634 {
82b1b41b 14635 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14636 printf (" ");
e0a31db1
NC		 14637
14638 if (dynamic_symbols == NULL)
14639 printf (_("<no dynamic symbols>"));
14640 else if (i < num_dynamic_syms)
14641 {
14642 Elf_Internal_Sym * psym = dynamic_symbols + i;
14643
14644 print_vma (psym->st_value, LONG_HEX);
14645 printf (" %-7s %3s ",
14646 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14647 get_symbol_index_type (psym->st_shndx));
14648
14649 if (VALID_DYNAMIC_NAME (psym->st_name))
14650 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14651 else
14652 printf (_("<corrupt: %14ld>"), psym->st_name);
14653 }
ccb4c951 14654 else
7fc5ac57
JBG		 14655 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14656 (unsigned long) i);
e0a31db1 14657
ccb4c951 14658 printf ("\n");
82b1b41b
NC		 14659 if (ent == (bfd_vma) -1)
14660 break;
ccb4c951
RS		 14661 }
14662 printf ("\n");
14663 }
14664
82b1b41b 14665 got_print_fail:
ccb4c951
RS		 14666 if (data)
14667 free (data);
14668 }
14669
861fb55a
DJ		 14670 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14671 {
91d6fa6a 14672 bfd_vma ent, end;
861fb55a
DJ		 14673 size_t offset, rel_offset;
14674 unsigned long count, i;
2cf0635d 14675 unsigned char * data;
861fb55a 14676 int addr_size, sym_width;
2cf0635d 14677 Elf_Internal_Rela * rels;
861fb55a
DJ		 14678
14679 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14680 if (pltrel == DT_RELA)
14681 {
14682 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14683 return 0;
14684 }
14685 else
14686 {
14687 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14688 return 0;
14689 }
14690
91d6fa6a 14691 ent = mips_pltgot;
861fb55a
DJ		 14692 addr_size = (is_32bit_elf ? 4 : 8);
14693 end = mips_pltgot + (2 + count) * addr_size;
14694
14695 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 14696 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 14697 1, _("Procedure Linkage Table data"));
59245841
NC		 14698 if (data == NULL)
14699 return 0;
14700
9cf03b7e 14701 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 14702 printf (_(" Reserved entries:\n"));
14703 printf (_(" %*s %*s Purpose\n"),
2b692964 14704 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 14705 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14706 printf (_(" PLT lazy resolver\n"));
91d6fa6a 14707 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14708 printf (_(" Module pointer\n"));
861fb55a
DJ		 14709 printf ("\n");
14710
14711 printf (_(" Entries:\n"));
cc5914eb 14712 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 14713 addr_size * 2, _("Address"),
14714 addr_size * 2, _("Initial"),
14715 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 14716 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14717 for (i = 0; i < count; i++)
14718 {
df97ab2a 14719 unsigned long idx = get_reloc_symindex (rels[i].r_info);
861fb55a 14720
91d6fa6a 14721 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 14722 printf (" ");
e0a31db1 14723
df97ab2a
MF		 14724 if (idx >= num_dynamic_syms)
14725 printf (_("<corrupt symbol index: %lu>"), idx);
861fb55a 14726 else
e0a31db1 14727 {
df97ab2a 14728 Elf_Internal_Sym * psym = dynamic_symbols + idx;
e0a31db1
NC		 14729
14730 print_vma (psym->st_value, LONG_HEX);
14731 printf (" %-7s %3s ",
14732 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14733 get_symbol_index_type (psym->st_shndx));
14734 if (VALID_DYNAMIC_NAME (psym->st_name))
14735 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14736 else
14737 printf (_("<corrupt: %14ld>"), psym->st_name);
14738 }
861fb55a
DJ		 14739 printf ("\n");
14740 }
14741 printf ("\n");
14742
14743 if (data)
14744 free (data);
14745 free (rels);
14746 }
14747
252b5132
RH		 14748 return 1;
14749}
14750
35c08157
KLC		 14751static int
14752process_nds32_specific (FILE * file)
14753{
14754 Elf_Internal_Shdr *sect = NULL;
14755
14756 sect = find_section (".nds32_e_flags");
14757 if (sect != NULL)
14758 {
14759 unsigned int *flag;
14760
14761 printf ("\nNDS32 elf flags section:\n");
14762 flag = get_data (NULL, file, sect->sh_offset, 1,
14763 sect->sh_size, _("NDS32 elf flags section"));
14764
14765 switch ((*flag) & 0x3)
14766 {
14767 case 0:
14768 printf ("(VEC_SIZE):\tNo entry.\n");
14769 break;
14770 case 1:
14771 printf ("(VEC_SIZE):\t4 bytes\n");
14772 break;
14773 case 2:
14774 printf ("(VEC_SIZE):\t16 bytes\n");
14775 break;
14776 case 3:
14777 printf ("(VEC_SIZE):\treserved\n");
14778 break;
14779 }
14780 }
14781
14782 return TRUE;
14783}
14784
047b2264 14785static int
2cf0635d 14786process_gnu_liblist (FILE * file)
047b2264 14787{
2cf0635d
NC		 14788 Elf_Internal_Shdr * section;
14789 Elf_Internal_Shdr * string_sec;
14790 Elf32_External_Lib * elib;
14791 char * strtab;
c256ffe7 14792 size_t strtab_size;
047b2264
JJ		 14793 size_t cnt;
14794 unsigned i;
14795
14796 if (! do_arch)
14797 return 0;
14798
14799 for (i = 0, section = section_headers;
14800 i < elf_header.e_shnum;
b34976b6 14801 i++, section++)
047b2264
JJ		 14802 {
14803 switch (section->sh_type)
14804 {
14805 case SHT_GNU_LIBLIST:
4fbb74a6 14806 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 14807 break;
14808
3f5e193b
NC		 14809 elib = (Elf32_External_Lib *)
14810 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 14811 _("liblist section data"));
047b2264
JJ		 14812
14813 if (elib == NULL)
14814 break;
4fbb74a6 14815 string_sec = section_headers + section->sh_link;
047b2264 14816
3f5e193b
NC		 14817 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14818 string_sec->sh_size,
14819 _("liblist string table"));
047b2264
JJ		 14820 if (strtab == NULL
14821 || section->sh_entsize != sizeof (Elf32_External_Lib))
14822 {
14823 free (elib);
2842702f 14824 free (strtab);
047b2264
JJ		 14825 break;
14826 }
59245841 14827 strtab_size = string_sec->sh_size;
047b2264
JJ		 14828
14829 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
74e1a04b 14830 printable_section_name (section),
0af1713e 14831 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 14832
2b692964 14833 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 14834
14835 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14836 ++cnt)
14837 {
14838 Elf32_Lib liblist;
91d6fa6a 14839 time_t atime;
047b2264 14840 char timebuf[20];
2cf0635d 14841 struct tm * tmp;
047b2264
JJ		 14842
14843 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14844 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 14845 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14846 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14847 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14848
91d6fa6a 14849 tmp = gmtime (&atime);
e9e44622
JJ		 14850 snprintf (timebuf, sizeof (timebuf),
14851 "%04u-%02u-%02uT%02u:%02u:%02u",
14852 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14853 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 14854
14855 printf ("%3lu: ", (unsigned long) cnt);
14856 if (do_wide)
c256ffe7 14857 printf ("%-20s", liblist.l_name < strtab_size
2b692964 14858 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 14859 else
c256ffe7 14860 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 14861 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 14862 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14863 liblist.l_version, liblist.l_flags);
14864 }
14865
14866 free (elib);
2842702f 14867 free (strtab);
047b2264
JJ		 14868 }
14869 }
14870
14871 return 1;
14872}
14873
9437c45b 14874static const char *
d3ba0551 14875get_note_type (unsigned e_type)
779fe533
NC		 14876{
14877 static char buff[64];
103f02d3 14878
1ec5cd37
NC		 14879 if (elf_header.e_type == ET_CORE)
14880 switch (e_type)
14881 {
57346661 14882 case NT_AUXV:
1ec5cd37 14883 return _("NT_AUXV (auxiliary vector)");
57346661 14884 case NT_PRSTATUS:
1ec5cd37 14885 return _("NT_PRSTATUS (prstatus structure)");
57346661 14886 case NT_FPREGSET:
1ec5cd37 14887 return _("NT_FPREGSET (floating point registers)");
57346661 14888 case NT_PRPSINFO:
1ec5cd37 14889 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 14890 case NT_TASKSTRUCT:
1ec5cd37 14891 return _("NT_TASKSTRUCT (task structure)");
57346661 14892 case NT_PRXFPREG:
1ec5cd37 14893 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 14894 case NT_PPC_VMX:
14895 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 14896 case NT_PPC_VSX:
14897 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 14898 case NT_386_TLS:
14899 return _("NT_386_TLS (x86 TLS information)");
14900 case NT_386_IOPERM:
14901 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 14902 case NT_X86_XSTATE:
14903 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 14904 case NT_S390_HIGH_GPRS:
14905 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 14906 case NT_S390_TIMER:
14907 return _("NT_S390_TIMER (s390 timer register)");
14908 case NT_S390_TODCMP:
14909 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14910 case NT_S390_TODPREG:
14911 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14912 case NT_S390_CTRS:
14913 return _("NT_S390_CTRS (s390 control registers)");
14914 case NT_S390_PREFIX:
14915 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 14916 case NT_S390_LAST_BREAK:
14917 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14918 case NT_S390_SYSTEM_CALL:
14919 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 14920 case NT_S390_TDB:
14921 return _("NT_S390_TDB (s390 transaction diagnostic block)");
4ef9f41a
AA		 14922 case NT_S390_VXRS_LOW:
14923 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
14924 case NT_S390_VXRS_HIGH:
14925 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
faa9a424
UW		 14926 case NT_ARM_VFP:
14927 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 14928 case NT_ARM_TLS:
14929 return _("NT_ARM_TLS (AArch TLS registers)");
14930 case NT_ARM_HW_BREAK:
14931 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14932 case NT_ARM_HW_WATCH:
14933 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 14934 case NT_PSTATUS:
1ec5cd37 14935 return _("NT_PSTATUS (pstatus structure)");
57346661 14936 case NT_FPREGS:
1ec5cd37 14937 return _("NT_FPREGS (floating point registers)");
57346661 14938 case NT_PSINFO:
1ec5cd37 14939 return _("NT_PSINFO (psinfo structure)");
57346661 14940 case NT_LWPSTATUS:
1ec5cd37 14941 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 14942 case NT_LWPSINFO:
1ec5cd37 14943 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 14944 case NT_WIN32PSTATUS:
1ec5cd37 14945 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 14946 case NT_SIGINFO:
14947 return _("NT_SIGINFO (siginfo_t data)");
14948 case NT_FILE:
14949 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 14950 default:
14951 break;
14952 }
14953 else
14954 switch (e_type)
14955 {
14956 case NT_VERSION:
14957 return _("NT_VERSION (version)");
14958 case NT_ARCH:
14959 return _("NT_ARCH (architecture)");
14960 default:
14961 break;
14962 }
14963
e9e44622 14964 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 14965 return buff;
779fe533
NC		 14966}
14967
9ece1fa9
TT		 14968static int
14969print_core_note (Elf_Internal_Note *pnote)
14970{
14971 unsigned int addr_size = is_32bit_elf ? 4 : 8;
14972 bfd_vma count, page_size;
14973 unsigned char *descdata, *filenames, *descend;
14974
14975 if (pnote->type != NT_FILE)
14976 return 1;
14977
14978#ifndef BFD64
14979 if (!is_32bit_elf)
14980 {
14981 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
14982 /* Still "successful". */
14983 return 1;
14984 }
14985#endif
14986
14987 if (pnote->descsz < 2 * addr_size)
14988 {
14989 printf (_(" Malformed note - too short for header\n"));
14990 return 0;
14991 }
14992
14993 descdata = (unsigned char *) pnote->descdata;
14994 descend = descdata + pnote->descsz;
14995
14996 if (descdata[pnote->descsz - 1] != '\0')
14997 {
14998 printf (_(" Malformed note - does not end with \\0\n"));
14999 return 0;
15000 }
15001
15002 count = byte_get (descdata, addr_size);
15003 descdata += addr_size;
15004
15005 page_size = byte_get (descdata, addr_size);
15006 descdata += addr_size;
15007
15008 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
15009 {
15010 printf (_(" Malformed note - too short for supplied file count\n"));
15011 return 0;
15012 }
15013
15014 printf (_(" Page size: "));
15015 print_vma (page_size, DEC);
15016 printf ("\n");
15017
15018 printf (_(" %*s%*s%*s\n"),
15019 (int) (2 + 2 * addr_size), _("Start"),
15020 (int) (4 + 2 * addr_size), _("End"),
15021 (int) (4 + 2 * addr_size), _("Page Offset"));
15022 filenames = descdata + count * 3 * addr_size;
15023 while (--count > 0)
15024 {
15025 bfd_vma start, end, file_ofs;
15026
15027 if (filenames == descend)
15028 {
15029 printf (_(" Malformed note - filenames end too early\n"));
15030 return 0;
15031 }
15032
15033 start = byte_get (descdata, addr_size);
15034 descdata += addr_size;
15035 end = byte_get (descdata, addr_size);
15036 descdata += addr_size;
15037 file_ofs = byte_get (descdata, addr_size);
15038 descdata += addr_size;
15039
15040 printf (" ");
15041 print_vma (start, FULL_HEX);
15042 printf (" ");
15043 print_vma (end, FULL_HEX);
15044 printf (" ");
15045 print_vma (file_ofs, FULL_HEX);
15046 printf ("\n %s\n", filenames);
15047
15048 filenames += 1 + strlen ((char *) filenames);
15049 }
15050
15051 return 1;
15052}
15053
1118d252
RM		 15054static const char *
15055get_gnu_elf_note_type (unsigned e_type)
15056{
15057 static char buff[64];
15058
15059 switch (e_type)
15060 {
15061 case NT_GNU_ABI_TAG:
15062 return _("NT_GNU_ABI_TAG (ABI version tag)");
15063 case NT_GNU_HWCAP:
15064 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15065 case NT_GNU_BUILD_ID:
15066 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 15067 case NT_GNU_GOLD_VERSION:
15068 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 15069 default:
15070 break;
15071 }
15072
15073 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15074 return buff;
15075}
15076
664f90a3
TT		 15077static int
15078print_gnu_note (Elf_Internal_Note *pnote)
15079{
15080 switch (pnote->type)
15081 {
15082 case NT_GNU_BUILD_ID:
15083 {
15084 unsigned long i;
15085
15086 printf (_(" Build ID: "));
15087 for (i = 0; i < pnote->descsz; ++i)
15088 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 15089 printf ("\n");
664f90a3
TT		 15090 }
15091 break;
15092
15093 case NT_GNU_ABI_TAG:
15094 {
15095 unsigned long os, major, minor, subminor;
15096 const char *osname;
15097
3102e897
NC		 15098 /* PR 17531: file: 030-599401-0.004. */
15099 if (pnote->descsz < 16)
15100 {
15101 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15102 break;
15103 }
15104
664f90a3
TT		 15105 os = byte_get ((unsigned char *) pnote->descdata, 4);
15106 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15107 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
15108 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
15109
15110 switch (os)
15111 {
15112 case GNU_ABI_TAG_LINUX:
15113 osname = "Linux";
15114 break;
15115 case GNU_ABI_TAG_HURD:
15116 osname = "Hurd";
15117 break;
15118 case GNU_ABI_TAG_SOLARIS:
15119 osname = "Solaris";
15120 break;
15121 case GNU_ABI_TAG_FREEBSD:
15122 osname = "FreeBSD";
15123 break;
15124 case GNU_ABI_TAG_NETBSD:
15125 osname = "NetBSD";
15126 break;
15127 default:
15128 osname = "Unknown";
15129 break;
15130 }
15131
15132 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
15133 major, minor, subminor);
15134 }
15135 break;
926c5385
CC		 15136
15137 case NT_GNU_GOLD_VERSION:
15138 {
15139 unsigned long i;
15140
15141 printf (_(" Version: "));
15142 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
15143 printf ("%c", pnote->descdata[i]);
15144 printf ("\n");
15145 }
15146 break;
664f90a3
TT		 15147 }
15148
15149 return 1;
15150}
15151
685080f2
NC		 15152static const char *
15153get_v850_elf_note_type (enum v850_notes n_type)
15154{
15155 static char buff[64];
15156
15157 switch (n_type)
15158 {
15159 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
15160 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
15161 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
15162 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
15163 case V850_NOTE_CACHE_INFO: return _("Use of cache");
15164 case V850_NOTE_MMU_INFO: return _("Use of MMU");
15165 default:
15166 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
15167 return buff;
15168 }
15169}
15170
15171static int
15172print_v850_note (Elf_Internal_Note * pnote)
15173{
15174 unsigned int val;
15175
15176 if (pnote->descsz != 4)
15177 return 0;
15178 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
15179
15180 if (val == 0)
15181 {
15182 printf (_("not set\n"));
15183 return 1;
15184 }
15185
15186 switch (pnote->type)
15187 {
15188 case V850_NOTE_ALIGNMENT:
15189 switch (val)
15190 {
15191 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
15192 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
15193 }
15194 break;
15195
15196 case V850_NOTE_DATA_SIZE:
15197 switch (val)
15198 {
15199 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
15200 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
15201 }
15202 break;
15203
15204 case V850_NOTE_FPU_INFO:
15205 switch (val)
15206 {
15207 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
15208 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
15209 }
15210 break;
15211
15212 case V850_NOTE_MMU_INFO:
15213 case V850_NOTE_CACHE_INFO:
15214 case V850_NOTE_SIMD_INFO:
15215 if (val == EF_RH850_SIMD)
15216 {
15217 printf (_("yes\n"));
15218 return 1;
15219 }
15220 break;
15221
15222 default:
15223 /* An 'unknown note type' message will already have been displayed. */
15224 break;
15225 }
15226
15227 printf (_("unknown value: %x\n"), val);
15228 return 0;
15229}
15230
9437c45b 15231static const char *
d3ba0551 15232get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 15233{
15234 static char buff[64];
15235
b4db1224 15236 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 15237 {
15238 /* NetBSD core "procinfo" structure. */
15239 return _("NetBSD procinfo structure");
15240 }
15241
15242 /* As of Jan 2002 there are no other machine-independent notes
15243 defined for NetBSD core files. If the note type is less
15244 than the start of the machine-dependent note types, we don't
15245 understand it. */
15246
b4db1224 15247 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 15248 {
e9e44622 15249 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 15250 return buff;
15251 }
15252
15253 switch (elf_header.e_machine)
15254 {
15255 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15256 and PT_GETFPREGS == mach+2. */
15257
15258 case EM_OLD_ALPHA:
15259 case EM_ALPHA:
15260 case EM_SPARC:
15261 case EM_SPARC32PLUS:
15262 case EM_SPARCV9:
15263 switch (e_type)
15264 {
2b692964 15265 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 15266 return _("PT_GETREGS (reg structure)");
2b692964 15267 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 15268 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15269 default:
15270 break;
15271 }
15272 break;
15273
15274 /* On all other arch's, PT_GETREGS == mach+1 and
15275 PT_GETFPREGS == mach+3. */
15276 default:
15277 switch (e_type)
15278 {
2b692964 15279 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 15280 return _("PT_GETREGS (reg structure)");
2b692964 15281 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 15282 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15283 default:
15284 break;
15285 }
15286 }
15287
9cf03b7e 15288 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 15289 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 15290 return buff;
15291}
15292
70616151
TT		 15293static const char *
15294get_stapsdt_note_type (unsigned e_type)
15295{
15296 static char buff[64];
15297
15298 switch (e_type)
15299 {
15300 case NT_STAPSDT:
15301 return _("NT_STAPSDT (SystemTap probe descriptors)");
15302
15303 default:
15304 break;
15305 }
15306
15307 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15308 return buff;
15309}
15310
c6a9fc58
TT		 15311static int
15312print_stapsdt_note (Elf_Internal_Note *pnote)
15313{
15314 int addr_size = is_32bit_elf ? 4 : 8;
15315 char *data = pnote->descdata;
15316 char *data_end = pnote->descdata + pnote->descsz;
15317 bfd_vma pc, base_addr, semaphore;
15318 char *provider, *probe, *arg_fmt;
15319
15320 pc = byte_get ((unsigned char *) data, addr_size);
15321 data += addr_size;
15322 base_addr = byte_get ((unsigned char *) data, addr_size);
15323 data += addr_size;
15324 semaphore = byte_get ((unsigned char *) data, addr_size);
15325 data += addr_size;
15326
15327 provider = data;
15328 data += strlen (data) + 1;
15329 probe = data;
15330 data += strlen (data) + 1;
15331 arg_fmt = data;
15332 data += strlen (data) + 1;
15333
15334 printf (_(" Provider: %s\n"), provider);
15335 printf (_(" Name: %s\n"), probe);
15336 printf (_(" Location: "));
15337 print_vma (pc, FULL_HEX);
15338 printf (_(", Base: "));
15339 print_vma (base_addr, FULL_HEX);
15340 printf (_(", Semaphore: "));
15341 print_vma (semaphore, FULL_HEX);
9cf03b7e 15342 printf ("\n");
c6a9fc58
TT		 15343 printf (_(" Arguments: %s\n"), arg_fmt);
15344
15345 return data == data_end;
15346}
15347
00e98fc7
TG		 15348static const char *
15349get_ia64_vms_note_type (unsigned e_type)
15350{
15351 static char buff[64];
15352
15353 switch (e_type)
15354 {
15355 case NT_VMS_MHD:
15356 return _("NT_VMS_MHD (module header)");
15357 case NT_VMS_LNM:
15358 return _("NT_VMS_LNM (language name)");
15359 case NT_VMS_SRC:
15360 return _("NT_VMS_SRC (source files)");
15361 case NT_VMS_TITLE:
9cf03b7e 15362 return "NT_VMS_TITLE";
00e98fc7
TG		 15363 case NT_VMS_EIDC:
15364 return _("NT_VMS_EIDC (consistency check)");
15365 case NT_VMS_FPMODE:
15366 return _("NT_VMS_FPMODE (FP mode)");
15367 case NT_VMS_LINKTIME:
9cf03b7e 15368 return "NT_VMS_LINKTIME";
00e98fc7
TG		 15369 case NT_VMS_IMGNAM:
15370 return _("NT_VMS_IMGNAM (image name)");
15371 case NT_VMS_IMGID:
15372 return _("NT_VMS_IMGID (image id)");
15373 case NT_VMS_LINKID:
15374 return _("NT_VMS_LINKID (link id)");
15375 case NT_VMS_IMGBID:
15376 return _("NT_VMS_IMGBID (build id)");
15377 case NT_VMS_GSTNAM:
15378 return _("NT_VMS_GSTNAM (sym table name)");
15379 case NT_VMS_ORIG_DYN:
9cf03b7e 15380 return "NT_VMS_ORIG_DYN";
00e98fc7 15381 case NT_VMS_PATCHTIME:
9cf03b7e 15382 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 15383 default:
15384 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15385 return buff;
15386 }
15387}
15388
15389static int
15390print_ia64_vms_note (Elf_Internal_Note * pnote)
15391{
15392 switch (pnote->type)
15393 {
15394 case NT_VMS_MHD:
15395 if (pnote->descsz > 36)
15396 {
15397 size_t l = strlen (pnote->descdata + 34);
15398 printf (_(" Creation date : %.17s\n"), pnote->descdata);
15399 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
15400 printf (_(" Module name : %s\n"), pnote->descdata + 34);
15401 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
15402 }
15403 else
15404 printf (_(" Invalid size\n"));
15405 break;
15406 case NT_VMS_LNM:
15407 printf (_(" Language: %s\n"), pnote->descdata);
15408 break;
15409#ifdef BFD64
15410 case NT_VMS_FPMODE:
9cf03b7e 15411 printf (_(" Floating Point mode: "));
4a5cb34f 15412 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15413 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
00e98fc7
TG		 15414 break;
15415 case NT_VMS_LINKTIME:
15416 printf (_(" Link time: "));
15417 print_vms_time
15418 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15419 printf ("\n");
15420 break;
15421 case NT_VMS_PATCHTIME:
15422 printf (_(" Patch time: "));
15423 print_vms_time
15424 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15425 printf ("\n");
15426 break;
15427 case NT_VMS_ORIG_DYN:
15428 printf (_(" Major id: %u, minor id: %u\n"),
15429 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15430 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 15431 printf (_(" Last modified : "));
00e98fc7
TG		 15432 print_vms_time
15433 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 15434 printf (_("\n Link flags : "));
4a5cb34f 15435 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15436 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
00e98fc7 15437 printf (_(" Header flags: 0x%08x\n"),
948f632f 15438 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
00e98fc7
TG		 15439 printf (_(" Image id : %s\n"), pnote->descdata + 32);
15440 break;
15441#endif
15442 case NT_VMS_IMGNAM:
15443 printf (_(" Image name: %s\n"), pnote->descdata);
15444 break;
15445 case NT_VMS_GSTNAM:
15446 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
15447 break;
15448 case NT_VMS_IMGID:
15449 printf (_(" Image id: %s\n"), pnote->descdata);
15450 break;
15451 case NT_VMS_LINKID:
15452 printf (_(" Linker id: %s\n"), pnote->descdata);
15453 break;
15454 default:
15455 break;
15456 }
15457 return 1;
15458}
15459
6d118b09
NC		 15460/* Note that by the ELF standard, the name field is already null byte
15461 terminated, and namesz includes the terminating null byte.
15462 I.E. the value of namesz for the name "FSF" is 4.
15463
e3c8793a 15464 If the value of namesz is zero, there is no name present. */
779fe533 15465static int
2cf0635d 15466process_note (Elf_Internal_Note * pnote)
779fe533 15467{
2cf0635d
NC		 15468 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15469 const char * nt;
9437c45b
JT		 15470
15471 if (pnote->namesz == 0)
1ec5cd37
NC		 15472 /* If there is no note name, then use the default set of
15473 note type strings. */
15474 nt = get_note_type (pnote->type);
15475
1118d252
RM		 15476 else if (const_strneq (pnote->namedata, "GNU"))
15477 /* GNU-specific object file notes. */
15478 nt = get_gnu_elf_note_type (pnote->type);
15479
0112cd26 15480 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 15481 /* NetBSD-specific core file notes. */
15482 nt = get_netbsd_elfcore_note_type (pnote->type);
15483
b15fa79e
AM		 15484 else if (strneq (pnote->namedata, "SPU/", 4))
15485 {
15486 /* SPU-specific core file notes. */
15487 nt = pnote->namedata + 4;
15488 name = "SPU";
15489 }
15490
00e98fc7
TG		 15491 else if (const_strneq (pnote->namedata, "IPF/VMS"))
15492 /* VMS/ia64-specific file notes. */
15493 nt = get_ia64_vms_note_type (pnote->type);
15494
70616151
TT		 15495 else if (const_strneq (pnote->namedata, "stapsdt"))
15496 nt = get_stapsdt_note_type (pnote->type);
15497
9437c45b 15498 else
1ec5cd37
NC		 15499 /* Don't recognize this note name; just use the default set of
15500 note type strings. */
00e98fc7 15501 nt = get_note_type (pnote->type);
9437c45b 15502
2aee03ae 15503 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 15504
15505 if (const_strneq (pnote->namedata, "IPF/VMS"))
15506 return print_ia64_vms_note (pnote);
664f90a3
TT		 15507 else if (const_strneq (pnote->namedata, "GNU"))
15508 return print_gnu_note (pnote);
c6a9fc58
TT		 15509 else if (const_strneq (pnote->namedata, "stapsdt"))
15510 return print_stapsdt_note (pnote);
9ece1fa9
TT		 15511 else if (const_strneq (pnote->namedata, "CORE"))
15512 return print_core_note (pnote);
00e98fc7
TG		 15513 else
15514 return 1;
779fe533
NC		 15515}
15516
6d118b09 15517
779fe533 15518static int
2cf0635d 15519process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 15520{
2cf0635d
NC		 15521 Elf_External_Note * pnotes;
15522 Elf_External_Note * external;
c8071705 15523 char * end;
b34976b6 15524 int res = 1;
103f02d3 15525
779fe533
NC		 15526 if (length <= 0)
15527 return 0;
103f02d3 15528
3f5e193b 15529 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 15530 _("notes"));
dd24e3da 15531 if (pnotes == NULL)
a6e9f9df 15532 return 0;
779fe533 15533
103f02d3 15534 external = pnotes;
103f02d3 15535
9dd3a467 15536 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 15537 (unsigned long) offset, (unsigned long) length);
2aee03ae 15538 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 15539
c8071705
NC		 15540 end = (char *) pnotes + length;
15541 while ((char *) external < end)
779fe533 15542 {
b34976b6 15543 Elf_Internal_Note inote;
15b42fb0
AM		 15544 size_t min_notesz;
15545 char *next;
2cf0635d 15546 char * temp = NULL;
c8071705 15547 size_t data_remaining = end - (char *) external;
6d118b09 15548
00e98fc7 15549 if (!is_ia64_vms ())
15b42fb0 15550 {
9dd3a467
NC		 15551 /* PR binutils/15191
15552 Make sure that there is enough data to read. */
15b42fb0
AM		 15553 min_notesz = offsetof (Elf_External_Note, name);
15554 if (data_remaining < min_notesz)
9dd3a467
NC		 15555 {
15556 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15557 (int) data_remaining);
15558 break;
15559 }
15b42fb0
AM		 15560 inote.type = BYTE_GET (external->type);
15561 inote.namesz = BYTE_GET (external->namesz);
15562 inote.namedata = external->name;
15563 inote.descsz = BYTE_GET (external->descsz);
15564 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
834f871c 15565 /* PR 17531: file: 3443835e. */
c8071705 15566 if (inote.descdata < (char *) pnotes || inote.descdata > end)
834f871c
NC		 15567 {
15568 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15569 inote.descdata = inote.namedata;
15570 inote.namesz = 0;
15571 }
c8071705 15572
15b42fb0
AM		 15573 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15574 next = inote.descdata + align_power (inote.descsz, 2);
15575 }
00e98fc7 15576 else
15b42fb0
AM		 15577 {
15578 Elf64_External_VMS_Note *vms_external;
00e98fc7 15579
9dd3a467
NC		 15580 /* PR binutils/15191
15581 Make sure that there is enough data to read. */
15b42fb0
AM		 15582 min_notesz = offsetof (Elf64_External_VMS_Note, name);
15583 if (data_remaining < min_notesz)
9dd3a467
NC		 15584 {
15585 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15586 (int) data_remaining);
15587 break;
15588 }
3e55a963 15589
15b42fb0
AM		 15590 vms_external = (Elf64_External_VMS_Note *) external;
15591 inote.type = BYTE_GET (vms_external->type);
15592 inote.namesz = BYTE_GET (vms_external->namesz);
15593 inote.namedata = vms_external->name;
15594 inote.descsz = BYTE_GET (vms_external->descsz);
15595 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15596 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15597 next = inote.descdata + align_power (inote.descsz, 3);
15598 }
15599
15600 if (inote.descdata < (char *) external + min_notesz
15601 || next < (char *) external + min_notesz
5d921cbd
NC		 15602 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15603 || inote.namedata + inote.namesz < inote.namedata
15604 || inote.descdata + inote.descsz < inote.descdata
15b42fb0 15605 || data_remaining < (size_t)(next - (char *) external))
3e55a963 15606 {
15b42fb0 15607 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 15608 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 15609 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 15610 inote.type, inote.namesz, inote.descsz);
15611 break;
15612 }
15613
15b42fb0 15614 external = (Elf_External_Note *) next;
dd24e3da 15615
6d118b09
NC		 15616 /* Verify that name is null terminated. It appears that at least
15617 one version of Linux (RedHat 6.0) generates corefiles that don't
15618 comply with the ELF spec by failing to include the null byte in
15619 namesz. */
8b971f9f 15620 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 15621 {
3f5e193b 15622 temp = (char *) malloc (inote.namesz + 1);
6d118b09
NC		 15623 if (temp == NULL)
15624 {
8b73c356 15625 error (_("Out of memory allocating space for inote name\n"));
6d118b09
NC		 15626 res = 0;
15627 break;
15628 }
76da6bbe 15629
6d118b09
NC		 15630 strncpy (temp, inote.namedata, inote.namesz);
15631 temp[inote.namesz] = 0;
76da6bbe 15632
6d118b09
NC		 15633 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15634 inote.namedata = temp;
15635 }
15636
15637 res &= process_note (& inote);
103f02d3 15638
6d118b09
NC		 15639 if (temp != NULL)
15640 {
15641 free (temp);
15642 temp = NULL;
15643 }
779fe533
NC		 15644 }
15645
15646 free (pnotes);
103f02d3 15647
779fe533
NC		 15648 return res;
15649}
15650
15651static int
2cf0635d 15652process_corefile_note_segments (FILE * file)
779fe533 15653{
2cf0635d 15654 Elf_Internal_Phdr * segment;
b34976b6
AM		 15655 unsigned int i;
15656 int res = 1;
103f02d3 15657
d93f0186 15658 if (! get_program_headers (file))
779fe533 15659 return 0;
103f02d3 15660
779fe533
NC		 15661 for (i = 0, segment = program_headers;
15662 i < elf_header.e_phnum;
b34976b6 15663 i++, segment++)
779fe533
NC		 15664 {
15665 if (segment->p_type == PT_NOTE)
103f02d3 15666 res &= process_corefile_note_segment (file,
30800947
NC		 15667 (bfd_vma) segment->p_offset,
15668 (bfd_vma) segment->p_filesz);
779fe533 15669 }
103f02d3 15670
779fe533
NC		 15671 return res;
15672}
15673
685080f2
NC		 15674static int
15675process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
15676{
15677 Elf_External_Note * pnotes;
15678 Elf_External_Note * external;
c8071705 15679 char * end;
685080f2
NC		 15680 int res = 1;
15681
15682 if (length <= 0)
15683 return 0;
15684
15685 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15686 _("v850 notes"));
15687 if (pnotes == NULL)
15688 return 0;
15689
15690 external = pnotes;
c8071705 15691 end = (char*) pnotes + length;
685080f2
NC		 15692
15693 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15694 (unsigned long) offset, (unsigned long) length);
15695
c8071705 15696 while ((char *) external + sizeof (Elf_External_Note) < end)
685080f2
NC		 15697 {
15698 Elf_External_Note * next;
15699 Elf_Internal_Note inote;
15700
15701 inote.type = BYTE_GET (external->type);
15702 inote.namesz = BYTE_GET (external->namesz);
15703 inote.namedata = external->name;
15704 inote.descsz = BYTE_GET (external->descsz);
15705 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15706 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15707
c8071705
NC		 15708 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
15709 {
15710 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15711 inote.descdata = inote.namedata;
15712 inote.namesz = 0;
15713 }
15714
685080f2
NC		 15715 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
15716
c8071705 15717 if ( ((char *) next > end)
685080f2
NC		 15718 || ((char *) next < (char *) pnotes))
15719 {
15720 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15721 (unsigned long) ((char *) external - (char *) pnotes));
15722 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15723 inote.type, inote.namesz, inote.descsz);
15724 break;
15725 }
15726
15727 external = next;
15728
15729 /* Prevent out-of-bounds indexing. */
c8071705 15730 if ( inote.namedata + inote.namesz > end
685080f2
NC		 15731 || inote.namedata + inote.namesz < inote.namedata)
15732 {
15733 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15734 (unsigned long) ((char *) external - (char *) pnotes));
15735 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15736 inote.type, inote.namesz, inote.descsz);
15737 break;
15738 }
15739
15740 printf (" %s: ", get_v850_elf_note_type (inote.type));
15741
15742 if (! print_v850_note (& inote))
15743 {
15744 res = 0;
15745 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15746 inote.namesz, inote.descsz);
15747 }
15748 }
15749
15750 free (pnotes);
15751
15752 return res;
15753}
15754
779fe533 15755static int
2cf0635d 15756process_note_sections (FILE * file)
1ec5cd37 15757{
2cf0635d 15758 Elf_Internal_Shdr * section;
1ec5cd37 15759 unsigned long i;
df565f32 15760 int n = 0;
1ec5cd37
NC		 15761 int res = 1;
15762
15763 for (i = 0, section = section_headers;
fa1908fd 15764 i < elf_header.e_shnum && section != NULL;
1ec5cd37 15765 i++, section++)
685080f2
NC		 15766 {
15767 if (section->sh_type == SHT_NOTE)
15768 {
15769 res &= process_corefile_note_segment (file,
15770 (bfd_vma) section->sh_offset,
15771 (bfd_vma) section->sh_size);
15772 n++;
15773 }
15774
15775 if (( elf_header.e_machine == EM_V800
15776 || elf_header.e_machine == EM_V850
15777 || elf_header.e_machine == EM_CYGNUS_V850)
15778 && section->sh_type == SHT_RENESAS_INFO)
15779 {
15780 res &= process_v850_notes (file,
15781 (bfd_vma) section->sh_offset,
15782 (bfd_vma) section->sh_size);
15783 n++;
15784 }
15785 }
df565f32
NC		 15786
15787 if (n == 0)
15788 /* Try processing NOTE segments instead. */
15789 return process_corefile_note_segments (file);
1ec5cd37
NC		 15790
15791 return res;
15792}
15793
15794static int
2cf0635d 15795process_notes (FILE * file)
779fe533
NC		 15796{
15797 /* If we have not been asked to display the notes then do nothing. */
15798 if (! do_notes)
15799 return 1;
103f02d3 15800
779fe533 15801 if (elf_header.e_type != ET_CORE)
1ec5cd37 15802 return process_note_sections (file);
103f02d3 15803
779fe533 15804 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 15805 if (elf_header.e_phnum > 0)
15806 return process_corefile_note_segments (file);
779fe533 15807
1ec5cd37
NC		 15808 printf (_("No note segments present in the core file.\n"));
15809 return 1;
779fe533
NC		 15810}
15811
252b5132 15812static int
2cf0635d 15813process_arch_specific (FILE * file)
252b5132 15814{
a952a375
NC		 15815 if (! do_arch)
15816 return 1;
15817
252b5132
RH		 15818 switch (elf_header.e_machine)
15819 {
11c1ff18
PB		 15820 case EM_ARM:
15821 return process_arm_specific (file);
252b5132 15822 case EM_MIPS:
4fe85591 15823 case EM_MIPS_RS3_LE:
252b5132
RH		 15824 return process_mips_specific (file);
15825 break;
35c08157
KLC		 15826 case EM_NDS32:
15827 return process_nds32_specific (file);
15828 break;
34c8bcba
JM		 15829 case EM_PPC:
15830 return process_power_specific (file);
15831 break;
643f7afb
AK		 15832 case EM_S390:
15833 case EM_S390_OLD:
15834 return process_s390_specific (file);
15835 break;
9e8c70f9
DM		 15836 case EM_SPARC:
15837 case EM_SPARC32PLUS:
15838 case EM_SPARCV9:
15839 return process_sparc_specific (file);
15840 break;
59e6276b
JM		 15841 case EM_TI_C6000:
15842 return process_tic6x_specific (file);
15843 break;
13761a11
NC		 15844 case EM_MSP430:
15845 return process_msp430x_specific (file);
252b5132
RH		 15846 default:
15847 break;
15848 }
15849 return 1;
15850}
15851
15852static int
2cf0635d 15853get_file_header (FILE * file)
252b5132 15854{
9ea033b2
NC		 15855 /* Read in the identity array. */
15856 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 15857 return 0;
15858
9ea033b2 15859 /* Determine how to read the rest of the header. */
b34976b6 15860 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 15861 {
15862 default: /* fall through */
15863 case ELFDATANONE: /* fall through */
adab8cdc
AO		 15864 case ELFDATA2LSB:
15865 byte_get = byte_get_little_endian;
15866 byte_put = byte_put_little_endian;
15867 break;
15868 case ELFDATA2MSB:
15869 byte_get = byte_get_big_endian;
15870 byte_put = byte_put_big_endian;
15871 break;
9ea033b2
NC		 15872 }
15873
15874 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 15875 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 15876
15877 /* Read in the rest of the header. */
15878 if (is_32bit_elf)
15879 {
15880 Elf32_External_Ehdr ehdr32;
252b5132 15881
9ea033b2
NC		 15882 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
15883 return 0;
103f02d3 15884
9ea033b2
NC		 15885 elf_header.e_type = BYTE_GET (ehdr32.e_type);
15886 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
15887 elf_header.e_version = BYTE_GET (ehdr32.e_version);
15888 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
15889 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
15890 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
15891 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
15892 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
15893 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
15894 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
15895 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
15896 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
15897 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
15898 }
252b5132 15899 else
9ea033b2
NC		 15900 {
15901 Elf64_External_Ehdr ehdr64;
a952a375
NC		 15902
15903 /* If we have been compiled with sizeof (bfd_vma) == 4, then
15904 we will not be able to cope with the 64bit data found in
15905 64 ELF files. Detect this now and abort before we start
50c2245b 15906 overwriting things. */
a952a375
NC		 15907 if (sizeof (bfd_vma) < 8)
15908 {
e3c8793a
NC		 15909 error (_("This instance of readelf has been built without support for a\n\
1591064 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 15911 return 0;
15912 }
103f02d3 15913
9ea033b2
NC		 15914 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
15915 return 0;
103f02d3 15916
9ea033b2
NC		 15917 elf_header.e_type = BYTE_GET (ehdr64.e_type);
15918 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
15919 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 15920 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
15921 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
15922 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 15923 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
15924 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
15925 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
15926 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
15927 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
15928 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
15929 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
15930 }
252b5132 15931
7ece0d85
JJ		 15932 if (elf_header.e_shoff)
15933 {
15934 /* There may be some extensions in the first section header. Don't
15935 bomb if we can't read it. */
15936 if (is_32bit_elf)
049b0c3a 15937 get_32bit_section_headers (file, TRUE);
7ece0d85 15938 else
049b0c3a 15939 get_64bit_section_headers (file, TRUE);
7ece0d85 15940 }
560f3c1c 15941
252b5132
RH		 15942 return 1;
15943}
15944
fb52b2f4
NC		 15945/* Process one ELF object file according to the command line options.
15946 This file may actually be stored in an archive. The file is
15947 positioned at the start of the ELF object. */
15948
ff78d6d6 15949static int
2cf0635d 15950process_object (char * file_name, FILE * file)
252b5132 15951{
252b5132
RH		 15952 unsigned int i;
15953
252b5132
RH		 15954 if (! get_file_header (file))
15955 {
15956 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 15957 return 1;
252b5132
RH		 15958 }
15959
15960 /* Initialise per file variables. */
60bca95a 15961 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 15962 version_info[i] = 0;
15963
60bca95a 15964 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 15965 dynamic_info[i] = 0;
5115b233 15966 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 15967
15968 /* Process the file. */
15969 if (show_name)
15970 printf (_("\nFile: %s\n"), file_name);
15971
18bd398b
NC		 15972 /* Initialise the dump_sects array from the cmdline_dump_sects array.
15973 Note we do this even if cmdline_dump_sects is empty because we
15974 must make sure that the dump_sets array is zeroed out before each
15975 object file is processed. */
15976 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 15977 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 15978
15979 if (num_cmdline_dump_sects > 0)
15980 {
15981 if (num_dump_sects == 0)
15982 /* A sneaky way of allocating the dump_sects array. */
09c11c86 15983 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 15984
15985 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 15986 memcpy (dump_sects, cmdline_dump_sects,
15987 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 15988 }
d70c5fc7 15989
252b5132 15990 if (! process_file_header ())
fb52b2f4 15991 return 1;
252b5132 15992
d1f5c6e3 15993 if (! process_section_headers (file))
2f62977e 15994 {
d1f5c6e3
L		 15995 /* Without loaded section headers we cannot process lots of
15996 things. */
2f62977e 15997 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 15998
2f62977e 15999 if (! do_using_dynamic)
2c610e4b 16000 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 16001 }
252b5132 16002
d1f5c6e3
L		 16003 if (! process_section_groups (file))
16004 {
16005 /* Without loaded section groups we cannot process unwind. */
16006 do_unwind = 0;
16007 }
16008
2f62977e 16009 if (process_program_headers (file))
b2d38a17 16010 process_dynamic_section (file);
252b5132
RH		 16011
16012 process_relocs (file);
16013
4d6ed7c8
NC		 16014 process_unwind (file);
16015
252b5132
RH		 16016 process_symbol_table (file);
16017
16018 process_syminfo (file);
16019
16020 process_version_sections (file);
16021
16022 process_section_contents (file);
f5842774 16023
1ec5cd37 16024 process_notes (file);
103f02d3 16025
047b2264
JJ		 16026 process_gnu_liblist (file);
16027
252b5132
RH		 16028 process_arch_specific (file);
16029
d93f0186
NC		 16030 if (program_headers)
16031 {
16032 free (program_headers);
16033 program_headers = NULL;
16034 }
16035
252b5132
RH		 16036 if (section_headers)
16037 {
16038 free (section_headers);
16039 section_headers = NULL;
16040 }
16041
16042 if (string_table)
16043 {
16044 free (string_table);
16045 string_table = NULL;
d40ac9bd 16046 string_table_length = 0;
252b5132
RH		 16047 }
16048
16049 if (dynamic_strings)
16050 {
16051 free (dynamic_strings);
16052 dynamic_strings = NULL;
d79b3d50 16053 dynamic_strings_length = 0;
252b5132
RH		 16054 }
16055
16056 if (dynamic_symbols)
16057 {
16058 free (dynamic_symbols);
16059 dynamic_symbols = NULL;
19936277 16060 num_dynamic_syms = 0;
252b5132
RH		 16061 }
16062
16063 if (dynamic_syminfo)
16064 {
16065 free (dynamic_syminfo);
16066 dynamic_syminfo = NULL;
16067 }
ff78d6d6 16068
293c573e
MR		 16069 if (dynamic_section)
16070 {
16071 free (dynamic_section);
16072 dynamic_section = NULL;
16073 }
16074
e4b17d5c
L		 16075 if (section_headers_groups)
16076 {
16077 free (section_headers_groups);
16078 section_headers_groups = NULL;
16079 }
16080
16081 if (section_groups)
16082 {
2cf0635d
NC		 16083 struct group_list * g;
16084 struct group_list * next;
e4b17d5c
L		 16085
16086 for (i = 0; i < group_count; i++)
16087 {
16088 for (g = section_groups [i].root; g != NULL; g = next)
16089 {
16090 next = g->next;
16091 free (g);
16092 }
16093 }
16094
16095 free (section_groups);
16096 section_groups = NULL;
16097 }
16098
19e6b90e 16099 free_debug_memory ();
18bd398b 16100
ff78d6d6 16101 return 0;
252b5132
RH		 16102}
16103
2cf0635d
NC		 16104/* Process an ELF archive.
16105 On entry the file is positioned just after the ARMAG string. */
16106
16107static int
16108process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
16109{
16110 struct archive_info arch;
16111 struct archive_info nested_arch;
16112 size_t got;
2cf0635d
NC		 16113 int ret;
16114
16115 show_name = 1;
16116
16117 /* The ARCH structure is used to hold information about this archive. */
16118 arch.file_name = NULL;
16119 arch.file = NULL;
16120 arch.index_array = NULL;
16121 arch.sym_table = NULL;
16122 arch.longnames = NULL;
16123
16124 /* The NESTED_ARCH structure is used as a single-item cache of information
16125 about a nested archive (when members of a thin archive reside within
16126 another regular archive file). */
16127 nested_arch.file_name = NULL;
16128 nested_arch.file = NULL;
16129 nested_arch.index_array = NULL;
16130 nested_arch.sym_table = NULL;
16131 nested_arch.longnames = NULL;
16132
16133 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
16134 {
16135 ret = 1;
16136 goto out;
4145f1d5 16137 }
fb52b2f4 16138
4145f1d5
NC		 16139 if (do_archive_index)
16140 {
2cf0635d 16141 if (arch.sym_table == NULL)
4145f1d5
NC		 16142 error (_("%s: unable to dump the index as none was found\n"), file_name);
16143 else
16144 {
591f7597 16145 unsigned long i, l;
4145f1d5
NC		 16146 unsigned long current_pos;
16147
591f7597
NC		 16148 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16149 file_name, (unsigned long) arch.index_num, arch.sym_size);
4145f1d5
NC		 16150 current_pos = ftell (file);
16151
2cf0635d 16152 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 16153 {
2cf0635d
NC		 16154 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
16155 {
16156 char * member_name;
4145f1d5 16157
2cf0635d
NC		 16158 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
16159
16160 if (member_name != NULL)
16161 {
16162 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
16163
16164 if (qualified_name != NULL)
16165 {
c2a7d3f5
NC		 16166 printf (_("Contents of binary %s at offset "), qualified_name);
16167 (void) print_vma (arch.index_array[i], PREFIX_HEX);
16168 putchar ('\n');
2cf0635d
NC		 16169 free (qualified_name);
16170 }
4145f1d5
NC		 16171 }
16172 }
2cf0635d
NC		 16173
16174 if (l >= arch.sym_size)
4145f1d5
NC		 16175 {
16176 error (_("%s: end of the symbol table reached before the end of the index\n"),
16177 file_name);
cb8f3167 16178 break;
4145f1d5 16179 }
591f7597
NC		 16180 /* PR 17531: file: 0b6630b2. */
16181 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
16182 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
4145f1d5
NC		 16183 }
16184
c2a7d3f5
NC		 16185 if (arch.uses_64bit_indicies)
16186 l = (l + 7) & ~ 7;
16187 else
16188 l += l & 1;
16189
2cf0635d 16190 if (l < arch.sym_size)
c2a7d3f5
NC		 16191 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16192 file_name, arch.sym_size - l);
4145f1d5 16193
4145f1d5
NC		 16194 if (fseek (file, current_pos, SEEK_SET) != 0)
16195 {
16196 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 16197 ret = 1;
16198 goto out;
4145f1d5 16199 }
fb52b2f4 16200 }
4145f1d5
NC		 16201
16202 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
16203 && !do_segments && !do_header && !do_dump && !do_version
16204 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 16205 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 16206 {
16207 ret = 0; /* Archive index only. */
16208 goto out;
16209 }
fb52b2f4
NC		 16210 }
16211
d989285c 16212 ret = 0;
fb52b2f4
NC		 16213
16214 while (1)
16215 {
2cf0635d
NC		 16216 char * name;
16217 size_t namelen;
16218 char * qualified_name;
16219
16220 /* Read the next archive header. */
16221 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
16222 {
16223 error (_("%s: failed to seek to next archive header\n"), file_name);
16224 return 1;
16225 }
16226 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
16227 if (got != sizeof arch.arhdr)
16228 {
16229 if (got == 0)
16230 break;
16231 error (_("%s: failed to read archive header\n"), file_name);
16232 ret = 1;
16233 break;
16234 }
16235 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
16236 {
16237 error (_("%s: did not find a valid archive header\n"), arch.file_name);
16238 ret = 1;
16239 break;
16240 }
16241
16242 arch.next_arhdr_offset += sizeof arch.arhdr;
16243
16244 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
16245 if (archive_file_size & 01)
16246 ++archive_file_size;
16247
16248 name = get_archive_member_name (&arch, &nested_arch);
16249 if (name == NULL)
fb52b2f4 16250 {
0fd3a477 16251 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16252 ret = 1;
16253 break;
fb52b2f4 16254 }
2cf0635d 16255 namelen = strlen (name);
fb52b2f4 16256
2cf0635d
NC		 16257 qualified_name = make_qualified_name (&arch, &nested_arch, name);
16258 if (qualified_name == NULL)
fb52b2f4 16259 {
2cf0635d 16260 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16261 ret = 1;
16262 break;
fb52b2f4
NC		 16263 }
16264
2cf0635d
NC		 16265 if (is_thin_archive && arch.nested_member_origin == 0)
16266 {
16267 /* This is a proxy for an external member of a thin archive. */
16268 FILE * member_file;
16269 char * member_file_name = adjust_relative_path (file_name, name, namelen);
16270 if (member_file_name == NULL)
16271 {
16272 ret = 1;
16273 break;
16274 }
16275
16276 member_file = fopen (member_file_name, "rb");
16277 if (member_file == NULL)
16278 {
16279 error (_("Input file '%s' is not readable.\n"), member_file_name);
16280 free (member_file_name);
16281 ret = 1;
16282 break;
16283 }
16284
16285 archive_file_offset = arch.nested_member_origin;
16286
16287 ret |= process_object (qualified_name, member_file);
16288
16289 fclose (member_file);
16290 free (member_file_name);
16291 }
16292 else if (is_thin_archive)
16293 {
a043396b
NC		 16294 /* PR 15140: Allow for corrupt thin archives. */
16295 if (nested_arch.file == NULL)
16296 {
16297 error (_("%s: contains corrupt thin archive: %s\n"),
16298 file_name, name);
16299 ret = 1;
16300 break;
16301 }
16302
2cf0635d
NC		 16303 /* This is a proxy for a member of a nested archive. */
16304 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
16305
16306 /* The nested archive file will have been opened and setup by
16307 get_archive_member_name. */
16308 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
16309 {
16310 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
16311 ret = 1;
16312 break;
16313 }
16314
16315 ret |= process_object (qualified_name, nested_arch.file);
16316 }
16317 else
16318 {
16319 archive_file_offset = arch.next_arhdr_offset;
16320 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 16321
2cf0635d
NC		 16322 ret |= process_object (qualified_name, file);
16323 }
fb52b2f4 16324
2b52916e
L		 16325 if (dump_sects != NULL)
16326 {
16327 free (dump_sects);
16328 dump_sects = NULL;
16329 num_dump_sects = 0;
16330 }
16331
2cf0635d 16332 free (qualified_name);
fb52b2f4
NC		 16333 }
16334
4145f1d5 16335 out:
2cf0635d
NC		 16336 if (nested_arch.file != NULL)
16337 fclose (nested_arch.file);
16338 release_archive (&nested_arch);
16339 release_archive (&arch);
fb52b2f4 16340
d989285c 16341 return ret;
fb52b2f4
NC		 16342}
16343
16344static int
2cf0635d 16345process_file (char * file_name)
fb52b2f4 16346{
2cf0635d 16347 FILE * file;
fb52b2f4
NC		 16348 struct stat statbuf;
16349 char armag[SARMAG];
16350 int ret;
16351
16352 if (stat (file_name, &statbuf) < 0)
16353 {
f24ddbdd
NC		 16354 if (errno == ENOENT)
16355 error (_("'%s': No such file\n"), file_name);
16356 else
16357 error (_("Could not locate '%s'. System error message: %s\n"),
16358 file_name, strerror (errno));
16359 return 1;
16360 }
16361
16362 if (! S_ISREG (statbuf.st_mode))
16363 {
16364 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 16365 return 1;
16366 }
16367
16368 file = fopen (file_name, "rb");
16369 if (file == NULL)
16370 {
f24ddbdd 16371 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 16372 return 1;
16373 }
16374
16375 if (fread (armag, SARMAG, 1, file) != 1)
16376 {
4145f1d5 16377 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 16378 fclose (file);
16379 return 1;
16380 }
16381
f54498b4
NC		 16382 current_file_size = (bfd_size_type) statbuf.st_size;
16383
fb52b2f4 16384 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 16385 ret = process_archive (file_name, file, FALSE);
16386 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16387 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 16388 else
16389 {
4145f1d5
NC		 16390 if (do_archive_index)
16391 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16392 file_name);
16393
fb52b2f4
NC		 16394 rewind (file);
16395 archive_file_size = archive_file_offset = 0;
16396 ret = process_object (file_name, file);
16397 }
16398
16399 fclose (file);
16400
f54498b4 16401 current_file_size = 0;
fb52b2f4
NC		 16402 return ret;
16403}
16404
252b5132
RH		 16405#ifdef SUPPORT_DISASSEMBLY
16406/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 16407 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 16408 symbols. */
252b5132
RH		 16409
16410void
2cf0635d 16411print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 16412{
16413 fprintf (outfile,"0x%8.8x", addr);
16414}
16415
e3c8793a 16416/* Needed by the i386 disassembler. */
252b5132
RH		 16417void
16418db_task_printsym (unsigned int addr)
16419{
16420 print_address (addr, stderr);
16421}
16422#endif
16423
16424int
2cf0635d 16425main (int argc, char ** argv)
252b5132 16426{
ff78d6d6
L		 16427 int err;
16428
252b5132
RH		 16429#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16430 setlocale (LC_MESSAGES, "");
3882b010
L		 16431#endif
16432#if defined (HAVE_SETLOCALE)
16433 setlocale (LC_CTYPE, "");
252b5132
RH		 16434#endif
16435 bindtextdomain (PACKAGE, LOCALEDIR);
16436 textdomain (PACKAGE);
16437
869b9d07
MM		 16438 expandargv (&argc, &argv);
16439
252b5132
RH		 16440 parse_args (argc, argv);
16441
18bd398b 16442 if (num_dump_sects > 0)
59f14fc0 16443 {
18bd398b 16444 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 16445 cmdline_dump_sects = (dump_type *)
16446 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 16447 if (cmdline_dump_sects == NULL)
591a748a 16448 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 16449 else
16450 {
09c11c86
NC		 16451 memcpy (cmdline_dump_sects, dump_sects,
16452 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 16453 num_cmdline_dump_sects = num_dump_sects;
16454 }
16455 }
16456
18bd398b
NC		 16457 if (optind < (argc - 1))
16458 show_name = 1;
5656ba2c
L		 16459 else if (optind >= argc)
16460 {
16461 warn (_("Nothing to do.\n"));
16462 usage (stderr);
16463 }
18bd398b 16464
ff78d6d6 16465 err = 0;
252b5132 16466 while (optind < argc)
18bd398b 16467 err |= process_file (argv[optind++]);
252b5132
RH		 16468
16469 if (dump_sects != NULL)
16470 free (dump_sects);
59f14fc0
AS		 16471 if (cmdline_dump_sects != NULL)
16472 free (cmdline_dump_sects);
252b5132 16473
ff78d6d6 16474 return err;
252b5132 16475}
Empty description
This page took 4.676665 seconds and 4 git commands to generate.