]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - binutils/readelf.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Automatic date update in version.in
[thirdparty/binutils-gdb.git] / binutils / readelf.c
CommitLineData
252b5132 1/* readelf.c -- display contents of an ELF format file
b90efa5b 2 Copyright (C) 1998-2015 Free Software Foundation, Inc.
252b5132
RH		 3
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
12ab83a9 5 Modifications by Nick Clifton <nickc@redhat.com>
252b5132
RH		 6
7 This file is part of GNU Binutils.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
32866df7 11 the Free Software Foundation; either version 3 of the License, or
252b5132
RH		 12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
b43b5d5f
NC		 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 02110-1301, USA. */
252b5132 23\f
9eb20dd8 24/* The difference between readelf and objdump:
252b5132 25
74013231 26 Both programs are capable of displaying the contents of ELF format files,
9eb20dd8 27 so why does the binutils project have two file dumpers ?
0de14b54 28
9eb20dd8
NC		 29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
35
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
38
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
42\f
3db64b00 43#include "sysdep.h"
252b5132 44#include <assert.h>
252b5132 45#include <time.h>
1b315056 46#include <zlib.h>
3bfcb652 47#ifdef HAVE_WCHAR_H
7bfd842d 48#include <wchar.h>
3bfcb652 49#endif
252b5132 50
a952a375 51#if __GNUC__ >= 2
19936277 52/* Define BFD64 here, even if our default architecture is 32 bit ELF
a952a375 53 as this will allow us to read in and parse 64bit and 32bit ELF files.
b34976b6 54 Only do this if we believe that the compiler can support a 64 bit
a952a375 55 data type. For now we only rely on GCC being able to do this. */
19936277 56#define BFD64
a952a375
NC		 57#endif
58
3db64b00
AM		 59#include "bfd.h"
60#include "bucomm.h"
3284fe0c 61#include "elfcomm.h"
19e6b90e 62#include "dwarf.h"
252b5132
RH		 63
64#include "elf/common.h"
65#include "elf/external.h"
66#include "elf/internal.h"
252b5132 67
4b78141a
NC		 68
69/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
73
74#include "elf/h8.h"
75#undef _ELF_H8_H
76
77/* Undo the effects of #including reloc-macros.h. */
78
79#undef START_RELOC_NUMBERS
80#undef RELOC_NUMBER
81#undef FAKE_RELOC
82#undef EMPTY_RELOC
83#undef END_RELOC_NUMBERS
84#undef _RELOC_MACROS_H
85
252b5132
RH		 86/* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
89
90#define RELOC_MACROS_GEN_FUNC
91
a06ea964 92#include "elf/aarch64.h"
252b5132 93#include "elf/alpha.h"
3b16e843 94#include "elf/arc.h"
252b5132 95#include "elf/arm.h"
3b16e843 96#include "elf/avr.h"
1d65ded4 97#include "elf/bfin.h"
60bca95a 98#include "elf/cr16.h"
3b16e843 99#include "elf/cris.h"
1c0d3aa6 100#include "elf/crx.h"
252b5132
RH		 101#include "elf/d10v.h"
102#include "elf/d30v.h"
d172d4ba 103#include "elf/dlx.h"
cfb8c092 104#include "elf/epiphany.h"
252b5132 105#include "elf/fr30.h"
5c70f934 106#include "elf/frv.h"
3f8107ab 107#include "elf/ft32.h"
3b16e843
NC		 108#include "elf/h8.h"
109#include "elf/hppa.h"
110#include "elf/i386.h"
35b1837e 111#include "elf/i370.h"
3b16e843
NC		 112#include "elf/i860.h"
113#include "elf/i960.h"
114#include "elf/ia64.h"
1e4cf259 115#include "elf/ip2k.h"
84e94c90 116#include "elf/lm32.h"
1c0d3aa6 117#include "elf/iq2000.h"
49f58d10 118#include "elf/m32c.h"
3b16e843
NC		 119#include "elf/m32r.h"
120#include "elf/m68k.h"
75751cd9 121#include "elf/m68hc11.h"
252b5132 122#include "elf/mcore.h"
15ab5209 123#include "elf/mep.h"
a3c62988 124#include "elf/metag.h"
7ba29e2a 125#include "elf/microblaze.h"
3b16e843 126#include "elf/mips.h"
3c3bdf30 127#include "elf/mmix.h"
3b16e843
NC		 128#include "elf/mn10200.h"
129#include "elf/mn10300.h"
5506d11a 130#include "elf/moxie.h"
4970f871 131#include "elf/mt.h"
2469cfa2 132#include "elf/msp430.h"
35c08157 133#include "elf/nds32.h"
13761a11 134#include "elf/nios2.h"
73589c9d 135#include "elf/or1k.h"
7d466069 136#include "elf/pj.h"
3b16e843 137#include "elf/ppc.h"
c833c019 138#include "elf/ppc64.h"
99c513f6 139#include "elf/rl78.h"
c7927a3c 140#include "elf/rx.h"
a85d7ed0 141#include "elf/s390.h"
1c0d3aa6 142#include "elf/score.h"
3b16e843
NC		 143#include "elf/sh.h"
144#include "elf/sparc.h"
e9f53129 145#include "elf/spu.h"
40b36596 146#include "elf/tic6x.h"
aa137e4d
NC		 147#include "elf/tilegx.h"
148#include "elf/tilepro.h"
3b16e843 149#include "elf/v850.h"
179d3252 150#include "elf/vax.h"
619ed720 151#include "elf/visium.h"
3b16e843 152#include "elf/x86-64.h"
c29aca4a 153#include "elf/xc16x.h"
f6c1a2d5 154#include "elf/xgate.h"
93fbbb04 155#include "elf/xstormy16.h"
88da6820 156#include "elf/xtensa.h"
252b5132 157
252b5132 158#include "getopt.h"
566b0d53 159#include "libiberty.h"
09c11c86 160#include "safe-ctype.h"
2cf0635d 161#include "filenames.h"
252b5132 162
15b42fb0
AM		 163#ifndef offsetof
164#define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
165#endif
166
2cf0635d 167char * program_name = "readelf";
c9c1d674 168static unsigned long archive_file_offset;
85b1c36d 169static unsigned long archive_file_size;
f54498b4 170static bfd_size_type current_file_size;
85b1c36d
BE		 171static unsigned long dynamic_addr;
172static bfd_size_type dynamic_size;
8b73c356 173static size_t dynamic_nent;
2cf0635d 174static char * dynamic_strings;
85b1c36d 175static unsigned long dynamic_strings_length;
2cf0635d 176static char * string_table;
85b1c36d
BE		 177static unsigned long string_table_length;
178static unsigned long num_dynamic_syms;
2cf0635d
NC		 179static Elf_Internal_Sym * dynamic_symbols;
180static Elf_Internal_Syminfo * dynamic_syminfo;
85b1c36d
BE		 181static unsigned long dynamic_syminfo_offset;
182static unsigned int dynamic_syminfo_nent;
f8eae8b2 183static char program_interpreter[PATH_MAX];
bb8a0291 184static bfd_vma dynamic_info[DT_ENCODING];
fdc90cb4 185static bfd_vma dynamic_info_DT_GNU_HASH;
85b1c36d
BE		 186static bfd_vma version_info[16];
187static Elf_Internal_Ehdr elf_header;
2cf0635d
NC		 188static Elf_Internal_Shdr * section_headers;
189static Elf_Internal_Phdr * program_headers;
190static Elf_Internal_Dyn * dynamic_section;
191static Elf_Internal_Shdr * symtab_shndx_hdr;
85b1c36d
BE		 192static int show_name;
193static int do_dynamic;
194static int do_syms;
2c610e4b 195static int do_dyn_syms;
85b1c36d
BE		 196static int do_reloc;
197static int do_sections;
198static int do_section_groups;
5477e8a0 199static int do_section_details;
85b1c36d
BE		 200static int do_segments;
201static int do_unwind;
202static int do_using_dynamic;
203static int do_header;
204static int do_dump;
205static int do_version;
85b1c36d
BE		 206static int do_histogram;
207static int do_debugging;
85b1c36d
BE		 208static int do_arch;
209static int do_notes;
4145f1d5 210static int do_archive_index;
85b1c36d 211static int is_32bit_elf;
252b5132 212
e4b17d5c
L		 213struct group_list
214{
2cf0635d 215 struct group_list * next;
e4b17d5c
L		 216 unsigned int section_index;
217};
218
219struct group
220{
2cf0635d 221 struct group_list * root;
e4b17d5c
L		 222 unsigned int group_index;
223};
224
85b1c36d 225static size_t group_count;
2cf0635d
NC		 226static struct group * section_groups;
227static struct group ** section_headers_groups;
e4b17d5c 228
09c11c86
NC		 229
230/* Flag bits indicating particular types of dump. */
231#define HEX_DUMP (1 << 0) /* The -x command line switch. */
232#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
233#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
234#define STRING_DUMP (1 << 3) /* The -p command line switch. */
cf13d699 235#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
09c11c86
NC		 236
237typedef unsigned char dump_type;
238
239/* A linked list of the section names for which dumps were requested. */
aef1f6d0
DJ		 240struct dump_list_entry
241{
2cf0635d 242 char * name;
09c11c86 243 dump_type type;
2cf0635d 244 struct dump_list_entry * next;
aef1f6d0 245};
2cf0635d 246static struct dump_list_entry * dump_sects_byname;
aef1f6d0 247
09c11c86
NC		 248/* A dynamic array of flags indicating for which sections a dump
249 has been requested via command line switches. */
250static dump_type * cmdline_dump_sects = NULL;
251static unsigned int num_cmdline_dump_sects = 0;
18bd398b
NC		 252
253/* A dynamic array of flags indicating for which sections a dump of
254 some kind has been requested. It is reset on a per-object file
aef1f6d0
DJ		 255 basis and then initialised from the cmdline_dump_sects array,
256 the results of interpreting the -w switch, and the
257 dump_sects_byname list. */
09c11c86
NC		 258static dump_type * dump_sects = NULL;
259static unsigned int num_dump_sects = 0;
252b5132 260
252b5132 261
c256ffe7 262/* How to print a vma value. */
843dd992
NC		 263typedef enum print_mode
264{
265 HEX,
266 DEC,
267 DEC_5,
268 UNSIGNED,
269 PREFIX_HEX,
270 FULL_HEX,
271 LONG_HEX
272}
273print_mode;
274
bb4d2ac2
L		 275/* Versioned symbol info. */
276enum versioned_symbol_info
277{
278 symbol_undefined,
279 symbol_hidden,
280 symbol_public
281};
282
283static const char *get_symbol_version_string
284 (FILE *file, int is_dynsym, const char *strtab,
285 unsigned long int strtab_size, unsigned int si,
286 Elf_Internal_Sym *psym, enum versioned_symbol_info *sym_info,
287 unsigned short *vna_other);
288
9c19a809
NC		 289#define UNKNOWN -1
290
2b692964
NC		 291#define SECTION_NAME(X) \
292 ((X) == NULL ? _("<none>") \
293 : string_table == NULL ? _("<no-name>") \
294 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
0b49d371 295 : string_table + (X)->sh_name))
252b5132 296
ee42cf8c 297#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
252b5132 298
ba5cdace
NC		 299#define GET_ELF_SYMBOLS(file, section, sym_count) \
300 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
301 : get_64bit_elf_symbols (file, section, sym_count))
9ea033b2 302
d79b3d50
NC		 303#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
304/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
305 already been called and verified that the string exists. */
306#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
18bd398b 307
61865e30
NC		 308#define REMOVE_ARCH_BITS(ADDR) \
309 do \
310 { \
311 if (elf_header.e_machine == EM_ARM) \
312 (ADDR) &= ~1; \
313 } \
314 while (0)
d79b3d50 315\f
c9c1d674
EG		 316/* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
317 the offset of the current archive member, if we are examining an archive.
59245841
NC		 318 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
319 using malloc and fill that. In either case return the pointer to the start of
320 the retrieved data or NULL if something went wrong. If something does go wrong
c9c1d674
EG		 321 and REASON is not NULL then emit an error message using REASON as part of the
322 context. */
59245841 323
c256ffe7 324static void *
57028622
NC		 325get_data (void * var, FILE * file, unsigned long offset, bfd_size_type size,
326 bfd_size_type nmemb, const char * reason)
a6e9f9df 327{
2cf0635d 328 void * mvar;
57028622 329 bfd_size_type amt = size * nmemb;
a6e9f9df 330
c256ffe7 331 if (size == 0 || nmemb == 0)
a6e9f9df
AM		 332 return NULL;
333
57028622
NC		 334 /* If the size_t type is smaller than the bfd_size_type, eg because
335 you are building a 32-bit tool on a 64-bit host, then make sure
336 that when the sizes are cast to (size_t) no information is lost. */
337 if (sizeof (size_t) < sizeof (bfd_size_type)
338 && ( (bfd_size_type) ((size_t) size) != size
339 || (bfd_size_type) ((size_t) nmemb) != nmemb))
340 {
341 if (reason)
342 error (_("Size truncation prevents reading 0x%llx elements of size 0x%llx for %s\n"),
343 (unsigned long long) nmemb, (unsigned long long) size, reason);
344 return NULL;
345 }
346
347 /* Check for size overflow. */
348 if (amt < nmemb)
349 {
350 if (reason)
351 error (_("Size overflow prevents reading 0x%llx elements of size 0x%llx for %s\n"),
352 (unsigned long long) nmemb, (unsigned long long) size, reason);
353 return NULL;
354 }
355
c9c1d674
EG		 356 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
357 attempting to allocate memory when the read is bound to fail. */
358 if (amt > current_file_size
359 || offset + archive_file_offset + amt > current_file_size)
a6e9f9df 360 {
049b0c3a 361 if (reason)
57028622
NC		 362 error (_("Reading 0x%llx bytes extends past end of file for %s\n"),
363 (unsigned long long) amt, reason);
a6e9f9df
AM		 364 return NULL;
365 }
366
c9c1d674 367 if (fseek (file, archive_file_offset + offset, SEEK_SET))
071436c6
NC		 368 {
369 if (reason)
c9c1d674
EG		 370 error (_("Unable to seek to 0x%lx for %s\n"),
371 (unsigned long) archive_file_offset + offset, reason);
071436c6
NC		 372 return NULL;
373 }
374
a6e9f9df
AM		 375 mvar = var;
376 if (mvar == NULL)
377 {
c256ffe7 378 /* Check for overflow. */
57028622 379 if (nmemb < (~(bfd_size_type) 0 - 1) / size)
c256ffe7 380 /* + 1 so that we can '\0' terminate invalid string table sections. */
57028622 381 mvar = malloc ((size_t) amt + 1);
a6e9f9df
AM		 382
383 if (mvar == NULL)
384 {
049b0c3a 385 if (reason)
57028622
NC		 386 error (_("Out of memory allocating 0x%llx bytes for %s\n"),
387 (unsigned long long) amt, reason);
a6e9f9df
AM		 388 return NULL;
389 }
c256ffe7 390
c9c1d674 391 ((char *) mvar)[amt] = '\0';
a6e9f9df
AM		 392 }
393
57028622 394 if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
a6e9f9df 395 {
049b0c3a 396 if (reason)
57028622
NC		 397 error (_("Unable to read in 0x%llx bytes of %s\n"),
398 (unsigned long long) amt, reason);
a6e9f9df
AM		 399 if (mvar != var)
400 free (mvar);
401 return NULL;
402 }
403
404 return mvar;
405}
406
14a91970 407/* Print a VMA value. */
cb8f3167 408
66543521 409static int
14a91970 410print_vma (bfd_vma vma, print_mode mode)
66543521 411{
66543521
AM		 412 int nc = 0;
413
14a91970 414 switch (mode)
66543521 415 {
14a91970
AM		 416 case FULL_HEX:
417 nc = printf ("0x");
418 /* Drop through. */
66543521 419
14a91970 420 case LONG_HEX:
f7a99963 421#ifdef BFD64
14a91970 422 if (is_32bit_elf)
437c2fb7 423 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
f7a99963 424#endif
14a91970
AM		 425 printf_vma (vma);
426 return nc + 16;
b19aac67 427
14a91970
AM		 428 case DEC_5:
429 if (vma <= 99999)
430 return printf ("%5" BFD_VMA_FMT "d", vma);
431 /* Drop through. */
66543521 432
14a91970
AM		 433 case PREFIX_HEX:
434 nc = printf ("0x");
435 /* Drop through. */
66543521 436
14a91970
AM		 437 case HEX:
438 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 439
14a91970
AM		 440 case DEC:
441 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 442
14a91970
AM		 443 case UNSIGNED:
444 return printf ("%" BFD_VMA_FMT "u", vma);
f7a99963 445 }
66543521 446 return 0;
f7a99963
NC		 447}
448
7bfd842d 449/* Display a symbol on stdout. Handles the display of control characters and
3bfcb652 450 multibye characters (assuming the host environment supports them).
31104126 451
7bfd842d
NC		 452 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
453
454 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
455 padding as necessary.
171191ba
NC		 456
457 Returns the number of emitted characters. */
458
459static unsigned int
7a88bc9c 460print_symbol (int width, const char *symbol)
31104126 461{
171191ba 462 bfd_boolean extra_padding = FALSE;
7bfd842d 463 int num_printed = 0;
3bfcb652 464#ifdef HAVE_MBSTATE_T
7bfd842d 465 mbstate_t state;
3bfcb652 466#endif
7bfd842d 467 int width_remaining;
961c521f 468
7bfd842d 469 if (width < 0)
961c521f 470 {
961c521f
NC		 471 /* Keep the width positive. This also helps. */
472 width = - width;
171191ba 473 extra_padding = TRUE;
0b4362b0 474 }
74e1a04b 475 assert (width != 0);
961c521f 476
7bfd842d
NC		 477 if (do_wide)
478 /* Set the remaining width to a very large value.
479 This simplifies the code below. */
480 width_remaining = INT_MAX;
481 else
482 width_remaining = width;
cb8f3167 483
3bfcb652 484#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 485 /* Initialise the multibyte conversion state. */
486 memset (& state, 0, sizeof (state));
3bfcb652 487#endif
961c521f 488
7bfd842d
NC		 489 while (width_remaining)
490 {
491 size_t n;
7bfd842d 492 const char c = *symbol++;
961c521f 493
7bfd842d 494 if (c == 0)
961c521f
NC		 495 break;
496
7bfd842d
NC		 497 /* Do not print control characters directly as they can affect terminal
498 settings. Such characters usually appear in the names generated
499 by the assembler for local labels. */
500 if (ISCNTRL (c))
961c521f 501 {
7bfd842d 502 if (width_remaining < 2)
961c521f
NC		 503 break;
504
7bfd842d
NC		 505 printf ("^%c", c + 0x40);
506 width_remaining -= 2;
171191ba 507 num_printed += 2;
961c521f 508 }
7bfd842d
NC		 509 else if (ISPRINT (c))
510 {
511 putchar (c);
512 width_remaining --;
513 num_printed ++;
514 }
961c521f
NC		 515 else
516 {
3bfcb652
NC		 517#ifdef HAVE_MBSTATE_T
518 wchar_t w;
519#endif
7bfd842d
NC		 520 /* Let printf do the hard work of displaying multibyte characters. */
521 printf ("%.1s", symbol - 1);
522 width_remaining --;
523 num_printed ++;
524
3bfcb652 525#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 526 /* Try to find out how many bytes made up the character that was
527 just printed. Advance the symbol pointer past the bytes that
528 were displayed. */
529 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
3bfcb652
NC		 530#else
531 n = 1;
532#endif
7bfd842d
NC		 533 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
534 symbol += (n - 1);
961c521f 535 }
961c521f 536 }
171191ba 537
7bfd842d 538 if (extra_padding && num_printed < width)
171191ba
NC		 539 {
540 /* Fill in the remaining spaces. */
7bfd842d
NC		 541 printf ("%-*s", width - num_printed, " ");
542 num_printed = width;
171191ba
NC		 543 }
544
545 return num_printed;
31104126
NC		 546}
547
74e1a04b
NC		 548/* Returns a pointer to a static buffer containing a printable version of
549 the given section's name. Like print_symbol, except that it does not try
550 to print multibyte characters, it just interprets them as hex values. */
551
552static const char *
0d2a7a93 553printable_section_name (const Elf_Internal_Shdr * sec)
74e1a04b
NC		 554{
555#define MAX_PRINT_SEC_NAME_LEN 128
556 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
557 const char * name = SECTION_NAME (sec);
558 char * buf = sec_name_buf;
559 char c;
560 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
561
562 while ((c = * name ++) != 0)
563 {
564 if (ISCNTRL (c))
565 {
566 if (remaining < 2)
567 break;
948f632f 568
74e1a04b
NC		 569 * buf ++ = '^';
570 * buf ++ = c + 0x40;
571 remaining -= 2;
572 }
573 else if (ISPRINT (c))
574 {
575 * buf ++ = c;
576 remaining -= 1;
577 }
578 else
579 {
580 static char hex[17] = "0123456789ABCDEF";
581
582 if (remaining < 4)
583 break;
584 * buf ++ = '<';
585 * buf ++ = hex[(c & 0xf0) >> 4];
586 * buf ++ = hex[c & 0x0f];
587 * buf ++ = '>';
588 remaining -= 4;
589 }
590
591 if (remaining == 0)
592 break;
593 }
594
595 * buf = 0;
596 return sec_name_buf;
597}
598
599static const char *
600printable_section_name_from_index (unsigned long ndx)
601{
602 if (ndx >= elf_header.e_shnum)
603 return _("<corrupt>");
604
605 return printable_section_name (section_headers + ndx);
606}
607
89fac5e3
RS		 608/* Return a pointer to section NAME, or NULL if no such section exists. */
609
610static Elf_Internal_Shdr *
2cf0635d 611find_section (const char * name)
89fac5e3
RS		 612{
613 unsigned int i;
614
615 for (i = 0; i < elf_header.e_shnum; i++)
616 if (streq (SECTION_NAME (section_headers + i), name))
617 return section_headers + i;
618
619 return NULL;
620}
621
0b6ae522
DJ		 622/* Return a pointer to a section containing ADDR, or NULL if no such
623 section exists. */
624
625static Elf_Internal_Shdr *
626find_section_by_address (bfd_vma addr)
627{
628 unsigned int i;
629
630 for (i = 0; i < elf_header.e_shnum; i++)
631 {
632 Elf_Internal_Shdr *sec = section_headers + i;
633 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
634 return sec;
635 }
636
637 return NULL;
638}
639
071436c6
NC		 640static Elf_Internal_Shdr *
641find_section_by_type (unsigned int type)
642{
643 unsigned int i;
644
645 for (i = 0; i < elf_header.e_shnum; i++)
646 {
647 Elf_Internal_Shdr *sec = section_headers + i;
648 if (sec->sh_type == type)
649 return sec;
650 }
651
652 return NULL;
653}
654
657d0d47
CC		 655/* Return a pointer to section NAME, or NULL if no such section exists,
656 restricted to the list of sections given in SET. */
657
658static Elf_Internal_Shdr *
659find_section_in_set (const char * name, unsigned int * set)
660{
661 unsigned int i;
662
663 if (set != NULL)
664 {
665 while ((i = *set++) > 0)
666 if (streq (SECTION_NAME (section_headers + i), name))
667 return section_headers + i;
668 }
669
670 return find_section (name);
671}
672
0b6ae522
DJ		 673/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
674 bytes read. */
675
f6f0e17b
NC		 676static inline unsigned long
677read_uleb128 (unsigned char *data,
678 unsigned int *length_return,
679 const unsigned char * const end)
0b6ae522 680{
f6f0e17b 681 return read_leb128 (data, length_return, FALSE, end);
0b6ae522
DJ		 682}
683
28f997cf
TG		 684/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
685 This OS has so many departures from the ELF standard that we test it at
686 many places. */
687
688static inline int
689is_ia64_vms (void)
690{
691 return elf_header.e_machine == EM_IA_64
692 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
693}
694
bcedfee6 695/* Guess the relocation size commonly used by the specific machines. */
252b5132 696
252b5132 697static int
2dc4cec1 698guess_is_rela (unsigned int e_machine)
252b5132 699{
9c19a809 700 switch (e_machine)
252b5132
RH		 701 {
702 /* Targets that use REL relocations. */
252b5132
RH		 703 case EM_386:
704 case EM_486:
63fcb9e9 705 case EM_960:
e9f53129 706 case EM_ARM:
2b0337b0 707 case EM_D10V:
252b5132 708 case EM_CYGNUS_D10V:
e9f53129 709 case EM_DLX:
252b5132 710 case EM_MIPS:
4fe85591 711 case EM_MIPS_RS3_LE:
e9f53129 712 case EM_CYGNUS_M32R:
1c0d3aa6 713 case EM_SCORE:
f6c1a2d5 714 case EM_XGATE:
9c19a809 715 return FALSE;
103f02d3 716
252b5132
RH		 717 /* Targets that use RELA relocations. */
718 case EM_68K:
e9f53129 719 case EM_860:
a06ea964 720 case EM_AARCH64:
cfb8c092 721 case EM_ADAPTEVA_EPIPHANY:
e9f53129
AM		 722 case EM_ALPHA:
723 case EM_ALTERA_NIOS2:
724 case EM_AVR:
725 case EM_AVR_OLD:
726 case EM_BLACKFIN:
60bca95a 727 case EM_CR16:
e9f53129
AM		 728 case EM_CRIS:
729 case EM_CRX:
2b0337b0 730 case EM_D30V:
252b5132 731 case EM_CYGNUS_D30V:
2b0337b0 732 case EM_FR30:
3f8107ab 733 case EM_FT32:
252b5132 734 case EM_CYGNUS_FR30:
5c70f934 735 case EM_CYGNUS_FRV:
e9f53129
AM		 736 case EM_H8S:
737 case EM_H8_300:
738 case EM_H8_300H:
800eeca4 739 case EM_IA_64:
1e4cf259
NC		 740 case EM_IP2K:
741 case EM_IP2K_OLD:
3b36097d 742 case EM_IQ2000:
84e94c90 743 case EM_LATTICEMICO32:
ff7eeb89 744 case EM_M32C_OLD:
49f58d10 745 case EM_M32C:
e9f53129
AM		 746 case EM_M32R:
747 case EM_MCORE:
15ab5209 748 case EM_CYGNUS_MEP:
a3c62988 749 case EM_METAG:
e9f53129
AM		 750 case EM_MMIX:
751 case EM_MN10200:
752 case EM_CYGNUS_MN10200:
753 case EM_MN10300:
754 case EM_CYGNUS_MN10300:
5506d11a 755 case EM_MOXIE:
e9f53129
AM		 756 case EM_MSP430:
757 case EM_MSP430_OLD:
d031aafb 758 case EM_MT:
35c08157 759 case EM_NDS32:
64fd6348 760 case EM_NIOS32:
73589c9d 761 case EM_OR1K:
e9f53129
AM		 762 case EM_PPC64:
763 case EM_PPC:
99c513f6 764 case EM_RL78:
c7927a3c 765 case EM_RX:
e9f53129
AM		 766 case EM_S390:
767 case EM_S390_OLD:
768 case EM_SH:
769 case EM_SPARC:
770 case EM_SPARC32PLUS:
771 case EM_SPARCV9:
772 case EM_SPU:
40b36596 773 case EM_TI_C6000:
aa137e4d
NC		 774 case EM_TILEGX:
775 case EM_TILEPRO:
708e2187 776 case EM_V800:
e9f53129
AM		 777 case EM_V850:
778 case EM_CYGNUS_V850:
779 case EM_VAX:
619ed720 780 case EM_VISIUM:
e9f53129 781 case EM_X86_64:
8a9036a4 782 case EM_L1OM:
7a9068fe 783 case EM_K1OM:
e9f53129
AM		 784 case EM_XSTORMY16:
785 case EM_XTENSA:
786 case EM_XTENSA_OLD:
7ba29e2a
NC		 787 case EM_MICROBLAZE:
788 case EM_MICROBLAZE_OLD:
9c19a809 789 return TRUE;
103f02d3 790
e9f53129
AM		 791 case EM_68HC05:
792 case EM_68HC08:
793 case EM_68HC11:
794 case EM_68HC16:
795 case EM_FX66:
796 case EM_ME16:
d1133906 797 case EM_MMA:
d1133906
NC		 798 case EM_NCPU:
799 case EM_NDR1:
e9f53129 800 case EM_PCP:
d1133906 801 case EM_ST100:
e9f53129 802 case EM_ST19:
d1133906 803 case EM_ST7:
e9f53129
AM		 804 case EM_ST9PLUS:
805 case EM_STARCORE:
d1133906 806 case EM_SVX:
e9f53129 807 case EM_TINYJ:
9c19a809
NC		 808 default:
809 warn (_("Don't know about relocations on this machine architecture\n"));
810 return FALSE;
811 }
812}
252b5132 813
9c19a809 814static int
2cf0635d 815slurp_rela_relocs (FILE * file,
d3ba0551
AM		 816 unsigned long rel_offset,
817 unsigned long rel_size,
2cf0635d
NC		 818 Elf_Internal_Rela ** relasp,
819 unsigned long * nrelasp)
9c19a809 820{
2cf0635d 821 Elf_Internal_Rela * relas;
8b73c356 822 size_t nrelas;
4d6ed7c8 823 unsigned int i;
252b5132 824
4d6ed7c8
NC		 825 if (is_32bit_elf)
826 {
2cf0635d 827 Elf32_External_Rela * erelas;
103f02d3 828
3f5e193b 829 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 830 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 831 if (!erelas)
832 return 0;
252b5132 833
4d6ed7c8 834 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 835
3f5e193b
NC		 836 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
837 sizeof (Elf_Internal_Rela));
103f02d3 838
4d6ed7c8
NC		 839 if (relas == NULL)
840 {
c256ffe7 841 free (erelas);
591a748a 842 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 843 return 0;
844 }
103f02d3 845
4d6ed7c8
NC		 846 for (i = 0; i < nrelas; i++)
847 {
848 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
849 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 850 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 851 }
103f02d3 852
4d6ed7c8
NC		 853 free (erelas);
854 }
855 else
856 {
2cf0635d 857 Elf64_External_Rela * erelas;
103f02d3 858
3f5e193b 859 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 860 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 861 if (!erelas)
862 return 0;
4d6ed7c8
NC		 863
864 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 865
3f5e193b
NC		 866 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
867 sizeof (Elf_Internal_Rela));
103f02d3 868
4d6ed7c8
NC		 869 if (relas == NULL)
870 {
c256ffe7 871 free (erelas);
591a748a 872 error (_("out of memory parsing relocs\n"));
4d6ed7c8 873 return 0;
9c19a809 874 }
4d6ed7c8
NC		 875
876 for (i = 0; i < nrelas; i++)
9c19a809 877 {
66543521
AM		 878 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
879 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 880 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 881
882 /* The #ifdef BFD64 below is to prevent a compile time
883 warning. We know that if we do not have a 64 bit data
884 type that we will never execute this code anyway. */
885#ifdef BFD64
886 if (elf_header.e_machine == EM_MIPS
887 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
888 {
889 /* In little-endian objects, r_info isn't really a
890 64-bit little-endian value: it has a 32-bit
891 little-endian symbol index followed by four
892 individual byte fields. Reorder INFO
893 accordingly. */
91d6fa6a
NC		 894 bfd_vma inf = relas[i].r_info;
895 inf = (((inf & 0xffffffff) << 32)
896 | ((inf >> 56) & 0xff)
897 | ((inf >> 40) & 0xff00)
898 | ((inf >> 24) & 0xff0000)
899 | ((inf >> 8) & 0xff000000));
900 relas[i].r_info = inf;
861fb55a
DJ		 901 }
902#endif /* BFD64 */
4d6ed7c8 903 }
103f02d3 904
4d6ed7c8
NC		 905 free (erelas);
906 }
907 *relasp = relas;
908 *nrelasp = nrelas;
909 return 1;
910}
103f02d3 911
4d6ed7c8 912static int
2cf0635d 913slurp_rel_relocs (FILE * file,
d3ba0551
AM		 914 unsigned long rel_offset,
915 unsigned long rel_size,
2cf0635d
NC		 916 Elf_Internal_Rela ** relsp,
917 unsigned long * nrelsp)
4d6ed7c8 918{
2cf0635d 919 Elf_Internal_Rela * rels;
8b73c356 920 size_t nrels;
4d6ed7c8 921 unsigned int i;
103f02d3 922
4d6ed7c8
NC		 923 if (is_32bit_elf)
924 {
2cf0635d 925 Elf32_External_Rel * erels;
103f02d3 926
3f5e193b 927 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 928 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 929 if (!erels)
930 return 0;
103f02d3 931
4d6ed7c8 932 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 933
3f5e193b 934 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 935
4d6ed7c8
NC		 936 if (rels == NULL)
937 {
c256ffe7 938 free (erels);
591a748a 939 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 940 return 0;
941 }
942
943 for (i = 0; i < nrels; i++)
944 {
945 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
946 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 947 rels[i].r_addend = 0;
9ea033b2 948 }
4d6ed7c8
NC		 949
950 free (erels);
9c19a809
NC		 951 }
952 else
953 {
2cf0635d 954 Elf64_External_Rel * erels;
9ea033b2 955
3f5e193b 956 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 957 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 958 if (!erels)
959 return 0;
103f02d3 960
4d6ed7c8 961 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 962
3f5e193b 963 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 964
4d6ed7c8 965 if (rels == NULL)
9c19a809 966 {
c256ffe7 967 free (erels);
591a748a 968 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 969 return 0;
970 }
103f02d3 971
4d6ed7c8
NC		 972 for (i = 0; i < nrels; i++)
973 {
66543521
AM		 974 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
975 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 976 rels[i].r_addend = 0;
861fb55a
DJ		 977
978 /* The #ifdef BFD64 below is to prevent a compile time
979 warning. We know that if we do not have a 64 bit data
980 type that we will never execute this code anyway. */
981#ifdef BFD64
982 if (elf_header.e_machine == EM_MIPS
983 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
984 {
985 /* In little-endian objects, r_info isn't really a
986 64-bit little-endian value: it has a 32-bit
987 little-endian symbol index followed by four
988 individual byte fields. Reorder INFO
989 accordingly. */
91d6fa6a
NC		 990 bfd_vma inf = rels[i].r_info;
991 inf = (((inf & 0xffffffff) << 32)
992 | ((inf >> 56) & 0xff)
993 | ((inf >> 40) & 0xff00)
994 | ((inf >> 24) & 0xff0000)
995 | ((inf >> 8) & 0xff000000));
996 rels[i].r_info = inf;
861fb55a
DJ		 997 }
998#endif /* BFD64 */
4d6ed7c8 999 }
103f02d3 1000
4d6ed7c8
NC		 1001 free (erels);
1002 }
1003 *relsp = rels;
1004 *nrelsp = nrels;
1005 return 1;
1006}
103f02d3 1007
aca88567
NC		 1008/* Returns the reloc type extracted from the reloc info field. */
1009
1010static unsigned int
1011get_reloc_type (bfd_vma reloc_info)
1012{
1013 if (is_32bit_elf)
1014 return ELF32_R_TYPE (reloc_info);
1015
1016 switch (elf_header.e_machine)
1017 {
1018 case EM_MIPS:
1019 /* Note: We assume that reloc_info has already been adjusted for us. */
1020 return ELF64_MIPS_R_TYPE (reloc_info);
1021
1022 case EM_SPARCV9:
1023 return ELF64_R_TYPE_ID (reloc_info);
1024
1025 default:
1026 return ELF64_R_TYPE (reloc_info);
1027 }
1028}
1029
1030/* Return the symbol index extracted from the reloc info field. */
1031
1032static bfd_vma
1033get_reloc_symindex (bfd_vma reloc_info)
1034{
1035 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1036}
1037
13761a11
NC		 1038static inline bfd_boolean
1039uses_msp430x_relocs (void)
1040{
1041 return
1042 elf_header.e_machine == EM_MSP430 /* Paranoia. */
1043 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1044 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1045 /* TI compiler uses ELFOSABI_NONE. */
1046 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1047}
1048
d3ba0551
AM		 1049/* Display the contents of the relocation data found at the specified
1050 offset. */
ee42cf8c 1051
41e92641 1052static void
2cf0635d 1053dump_relocations (FILE * file,
d3ba0551
AM		 1054 unsigned long rel_offset,
1055 unsigned long rel_size,
2cf0635d 1056 Elf_Internal_Sym * symtab,
d3ba0551 1057 unsigned long nsyms,
2cf0635d 1058 char * strtab,
d79b3d50 1059 unsigned long strtablen,
bb4d2ac2
L		 1060 int is_rela,
1061 int is_dynsym)
4d6ed7c8 1062{
b34976b6 1063 unsigned int i;
2cf0635d 1064 Elf_Internal_Rela * rels;
103f02d3 1065
4d6ed7c8
NC		 1066 if (is_rela == UNKNOWN)
1067 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 1068
4d6ed7c8
NC		 1069 if (is_rela)
1070 {
c8286bd1 1071 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1072 return;
4d6ed7c8
NC		 1073 }
1074 else
1075 {
1076 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1077 return;
252b5132
RH		 1078 }
1079
410f7a12
L		 1080 if (is_32bit_elf)
1081 {
1082 if (is_rela)
2c71103e
NC		 1083 {
1084 if (do_wide)
1085 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1086 else
1087 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1088 }
410f7a12 1089 else
2c71103e
NC		 1090 {
1091 if (do_wide)
1092 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1093 else
1094 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1095 }
410f7a12 1096 }
252b5132 1097 else
410f7a12
L		 1098 {
1099 if (is_rela)
2c71103e
NC		 1100 {
1101 if (do_wide)
8beeaeb7 1102 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 1103 else
1104 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1105 }
410f7a12 1106 else
2c71103e
NC		 1107 {
1108 if (do_wide)
8beeaeb7 1109 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 1110 else
1111 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1112 }
410f7a12 1113 }
252b5132
RH		 1114
1115 for (i = 0; i < rel_size; i++)
1116 {
2cf0635d 1117 const char * rtype;
b34976b6 1118 bfd_vma offset;
91d6fa6a 1119 bfd_vma inf;
b34976b6
AM		 1120 bfd_vma symtab_index;
1121 bfd_vma type;
103f02d3 1122
b34976b6 1123 offset = rels[i].r_offset;
91d6fa6a 1124 inf = rels[i].r_info;
103f02d3 1125
91d6fa6a
NC		 1126 type = get_reloc_type (inf);
1127 symtab_index = get_reloc_symindex (inf);
252b5132 1128
410f7a12
L		 1129 if (is_32bit_elf)
1130 {
39dbeff8
AM		 1131 printf ("%8.8lx %8.8lx ",
1132 (unsigned long) offset & 0xffffffff,
91d6fa6a 1133 (unsigned long) inf & 0xffffffff);
410f7a12
L		 1134 }
1135 else
1136 {
39dbeff8
AM		 1137#if BFD_HOST_64BIT_LONG
1138 printf (do_wide
1139 ? "%16.16lx %16.16lx "
1140 : "%12.12lx %12.12lx ",
91d6fa6a 1141 offset, inf);
39dbeff8 1142#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 1143#ifndef __MSVCRT__
39dbeff8
AM		 1144 printf (do_wide
1145 ? "%16.16llx %16.16llx "
1146 : "%12.12llx %12.12llx ",
91d6fa6a 1147 offset, inf);
6e3d6dc1
NC		 1148#else
1149 printf (do_wide
1150 ? "%16.16I64x %16.16I64x "
1151 : "%12.12I64x %12.12I64x ",
91d6fa6a 1152 offset, inf);
6e3d6dc1 1153#endif
39dbeff8 1154#else
2c71103e
NC		 1155 printf (do_wide
1156 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1157 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 1158 _bfd_int64_high (offset),
1159 _bfd_int64_low (offset),
91d6fa6a
NC		 1160 _bfd_int64_high (inf),
1161 _bfd_int64_low (inf));
9ea033b2 1162#endif
410f7a12 1163 }
103f02d3 1164
252b5132
RH		 1165 switch (elf_header.e_machine)
1166 {
1167 default:
1168 rtype = NULL;
1169 break;
1170
a06ea964
NC		 1171 case EM_AARCH64:
1172 rtype = elf_aarch64_reloc_type (type);
1173 break;
1174
2b0337b0 1175 case EM_M32R:
252b5132 1176 case EM_CYGNUS_M32R:
9ea033b2 1177 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 1178 break;
1179
1180 case EM_386:
1181 case EM_486:
9ea033b2 1182 rtype = elf_i386_reloc_type (type);
252b5132
RH		 1183 break;
1184
ba2685cc
AM		 1185 case EM_68HC11:
1186 case EM_68HC12:
1187 rtype = elf_m68hc11_reloc_type (type);
1188 break;
75751cd9 1189
252b5132 1190 case EM_68K:
9ea033b2 1191 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1192 break;
1193
63fcb9e9 1194 case EM_960:
9ea033b2 1195 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1196 break;
1197
adde6300 1198 case EM_AVR:
2b0337b0 1199 case EM_AVR_OLD:
adde6300
AM		 1200 rtype = elf_avr_reloc_type (type);
1201 break;
1202
9ea033b2
NC		 1203 case EM_OLD_SPARCV9:
1204 case EM_SPARC32PLUS:
1205 case EM_SPARCV9:
252b5132 1206 case EM_SPARC:
9ea033b2 1207 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1208 break;
1209
e9f53129
AM		 1210 case EM_SPU:
1211 rtype = elf_spu_reloc_type (type);
1212 break;
1213
708e2187
NC		 1214 case EM_V800:
1215 rtype = v800_reloc_type (type);
1216 break;
2b0337b0 1217 case EM_V850:
252b5132 1218 case EM_CYGNUS_V850:
9ea033b2 1219 rtype = v850_reloc_type (type);
252b5132
RH		 1220 break;
1221
2b0337b0 1222 case EM_D10V:
252b5132 1223 case EM_CYGNUS_D10V:
9ea033b2 1224 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1225 break;
1226
2b0337b0 1227 case EM_D30V:
252b5132 1228 case EM_CYGNUS_D30V:
9ea033b2 1229 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1230 break;
1231
d172d4ba
NC		 1232 case EM_DLX:
1233 rtype = elf_dlx_reloc_type (type);
1234 break;
1235
252b5132 1236 case EM_SH:
9ea033b2 1237 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1238 break;
1239
2b0337b0 1240 case EM_MN10300:
252b5132 1241 case EM_CYGNUS_MN10300:
9ea033b2 1242 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1243 break;
1244
2b0337b0 1245 case EM_MN10200:
252b5132 1246 case EM_CYGNUS_MN10200:
9ea033b2 1247 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1248 break;
1249
2b0337b0 1250 case EM_FR30:
252b5132 1251 case EM_CYGNUS_FR30:
9ea033b2 1252 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1253 break;
1254
ba2685cc
AM		 1255 case EM_CYGNUS_FRV:
1256 rtype = elf_frv_reloc_type (type);
1257 break;
5c70f934 1258
3f8107ab
AM		 1259 case EM_FT32:
1260 rtype = elf_ft32_reloc_type (type);
1261 break;
1262
252b5132 1263 case EM_MCORE:
9ea033b2 1264 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1265 break;
1266
3c3bdf30
NC		 1267 case EM_MMIX:
1268 rtype = elf_mmix_reloc_type (type);
1269 break;
1270
5506d11a
AM		 1271 case EM_MOXIE:
1272 rtype = elf_moxie_reloc_type (type);
1273 break;
1274
2469cfa2 1275 case EM_MSP430:
13761a11
NC		 1276 if (uses_msp430x_relocs ())
1277 {
1278 rtype = elf_msp430x_reloc_type (type);
1279 break;
1280 }
2469cfa2
NC		 1281 case EM_MSP430_OLD:
1282 rtype = elf_msp430_reloc_type (type);
1283 break;
1284
35c08157
KLC		 1285 case EM_NDS32:
1286 rtype = elf_nds32_reloc_type (type);
1287 break;
1288
252b5132 1289 case EM_PPC:
9ea033b2 1290 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1291 break;
1292
c833c019
AM		 1293 case EM_PPC64:
1294 rtype = elf_ppc64_reloc_type (type);
1295 break;
1296
252b5132 1297 case EM_MIPS:
4fe85591 1298 case EM_MIPS_RS3_LE:
9ea033b2 1299 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1300 break;
1301
1302 case EM_ALPHA:
9ea033b2 1303 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1304 break;
1305
1306 case EM_ARM:
9ea033b2 1307 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1308 break;
1309
584da044 1310 case EM_ARC:
9ea033b2 1311 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1312 break;
1313
1314 case EM_PARISC:
69e617ca 1315 rtype = elf_hppa_reloc_type (type);
252b5132 1316 break;
7d466069 1317
b8720f9d
JL		 1318 case EM_H8_300:
1319 case EM_H8_300H:
1320 case EM_H8S:
1321 rtype = elf_h8_reloc_type (type);
1322 break;
1323
73589c9d
CS		 1324 case EM_OR1K:
1325 rtype = elf_or1k_reloc_type (type);
3b16e843
NC		 1326 break;
1327
7d466069 1328 case EM_PJ:
2b0337b0 1329 case EM_PJ_OLD:
7d466069
ILT		 1330 rtype = elf_pj_reloc_type (type);
1331 break;
800eeca4
JW		 1332 case EM_IA_64:
1333 rtype = elf_ia64_reloc_type (type);
1334 break;
1b61cf92
HPN		 1335
1336 case EM_CRIS:
1337 rtype = elf_cris_reloc_type (type);
1338 break;
535c37ff
JE		 1339
1340 case EM_860:
1341 rtype = elf_i860_reloc_type (type);
1342 break;
bcedfee6
NC		 1343
1344 case EM_X86_64:
8a9036a4 1345 case EM_L1OM:
7a9068fe 1346 case EM_K1OM:
bcedfee6
NC		 1347 rtype = elf_x86_64_reloc_type (type);
1348 break;
a85d7ed0 1349
35b1837e
AM		 1350 case EM_S370:
1351 rtype = i370_reloc_type (type);
1352 break;
1353
53c7db4b
KH		 1354 case EM_S390_OLD:
1355 case EM_S390:
1356 rtype = elf_s390_reloc_type (type);
1357 break;
93fbbb04 1358
1c0d3aa6
NC		 1359 case EM_SCORE:
1360 rtype = elf_score_reloc_type (type);
1361 break;
1362
93fbbb04
GK		 1363 case EM_XSTORMY16:
1364 rtype = elf_xstormy16_reloc_type (type);
1365 break;
179d3252 1366
1fe1f39c
NC		 1367 case EM_CRX:
1368 rtype = elf_crx_reloc_type (type);
1369 break;
1370
179d3252
JT		 1371 case EM_VAX:
1372 rtype = elf_vax_reloc_type (type);
1373 break;
1e4cf259 1374
619ed720
EB		 1375 case EM_VISIUM:
1376 rtype = elf_visium_reloc_type (type);
1377 break;
1378
cfb8c092
NC		 1379 case EM_ADAPTEVA_EPIPHANY:
1380 rtype = elf_epiphany_reloc_type (type);
1381 break;
1382
1e4cf259
NC		 1383 case EM_IP2K:
1384 case EM_IP2K_OLD:
1385 rtype = elf_ip2k_reloc_type (type);
1386 break;
3b36097d
SC		 1387
1388 case EM_IQ2000:
1389 rtype = elf_iq2000_reloc_type (type);
1390 break;
88da6820
NC		 1391
1392 case EM_XTENSA_OLD:
1393 case EM_XTENSA:
1394 rtype = elf_xtensa_reloc_type (type);
1395 break;
a34e3ecb 1396
84e94c90
NC		 1397 case EM_LATTICEMICO32:
1398 rtype = elf_lm32_reloc_type (type);
1399 break;
1400
ff7eeb89 1401 case EM_M32C_OLD:
49f58d10
JB		 1402 case EM_M32C:
1403 rtype = elf_m32c_reloc_type (type);
1404 break;
1405
d031aafb
NS		 1406 case EM_MT:
1407 rtype = elf_mt_reloc_type (type);
a34e3ecb 1408 break;
1d65ded4
CM		 1409
1410 case EM_BLACKFIN:
1411 rtype = elf_bfin_reloc_type (type);
1412 break;
15ab5209
DB		 1413
1414 case EM_CYGNUS_MEP:
1415 rtype = elf_mep_reloc_type (type);
1416 break;
60bca95a
NC		 1417
1418 case EM_CR16:
1419 rtype = elf_cr16_reloc_type (type);
1420 break;
dd24e3da 1421
7ba29e2a
NC		 1422 case EM_MICROBLAZE:
1423 case EM_MICROBLAZE_OLD:
1424 rtype = elf_microblaze_reloc_type (type);
1425 break;
c7927a3c 1426
99c513f6
DD		 1427 case EM_RL78:
1428 rtype = elf_rl78_reloc_type (type);
1429 break;
1430
c7927a3c
NC		 1431 case EM_RX:
1432 rtype = elf_rx_reloc_type (type);
1433 break;
c29aca4a 1434
a3c62988
NC		 1435 case EM_METAG:
1436 rtype = elf_metag_reloc_type (type);
1437 break;
1438
c29aca4a
NC		 1439 case EM_XC16X:
1440 case EM_C166:
1441 rtype = elf_xc16x_reloc_type (type);
1442 break;
40b36596
JM		 1443
1444 case EM_TI_C6000:
1445 rtype = elf_tic6x_reloc_type (type);
1446 break;
aa137e4d
NC		 1447
1448 case EM_TILEGX:
1449 rtype = elf_tilegx_reloc_type (type);
1450 break;
1451
1452 case EM_TILEPRO:
1453 rtype = elf_tilepro_reloc_type (type);
1454 break;
f6c1a2d5
NC		 1455
1456 case EM_XGATE:
1457 rtype = elf_xgate_reloc_type (type);
1458 break;
36591ba1
SL		 1459
1460 case EM_ALTERA_NIOS2:
1461 rtype = elf_nios2_reloc_type (type);
1462 break;
252b5132
RH		 1463 }
1464
1465 if (rtype == NULL)
39dbeff8 1466 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1467 else
8beeaeb7 1468 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1469
7ace3541 1470 if (elf_header.e_machine == EM_ALPHA
157c2599 1471 && rtype != NULL
7ace3541
RH		 1472 && streq (rtype, "R_ALPHA_LITUSE")
1473 && is_rela)
1474 {
1475 switch (rels[i].r_addend)
1476 {
1477 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1478 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1479 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1480 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1481 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1482 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1483 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1484 default: rtype = NULL;
1485 }
1486 if (rtype)
1487 printf (" (%s)", rtype);
1488 else
1489 {
1490 putchar (' ');
1491 printf (_("<unknown addend: %lx>"),
1492 (unsigned long) rels[i].r_addend);
1493 }
1494 }
1495 else if (symtab_index)
252b5132 1496 {
af3fc3bc 1497 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1498 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1499 else
19936277 1500 {
2cf0635d 1501 Elf_Internal_Sym * psym;
bb4d2ac2
L		 1502 const char * version_string;
1503 enum versioned_symbol_info sym_info;
1504 unsigned short vna_other;
19936277 1505
af3fc3bc 1506 psym = symtab + symtab_index;
103f02d3 1507
bb4d2ac2
L		 1508 version_string
1509 = get_symbol_version_string (file, is_dynsym,
1510 strtab, strtablen,
1511 symtab_index,
1512 psym,
1513 &sym_info,
1514 &vna_other);
1515
af3fc3bc 1516 printf (" ");
171191ba 1517
d8045f23
NC		 1518 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1519 {
1520 const char * name;
1521 unsigned int len;
1522 unsigned int width = is_32bit_elf ? 8 : 14;
1523
1524 /* Relocations against GNU_IFUNC symbols do not use the value
1525 of the symbol as the address to relocate against. Instead
1526 they invoke the function named by the symbol and use its
1527 result as the address for relocation.
1528
1529 To indicate this to the user, do not display the value of
1530 the symbol in the "Symbols's Value" field. Instead show
1531 its name followed by () as a hint that the symbol is
1532 invoked. */
1533
1534 if (strtab == NULL
1535 || psym->st_name == 0
1536 || psym->st_name >= strtablen)
1537 name = "??";
1538 else
1539 name = strtab + psym->st_name;
1540
1541 len = print_symbol (width, name);
bb4d2ac2
L		 1542 if (version_string)
1543 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1544 version_string);
d8045f23
NC		 1545 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1546 }
1547 else
1548 {
1549 print_vma (psym->st_value, LONG_HEX);
171191ba 1550
d8045f23
NC		 1551 printf (is_32bit_elf ? " " : " ");
1552 }
103f02d3 1553
af3fc3bc 1554 if (psym->st_name == 0)
f1ef08cb 1555 {
2cf0635d 1556 const char * sec_name = "<null>";
f1ef08cb
AM		 1557 char name_buf[40];
1558
1559 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1560 {
4fbb74a6 1561 if (psym->st_shndx < elf_header.e_shnum)
74e1a04b 1562 sec_name = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1563 else if (psym->st_shndx == SHN_ABS)
1564 sec_name = "ABS";
1565 else if (psym->st_shndx == SHN_COMMON)
1566 sec_name = "COMMON";
ac145307
BS		 1567 else if ((elf_header.e_machine == EM_MIPS
1568 && psym->st_shndx == SHN_MIPS_SCOMMON)
1569 || (elf_header.e_machine == EM_TI_C6000
1570 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1571 sec_name = "SCOMMON";
1572 else if (elf_header.e_machine == EM_MIPS
1573 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1574 sec_name = "SUNDEF";
8a9036a4 1575 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1576 || elf_header.e_machine == EM_L1OM
1577 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1578 && psym->st_shndx == SHN_X86_64_LCOMMON)
1579 sec_name = "LARGE_COMMON";
9ce701e2
L		 1580 else if (elf_header.e_machine == EM_IA_64
1581 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1582 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1583 sec_name = "ANSI_COM";
28f997cf 1584 else if (is_ia64_vms ()
148b93f2
NC		 1585 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1586 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1587 else
1588 {
1589 sprintf (name_buf, "<section 0x%x>",
1590 (unsigned int) psym->st_shndx);
1591 sec_name = name_buf;
1592 }
1593 }
1594 print_symbol (22, sec_name);
1595 }
af3fc3bc 1596 else if (strtab == NULL)
d79b3d50 1597 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1598 else if (psym->st_name >= strtablen)
d79b3d50 1599 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1600 else
bb4d2ac2
L		 1601 {
1602 print_symbol (22, strtab + psym->st_name);
1603 if (version_string)
1604 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1605 version_string);
1606 }
103f02d3 1607
af3fc3bc 1608 if (is_rela)
171191ba 1609 {
598aaa76 1610 bfd_signed_vma off = rels[i].r_addend;
171191ba 1611
834f871c
NC		 1612 /* PR 17531: file: 2e63226f. */
1613 if (off == ((bfd_signed_vma) 1) << ((sizeof (bfd_signed_vma) * 8) - 1))
1614 printf (" + %" BFD_VMA_FMT "x", off);
1615 else if (off < 0)
598aaa76 1616 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1617 else
598aaa76 1618 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1619 }
19936277 1620 }
252b5132 1621 }
1b228002 1622 else if (is_rela)
f7a99963 1623 {
e04d7088
L		 1624 bfd_signed_vma off = rels[i].r_addend;
1625
1626 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
834f871c
NC		 1627 /* PR 17531: file: 2e63226f. */
1628 if (off == ((bfd_signed_vma) 1) << ((sizeof (bfd_signed_vma) * 8) - 1))
1629 printf ("%" BFD_VMA_FMT "x", off);
1630 else if (off < 0)
e04d7088
L		 1631 printf ("-%" BFD_VMA_FMT "x", - off);
1632 else
1633 printf ("%" BFD_VMA_FMT "x", off);
f7a99963 1634 }
252b5132 1635
157c2599
NC		 1636 if (elf_header.e_machine == EM_SPARCV9
1637 && rtype != NULL
1638 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1639 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1640
252b5132 1641 putchar ('\n');
2c71103e 1642
aca88567 1643#ifdef BFD64
53c7db4b 1644 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1645 {
91d6fa6a
NC		 1646 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1647 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1648 const char * rtype2 = elf_mips_reloc_type (type2);
1649 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1650
2c71103e
NC		 1651 printf (" Type2: ");
1652
1653 if (rtype2 == NULL)
39dbeff8
AM		 1654 printf (_("unrecognized: %-7lx"),
1655 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1656 else
1657 printf ("%-17.17s", rtype2);
1658
18bd398b 1659 printf ("\n Type3: ");
2c71103e
NC		 1660
1661 if (rtype3 == NULL)
39dbeff8
AM		 1662 printf (_("unrecognized: %-7lx"),
1663 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1664 else
1665 printf ("%-17.17s", rtype3);
1666
53c7db4b 1667 putchar ('\n');
2c71103e 1668 }
aca88567 1669#endif /* BFD64 */
252b5132
RH		 1670 }
1671
c8286bd1 1672 free (rels);
252b5132
RH		 1673}
1674
1675static const char *
d3ba0551 1676get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1677{
1678 switch (type)
1679 {
1680 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1681 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1682 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1683 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1684 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1685 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1686 case DT_MIPS_MSYM: return "MIPS_MSYM";
1687 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1688 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1689 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1690 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1691 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1692 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1693 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1694 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1695 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1696 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1697 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1698 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1699 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1700 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1701 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1702 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1703 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1704 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1705 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1706 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1707 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1708 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1709 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1710 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1711 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1712 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1713 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1714 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1715 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1716 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1717 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1718 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1719 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1720 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1721 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1722 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1723 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1724 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1725 default:
1726 return NULL;
1727 }
1728}
1729
9a097730 1730static const char *
d3ba0551 1731get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1732{
1733 switch (type)
1734 {
1735 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1736 default:
1737 return NULL;
1738 }
103f02d3
UD		 1739}
1740
7490d522
AM		 1741static const char *
1742get_ppc_dynamic_type (unsigned long type)
1743{
1744 switch (type)
1745 {
a7f2871e 1746 case DT_PPC_GOT: return "PPC_GOT";
e8910a83 1747 case DT_PPC_OPT: return "PPC_OPT";
7490d522
AM		 1748 default:
1749 return NULL;
1750 }
1751}
1752
f1cb7e17 1753static const char *
d3ba0551 1754get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1755{
1756 switch (type)
1757 {
a7f2871e
AM		 1758 case DT_PPC64_GLINK: return "PPC64_GLINK";
1759 case DT_PPC64_OPD: return "PPC64_OPD";
1760 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
e8910a83 1761 case DT_PPC64_OPT: return "PPC64_OPT";
f1cb7e17
AM		 1762 default:
1763 return NULL;
1764 }
1765}
1766
103f02d3 1767static const char *
d3ba0551 1768get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1769{
1770 switch (type)
1771 {
1772 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1773 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1774 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1775 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1776 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1777 case DT_HP_PREINIT: return "HP_PREINIT";
1778 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1779 case DT_HP_NEEDED: return "HP_NEEDED";
1780 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1781 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1782 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1783 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1784 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1785 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1786 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1787 case DT_HP_FILTERED: return "HP_FILTERED";
1788 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1789 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1790 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1791 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1792 case DT_PLT: return "PLT";
1793 case DT_PLT_SIZE: return "PLT_SIZE";
1794 case DT_DLT: return "DLT";
1795 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1796 default:
1797 return NULL;
1798 }
1799}
9a097730 1800
ecc51f48 1801static const char *
d3ba0551 1802get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1803{
1804 switch (type)
1805 {
148b93f2
NC		 1806 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1807 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1808 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1809 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1810 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1811 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1812 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1813 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1814 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1815 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1816 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1817 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1818 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1819 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1820 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1821 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1822 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1823 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1824 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1825 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1826 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1827 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1828 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1829 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1830 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1831 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1832 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1833 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1834 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1835 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1836 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1837 default:
1838 return NULL;
1839 }
1840}
1841
fabcb361
RH		 1842static const char *
1843get_alpha_dynamic_type (unsigned long type)
1844{
1845 switch (type)
1846 {
1847 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1848 default:
1849 return NULL;
1850 }
1851}
1852
1c0d3aa6
NC		 1853static const char *
1854get_score_dynamic_type (unsigned long type)
1855{
1856 switch (type)
1857 {
1858 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1859 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1860 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1861 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1862 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1863 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1864 default:
1865 return NULL;
1866 }
1867}
1868
40b36596
JM		 1869static const char *
1870get_tic6x_dynamic_type (unsigned long type)
1871{
1872 switch (type)
1873 {
1874 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1875 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1876 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1877 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1878 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1879 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1880 default:
1881 return NULL;
1882 }
1883}
1c0d3aa6 1884
36591ba1
SL		 1885static const char *
1886get_nios2_dynamic_type (unsigned long type)
1887{
1888 switch (type)
1889 {
1890 case DT_NIOS2_GP: return "NIOS2_GP";
1891 default:
1892 return NULL;
1893 }
1894}
1895
252b5132 1896static const char *
d3ba0551 1897get_dynamic_type (unsigned long type)
252b5132 1898{
e9e44622 1899 static char buff[64];
252b5132
RH		 1900
1901 switch (type)
1902 {
1903 case DT_NULL: return "NULL";
1904 case DT_NEEDED: return "NEEDED";
1905 case DT_PLTRELSZ: return "PLTRELSZ";
1906 case DT_PLTGOT: return "PLTGOT";
1907 case DT_HASH: return "HASH";
1908 case DT_STRTAB: return "STRTAB";
1909 case DT_SYMTAB: return "SYMTAB";
1910 case DT_RELA: return "RELA";
1911 case DT_RELASZ: return "RELASZ";
1912 case DT_RELAENT: return "RELAENT";
1913 case DT_STRSZ: return "STRSZ";
1914 case DT_SYMENT: return "SYMENT";
1915 case DT_INIT: return "INIT";
1916 case DT_FINI: return "FINI";
1917 case DT_SONAME: return "SONAME";
1918 case DT_RPATH: return "RPATH";
1919 case DT_SYMBOLIC: return "SYMBOLIC";
1920 case DT_REL: return "REL";
1921 case DT_RELSZ: return "RELSZ";
1922 case DT_RELENT: return "RELENT";
1923 case DT_PLTREL: return "PLTREL";
1924 case DT_DEBUG: return "DEBUG";
1925 case DT_TEXTREL: return "TEXTREL";
1926 case DT_JMPREL: return "JMPREL";
1927 case DT_BIND_NOW: return "BIND_NOW";
1928 case DT_INIT_ARRAY: return "INIT_ARRAY";
1929 case DT_FINI_ARRAY: return "FINI_ARRAY";
1930 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1931 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1932 case DT_RUNPATH: return "RUNPATH";
1933 case DT_FLAGS: return "FLAGS";
2d0e6f43 1934
d1133906
NC		 1935 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1936 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1937
05107a46 1938 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1939 case DT_PLTPADSZ: return "PLTPADSZ";
1940 case DT_MOVEENT: return "MOVEENT";
1941 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1942 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1943 case DT_POSFLAG_1: return "POSFLAG_1";
1944 case DT_SYMINSZ: return "SYMINSZ";
1945 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1946
252b5132 1947 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1948 case DT_CONFIG: return "CONFIG";
1949 case DT_DEPAUDIT: return "DEPAUDIT";
1950 case DT_AUDIT: return "AUDIT";
1951 case DT_PLTPAD: return "PLTPAD";
1952 case DT_MOVETAB: return "MOVETAB";
252b5132 1953 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1954
252b5132 1955 case DT_VERSYM: return "VERSYM";
103f02d3 1956
67a4f2b7
AO		 1957 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1958 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1959 case DT_RELACOUNT: return "RELACOUNT";
1960 case DT_RELCOUNT: return "RELCOUNT";
1961 case DT_FLAGS_1: return "FLAGS_1";
1962 case DT_VERDEF: return "VERDEF";
1963 case DT_VERDEFNUM: return "VERDEFNUM";
1964 case DT_VERNEED: return "VERNEED";
1965 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1966
019148e4 1967 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1968 case DT_USED: return "USED";
1969 case DT_FILTER: return "FILTER";
103f02d3 1970
047b2264
JJ		 1971 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1972 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1973 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1974 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1975 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1976 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1977
252b5132
RH		 1978 default:
1979 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1980 {
2cf0635d 1981 const char * result;
103f02d3 1982
252b5132
RH		 1983 switch (elf_header.e_machine)
1984 {
1985 case EM_MIPS:
4fe85591 1986 case EM_MIPS_RS3_LE:
252b5132
RH		 1987 result = get_mips_dynamic_type (type);
1988 break;
9a097730
RH		 1989 case EM_SPARCV9:
1990 result = get_sparc64_dynamic_type (type);
1991 break;
7490d522
AM		 1992 case EM_PPC:
1993 result = get_ppc_dynamic_type (type);
1994 break;
f1cb7e17
AM		 1995 case EM_PPC64:
1996 result = get_ppc64_dynamic_type (type);
1997 break;
ecc51f48
NC		 1998 case EM_IA_64:
1999 result = get_ia64_dynamic_type (type);
2000 break;
fabcb361
RH		 2001 case EM_ALPHA:
2002 result = get_alpha_dynamic_type (type);
2003 break;
1c0d3aa6
NC		 2004 case EM_SCORE:
2005 result = get_score_dynamic_type (type);
2006 break;
40b36596
JM		 2007 case EM_TI_C6000:
2008 result = get_tic6x_dynamic_type (type);
2009 break;
36591ba1
SL		 2010 case EM_ALTERA_NIOS2:
2011 result = get_nios2_dynamic_type (type);
2012 break;
252b5132
RH		 2013 default:
2014 result = NULL;
2015 break;
2016 }
2017
2018 if (result != NULL)
2019 return result;
2020
e9e44622 2021 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 2022 }
eec8f817
DA		 2023 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2024 || (elf_header.e_machine == EM_PARISC
2025 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 2026 {
2cf0635d 2027 const char * result;
103f02d3
UD		 2028
2029 switch (elf_header.e_machine)
2030 {
2031 case EM_PARISC:
2032 result = get_parisc_dynamic_type (type);
2033 break;
148b93f2
NC		 2034 case EM_IA_64:
2035 result = get_ia64_dynamic_type (type);
2036 break;
103f02d3
UD		 2037 default:
2038 result = NULL;
2039 break;
2040 }
2041
2042 if (result != NULL)
2043 return result;
2044
e9e44622
JJ		 2045 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2046 type);
103f02d3 2047 }
252b5132 2048 else
e9e44622 2049 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 2050
252b5132
RH		 2051 return buff;
2052 }
2053}
2054
2055static char *
d3ba0551 2056get_file_type (unsigned e_type)
252b5132 2057{
b34976b6 2058 static char buff[32];
252b5132
RH		 2059
2060 switch (e_type)
2061 {
2062 case ET_NONE: return _("NONE (None)");
2063 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 2064 case ET_EXEC: return _("EXEC (Executable file)");
2065 case ET_DYN: return _("DYN (Shared object file)");
2066 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 2067
2068 default:
2069 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 2070 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 2071 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 2072 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 2073 else
e9e44622 2074 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 2075 return buff;
2076 }
2077}
2078
2079static char *
d3ba0551 2080get_machine_name (unsigned e_machine)
252b5132 2081{
b34976b6 2082 static char buff[64]; /* XXX */
252b5132
RH		 2083
2084 switch (e_machine)
2085 {
c45021f2 2086 case EM_NONE: return _("None");
a06ea964 2087 case EM_AARCH64: return "AArch64";
c45021f2
NC		 2088 case EM_M32: return "WE32100";
2089 case EM_SPARC: return "Sparc";
e9f53129 2090 case EM_SPU: return "SPU";
c45021f2
NC		 2091 case EM_386: return "Intel 80386";
2092 case EM_68K: return "MC68000";
2093 case EM_88K: return "MC88000";
2094 case EM_486: return "Intel 80486";
2095 case EM_860: return "Intel 80860";
2096 case EM_MIPS: return "MIPS R3000";
2097 case EM_S370: return "IBM System/370";
7036c0e1 2098 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 2099 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 2100 case EM_PARISC: return "HPPA";
252b5132 2101 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 2102 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 2103 case EM_960: return "Intel 90860";
2104 case EM_PPC: return "PowerPC";
285d1771 2105 case EM_PPC64: return "PowerPC64";
c45021f2 2106 case EM_FR20: return "Fujitsu FR20";
3f8107ab 2107 case EM_FT32: return "FTDI FT32";
c45021f2 2108 case EM_RH32: return "TRW RH32";
b34976b6 2109 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 2110 case EM_ARM: return "ARM";
2111 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 2112 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 2113 case EM_SPARCV9: return "Sparc v9";
2114 case EM_TRICORE: return "Siemens Tricore";
584da044 2115 case EM_ARC: return "ARC";
c2dcd04e
NC		 2116 case EM_H8_300: return "Renesas H8/300";
2117 case EM_H8_300H: return "Renesas H8/300H";
2118 case EM_H8S: return "Renesas H8S";
2119 case EM_H8_500: return "Renesas H8/500";
30800947 2120 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 2121 case EM_MIPS_X: return "Stanford MIPS-X";
2122 case EM_COLDFIRE: return "Motorola Coldfire";
c45021f2 2123 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 2124 case EM_CYGNUS_D10V:
2125 case EM_D10V: return "d10v";
2126 case EM_CYGNUS_D30V:
b34976b6 2127 case EM_D30V: return "d30v";
2b0337b0 2128 case EM_CYGNUS_M32R:
26597c86 2129 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 2130 case EM_CYGNUS_V850:
708e2187 2131 case EM_V800: return "Renesas V850 (using RH850 ABI)";
f6c1a2d5 2132 case EM_V850: return "Renesas V850";
2b0337b0
AO		 2133 case EM_CYGNUS_MN10300:
2134 case EM_MN10300: return "mn10300";
2135 case EM_CYGNUS_MN10200:
2136 case EM_MN10200: return "mn10200";
5506d11a 2137 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 2138 case EM_CYGNUS_FR30:
2139 case EM_FR30: return "Fujitsu FR30";
b34976b6 2140 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 2141 case EM_PJ_OLD:
b34976b6 2142 case EM_PJ: return "picoJava";
7036c0e1
AJ		 2143 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2144 case EM_PCP: return "Siemens PCP";
2145 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2146 case EM_NDR1: return "Denso NDR1 microprocesspr";
2147 case EM_STARCORE: return "Motorola Star*Core processor";
2148 case EM_ME16: return "Toyota ME16 processor";
2149 case EM_ST100: return "STMicroelectronics ST100 processor";
2150 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 2151 case EM_PDSP: return "Sony DSP processor";
2152 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2153 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 2154 case EM_FX66: return "Siemens FX66 microcontroller";
2155 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2156 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2157 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
6927f982 2158 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ		 2159 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2160 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2161 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2162 case EM_SVX: return "Silicon Graphics SVx";
2163 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2164 case EM_VAX: return "Digital VAX";
619ed720 2165 case EM_VISIUM: return "CDS VISIUMcore processor";
2b0337b0 2166 case EM_AVR_OLD:
b34976b6 2167 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 2168 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 2169 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2170 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2171 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 2172 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 2173 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 2174 case EM_PRISM: return "Vitesse Prism";
bcedfee6 2175 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 2176 case EM_L1OM: return "Intel L1OM";
7a9068fe 2177 case EM_K1OM: return "Intel K1OM";
b7498e0e 2178 case EM_S390_OLD:
b34976b6 2179 case EM_S390: return "IBM S/390";
1c0d3aa6 2180 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 2181 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
73589c9d 2182 case EM_OR1K: return "OpenRISC 1000";
11636f9e 2183 case EM_ARC_A5: return "ARC International ARCompact processor";
1fe1f39c 2184 case EM_CRX: return "National Semiconductor CRX microprocessor";
cfb8c092 2185 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
d172d4ba 2186 case EM_DLX: return "OpenDLX";
1e4cf259 2187 case EM_IP2K_OLD:
b34976b6 2188 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 2189 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 2190 case EM_XTENSA_OLD:
2191 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 2192 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2193 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2194 case EM_NS32K: return "National Semiconductor 32000 series";
2195 case EM_TPC: return "Tenor Network TPC processor";
2196 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2197 case EM_MAX: return "MAX Processor";
2198 case EM_CR: return "National Semiconductor CompactRISC";
2199 case EM_F2MC16: return "Fujitsu F2MC16";
2200 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 2201 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 2202 case EM_M32C_OLD:
49f58d10 2203 case EM_M32C: return "Renesas M32c";
d031aafb 2204 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 2205 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 2206 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2207 case EM_SEP: return "Sharp embedded microprocessor";
2208 case EM_ARCA: return "Arca RISC microprocessor";
2209 case EM_UNICORE: return "Unicore";
2210 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2211 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 2212 case EM_NIOS32: return "Altera Nios";
2213 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 2214 case EM_C166:
d70c5fc7 2215 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 2216 case EM_M16C: return "Renesas M16C series microprocessors";
2217 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2218 case EM_CE: return "Freescale Communication Engine RISC core";
2219 case EM_TSK3000: return "Altium TSK3000 core";
2220 case EM_RS08: return "Freescale RS08 embedded processor";
2221 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2222 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2223 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2224 case EM_SE_C17: return "Seiko Epson C17 family";
2225 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2226 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2227 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2228 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2229 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2230 case EM_R32C: return "Renesas R32C series microprocessors";
2231 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2232 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2233 case EM_8051: return "Intel 8051 and variants";
2234 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2235 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2236 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2237 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2238 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2239 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2240 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 2241 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 2242 case EM_CR16:
f6c1a2d5 2243 case EM_MICROBLAZE:
7ba29e2a 2244 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
99c513f6 2245 case EM_RL78: return "Renesas RL78";
c7927a3c 2246 case EM_RX: return "Renesas RX";
a3c62988 2247 case EM_METAG: return "Imagination Technologies Meta processor architecture";
11636f9e
JM		 2248 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2249 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2250 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2251 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2252 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2253 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2254 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2255 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 2256 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 2257 case EM_CUDA: return "NVIDIA CUDA architecture";
f6c1a2d5 2258 case EM_XGATE: return "Motorola XGATE embedded processor";
252b5132 2259 default:
35d9dd2f 2260 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2261 return buff;
2262 }
2263}
2264
f3485b74 2265static void
d3ba0551 2266decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2267{
2268 unsigned eabi;
2269 int unknown = 0;
2270
2271 eabi = EF_ARM_EABI_VERSION (e_flags);
2272 e_flags &= ~ EF_ARM_EABIMASK;
2273
2274 /* Handle "generic" ARM flags. */
2275 if (e_flags & EF_ARM_RELEXEC)
2276 {
2277 strcat (buf, ", relocatable executable");
2278 e_flags &= ~ EF_ARM_RELEXEC;
2279 }
76da6bbe 2280
f3485b74
NC		 2281 /* Now handle EABI specific flags. */
2282 switch (eabi)
2283 {
2284 default:
2c71103e 2285 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2286 if (e_flags)
2287 unknown = 1;
2288 break;
2289
2290 case EF_ARM_EABI_VER1:
a5bcd848 2291 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2292 while (e_flags)
2293 {
2294 unsigned flag;
76da6bbe 2295
f3485b74
NC		 2296 /* Process flags one bit at a time. */
2297 flag = e_flags & - e_flags;
2298 e_flags &= ~ flag;
76da6bbe 2299
f3485b74
NC		 2300 switch (flag)
2301 {
a5bcd848 2302 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2303 strcat (buf, ", sorted symbol tables");
2304 break;
76da6bbe 2305
f3485b74
NC		 2306 default:
2307 unknown = 1;
2308 break;
2309 }
2310 }
2311 break;
76da6bbe 2312
a5bcd848
PB		 2313 case EF_ARM_EABI_VER2:
2314 strcat (buf, ", Version2 EABI");
2315 while (e_flags)
2316 {
2317 unsigned flag;
2318
2319 /* Process flags one bit at a time. */
2320 flag = e_flags & - e_flags;
2321 e_flags &= ~ flag;
2322
2323 switch (flag)
2324 {
2325 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2326 strcat (buf, ", sorted symbol tables");
2327 break;
2328
2329 case EF_ARM_DYNSYMSUSESEGIDX:
2330 strcat (buf, ", dynamic symbols use segment index");
2331 break;
2332
2333 case EF_ARM_MAPSYMSFIRST:
2334 strcat (buf, ", mapping symbols precede others");
2335 break;
2336
2337 default:
2338 unknown = 1;
2339 break;
2340 }
2341 }
2342 break;
2343
d507cf36
PB		 2344 case EF_ARM_EABI_VER3:
2345 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2346 break;
2347
2348 case EF_ARM_EABI_VER4:
2349 strcat (buf, ", Version4 EABI");
3bfcb652
NC		 2350 while (e_flags)
2351 {
2352 unsigned flag;
2353
2354 /* Process flags one bit at a time. */
2355 flag = e_flags & - e_flags;
2356 e_flags &= ~ flag;
2357
2358 switch (flag)
2359 {
2360 case EF_ARM_BE8:
2361 strcat (buf, ", BE8");
2362 break;
2363
2364 case EF_ARM_LE8:
2365 strcat (buf, ", LE8");
2366 break;
2367
2368 default:
2369 unknown = 1;
2370 break;
2371 }
2372 break;
2373 }
2374 break;
3a4a14e9
PB		 2375
2376 case EF_ARM_EABI_VER5:
2377 strcat (buf, ", Version5 EABI");
d507cf36
PB		 2378 while (e_flags)
2379 {
2380 unsigned flag;
2381
2382 /* Process flags one bit at a time. */
2383 flag = e_flags & - e_flags;
2384 e_flags &= ~ flag;
2385
2386 switch (flag)
2387 {
2388 case EF_ARM_BE8:
2389 strcat (buf, ", BE8");
2390 break;
2391
2392 case EF_ARM_LE8:
2393 strcat (buf, ", LE8");
2394 break;
2395
3bfcb652
NC		 2396 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2397 strcat (buf, ", soft-float ABI");
2398 break;
2399
2400 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2401 strcat (buf, ", hard-float ABI");
2402 break;
2403
d507cf36
PB		 2404 default:
2405 unknown = 1;
2406 break;
2407 }
2408 }
2409 break;
2410
f3485b74 2411 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2412 strcat (buf, ", GNU EABI");
f3485b74
NC		 2413 while (e_flags)
2414 {
2415 unsigned flag;
76da6bbe 2416
f3485b74
NC		 2417 /* Process flags one bit at a time. */
2418 flag = e_flags & - e_flags;
2419 e_flags &= ~ flag;
76da6bbe 2420
f3485b74
NC		 2421 switch (flag)
2422 {
a5bcd848 2423 case EF_ARM_INTERWORK:
f3485b74
NC		 2424 strcat (buf, ", interworking enabled");
2425 break;
76da6bbe 2426
a5bcd848 2427 case EF_ARM_APCS_26:
f3485b74
NC		 2428 strcat (buf, ", uses APCS/26");
2429 break;
76da6bbe 2430
a5bcd848 2431 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2432 strcat (buf, ", uses APCS/float");
2433 break;
76da6bbe 2434
a5bcd848 2435 case EF_ARM_PIC:
f3485b74
NC		 2436 strcat (buf, ", position independent");
2437 break;
76da6bbe 2438
a5bcd848 2439 case EF_ARM_ALIGN8:
f3485b74
NC		 2440 strcat (buf, ", 8 bit structure alignment");
2441 break;
76da6bbe 2442
a5bcd848 2443 case EF_ARM_NEW_ABI:
f3485b74
NC		 2444 strcat (buf, ", uses new ABI");
2445 break;
76da6bbe 2446
a5bcd848 2447 case EF_ARM_OLD_ABI:
f3485b74
NC		 2448 strcat (buf, ", uses old ABI");
2449 break;
76da6bbe 2450
a5bcd848 2451 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2452 strcat (buf, ", software FP");
2453 break;
76da6bbe 2454
90e01f86
ILT		 2455 case EF_ARM_VFP_FLOAT:
2456 strcat (buf, ", VFP");
2457 break;
2458
fde78edd
NC		 2459 case EF_ARM_MAVERICK_FLOAT:
2460 strcat (buf, ", Maverick FP");
2461 break;
2462
f3485b74
NC		 2463 default:
2464 unknown = 1;
2465 break;
2466 }
2467 }
2468 }
f3485b74
NC		 2469
2470 if (unknown)
2b692964 2471 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2472}
2473
343433df
AB		 2474static void
2475decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2476{
2477 --size; /* Leave space for null terminator. */
2478
2479 switch (e_flags & EF_AVR_MACH)
2480 {
2481 case E_AVR_MACH_AVR1:
2482 strncat (buf, ", avr:1", size);
2483 break;
2484 case E_AVR_MACH_AVR2:
2485 strncat (buf, ", avr:2", size);
2486 break;
2487 case E_AVR_MACH_AVR25:
2488 strncat (buf, ", avr:25", size);
2489 break;
2490 case E_AVR_MACH_AVR3:
2491 strncat (buf, ", avr:3", size);
2492 break;
2493 case E_AVR_MACH_AVR31:
2494 strncat (buf, ", avr:31", size);
2495 break;
2496 case E_AVR_MACH_AVR35:
2497 strncat (buf, ", avr:35", size);
2498 break;
2499 case E_AVR_MACH_AVR4:
2500 strncat (buf, ", avr:4", size);
2501 break;
2502 case E_AVR_MACH_AVR5:
2503 strncat (buf, ", avr:5", size);
2504 break;
2505 case E_AVR_MACH_AVR51:
2506 strncat (buf, ", avr:51", size);
2507 break;
2508 case E_AVR_MACH_AVR6:
2509 strncat (buf, ", avr:6", size);
2510 break;
2511 case E_AVR_MACH_AVRTINY:
2512 strncat (buf, ", avr:100", size);
2513 break;
2514 case E_AVR_MACH_XMEGA1:
2515 strncat (buf, ", avr:101", size);
2516 break;
2517 case E_AVR_MACH_XMEGA2:
2518 strncat (buf, ", avr:102", size);
2519 break;
2520 case E_AVR_MACH_XMEGA3:
2521 strncat (buf, ", avr:103", size);
2522 break;
2523 case E_AVR_MACH_XMEGA4:
2524 strncat (buf, ", avr:104", size);
2525 break;
2526 case E_AVR_MACH_XMEGA5:
2527 strncat (buf, ", avr:105", size);
2528 break;
2529 case E_AVR_MACH_XMEGA6:
2530 strncat (buf, ", avr:106", size);
2531 break;
2532 case E_AVR_MACH_XMEGA7:
2533 strncat (buf, ", avr:107", size);
2534 break;
2535 default:
2536 strncat (buf, ", avr:<unknown>", size);
2537 break;
2538 }
2539
2540 size -= strlen (buf);
2541 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2542 strncat (buf, ", link-relax", size);
2543}
2544
35c08157
KLC		 2545static void
2546decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2547{
2548 unsigned abi;
2549 unsigned arch;
2550 unsigned config;
2551 unsigned version;
2552 int has_fpu = 0;
2553 int r = 0;
2554
2555 static const char *ABI_STRINGS[] =
2556 {
2557 "ABI v0", /* use r5 as return register; only used in N1213HC */
2558 "ABI v1", /* use r0 as return register */
2559 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2560 "ABI v2fp", /* for FPU */
40c7a7cb
KLC		 2561 "AABI",
2562 "ABI2 FP+"
35c08157
KLC		 2563 };
2564 static const char *VER_STRINGS[] =
2565 {
2566 "Andes ELF V1.3 or older",
2567 "Andes ELF V1.3.1",
2568 "Andes ELF V1.4"
2569 };
2570 static const char *ARCH_STRINGS[] =
2571 {
2572 "",
2573 "Andes Star v1.0",
2574 "Andes Star v2.0",
2575 "Andes Star v3.0",
2576 "Andes Star v3.0m"
2577 };
2578
2579 abi = EF_NDS_ABI & e_flags;
2580 arch = EF_NDS_ARCH & e_flags;
2581 config = EF_NDS_INST & e_flags;
2582 version = EF_NDS32_ELF_VERSION & e_flags;
2583
2584 memset (buf, 0, size);
2585
2586 switch (abi)
2587 {
2588 case E_NDS_ABI_V0:
2589 case E_NDS_ABI_V1:
2590 case E_NDS_ABI_V2:
2591 case E_NDS_ABI_V2FP:
2592 case E_NDS_ABI_AABI:
40c7a7cb 2593 case E_NDS_ABI_V2FP_PLUS:
35c08157
KLC		 2594 /* In case there are holes in the array. */
2595 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2596 break;
2597
2598 default:
2599 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2600 break;
2601 }
2602
2603 switch (version)
2604 {
2605 case E_NDS32_ELF_VER_1_2:
2606 case E_NDS32_ELF_VER_1_3:
2607 case E_NDS32_ELF_VER_1_4:
2608 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2609 break;
2610
2611 default:
2612 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2613 break;
2614 }
2615
2616 if (E_NDS_ABI_V0 == abi)
2617 {
2618 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2619 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2620 if (arch == E_NDS_ARCH_STAR_V1_0)
2621 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2622 return;
2623 }
2624
2625 switch (arch)
2626 {
2627 case E_NDS_ARCH_STAR_V1_0:
2628 case E_NDS_ARCH_STAR_V2_0:
2629 case E_NDS_ARCH_STAR_V3_0:
2630 case E_NDS_ARCH_STAR_V3_M:
2631 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2632 break;
2633
2634 default:
2635 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2636 /* ARCH version determines how the e_flags are interpreted.
2637 If it is unknown, we cannot proceed. */
2638 return;
2639 }
2640
2641 /* Newer ABI; Now handle architecture specific flags. */
2642 if (arch == E_NDS_ARCH_STAR_V1_0)
2643 {
2644 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2645 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2646
2647 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2648 r += snprintf (buf + r, size -r, ", MAC");
2649
2650 if (config & E_NDS32_HAS_DIV_INST)
2651 r += snprintf (buf + r, size -r, ", DIV");
2652
2653 if (config & E_NDS32_HAS_16BIT_INST)
2654 r += snprintf (buf + r, size -r, ", 16b");
2655 }
2656 else
2657 {
2658 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2659 {
2660 if (version <= E_NDS32_ELF_VER_1_3)
2661 r += snprintf (buf + r, size -r, ", [B8]");
2662 else
2663 r += snprintf (buf + r, size -r, ", EX9");
2664 }
2665
2666 if (config & E_NDS32_HAS_MAC_DX_INST)
2667 r += snprintf (buf + r, size -r, ", MAC_DX");
2668
2669 if (config & E_NDS32_HAS_DIV_DX_INST)
2670 r += snprintf (buf + r, size -r, ", DIV_DX");
2671
2672 if (config & E_NDS32_HAS_16BIT_INST)
2673 {
2674 if (version <= E_NDS32_ELF_VER_1_3)
2675 r += snprintf (buf + r, size -r, ", 16b");
2676 else
2677 r += snprintf (buf + r, size -r, ", IFC");
2678 }
2679 }
2680
2681 if (config & E_NDS32_HAS_EXT_INST)
2682 r += snprintf (buf + r, size -r, ", PERF1");
2683
2684 if (config & E_NDS32_HAS_EXT2_INST)
2685 r += snprintf (buf + r, size -r, ", PERF2");
2686
2687 if (config & E_NDS32_HAS_FPU_INST)
2688 {
2689 has_fpu = 1;
2690 r += snprintf (buf + r, size -r, ", FPU_SP");
2691 }
2692
2693 if (config & E_NDS32_HAS_FPU_DP_INST)
2694 {
2695 has_fpu = 1;
2696 r += snprintf (buf + r, size -r, ", FPU_DP");
2697 }
2698
2699 if (config & E_NDS32_HAS_FPU_MAC_INST)
2700 {
2701 has_fpu = 1;
2702 r += snprintf (buf + r, size -r, ", FPU_MAC");
2703 }
2704
2705 if (has_fpu)
2706 {
2707 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2708 {
2709 case E_NDS32_FPU_REG_8SP_4DP:
2710 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2711 break;
2712 case E_NDS32_FPU_REG_16SP_8DP:
2713 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2714 break;
2715 case E_NDS32_FPU_REG_32SP_16DP:
2716 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2717 break;
2718 case E_NDS32_FPU_REG_32SP_32DP:
2719 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2720 break;
2721 }
2722 }
2723
2724 if (config & E_NDS32_HAS_AUDIO_INST)
2725 r += snprintf (buf + r, size -r, ", AUDIO");
2726
2727 if (config & E_NDS32_HAS_STRING_INST)
2728 r += snprintf (buf + r, size -r, ", STR");
2729
2730 if (config & E_NDS32_HAS_REDUCED_REGS)
2731 r += snprintf (buf + r, size -r, ", 16REG");
2732
2733 if (config & E_NDS32_HAS_VIDEO_INST)
2734 {
2735 if (version <= E_NDS32_ELF_VER_1_3)
2736 r += snprintf (buf + r, size -r, ", VIDEO");
2737 else
2738 r += snprintf (buf + r, size -r, ", SATURATION");
2739 }
2740
2741 if (config & E_NDS32_HAS_ENCRIPT_INST)
2742 r += snprintf (buf + r, size -r, ", ENCRP");
2743
2744 if (config & E_NDS32_HAS_L2C_INST)
2745 r += snprintf (buf + r, size -r, ", L2C");
2746}
2747
252b5132 2748static char *
d3ba0551 2749get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2750{
b34976b6 2751 static char buf[1024];
252b5132
RH		 2752
2753 buf[0] = '\0';
76da6bbe 2754
252b5132
RH		 2755 if (e_flags)
2756 {
2757 switch (e_machine)
2758 {
2759 default:
2760 break;
2761
f3485b74
NC		 2762 case EM_ARM:
2763 decode_ARM_machine_flags (e_flags, buf);
2764 break;
76da6bbe 2765
343433df
AB		 2766 case EM_AVR:
2767 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2768 break;
2769
781303ce
MF		 2770 case EM_BLACKFIN:
2771 if (e_flags & EF_BFIN_PIC)
2772 strcat (buf, ", PIC");
2773
2774 if (e_flags & EF_BFIN_FDPIC)
2775 strcat (buf, ", FDPIC");
2776
2777 if (e_flags & EF_BFIN_CODE_IN_L1)
2778 strcat (buf, ", code in L1");
2779
2780 if (e_flags & EF_BFIN_DATA_IN_L1)
2781 strcat (buf, ", data in L1");
2782
2783 break;
2784
ec2dfb42
AO		 2785 case EM_CYGNUS_FRV:
2786 switch (e_flags & EF_FRV_CPU_MASK)
2787 {
2788 case EF_FRV_CPU_GENERIC:
2789 break;
2790
2791 default:
2792 strcat (buf, ", fr???");
2793 break;
57346661 2794
ec2dfb42
AO		 2795 case EF_FRV_CPU_FR300:
2796 strcat (buf, ", fr300");
2797 break;
2798
2799 case EF_FRV_CPU_FR400:
2800 strcat (buf, ", fr400");
2801 break;
2802 case EF_FRV_CPU_FR405:
2803 strcat (buf, ", fr405");
2804 break;
2805
2806 case EF_FRV_CPU_FR450:
2807 strcat (buf, ", fr450");
2808 break;
2809
2810 case EF_FRV_CPU_FR500:
2811 strcat (buf, ", fr500");
2812 break;
2813 case EF_FRV_CPU_FR550:
2814 strcat (buf, ", fr550");
2815 break;
2816
2817 case EF_FRV_CPU_SIMPLE:
2818 strcat (buf, ", simple");
2819 break;
2820 case EF_FRV_CPU_TOMCAT:
2821 strcat (buf, ", tomcat");
2822 break;
2823 }
1c877e87 2824 break;
ec2dfb42 2825
53c7db4b 2826 case EM_68K:
425c6cb0 2827 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2828 strcat (buf, ", m68000");
425c6cb0 2829 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2830 strcat (buf, ", cpu32");
2831 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2832 strcat (buf, ", fido_a");
425c6cb0 2833 else
266abb8f 2834 {
2cf0635d
NC		 2835 char const * isa = _("unknown");
2836 char const * mac = _("unknown mac");
2837 char const * additional = NULL;
0112cd26 2838
c694fd50 2839 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2840 {
c694fd50 2841 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2842 isa = "A";
2843 additional = ", nodiv";
2844 break;
c694fd50 2845 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2846 isa = "A";
2847 break;
c694fd50 2848 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2849 isa = "A+";
2850 break;
c694fd50 2851 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2852 isa = "B";
2853 additional = ", nousp";
2854 break;
c694fd50 2855 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2856 isa = "B";
2857 break;
f608cd77
NS		 2858 case EF_M68K_CF_ISA_C:
2859 isa = "C";
2860 break;
2861 case EF_M68K_CF_ISA_C_NODIV:
2862 isa = "C";
2863 additional = ", nodiv";
2864 break;
266abb8f
NS		 2865 }
2866 strcat (buf, ", cf, isa ");
2867 strcat (buf, isa);
0b2e31dc
NS		 2868 if (additional)
2869 strcat (buf, additional);
c694fd50 2870 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2871 strcat (buf, ", float");
c694fd50 2872 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2873 {
2874 case 0:
2875 mac = NULL;
2876 break;
c694fd50 2877 case EF_M68K_CF_MAC:
266abb8f
NS		 2878 mac = "mac";
2879 break;
c694fd50 2880 case EF_M68K_CF_EMAC:
266abb8f
NS		 2881 mac = "emac";
2882 break;
f608cd77
NS		 2883 case EF_M68K_CF_EMAC_B:
2884 mac = "emac_b";
2885 break;
266abb8f
NS		 2886 }
2887 if (mac)
2888 {
2889 strcat (buf, ", ");
2890 strcat (buf, mac);
2891 }
266abb8f 2892 }
53c7db4b 2893 break;
33c63f9d 2894
153a2776
NC		 2895 case EM_CYGNUS_MEP:
2896 switch (e_flags & EF_MEP_CPU_MASK)
2897 {
2898 case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
2899 case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
2900 case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
2901 case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
2902 case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
2903 case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
2904 default: strcat (buf, _(", <unknown MeP cpu type>")); break;
2905 }
2906
2907 switch (e_flags & EF_MEP_COP_MASK)
2908 {
2909 case EF_MEP_COP_NONE: break;
2910 case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
2911 case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
2912 case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
2913 case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
2914 default: strcat (buf, _("<unknown MeP copro type>")); break;
2915 }
2916
2917 if (e_flags & EF_MEP_LIBRARY)
2918 strcat (buf, ", Built for Library");
2919
2920 if (e_flags & EF_MEP_INDEX_MASK)
2921 sprintf (buf + strlen (buf), ", Configuration Index: %#x",
2922 e_flags & EF_MEP_INDEX_MASK);
2923
2924 if (e_flags & ~ EF_MEP_ALL_FLAGS)
2925 sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
2926 e_flags & ~ EF_MEP_ALL_FLAGS);
2927 break;
2928
252b5132
RH		 2929 case EM_PPC:
2930 if (e_flags & EF_PPC_EMB)
2931 strcat (buf, ", emb");
2932
2933 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2934 strcat (buf, _(", relocatable"));
252b5132
RH		 2935
2936 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 2937 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 2938 break;
2939
ee67d69a
AM		 2940 case EM_PPC64:
2941 if (e_flags & EF_PPC64_ABI)
2942 {
2943 char abi[] = ", abiv0";
2944
2945 abi[6] += e_flags & EF_PPC64_ABI;
2946 strcat (buf, abi);
2947 }
2948 break;
2949
708e2187
NC		 2950 case EM_V800:
2951 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2952 strcat (buf, ", RH850 ABI");
0b4362b0 2953
708e2187
NC		 2954 if (e_flags & EF_V800_850E3)
2955 strcat (buf, ", V3 architecture");
2956
2957 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2958 strcat (buf, ", FPU not used");
2959
2960 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2961 strcat (buf, ", regmode: COMMON");
2962
2963 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2964 strcat (buf, ", r4 not used");
2965
2966 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2967 strcat (buf, ", r30 not used");
2968
2969 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2970 strcat (buf, ", r5 not used");
2971
2972 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2973 strcat (buf, ", r2 not used");
2974
2975 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2976 {
2977 switch (e_flags & - e_flags)
2978 {
2979 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2980 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
708e2187
NC		 2981 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2982 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
708e2187
NC		 2983 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2984 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2985 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2986 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2987 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2988 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2989 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2990 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2991 default: break;
2992 }
2993 }
2994 break;
2995
2b0337b0 2996 case EM_V850:
252b5132
RH		 2997 case EM_CYGNUS_V850:
2998 switch (e_flags & EF_V850_ARCH)
2999 {
78c8d46c
NC		 3000 case E_V850E3V5_ARCH:
3001 strcat (buf, ", v850e3v5");
3002 break;
1cd986c5
NC		 3003 case E_V850E2V3_ARCH:
3004 strcat (buf, ", v850e2v3");
3005 break;
3006 case E_V850E2_ARCH:
3007 strcat (buf, ", v850e2");
3008 break;
3009 case E_V850E1_ARCH:
3010 strcat (buf, ", v850e1");
8ad30312 3011 break;
252b5132
RH		 3012 case E_V850E_ARCH:
3013 strcat (buf, ", v850e");
3014 break;
252b5132
RH		 3015 case E_V850_ARCH:
3016 strcat (buf, ", v850");
3017 break;
3018 default:
2b692964 3019 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 3020 break;
3021 }
3022 break;
3023
2b0337b0 3024 case EM_M32R:
252b5132
RH		 3025 case EM_CYGNUS_M32R:
3026 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3027 strcat (buf, ", m32r");
252b5132
RH		 3028 break;
3029
3030 case EM_MIPS:
4fe85591 3031 case EM_MIPS_RS3_LE:
252b5132
RH		 3032 if (e_flags & EF_MIPS_NOREORDER)
3033 strcat (buf, ", noreorder");
3034
3035 if (e_flags & EF_MIPS_PIC)
3036 strcat (buf, ", pic");
3037
3038 if (e_flags & EF_MIPS_CPIC)
3039 strcat (buf, ", cpic");
3040
d1bdd336
TS		 3041 if (e_flags & EF_MIPS_UCODE)
3042 strcat (buf, ", ugen_reserved");
3043
252b5132
RH		 3044 if (e_flags & EF_MIPS_ABI2)
3045 strcat (buf, ", abi2");
3046
43521d43
TS		 3047 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3048 strcat (buf, ", odk first");
3049
a5d22d2a
TS		 3050 if (e_flags & EF_MIPS_32BITMODE)
3051 strcat (buf, ", 32bitmode");
3052
ba92f887
MR		 3053 if (e_flags & EF_MIPS_NAN2008)
3054 strcat (buf, ", nan2008");
3055
fef1b0b3
SE		 3056 if (e_flags & EF_MIPS_FP64)
3057 strcat (buf, ", fp64");
3058
156c2f8b
NC		 3059 switch ((e_flags & EF_MIPS_MACH))
3060 {
3061 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3062 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3063 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 3064 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 3065 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3066 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3067 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3068 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 3069 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 3070 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 3071 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3072 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 3073 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 3074 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 3075 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
d32e5c54 3076 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
52b6b6b9 3077 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 3078 case 0:
3079 /* We simply ignore the field in this case to avoid confusion:
3080 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3081 extension. */
3082 break;
2b692964 3083 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 3084 }
43521d43
TS		 3085
3086 switch ((e_flags & EF_MIPS_ABI))
3087 {
3088 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3089 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3090 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3091 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3092 case 0:
3093 /* We simply ignore the field in this case to avoid confusion:
3094 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3095 This means it is likely to be an o32 file, but not for
3096 sure. */
3097 break;
2b692964 3098 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 3099 }
3100
3101 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3102 strcat (buf, ", mdmx");
3103
3104 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3105 strcat (buf, ", mips16");
3106
df58fc94
RS		 3107 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3108 strcat (buf, ", micromips");
3109
43521d43
TS		 3110 switch ((e_flags & EF_MIPS_ARCH))
3111 {
3112 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3113 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3114 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3115 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3116 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3117 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 3118 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
7361da2c 3119 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
43521d43 3120 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 3121 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
7361da2c 3122 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
2b692964 3123 default: strcat (buf, _(", unknown ISA")); break;
43521d43 3124 }
252b5132 3125 break;
351b4b40 3126
35c08157
KLC		 3127 case EM_NDS32:
3128 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3129 break;
3130
ccde1100
AO		 3131 case EM_SH:
3132 switch ((e_flags & EF_SH_MACH_MASK))
3133 {
3134 case EF_SH1: strcat (buf, ", sh1"); break;
3135 case EF_SH2: strcat (buf, ", sh2"); break;
3136 case EF_SH3: strcat (buf, ", sh3"); break;
3137 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3138 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3139 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3140 case EF_SH3E: strcat (buf, ", sh3e"); break;
3141 case EF_SH4: strcat (buf, ", sh4"); break;
3142 case EF_SH5: strcat (buf, ", sh5"); break;
3143 case EF_SH2E: strcat (buf, ", sh2e"); break;
3144 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 3145 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 3146 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3147 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 3148 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 3149 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3150 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3151 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3152 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3153 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3154 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 3155 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 3156 }
3157
cec6a5b8
MR		 3158 if (e_flags & EF_SH_PIC)
3159 strcat (buf, ", pic");
3160
3161 if (e_flags & EF_SH_FDPIC)
3162 strcat (buf, ", fdpic");
ccde1100 3163 break;
948f632f 3164
73589c9d
CS		 3165 case EM_OR1K:
3166 if (e_flags & EF_OR1K_NODELAY)
3167 strcat (buf, ", no delay");
3168 break;
57346661 3169
351b4b40
RH		 3170 case EM_SPARCV9:
3171 if (e_flags & EF_SPARC_32PLUS)
3172 strcat (buf, ", v8+");
3173
3174 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 3175 strcat (buf, ", ultrasparcI");
3176
3177 if (e_flags & EF_SPARC_SUN_US3)
3178 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 3179
3180 if (e_flags & EF_SPARC_HAL_R1)
3181 strcat (buf, ", halr1");
3182
3183 if (e_flags & EF_SPARC_LEDATA)
3184 strcat (buf, ", ledata");
3185
3186 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3187 strcat (buf, ", tso");
3188
3189 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3190 strcat (buf, ", pso");
3191
3192 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3193 strcat (buf, ", rmo");
3194 break;
7d466069 3195
103f02d3
UD		 3196 case EM_PARISC:
3197 switch (e_flags & EF_PARISC_ARCH)
3198 {
3199 case EFA_PARISC_1_0:
3200 strcpy (buf, ", PA-RISC 1.0");
3201 break;
3202 case EFA_PARISC_1_1:
3203 strcpy (buf, ", PA-RISC 1.1");
3204 break;
3205 case EFA_PARISC_2_0:
3206 strcpy (buf, ", PA-RISC 2.0");
3207 break;
3208 default:
3209 break;
3210 }
3211 if (e_flags & EF_PARISC_TRAPNIL)
3212 strcat (buf, ", trapnil");
3213 if (e_flags & EF_PARISC_EXT)
3214 strcat (buf, ", ext");
3215 if (e_flags & EF_PARISC_LSB)
3216 strcat (buf, ", lsb");
3217 if (e_flags & EF_PARISC_WIDE)
3218 strcat (buf, ", wide");
3219 if (e_flags & EF_PARISC_NO_KABP)
3220 strcat (buf, ", no kabp");
3221 if (e_flags & EF_PARISC_LAZYSWAP)
3222 strcat (buf, ", lazyswap");
30800947 3223 break;
76da6bbe 3224
7d466069 3225 case EM_PJ:
2b0337b0 3226 case EM_PJ_OLD:
7d466069
ILT		 3227 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3228 strcat (buf, ", new calling convention");
3229
3230 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3231 strcat (buf, ", gnu calling convention");
3232 break;
4d6ed7c8
NC		 3233
3234 case EM_IA_64:
3235 if ((e_flags & EF_IA_64_ABI64))
3236 strcat (buf, ", 64-bit");
3237 else
3238 strcat (buf, ", 32-bit");
3239 if ((e_flags & EF_IA_64_REDUCEDFP))
3240 strcat (buf, ", reduced fp model");
3241 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3242 strcat (buf, ", no function descriptors, constant gp");
3243 else if ((e_flags & EF_IA_64_CONS_GP))
3244 strcat (buf, ", constant gp");
3245 if ((e_flags & EF_IA_64_ABSOLUTE))
3246 strcat (buf, ", absolute");
28f997cf
TG		 3247 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3248 {
3249 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3250 strcat (buf, ", vms_linkages");
3251 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3252 {
3253 case EF_IA_64_VMS_COMCOD_SUCCESS:
3254 break;
3255 case EF_IA_64_VMS_COMCOD_WARNING:
3256 strcat (buf, ", warning");
3257 break;
3258 case EF_IA_64_VMS_COMCOD_ERROR:
3259 strcat (buf, ", error");
3260 break;
3261 case EF_IA_64_VMS_COMCOD_ABORT:
3262 strcat (buf, ", abort");
3263 break;
3264 default:
bee0ee85
NC		 3265 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3266 e_flags & EF_IA_64_VMS_COMCOD);
3267 strcat (buf, ", <unknown>");
28f997cf
TG		 3268 }
3269 }
4d6ed7c8 3270 break;
179d3252
JT		 3271
3272 case EM_VAX:
3273 if ((e_flags & EF_VAX_NONPIC))
3274 strcat (buf, ", non-PIC");
3275 if ((e_flags & EF_VAX_DFLOAT))
3276 strcat (buf, ", D-Float");
3277 if ((e_flags & EF_VAX_GFLOAT))
3278 strcat (buf, ", G-Float");
3279 break;
c7927a3c 3280
619ed720
EB		 3281 case EM_VISIUM:
3282 if (e_flags & EF_VISIUM_ARCH_MCM)
3283 strcat (buf, ", mcm");
3284 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3285 strcat (buf, ", mcm24");
3286 if (e_flags & EF_VISIUM_ARCH_GR6)
3287 strcat (buf, ", gr6");
3288 break;
3289
4046d87a 3290 case EM_RL78:
1740ba0c
NC		 3291 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3292 {
3293 case E_FLAG_RL78_ANY_CPU: break;
3294 case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3295 case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3296 case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3297 }
856ea05c
KP		 3298 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3299 strcat (buf, ", 64-bit doubles");
4046d87a 3300 break;
0b4362b0 3301
c7927a3c
NC		 3302 case EM_RX:
3303 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3304 strcat (buf, ", 64-bit doubles");
3305 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 3306 strcat (buf, ", dsp");
d4cb0ea0 3307 if (e_flags & E_FLAG_RX_PID)
0b4362b0 3308 strcat (buf, ", pid");
708e2187
NC		 3309 if (e_flags & E_FLAG_RX_ABI)
3310 strcat (buf, ", RX ABI");
3525236c
NC		 3311 if (e_flags & E_FLAG_RX_SINSNS_SET)
3312 strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3313 ? ", uses String instructions" : ", bans String instructions");
d4cb0ea0 3314 break;
55786da2
AK		 3315
3316 case EM_S390:
3317 if (e_flags & EF_S390_HIGH_GPRS)
3318 strcat (buf, ", highgprs");
d4cb0ea0 3319 break;
40b36596
JM		 3320
3321 case EM_TI_C6000:
3322 if ((e_flags & EF_C6000_REL))
3323 strcat (buf, ", relocatable module");
d4cb0ea0 3324 break;
13761a11
NC		 3325
3326 case EM_MSP430:
3327 strcat (buf, _(": architecture variant: "));
3328 switch (e_flags & EF_MSP430_MACH)
3329 {
3330 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3331 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3332 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3333 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3334 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3335 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3336 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3337 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3338 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3339 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3340 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3341 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3342 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3343 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3344 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3345 default:
3346 strcat (buf, _(": unknown")); break;
3347 }
3348
3349 if (e_flags & ~ EF_MSP430_MACH)
3350 strcat (buf, _(": unknown extra flag bits also present"));
252b5132
RH		 3351 }
3352 }
3353
3354 return buf;
3355}
3356
252b5132 3357static const char *
d3ba0551
AM		 3358get_osabi_name (unsigned int osabi)
3359{
3360 static char buff[32];
3361
3362 switch (osabi)
3363 {
3364 case ELFOSABI_NONE: return "UNIX - System V";
3365 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3366 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 3367 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 3368 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3369 case ELFOSABI_AIX: return "UNIX - AIX";
3370 case ELFOSABI_IRIX: return "UNIX - IRIX";
3371 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3372 case ELFOSABI_TRU64: return "UNIX - TRU64";
3373 case ELFOSABI_MODESTO: return "Novell - Modesto";
3374 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3375 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3376 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 3377 case ELFOSABI_AROS: return "AROS";
11636f9e 3378 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 3379 default:
40b36596
JM		 3380 if (osabi >= 64)
3381 switch (elf_header.e_machine)
3382 {
3383 case EM_ARM:
3384 switch (osabi)
3385 {
3386 case ELFOSABI_ARM: return "ARM";
3387 default:
3388 break;
3389 }
3390 break;
3391
3392 case EM_MSP430:
3393 case EM_MSP430_OLD:
619ed720 3394 case EM_VISIUM:
40b36596
JM		 3395 switch (osabi)
3396 {
3397 case ELFOSABI_STANDALONE: return _("Standalone App");
3398 default:
3399 break;
3400 }
3401 break;
3402
3403 case EM_TI_C6000:
3404 switch (osabi)
3405 {
3406 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3407 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3408 default:
3409 break;
3410 }
3411 break;
3412
3413 default:
3414 break;
3415 }
e9e44622 3416 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 3417 return buff;
3418 }
3419}
3420
a06ea964
NC		 3421static const char *
3422get_aarch64_segment_type (unsigned long type)
3423{
3424 switch (type)
3425 {
3426 case PT_AARCH64_ARCHEXT:
3427 return "AARCH64_ARCHEXT";
3428 default:
3429 break;
3430 }
3431
3432 return NULL;
3433}
3434
b294bdf8
MM		 3435static const char *
3436get_arm_segment_type (unsigned long type)
3437{
3438 switch (type)
3439 {
3440 case PT_ARM_EXIDX:
3441 return "EXIDX";
3442 default:
3443 break;
3444 }
3445
3446 return NULL;
3447}
3448
d3ba0551
AM		 3449static const char *
3450get_mips_segment_type (unsigned long type)
252b5132
RH		 3451{
3452 switch (type)
3453 {
3454 case PT_MIPS_REGINFO:
3455 return "REGINFO";
3456 case PT_MIPS_RTPROC:
3457 return "RTPROC";
3458 case PT_MIPS_OPTIONS:
3459 return "OPTIONS";
351cdf24
MF		 3460 case PT_MIPS_ABIFLAGS:
3461 return "ABIFLAGS";
252b5132
RH		 3462 default:
3463 break;
3464 }
3465
3466 return NULL;
3467}
3468
103f02d3 3469static const char *
d3ba0551 3470get_parisc_segment_type (unsigned long type)
103f02d3
UD		 3471{
3472 switch (type)
3473 {
3474 case PT_HP_TLS: return "HP_TLS";
3475 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3476 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3477 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3478 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3479 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3480 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3481 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3482 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3483 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3484 case PT_HP_PARALLEL: return "HP_PARALLEL";
3485 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 3486 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3487 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3488 case PT_HP_STACK: return "HP_STACK";
3489 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 3490 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3491 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 3492 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 3493 default:
3494 break;
3495 }
3496
3497 return NULL;
3498}
3499
4d6ed7c8 3500static const char *
d3ba0551 3501get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 3502{
3503 switch (type)
3504 {
3505 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3506 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 3507 case PT_HP_TLS: return "HP_TLS";
3508 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3509 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3510 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 3511 default:
3512 break;
3513 }
3514
3515 return NULL;
3516}
3517
40b36596
JM		 3518static const char *
3519get_tic6x_segment_type (unsigned long type)
3520{
3521 switch (type)
3522 {
3523 case PT_C6000_PHATTR: return "C6000_PHATTR";
3524 default:
3525 break;
3526 }
3527
3528 return NULL;
3529}
3530
252b5132 3531static const char *
d3ba0551 3532get_segment_type (unsigned long p_type)
252b5132 3533{
b34976b6 3534 static char buff[32];
252b5132
RH		 3535
3536 switch (p_type)
3537 {
b34976b6
AM		 3538 case PT_NULL: return "NULL";
3539 case PT_LOAD: return "LOAD";
252b5132 3540 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 3541 case PT_INTERP: return "INTERP";
3542 case PT_NOTE: return "NOTE";
3543 case PT_SHLIB: return "SHLIB";
3544 case PT_PHDR: return "PHDR";
13ae64f3 3545 case PT_TLS: return "TLS";
252b5132 3546
65765700
JJ		 3547 case PT_GNU_EH_FRAME:
3548 return "GNU_EH_FRAME";
2b05f1b7 3549 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 3550 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 3551
252b5132
RH		 3552 default:
3553 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3554 {
2cf0635d 3555 const char * result;
103f02d3 3556
252b5132
RH		 3557 switch (elf_header.e_machine)
3558 {
a06ea964
NC		 3559 case EM_AARCH64:
3560 result = get_aarch64_segment_type (p_type);
3561 break;
b294bdf8
MM		 3562 case EM_ARM:
3563 result = get_arm_segment_type (p_type);
3564 break;
252b5132 3565 case EM_MIPS:
4fe85591 3566 case EM_MIPS_RS3_LE:
252b5132
RH		 3567 result = get_mips_segment_type (p_type);
3568 break;
103f02d3
UD		 3569 case EM_PARISC:
3570 result = get_parisc_segment_type (p_type);
3571 break;
4d6ed7c8
NC		 3572 case EM_IA_64:
3573 result = get_ia64_segment_type (p_type);
3574 break;
40b36596
JM		 3575 case EM_TI_C6000:
3576 result = get_tic6x_segment_type (p_type);
3577 break;
252b5132
RH		 3578 default:
3579 result = NULL;
3580 break;
3581 }
103f02d3 3582
252b5132
RH		 3583 if (result != NULL)
3584 return result;
103f02d3 3585
252b5132
RH		 3586 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3587 }
3588 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3589 {
2cf0635d 3590 const char * result;
103f02d3
UD		 3591
3592 switch (elf_header.e_machine)
3593 {
3594 case EM_PARISC:
3595 result = get_parisc_segment_type (p_type);
3596 break;
00428cca
AM		 3597 case EM_IA_64:
3598 result = get_ia64_segment_type (p_type);
3599 break;
103f02d3
UD		 3600 default:
3601 result = NULL;
3602 break;
3603 }
3604
3605 if (result != NULL)
3606 return result;
3607
3608 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3609 }
252b5132 3610 else
e9e44622 3611 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3612
3613 return buff;
3614 }
3615}
3616
3617static const char *
d3ba0551 3618get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3619{
3620 switch (sh_type)
3621 {
b34976b6
AM		 3622 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3623 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3624 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3625 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3626 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3627 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3628 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3629 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3630 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3631 case SHT_MIPS_RELD: return "MIPS_RELD";
3632 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3633 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3634 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3635 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3636 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3637 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3638 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3639 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3640 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3641 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3642 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3643 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3644 case SHT_MIPS_LINE: return "MIPS_LINE";
3645 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3646 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3647 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3648 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3649 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3650 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3651 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3652 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3653 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3654 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3655 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3656 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3657 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3658 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3659 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132 3660 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
351cdf24 3661 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
252b5132
RH		 3662 default:
3663 break;
3664 }
3665 return NULL;
3666}
3667
103f02d3 3668static const char *
d3ba0551 3669get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3670{
3671 switch (sh_type)
3672 {
3673 case SHT_PARISC_EXT: return "PARISC_EXT";
3674 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3675 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3676 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3677 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3678 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3679 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3680 default:
3681 break;
3682 }
3683 return NULL;
3684}
3685
4d6ed7c8 3686static const char *
d3ba0551 3687get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3688{
18bd398b 3689 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3690 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3691 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3692
4d6ed7c8
NC		 3693 switch (sh_type)
3694 {
148b93f2
NC		 3695 case SHT_IA_64_EXT: return "IA_64_EXT";
3696 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3697 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3698 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3699 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3700 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3701 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3702 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3703 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3704 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3705 default:
3706 break;
3707 }
3708 return NULL;
3709}
3710
d2b2c203
DJ		 3711static const char *
3712get_x86_64_section_type_name (unsigned int sh_type)
3713{
3714 switch (sh_type)
3715 {
3716 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3717 default:
3718 break;
3719 }
3720 return NULL;
3721}
3722
a06ea964
NC		 3723static const char *
3724get_aarch64_section_type_name (unsigned int sh_type)
3725{
3726 switch (sh_type)
3727 {
3728 case SHT_AARCH64_ATTRIBUTES:
3729 return "AARCH64_ATTRIBUTES";
3730 default:
3731 break;
3732 }
3733 return NULL;
3734}
3735
40a18ebd
NC		 3736static const char *
3737get_arm_section_type_name (unsigned int sh_type)
3738{
3739 switch (sh_type)
3740 {
7f6fed87
NC		 3741 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3742 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3743 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3744 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3745 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3746 default:
3747 break;
3748 }
3749 return NULL;
3750}
3751
40b36596
JM		 3752static const char *
3753get_tic6x_section_type_name (unsigned int sh_type)
3754{
3755 switch (sh_type)
3756 {
3757 case SHT_C6000_UNWIND:
3758 return "C6000_UNWIND";
3759 case SHT_C6000_PREEMPTMAP:
3760 return "C6000_PREEMPTMAP";
3761 case SHT_C6000_ATTRIBUTES:
3762 return "C6000_ATTRIBUTES";
3763 case SHT_TI_ICODE:
3764 return "TI_ICODE";
3765 case SHT_TI_XREF:
3766 return "TI_XREF";
3767 case SHT_TI_HANDLER:
3768 return "TI_HANDLER";
3769 case SHT_TI_INITINFO:
3770 return "TI_INITINFO";
3771 case SHT_TI_PHATTRS:
3772 return "TI_PHATTRS";
3773 default:
3774 break;
3775 }
3776 return NULL;
3777}
3778
13761a11
NC		 3779static const char *
3780get_msp430x_section_type_name (unsigned int sh_type)
3781{
3782 switch (sh_type)
3783 {
3784 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3785 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3786 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3787 default: return NULL;
3788 }
3789}
3790
685080f2
NC		 3791static const char *
3792get_v850_section_type_name (unsigned int sh_type)
3793{
3794 switch (sh_type)
3795 {
3796 case SHT_V850_SCOMMON: return "V850 Small Common";
3797 case SHT_V850_TCOMMON: return "V850 Tiny Common";
3798 case SHT_V850_ZCOMMON: return "V850 Zero Common";
3799 case SHT_RENESAS_IOP: return "RENESAS IOP";
3800 case SHT_RENESAS_INFO: return "RENESAS INFO";
3801 default: return NULL;
3802 }
3803}
3804
252b5132 3805static const char *
d3ba0551 3806get_section_type_name (unsigned int sh_type)
252b5132 3807{
b34976b6 3808 static char buff[32];
252b5132
RH		 3809
3810 switch (sh_type)
3811 {
3812 case SHT_NULL: return "NULL";
3813 case SHT_PROGBITS: return "PROGBITS";
3814 case SHT_SYMTAB: return "SYMTAB";
3815 case SHT_STRTAB: return "STRTAB";
3816 case SHT_RELA: return "RELA";
3817 case SHT_HASH: return "HASH";
3818 case SHT_DYNAMIC: return "DYNAMIC";
3819 case SHT_NOTE: return "NOTE";
3820 case SHT_NOBITS: return "NOBITS";
3821 case SHT_REL: return "REL";
3822 case SHT_SHLIB: return "SHLIB";
3823 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3824 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3825 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3826 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3827 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3828 case SHT_GROUP: return "GROUP";
3829 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3830 case SHT_GNU_verdef: return "VERDEF";
3831 case SHT_GNU_verneed: return "VERNEED";
3832 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3833 case 0x6ffffff0: return "VERSYM";
3834 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3835 case 0x7ffffffd: return "AUXILIARY";
3836 case 0x7fffffff: return "FILTER";
047b2264 3837 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3838
3839 default:
3840 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3841 {
2cf0635d 3842 const char * result;
252b5132
RH		 3843
3844 switch (elf_header.e_machine)
3845 {
3846 case EM_MIPS:
4fe85591 3847 case EM_MIPS_RS3_LE:
252b5132
RH		 3848 result = get_mips_section_type_name (sh_type);
3849 break;
103f02d3
UD		 3850 case EM_PARISC:
3851 result = get_parisc_section_type_name (sh_type);
3852 break;
4d6ed7c8
NC		 3853 case EM_IA_64:
3854 result = get_ia64_section_type_name (sh_type);
3855 break;
d2b2c203 3856 case EM_X86_64:
8a9036a4 3857 case EM_L1OM:
7a9068fe 3858 case EM_K1OM:
d2b2c203
DJ		 3859 result = get_x86_64_section_type_name (sh_type);
3860 break;
a06ea964
NC		 3861 case EM_AARCH64:
3862 result = get_aarch64_section_type_name (sh_type);
3863 break;
40a18ebd
NC		 3864 case EM_ARM:
3865 result = get_arm_section_type_name (sh_type);
3866 break;
40b36596
JM		 3867 case EM_TI_C6000:
3868 result = get_tic6x_section_type_name (sh_type);
3869 break;
13761a11
NC		 3870 case EM_MSP430:
3871 result = get_msp430x_section_type_name (sh_type);
3872 break;
685080f2
NC		 3873 case EM_V800:
3874 case EM_V850:
3875 case EM_CYGNUS_V850:
3876 result = get_v850_section_type_name (sh_type);
3877 break;
252b5132
RH		 3878 default:
3879 result = NULL;
3880 break;
3881 }
3882
3883 if (result != NULL)
3884 return result;
3885
c91d0dfb 3886 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3887 }
3888 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3889 {
2cf0635d 3890 const char * result;
148b93f2
NC		 3891
3892 switch (elf_header.e_machine)
3893 {
3894 case EM_IA_64:
3895 result = get_ia64_section_type_name (sh_type);
3896 break;
3897 default:
3898 result = NULL;
3899 break;
3900 }
3901
3902 if (result != NULL)
3903 return result;
3904
3905 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3906 }
252b5132 3907 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
685080f2
NC		 3908 {
3909 switch (elf_header.e_machine)
3910 {
3911 case EM_V800:
3912 case EM_V850:
3913 case EM_CYGNUS_V850:
3914 return get_v850_section_type_name (sh_type);
3915 default:
3916 break;
3917 }
3918
3919 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3920 }
252b5132 3921 else
a7dbfd1c
NC		 3922 /* This message is probably going to be displayed in a 15
3923 character wide field, so put the hex value first. */
3924 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3925
252b5132
RH		 3926 return buff;
3927 }
3928}
3929
2979dc34 3930#define OPTION_DEBUG_DUMP 512
2c610e4b 3931#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3932#define OPTION_DWARF_DEPTH 514
3933#define OPTION_DWARF_START 515
4723351a 3934#define OPTION_DWARF_CHECK 516
2979dc34 3935
85b1c36d 3936static struct option options[] =
252b5132 3937{
b34976b6 3938 {"all", no_argument, 0, 'a'},
252b5132
RH		 3939 {"file-header", no_argument, 0, 'h'},
3940 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3941 {"headers", no_argument, 0, 'e'},
3942 {"histogram", no_argument, 0, 'I'},
3943 {"segments", no_argument, 0, 'l'},
3944 {"sections", no_argument, 0, 'S'},
252b5132 3945 {"section-headers", no_argument, 0, 'S'},
f5842774 3946 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3947 {"section-details", no_argument, 0, 't'},
595cf52e 3948 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3949 {"symbols", no_argument, 0, 's'},
3950 {"syms", no_argument, 0, 's'},
2c610e4b 3951 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3952 {"relocs", no_argument, 0, 'r'},
3953 {"notes", no_argument, 0, 'n'},
3954 {"dynamic", no_argument, 0, 'd'},
a952a375 3955 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3956 {"version-info", no_argument, 0, 'V'},
3957 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3958 {"unwind", no_argument, 0, 'u'},
4145f1d5 3959 {"archive-index", no_argument, 0, 'c'},
b34976b6 3960 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3961 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3962 {"string-dump", required_argument, 0, 'p'},
252b5132
RH		 3963#ifdef SUPPORT_DISASSEMBLY
3964 {"instruction-dump", required_argument, 0, 'i'},
3965#endif
cf13d699 3966 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3967
fd2f0033
TT		 3968 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3969 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 3970 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 3971
b34976b6
AM		 3972 {"version", no_argument, 0, 'v'},
3973 {"wide", no_argument, 0, 'W'},
3974 {"help", no_argument, 0, 'H'},
3975 {0, no_argument, 0, 0}
252b5132
RH		 3976};
3977
3978static void
2cf0635d 3979usage (FILE * stream)
252b5132 3980{
92f01d61
JM		 3981 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3982 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3983 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3984 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3985 -h --file-header Display the ELF file header\n\
3986 -l --program-headers Display the program headers\n\
3987 --segments An alias for --program-headers\n\
3988 -S --section-headers Display the sections' header\n\
3989 --sections An alias for --section-headers\n\
f5842774 3990 -g --section-groups Display the section groups\n\
5477e8a0 3991 -t --section-details Display the section details\n\
8b53311e
NC		 3992 -e --headers Equivalent to: -h -l -S\n\
3993 -s --syms Display the symbol table\n\
3f08eb35 3994 --symbols An alias for --syms\n\
2c610e4b 3995 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3996 -n --notes Display the core notes (if present)\n\
3997 -r --relocs Display the relocations (if present)\n\
3998 -u --unwind Display the unwind info (if present)\n\
b2d38a17 3999 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 4000 -V --version-info Display the version sections (if present)\n\
1b31d05e 4001 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 4002 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 4003 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 4004 -x --hex-dump=<number|name>\n\
4005 Dump the contents of section <number|name> as bytes\n\
4006 -p --string-dump=<number|name>\n\
4007 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 4008 -R --relocated-dump=<number|name>\n\
4009 Dump the contents of section <number|name> as relocated bytes\n\
f9f0e732 4010 -w[lLiaprmfFsoRt] or\n\
1ed06042 4011 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 4012 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 4013 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4014 =addr,=cu_index]\n\
8b53311e 4015 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 4016 fprintf (stream, _("\
4017 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4018 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4019 or deeper\n"));
252b5132 4020#ifdef SUPPORT_DISASSEMBLY
92f01d61 4021 fprintf (stream, _("\
09c11c86
NC		 4022 -i --instruction-dump=<number|name>\n\
4023 Disassemble the contents of section <number|name>\n"));
252b5132 4024#endif
92f01d61 4025 fprintf (stream, _("\
8b53311e
NC		 4026 -I --histogram Display histogram of bucket list lengths\n\
4027 -W --wide Allow output width to exceed 80 characters\n\
07012eee 4028 @<file> Read options from <file>\n\
8b53311e
NC		 4029 -H --help Display this information\n\
4030 -v --version Display the version number of readelf\n"));
1118d252 4031
92f01d61
JM		 4032 if (REPORT_BUGS_TO[0] && stream == stdout)
4033 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 4034
92f01d61 4035 exit (stream == stdout ? 0 : 1);
252b5132
RH		 4036}
4037
18bd398b
NC		 4038/* Record the fact that the user wants the contents of section number
4039 SECTION to be displayed using the method(s) encoded as flags bits
4040 in TYPE. Note, TYPE can be zero if we are creating the array for
4041 the first time. */
4042
252b5132 4043static void
09c11c86 4044request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 4045{
4046 if (section >= num_dump_sects)
4047 {
2cf0635d 4048 dump_type * new_dump_sects;
252b5132 4049
3f5e193b
NC		 4050 new_dump_sects = (dump_type *) calloc (section + 1,
4051 sizeof (* dump_sects));
252b5132
RH		 4052
4053 if (new_dump_sects == NULL)
591a748a 4054 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 4055 else
4056 {
4057 /* Copy current flag settings. */
09c11c86 4058 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 4059
4060 free (dump_sects);
4061
4062 dump_sects = new_dump_sects;
4063 num_dump_sects = section + 1;
4064 }
4065 }
4066
4067 if (dump_sects)
b34976b6 4068 dump_sects[section] |= type;
252b5132
RH		 4069
4070 return;
4071}
4072
aef1f6d0
DJ		 4073/* Request a dump by section name. */
4074
4075static void
2cf0635d 4076request_dump_byname (const char * section, dump_type type)
aef1f6d0 4077{
2cf0635d 4078 struct dump_list_entry * new_request;
aef1f6d0 4079
3f5e193b
NC		 4080 new_request = (struct dump_list_entry *)
4081 malloc (sizeof (struct dump_list_entry));
aef1f6d0 4082 if (!new_request)
591a748a 4083 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4084
4085 new_request->name = strdup (section);
4086 if (!new_request->name)
591a748a 4087 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4088
4089 new_request->type = type;
4090
4091 new_request->next = dump_sects_byname;
4092 dump_sects_byname = new_request;
4093}
4094
cf13d699
NC		 4095static inline void
4096request_dump (dump_type type)
4097{
4098 int section;
4099 char * cp;
4100
4101 do_dump++;
4102 section = strtoul (optarg, & cp, 0);
4103
4104 if (! *cp && section >= 0)
4105 request_dump_bynumber (section, type);
4106 else
4107 request_dump_byname (optarg, type);
4108}
4109
4110
252b5132 4111static void
2cf0635d 4112parse_args (int argc, char ** argv)
252b5132
RH		 4113{
4114 int c;
4115
4116 if (argc < 2)
92f01d61 4117 usage (stderr);
252b5132
RH		 4118
4119 while ((c = getopt_long
cf13d699 4120 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
252b5132 4121 {
252b5132
RH		 4122 switch (c)
4123 {
4124 case 0:
4125 /* Long options. */
4126 break;
4127 case 'H':
92f01d61 4128 usage (stdout);
252b5132
RH		 4129 break;
4130
4131 case 'a':
b34976b6
AM		 4132 do_syms++;
4133 do_reloc++;
4134 do_unwind++;
4135 do_dynamic++;
4136 do_header++;
4137 do_sections++;
f5842774 4138 do_section_groups++;
b34976b6
AM		 4139 do_segments++;
4140 do_version++;
4141 do_histogram++;
4142 do_arch++;
4143 do_notes++;
252b5132 4144 break;
f5842774
L		 4145 case 'g':
4146 do_section_groups++;
4147 break;
5477e8a0 4148 case 't':
595cf52e 4149 case 'N':
5477e8a0
L		 4150 do_sections++;
4151 do_section_details++;
595cf52e 4152 break;
252b5132 4153 case 'e':
b34976b6
AM		 4154 do_header++;
4155 do_sections++;
4156 do_segments++;
252b5132 4157 break;
a952a375 4158 case 'A':
b34976b6 4159 do_arch++;
a952a375 4160 break;
252b5132 4161 case 'D':
b34976b6 4162 do_using_dynamic++;
252b5132
RH		 4163 break;
4164 case 'r':
b34976b6 4165 do_reloc++;
252b5132 4166 break;
4d6ed7c8 4167 case 'u':
b34976b6 4168 do_unwind++;
4d6ed7c8 4169 break;
252b5132 4170 case 'h':
b34976b6 4171 do_header++;
252b5132
RH		 4172 break;
4173 case 'l':
b34976b6 4174 do_segments++;
252b5132
RH		 4175 break;
4176 case 's':
b34976b6 4177 do_syms++;
252b5132
RH		 4178 break;
4179 case 'S':
b34976b6 4180 do_sections++;
252b5132
RH		 4181 break;
4182 case 'd':
b34976b6 4183 do_dynamic++;
252b5132 4184 break;
a952a375 4185 case 'I':
b34976b6 4186 do_histogram++;
a952a375 4187 break;
779fe533 4188 case 'n':
b34976b6 4189 do_notes++;
779fe533 4190 break;
4145f1d5
NC		 4191 case 'c':
4192 do_archive_index++;
4193 break;
252b5132 4194 case 'x':
cf13d699 4195 request_dump (HEX_DUMP);
aef1f6d0 4196 break;
09c11c86 4197 case 'p':
cf13d699
NC		 4198 request_dump (STRING_DUMP);
4199 break;
4200 case 'R':
4201 request_dump (RELOC_DUMP);
09c11c86 4202 break;
252b5132 4203 case 'w':
b34976b6 4204 do_dump++;
252b5132 4205 if (optarg == 0)
613ff48b
CC		 4206 {
4207 do_debugging = 1;
4208 dwarf_select_sections_all ();
4209 }
252b5132
RH		 4210 else
4211 {
4212 do_debugging = 0;
4cb93e3b 4213 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 4214 }
4215 break;
2979dc34 4216 case OPTION_DEBUG_DUMP:
b34976b6 4217 do_dump++;
2979dc34
JJ		 4218 if (optarg == 0)
4219 do_debugging = 1;
4220 else
4221 {
2979dc34 4222 do_debugging = 0;
4cb93e3b 4223 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 4224 }
4225 break;
fd2f0033
TT		 4226 case OPTION_DWARF_DEPTH:
4227 {
4228 char *cp;
4229
4230 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4231 }
4232 break;
4233 case OPTION_DWARF_START:
4234 {
4235 char *cp;
4236
4237 dwarf_start_die = strtoul (optarg, & cp, 0);
4238 }
4239 break;
4723351a
CC		 4240 case OPTION_DWARF_CHECK:
4241 dwarf_check = 1;
4242 break;
2c610e4b
L		 4243 case OPTION_DYN_SYMS:
4244 do_dyn_syms++;
4245 break;
252b5132
RH		 4246#ifdef SUPPORT_DISASSEMBLY
4247 case 'i':
cf13d699
NC		 4248 request_dump (DISASS_DUMP);
4249 break;
252b5132
RH		 4250#endif
4251 case 'v':
4252 print_version (program_name);
4253 break;
4254 case 'V':
b34976b6 4255 do_version++;
252b5132 4256 break;
d974e256 4257 case 'W':
b34976b6 4258 do_wide++;
d974e256 4259 break;
252b5132 4260 default:
252b5132
RH		 4261 /* xgettext:c-format */
4262 error (_("Invalid option '-%c'\n"), c);
4263 /* Drop through. */
4264 case '?':
92f01d61 4265 usage (stderr);
252b5132
RH		 4266 }
4267 }
4268
4d6ed7c8 4269 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 4270 && !do_segments && !do_header && !do_dump && !do_version
f5842774 4271 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 4272 && !do_section_groups && !do_archive_index
4273 && !do_dyn_syms)
92f01d61 4274 usage (stderr);
252b5132
RH		 4275}
4276
4277static const char *
d3ba0551 4278get_elf_class (unsigned int elf_class)
252b5132 4279{
b34976b6 4280 static char buff[32];
103f02d3 4281
252b5132
RH		 4282 switch (elf_class)
4283 {
4284 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 4285 case ELFCLASS32: return "ELF32";
4286 case ELFCLASS64: return "ELF64";
ab5e7794 4287 default:
e9e44622 4288 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 4289 return buff;
252b5132
RH		 4290 }
4291}
4292
4293static const char *
d3ba0551 4294get_data_encoding (unsigned int encoding)
252b5132 4295{
b34976b6 4296 static char buff[32];
103f02d3 4297
252b5132
RH		 4298 switch (encoding)
4299 {
4300 case ELFDATANONE: return _("none");
33c63f9d
CM		 4301 case ELFDATA2LSB: return _("2's complement, little endian");
4302 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 4303 default:
e9e44622 4304 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 4305 return buff;
252b5132
RH		 4306 }
4307}
4308
252b5132 4309/* Decode the data held in 'elf_header'. */
ee42cf8c 4310
252b5132 4311static int
d3ba0551 4312process_file_header (void)
252b5132 4313{
b34976b6
AM		 4314 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4315 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4316 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4317 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 4318 {
4319 error
4320 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4321 return 0;
4322 }
4323
2dc4cec1
L		 4324 init_dwarf_regnames (elf_header.e_machine);
4325
252b5132
RH		 4326 if (do_header)
4327 {
4328 int i;
4329
4330 printf (_("ELF Header:\n"));
4331 printf (_(" Magic: "));
b34976b6
AM		 4332 for (i = 0; i < EI_NIDENT; i++)
4333 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 4334 printf ("\n");
4335 printf (_(" Class: %s\n"),
b34976b6 4336 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 4337 printf (_(" Data: %s\n"),
b34976b6 4338 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 4339 printf (_(" Version: %d %s\n"),
b34976b6
AM		 4340 elf_header.e_ident[EI_VERSION],
4341 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 4342 ? "(current)"
b34976b6 4343 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 4344 ? _("<unknown: %lx>")
789be9f7 4345 : "")));
252b5132 4346 printf (_(" OS/ABI: %s\n"),
b34976b6 4347 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 4348 printf (_(" ABI Version: %d\n"),
b34976b6 4349 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 4350 printf (_(" Type: %s\n"),
4351 get_file_type (elf_header.e_type));
4352 printf (_(" Machine: %s\n"),
4353 get_machine_name (elf_header.e_machine));
4354 printf (_(" Version: 0x%lx\n"),
4355 (unsigned long) elf_header.e_version);
76da6bbe 4356
f7a99963
NC		 4357 printf (_(" Entry point address: "));
4358 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4359 printf (_("\n Start of program headers: "));
4360 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4361 printf (_(" (bytes into file)\n Start of section headers: "));
4362 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4363 printf (_(" (bytes into file)\n"));
76da6bbe 4364
252b5132
RH		 4365 printf (_(" Flags: 0x%lx%s\n"),
4366 (unsigned long) elf_header.e_flags,
4367 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4368 printf (_(" Size of this header: %ld (bytes)\n"),
4369 (long) elf_header.e_ehsize);
4370 printf (_(" Size of program headers: %ld (bytes)\n"),
4371 (long) elf_header.e_phentsize);
2046a35d 4372 printf (_(" Number of program headers: %ld"),
252b5132 4373 (long) elf_header.e_phnum);
2046a35d
AM		 4374 if (section_headers != NULL
4375 && elf_header.e_phnum == PN_XNUM
4376 && section_headers[0].sh_info != 0)
cc5914eb 4377 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 4378 putc ('\n', stdout);
252b5132
RH		 4379 printf (_(" Size of section headers: %ld (bytes)\n"),
4380 (long) elf_header.e_shentsize);
560f3c1c 4381 printf (_(" Number of section headers: %ld"),
252b5132 4382 (long) elf_header.e_shnum);
4fbb74a6 4383 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 4384 printf (" (%ld)", (long) section_headers[0].sh_size);
4385 putc ('\n', stdout);
4386 printf (_(" Section header string table index: %ld"),
252b5132 4387 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 4388 if (section_headers != NULL
4389 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 4390 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 4391 else if (elf_header.e_shstrndx != SHN_UNDEF
4392 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 4393 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 4394 putc ('\n', stdout);
4395 }
4396
4397 if (section_headers != NULL)
4398 {
2046a35d
AM		 4399 if (elf_header.e_phnum == PN_XNUM
4400 && section_headers[0].sh_info != 0)
4401 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 4402 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 4403 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 4404 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 4405 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 4406 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 4407 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 4408 free (section_headers);
4409 section_headers = NULL;
252b5132 4410 }
103f02d3 4411
9ea033b2
NC		 4412 return 1;
4413}
4414
e0a31db1 4415static bfd_boolean
91d6fa6a 4416get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4417{
2cf0635d
NC		 4418 Elf32_External_Phdr * phdrs;
4419 Elf32_External_Phdr * external;
4420 Elf_Internal_Phdr * internal;
b34976b6 4421 unsigned int i;
e0a31db1
NC		 4422 unsigned int size = elf_header.e_phentsize;
4423 unsigned int num = elf_header.e_phnum;
4424
4425 /* PR binutils/17531: Cope with unexpected section header sizes. */
4426 if (size == 0 || num == 0)
4427 return FALSE;
4428 if (size < sizeof * phdrs)
4429 {
4430 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4431 return FALSE;
4432 }
4433 if (size > sizeof * phdrs)
4434 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4435
3f5e193b 4436 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1
NC		 4437 size, num, _("program headers"));
4438 if (phdrs == NULL)
4439 return FALSE;
9ea033b2 4440
91d6fa6a 4441 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4442 i < elf_header.e_phnum;
b34976b6 4443 i++, internal++, external++)
252b5132 4444 {
9ea033b2
NC		 4445 internal->p_type = BYTE_GET (external->p_type);
4446 internal->p_offset = BYTE_GET (external->p_offset);
4447 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4448 internal->p_paddr = BYTE_GET (external->p_paddr);
4449 internal->p_filesz = BYTE_GET (external->p_filesz);
4450 internal->p_memsz = BYTE_GET (external->p_memsz);
4451 internal->p_flags = BYTE_GET (external->p_flags);
4452 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 4453 }
4454
9ea033b2 4455 free (phdrs);
e0a31db1 4456 return TRUE;
252b5132
RH		 4457}
4458
e0a31db1 4459static bfd_boolean
91d6fa6a 4460get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4461{
2cf0635d
NC		 4462 Elf64_External_Phdr * phdrs;
4463 Elf64_External_Phdr * external;
4464 Elf_Internal_Phdr * internal;
b34976b6 4465 unsigned int i;
e0a31db1
NC		 4466 unsigned int size = elf_header.e_phentsize;
4467 unsigned int num = elf_header.e_phnum;
4468
4469 /* PR binutils/17531: Cope with unexpected section header sizes. */
4470 if (size == 0 || num == 0)
4471 return FALSE;
4472 if (size < sizeof * phdrs)
4473 {
4474 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4475 return FALSE;
4476 }
4477 if (size > sizeof * phdrs)
4478 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4479
3f5e193b 4480 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1 4481 size, num, _("program headers"));
a6e9f9df 4482 if (!phdrs)
e0a31db1 4483 return FALSE;
9ea033b2 4484
91d6fa6a 4485 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4486 i < elf_header.e_phnum;
b34976b6 4487 i++, internal++, external++)
9ea033b2
NC		 4488 {
4489 internal->p_type = BYTE_GET (external->p_type);
4490 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 4491 internal->p_offset = BYTE_GET (external->p_offset);
4492 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4493 internal->p_paddr = BYTE_GET (external->p_paddr);
4494 internal->p_filesz = BYTE_GET (external->p_filesz);
4495 internal->p_memsz = BYTE_GET (external->p_memsz);
4496 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 4497 }
4498
4499 free (phdrs);
e0a31db1 4500 return TRUE;
9ea033b2 4501}
252b5132 4502
d93f0186
NC		 4503/* Returns 1 if the program headers were read into `program_headers'. */
4504
4505static int
2cf0635d 4506get_program_headers (FILE * file)
d93f0186 4507{
2cf0635d 4508 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 4509
4510 /* Check cache of prior read. */
4511 if (program_headers != NULL)
4512 return 1;
4513
3f5e193b
NC		 4514 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4515 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 4516
4517 if (phdrs == NULL)
4518 {
8b73c356
NC		 4519 error (_("Out of memory reading %u program headers\n"),
4520 elf_header.e_phnum);
d93f0186
NC		 4521 return 0;
4522 }
4523
4524 if (is_32bit_elf
4525 ? get_32bit_program_headers (file, phdrs)
4526 : get_64bit_program_headers (file, phdrs))
4527 {
4528 program_headers = phdrs;
4529 return 1;
4530 }
4531
4532 free (phdrs);
4533 return 0;
4534}
4535
2f62977e
NC		 4536/* Returns 1 if the program headers were loaded. */
4537
252b5132 4538static int
2cf0635d 4539process_program_headers (FILE * file)
252b5132 4540{
2cf0635d 4541 Elf_Internal_Phdr * segment;
b34976b6 4542 unsigned int i;
252b5132
RH		 4543
4544 if (elf_header.e_phnum == 0)
4545 {
82f2dbf7
NC		 4546 /* PR binutils/12467. */
4547 if (elf_header.e_phoff != 0)
4548 warn (_("possibly corrupt ELF header - it has a non-zero program"
9035ed51 4549 " header offset, but no program headers\n"));
82f2dbf7 4550 else if (do_segments)
252b5132 4551 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 4552 return 0;
252b5132
RH		 4553 }
4554
4555 if (do_segments && !do_header)
4556 {
f7a99963
NC		 4557 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4558 printf (_("Entry point "));
4559 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4560 printf (_("\nThere are %d program headers, starting at offset "),
4561 elf_header.e_phnum);
4562 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4563 printf ("\n");
252b5132
RH		 4564 }
4565
d93f0186 4566 if (! get_program_headers (file))
252b5132 4567 return 0;
103f02d3 4568
252b5132
RH		 4569 if (do_segments)
4570 {
3a1a2036
NC		 4571 if (elf_header.e_phnum > 1)
4572 printf (_("\nProgram Headers:\n"));
4573 else
4574 printf (_("\nProgram Headers:\n"));
76da6bbe 4575
f7a99963
NC		 4576 if (is_32bit_elf)
4577 printf
4578 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 4579 else if (do_wide)
4580 printf
4581 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 4582 else
4583 {
4584 printf
4585 (_(" Type Offset VirtAddr PhysAddr\n"));
4586 printf
4587 (_(" FileSiz MemSiz Flags Align\n"));
4588 }
252b5132
RH		 4589 }
4590
252b5132 4591 dynamic_addr = 0;
1b228002 4592 dynamic_size = 0;
252b5132
RH		 4593
4594 for (i = 0, segment = program_headers;
4595 i < elf_header.e_phnum;
b34976b6 4596 i++, segment++)
252b5132
RH		 4597 {
4598 if (do_segments)
4599 {
103f02d3 4600 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 4601
4602 if (is_32bit_elf)
4603 {
4604 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4605 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4606 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4607 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4608 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4609 printf ("%c%c%c ",
4610 (segment->p_flags & PF_R ? 'R' : ' '),
4611 (segment->p_flags & PF_W ? 'W' : ' '),
4612 (segment->p_flags & PF_X ? 'E' : ' '));
4613 printf ("%#lx", (unsigned long) segment->p_align);
4614 }
d974e256
JJ		 4615 else if (do_wide)
4616 {
4617 if ((unsigned long) segment->p_offset == segment->p_offset)
4618 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4619 else
4620 {
4621 print_vma (segment->p_offset, FULL_HEX);
4622 putchar (' ');
4623 }
4624
4625 print_vma (segment->p_vaddr, FULL_HEX);
4626 putchar (' ');
4627 print_vma (segment->p_paddr, FULL_HEX);
4628 putchar (' ');
4629
4630 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4631 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4632 else
4633 {
4634 print_vma (segment->p_filesz, FULL_HEX);
4635 putchar (' ');
4636 }
4637
4638 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4639 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4640 else
4641 {
f48e6c45 4642 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 4643 }
4644
4645 printf (" %c%c%c ",
4646 (segment->p_flags & PF_R ? 'R' : ' '),
4647 (segment->p_flags & PF_W ? 'W' : ' '),
4648 (segment->p_flags & PF_X ? 'E' : ' '));
4649
4650 if ((unsigned long) segment->p_align == segment->p_align)
4651 printf ("%#lx", (unsigned long) segment->p_align);
4652 else
4653 {
4654 print_vma (segment->p_align, PREFIX_HEX);
4655 }
4656 }
f7a99963
NC		 4657 else
4658 {
4659 print_vma (segment->p_offset, FULL_HEX);
4660 putchar (' ');
4661 print_vma (segment->p_vaddr, FULL_HEX);
4662 putchar (' ');
4663 print_vma (segment->p_paddr, FULL_HEX);
4664 printf ("\n ");
4665 print_vma (segment->p_filesz, FULL_HEX);
4666 putchar (' ');
4667 print_vma (segment->p_memsz, FULL_HEX);
4668 printf (" %c%c%c ",
4669 (segment->p_flags & PF_R ? 'R' : ' '),
4670 (segment->p_flags & PF_W ? 'W' : ' '),
4671 (segment->p_flags & PF_X ? 'E' : ' '));
4672 print_vma (segment->p_align, HEX);
4673 }
252b5132
RH		 4674 }
4675
f54498b4
NC		 4676 if (do_segments)
4677 putc ('\n', stdout);
4678
252b5132
RH		 4679 switch (segment->p_type)
4680 {
252b5132
RH		 4681 case PT_DYNAMIC:
4682 if (dynamic_addr)
4683 error (_("more than one dynamic segment\n"));
4684
20737c13
AM		 4685 /* By default, assume that the .dynamic section is the first
4686 section in the DYNAMIC segment. */
4687 dynamic_addr = segment->p_offset;
4688 dynamic_size = segment->p_filesz;
f54498b4
NC		 4689 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4690 if (dynamic_addr + dynamic_size >= current_file_size)
4691 {
4692 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4693 dynamic_addr = dynamic_size = 0;
4694 }
20737c13 4695
b2d38a17
NC		 4696 /* Try to locate the .dynamic section. If there is
4697 a section header table, we can easily locate it. */
4698 if (section_headers != NULL)
4699 {
2cf0635d 4700 Elf_Internal_Shdr * sec;
b2d38a17 4701
89fac5e3
RS		 4702 sec = find_section (".dynamic");
4703 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4704 {
28f997cf
TG		 4705 /* A corresponding .dynamic section is expected, but on
4706 IA-64/OpenVMS it is OK for it to be missing. */
4707 if (!is_ia64_vms ())
4708 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 4709 break;
4710 }
4711
42bb2e33 4712 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 4713 {
4714 dynamic_size = 0;
4715 break;
4716 }
42bb2e33 4717
b2d38a17
NC		 4718 dynamic_addr = sec->sh_offset;
4719 dynamic_size = sec->sh_size;
4720
4721 if (dynamic_addr < segment->p_offset
4722 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 4723 warn (_("the .dynamic section is not contained"
4724 " within the dynamic segment\n"));
b2d38a17 4725 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 4726 warn (_("the .dynamic section is not the first section"
4727 " in the dynamic segment.\n"));
b2d38a17 4728 }
252b5132
RH		 4729 break;
4730
4731 case PT_INTERP:
fb52b2f4
NC		 4732 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4733 SEEK_SET))
252b5132
RH		 4734 error (_("Unable to find program interpreter name\n"));
4735 else
4736 {
f8eae8b2 4737 char fmt [32];
9495b2e6 4738 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
f8eae8b2
L		 4739
4740 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4741 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4742
252b5132 4743 program_interpreter[0] = 0;
7bd7b3ef
AM		 4744 if (fscanf (file, fmt, program_interpreter) <= 0)
4745 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 4746
4747 if (do_segments)
f54498b4 4748 printf (_(" [Requesting program interpreter: %s]\n"),
252b5132
RH		 4749 program_interpreter);
4750 }
4751 break;
4752 }
252b5132
RH		 4753 }
4754
c256ffe7 4755 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 4756 {
4757 printf (_("\n Section to Segment mapping:\n"));
4758 printf (_(" Segment Sections...\n"));
4759
252b5132
RH		 4760 for (i = 0; i < elf_header.e_phnum; i++)
4761 {
9ad5cbcf 4762 unsigned int j;
2cf0635d 4763 Elf_Internal_Shdr * section;
252b5132
RH		 4764
4765 segment = program_headers + i;
b391a3e3 4766 section = section_headers + 1;
252b5132
RH		 4767
4768 printf (" %2.2d ", i);
4769
b34976b6 4770 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4771 {
f4638467
AM		 4772 if (!ELF_TBSS_SPECIAL (section, segment)
4773 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
74e1a04b 4774 printf ("%s ", printable_section_name (section));
252b5132
RH		 4775 }
4776
4777 putc ('\n',stdout);
4778 }
4779 }
4780
252b5132
RH		 4781 return 1;
4782}
4783
4784
d93f0186
NC		 4785/* Find the file offset corresponding to VMA by using the program headers. */
4786
4787static long
2cf0635d 4788offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4789{
2cf0635d 4790 Elf_Internal_Phdr * seg;
d93f0186
NC		 4791
4792 if (! get_program_headers (file))
4793 {
4794 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4795 return (long) vma;
4796 }
4797
4798 for (seg = program_headers;
4799 seg < program_headers + elf_header.e_phnum;
4800 ++seg)
4801 {
4802 if (seg->p_type != PT_LOAD)
4803 continue;
4804
4805 if (vma >= (seg->p_vaddr & -seg->p_align)
4806 && vma + size <= seg->p_vaddr + seg->p_filesz)
4807 return vma - seg->p_vaddr + seg->p_offset;
4808 }
4809
4810 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4811 (unsigned long) vma);
d93f0186
NC		 4812 return (long) vma;
4813}
4814
4815
049b0c3a
NC		 4816/* Allocate memory and load the sections headers into the global pointer
4817 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4818 generate any error messages if the load fails. */
4819
4820static bfd_boolean
4821get_32bit_section_headers (FILE * file, bfd_boolean probe)
252b5132 4822{
2cf0635d
NC		 4823 Elf32_External_Shdr * shdrs;
4824 Elf_Internal_Shdr * internal;
b34976b6 4825 unsigned int i;
049b0c3a
NC		 4826 unsigned int size = elf_header.e_shentsize;
4827 unsigned int num = probe ? 1 : elf_header.e_shnum;
4828
4829 /* PR binutils/17531: Cope with unexpected section header sizes. */
4830 if (size == 0 || num == 0)
4831 return FALSE;
4832 if (size < sizeof * shdrs)
4833 {
4834 if (! probe)
4835 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4836 return FALSE;
4837 }
4838 if (!probe && size > sizeof * shdrs)
4839 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
252b5132 4840
3f5e193b 4841 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4842 size, num,
4843 probe ? NULL : _("section headers"));
4844 if (shdrs == NULL)
4845 return FALSE;
252b5132 4846
049b0c3a
NC		 4847 if (section_headers != NULL)
4848 free (section_headers);
3f5e193b
NC		 4849 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4850 sizeof (Elf_Internal_Shdr));
252b5132
RH		 4851 if (section_headers == NULL)
4852 {
049b0c3a 4853 if (!probe)
8b73c356 4854 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4855 return FALSE;
252b5132
RH		 4856 }
4857
4858 for (i = 0, internal = section_headers;
560f3c1c 4859 i < num;
b34976b6 4860 i++, internal++)
252b5132
RH		 4861 {
4862 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4863 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4864 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4865 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4866 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4867 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4868 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4869 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4870 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4871 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4872 }
4873
4874 free (shdrs);
049b0c3a 4875 return TRUE;
252b5132
RH		 4876}
4877
049b0c3a
NC		 4878static bfd_boolean
4879get_64bit_section_headers (FILE * file, bfd_boolean probe)
9ea033b2 4880{
2cf0635d
NC		 4881 Elf64_External_Shdr * shdrs;
4882 Elf_Internal_Shdr * internal;
b34976b6 4883 unsigned int i;
049b0c3a
NC		 4884 unsigned int size = elf_header.e_shentsize;
4885 unsigned int num = probe ? 1 : elf_header.e_shnum;
4886
4887 /* PR binutils/17531: Cope with unexpected section header sizes. */
4888 if (size == 0 || num == 0)
4889 return FALSE;
4890 if (size < sizeof * shdrs)
4891 {
4892 if (! probe)
4893 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4894 return FALSE;
4895 }
4896 if (! probe && size > sizeof * shdrs)
4897 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
9ea033b2 4898
3f5e193b 4899 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4900 size, num,
4901 probe ? NULL : _("section headers"));
4902 if (shdrs == NULL)
4903 return FALSE;
9ea033b2 4904
049b0c3a
NC		 4905 if (section_headers != NULL)
4906 free (section_headers);
3f5e193b
NC		 4907 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4908 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4909 if (section_headers == NULL)
4910 {
049b0c3a 4911 if (! probe)
8b73c356 4912 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4913 return FALSE;
9ea033b2
NC		 4914 }
4915
4916 for (i = 0, internal = section_headers;
560f3c1c 4917 i < num;
b34976b6 4918 i++, internal++)
9ea033b2
NC		 4919 {
4920 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4921 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4922 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4923 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4924 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4925 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4926 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4927 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4928 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4929 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4930 }
4931
4932 free (shdrs);
049b0c3a 4933 return TRUE;
9ea033b2
NC		 4934}
4935
252b5132 4936static Elf_Internal_Sym *
ba5cdace
NC		 4937get_32bit_elf_symbols (FILE * file,
4938 Elf_Internal_Shdr * section,
4939 unsigned long * num_syms_return)
252b5132 4940{
ba5cdace 4941 unsigned long number = 0;
dd24e3da 4942 Elf32_External_Sym * esyms = NULL;
ba5cdace 4943 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 4944 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4945 Elf_Internal_Sym * psym;
b34976b6 4946 unsigned int j;
252b5132 4947
c9c1d674
EG		 4948 if (section->sh_size == 0)
4949 {
4950 if (num_syms_return != NULL)
4951 * num_syms_return = 0;
4952 return NULL;
4953 }
4954
dd24e3da 4955 /* Run some sanity checks first. */
c9c1d674 4956 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 4957 {
c9c1d674
EG		 4958 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4959 printable_section_name (section), (unsigned long) section->sh_entsize);
ba5cdace 4960 goto exit_point;
dd24e3da
NC		 4961 }
4962
f54498b4
NC		 4963 if (section->sh_size > current_file_size)
4964 {
4965 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
74e1a04b 4966 printable_section_name (section), (unsigned long) section->sh_size);
f54498b4
NC		 4967 goto exit_point;
4968 }
4969
dd24e3da
NC		 4970 number = section->sh_size / section->sh_entsize;
4971
4972 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4973 {
c9c1d674 4974 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 4975 (unsigned long) section->sh_size,
4976 printable_section_name (section),
4977 (unsigned long) section->sh_entsize);
ba5cdace 4978 goto exit_point;
dd24e3da
NC		 4979 }
4980
3f5e193b
NC		 4981 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4982 section->sh_size, _("symbols"));
dd24e3da 4983 if (esyms == NULL)
ba5cdace 4984 goto exit_point;
252b5132 4985
9ad5cbcf
AM		 4986 shndx = NULL;
4987 if (symtab_shndx_hdr != NULL
4988 && (symtab_shndx_hdr->sh_link
4fbb74a6 4989 == (unsigned long) (section - section_headers)))
9ad5cbcf 4990 {
3f5e193b
NC		 4991 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4992 symtab_shndx_hdr->sh_offset,
4993 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4994 _("symbol table section indicies"));
dd24e3da
NC		 4995 if (shndx == NULL)
4996 goto exit_point;
c9c1d674
EG		 4997 /* PR17531: file: heap-buffer-overflow */
4998 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
4999 {
5000 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5001 printable_section_name (symtab_shndx_hdr),
5002 (unsigned long) symtab_shndx_hdr->sh_size,
5003 (unsigned long) section->sh_size);
5004 goto exit_point;
5005 }
9ad5cbcf
AM		 5006 }
5007
3f5e193b 5008 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 5009
5010 if (isyms == NULL)
5011 {
8b73c356
NC		 5012 error (_("Out of memory reading %lu symbols\n"),
5013 (unsigned long) number);
dd24e3da 5014 goto exit_point;
252b5132
RH		 5015 }
5016
dd24e3da 5017 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 5018 {
5019 psym->st_name = BYTE_GET (esyms[j].st_name);
5020 psym->st_value = BYTE_GET (esyms[j].st_value);
5021 psym->st_size = BYTE_GET (esyms[j].st_size);
5022 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 5023 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5024 psym->st_shndx
5025 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5026 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5027 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 5028 psym->st_info = BYTE_GET (esyms[j].st_info);
5029 psym->st_other = BYTE_GET (esyms[j].st_other);
5030 }
5031
dd24e3da 5032 exit_point:
ba5cdace 5033 if (shndx != NULL)
9ad5cbcf 5034 free (shndx);
ba5cdace 5035 if (esyms != NULL)
dd24e3da 5036 free (esyms);
252b5132 5037
ba5cdace
NC		 5038 if (num_syms_return != NULL)
5039 * num_syms_return = isyms == NULL ? 0 : number;
5040
252b5132
RH		 5041 return isyms;
5042}
5043
9ea033b2 5044static Elf_Internal_Sym *
ba5cdace
NC		 5045get_64bit_elf_symbols (FILE * file,
5046 Elf_Internal_Shdr * section,
5047 unsigned long * num_syms_return)
9ea033b2 5048{
ba5cdace
NC		 5049 unsigned long number = 0;
5050 Elf64_External_Sym * esyms = NULL;
5051 Elf_External_Sym_Shndx * shndx = NULL;
5052 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5053 Elf_Internal_Sym * psym;
b34976b6 5054 unsigned int j;
9ea033b2 5055
c9c1d674
EG		 5056 if (section->sh_size == 0)
5057 {
5058 if (num_syms_return != NULL)
5059 * num_syms_return = 0;
5060 return NULL;
5061 }
5062
dd24e3da 5063 /* Run some sanity checks first. */
c9c1d674 5064 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5065 {
c9c1d674 5066 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
8066deb1
AM		 5067 printable_section_name (section),
5068 (unsigned long) section->sh_entsize);
ba5cdace 5069 goto exit_point;
dd24e3da
NC		 5070 }
5071
f54498b4
NC		 5072 if (section->sh_size > current_file_size)
5073 {
5074 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
8066deb1
AM		 5075 printable_section_name (section),
5076 (unsigned long) section->sh_size);
f54498b4
NC		 5077 goto exit_point;
5078 }
5079
dd24e3da
NC		 5080 number = section->sh_size / section->sh_entsize;
5081
5082 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5083 {
c9c1d674 5084 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5085 (unsigned long) section->sh_size,
5086 printable_section_name (section),
5087 (unsigned long) section->sh_entsize);
ba5cdace 5088 goto exit_point;
dd24e3da
NC		 5089 }
5090
3f5e193b
NC		 5091 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5092 section->sh_size, _("symbols"));
a6e9f9df 5093 if (!esyms)
ba5cdace 5094 goto exit_point;
9ea033b2 5095
9ad5cbcf
AM		 5096 if (symtab_shndx_hdr != NULL
5097 && (symtab_shndx_hdr->sh_link
4fbb74a6 5098 == (unsigned long) (section - section_headers)))
9ad5cbcf 5099 {
3f5e193b
NC		 5100 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5101 symtab_shndx_hdr->sh_offset,
5102 1, symtab_shndx_hdr->sh_size,
9cf03b7e 5103 _("symbol table section indicies"));
ba5cdace
NC		 5104 if (shndx == NULL)
5105 goto exit_point;
c9c1d674
EG		 5106 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5107 {
5108 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5109 printable_section_name (symtab_shndx_hdr),
5110 (unsigned long) symtab_shndx_hdr->sh_size,
5111 (unsigned long) section->sh_size);
5112 goto exit_point;
5113 }
9ad5cbcf
AM		 5114 }
5115
3f5e193b 5116 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 5117
5118 if (isyms == NULL)
5119 {
8b73c356
NC		 5120 error (_("Out of memory reading %lu symbols\n"),
5121 (unsigned long) number);
ba5cdace 5122 goto exit_point;
9ea033b2
NC		 5123 }
5124
ba5cdace 5125 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 5126 {
5127 psym->st_name = BYTE_GET (esyms[j].st_name);
5128 psym->st_info = BYTE_GET (esyms[j].st_info);
5129 psym->st_other = BYTE_GET (esyms[j].st_other);
5130 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 5131
4fbb74a6 5132 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5133 psym->st_shndx
5134 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5135 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5136 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 5137
66543521
AM		 5138 psym->st_value = BYTE_GET (esyms[j].st_value);
5139 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 5140 }
5141
ba5cdace
NC		 5142 exit_point:
5143 if (shndx != NULL)
9ad5cbcf 5144 free (shndx);
ba5cdace
NC		 5145 if (esyms != NULL)
5146 free (esyms);
5147
5148 if (num_syms_return != NULL)
5149 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 5150
5151 return isyms;
5152}
5153
d1133906 5154static const char *
d3ba0551 5155get_elf_section_flags (bfd_vma sh_flags)
d1133906 5156{
5477e8a0 5157 static char buff[1024];
2cf0635d 5158 char * p = buff;
8d5ff12c 5159 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 5160 int sindex;
5161 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 5162 bfd_vma os_flags = 0;
5163 bfd_vma proc_flags = 0;
5164 bfd_vma unknown_flags = 0;
148b93f2 5165 static const struct
5477e8a0 5166 {
2cf0635d 5167 const char * str;
5477e8a0
L		 5168 int len;
5169 }
5170 flags [] =
5171 {
cfcac11d
NC		 5172 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5173 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5174 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5175 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5176 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5177 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5178 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5179 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5180 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5181 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5182 /* IA-64 specific. */
5183 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5184 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5185 /* IA-64 OpenVMS specific. */
5186 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5187 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5188 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5189 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5190 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5191 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 5192 /* Generic. */
cfcac11d 5193 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 5194 /* SPARC specific. */
77115a4a
L		 5195 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5196 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") }
5477e8a0
L		 5197 };
5198
5199 if (do_section_details)
5200 {
8d5ff12c
L		 5201 sprintf (buff, "[%*.*lx]: ",
5202 field_size, field_size, (unsigned long) sh_flags);
5203 p += field_size + 4;
5477e8a0 5204 }
76da6bbe 5205
d1133906
NC		 5206 while (sh_flags)
5207 {
5208 bfd_vma flag;
5209
5210 flag = sh_flags & - sh_flags;
5211 sh_flags &= ~ flag;
76da6bbe 5212
5477e8a0 5213 if (do_section_details)
d1133906 5214 {
5477e8a0
L		 5215 switch (flag)
5216 {
91d6fa6a
NC		 5217 case SHF_WRITE: sindex = 0; break;
5218 case SHF_ALLOC: sindex = 1; break;
5219 case SHF_EXECINSTR: sindex = 2; break;
5220 case SHF_MERGE: sindex = 3; break;
5221 case SHF_STRINGS: sindex = 4; break;
5222 case SHF_INFO_LINK: sindex = 5; break;
5223 case SHF_LINK_ORDER: sindex = 6; break;
5224 case SHF_OS_NONCONFORMING: sindex = 7; break;
5225 case SHF_GROUP: sindex = 8; break;
5226 case SHF_TLS: sindex = 9; break;
18ae9cc1 5227 case SHF_EXCLUDE: sindex = 18; break;
77115a4a 5228 case SHF_COMPRESSED: sindex = 20; break;
76da6bbe 5229
5477e8a0 5230 default:
91d6fa6a 5231 sindex = -1;
cfcac11d 5232 switch (elf_header.e_machine)
148b93f2 5233 {
cfcac11d 5234 case EM_IA_64:
148b93f2 5235 if (flag == SHF_IA_64_SHORT)
91d6fa6a 5236 sindex = 10;
148b93f2 5237 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 5238 sindex = 11;
148b93f2
NC		 5239#ifdef BFD64
5240 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5241 switch (flag)
5242 {
91d6fa6a
NC		 5243 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5244 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5245 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5246 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5247 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5248 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 5249 default: break;
5250 }
5251#endif
cfcac11d
NC		 5252 break;
5253
caa83f8b
NC		 5254 case EM_386:
5255 case EM_486:
5256 case EM_X86_64:
7f502d6c 5257 case EM_L1OM:
7a9068fe 5258 case EM_K1OM:
cfcac11d
NC		 5259 case EM_OLD_SPARCV9:
5260 case EM_SPARC32PLUS:
5261 case EM_SPARCV9:
5262 case EM_SPARC:
18ae9cc1 5263 if (flag == SHF_ORDERED)
91d6fa6a 5264 sindex = 19;
cfcac11d
NC		 5265 break;
5266 default:
5267 break;
148b93f2 5268 }
5477e8a0
L		 5269 }
5270
91d6fa6a 5271 if (sindex != -1)
5477e8a0 5272 {
8d5ff12c
L		 5273 if (p != buff + field_size + 4)
5274 {
5275 if (size < (10 + 2))
bee0ee85
NC		 5276 {
5277 warn (_("Internal error: not enough buffer room for section flag info"));
5278 return _("<unknown>");
5279 }
8d5ff12c
L		 5280 size -= 2;
5281 *p++ = ',';
5282 *p++ = ' ';
5283 }
5284
91d6fa6a
NC		 5285 size -= flags [sindex].len;
5286 p = stpcpy (p, flags [sindex].str);
5477e8a0 5287 }
3b22753a 5288 else if (flag & SHF_MASKOS)
8d5ff12c 5289 os_flags |= flag;
d1133906 5290 else if (flag & SHF_MASKPROC)
8d5ff12c 5291 proc_flags |= flag;
d1133906 5292 else
8d5ff12c 5293 unknown_flags |= flag;
5477e8a0
L		 5294 }
5295 else
5296 {
5297 switch (flag)
5298 {
5299 case SHF_WRITE: *p = 'W'; break;
5300 case SHF_ALLOC: *p = 'A'; break;
5301 case SHF_EXECINSTR: *p = 'X'; break;
5302 case SHF_MERGE: *p = 'M'; break;
5303 case SHF_STRINGS: *p = 'S'; break;
5304 case SHF_INFO_LINK: *p = 'I'; break;
5305 case SHF_LINK_ORDER: *p = 'L'; break;
5306 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5307 case SHF_GROUP: *p = 'G'; break;
5308 case SHF_TLS: *p = 'T'; break;
18ae9cc1 5309 case SHF_EXCLUDE: *p = 'E'; break;
77115a4a 5310 case SHF_COMPRESSED: *p = 'C'; break;
5477e8a0
L		 5311
5312 default:
8a9036a4 5313 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 5314 || elf_header.e_machine == EM_L1OM
5315 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 5316 && flag == SHF_X86_64_LARGE)
5317 *p = 'l';
5318 else if (flag & SHF_MASKOS)
5319 {
5320 *p = 'o';
5321 sh_flags &= ~ SHF_MASKOS;
5322 }
5323 else if (flag & SHF_MASKPROC)
5324 {
5325 *p = 'p';
5326 sh_flags &= ~ SHF_MASKPROC;
5327 }
5328 else
5329 *p = 'x';
5330 break;
5331 }
5332 p++;
d1133906
NC		 5333 }
5334 }
76da6bbe 5335
8d5ff12c
L		 5336 if (do_section_details)
5337 {
5338 if (os_flags)
5339 {
5340 size -= 5 + field_size;
5341 if (p != buff + field_size + 4)
5342 {
5343 if (size < (2 + 1))
bee0ee85
NC		 5344 {
5345 warn (_("Internal error: not enough buffer room for section flag info"));
5346 return _("<unknown>");
5347 }
8d5ff12c
L		 5348 size -= 2;
5349 *p++ = ',';
5350 *p++ = ' ';
5351 }
5352 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5353 (unsigned long) os_flags);
5354 p += 5 + field_size;
5355 }
5356 if (proc_flags)
5357 {
5358 size -= 7 + field_size;
5359 if (p != buff + field_size + 4)
5360 {
5361 if (size < (2 + 1))
bee0ee85
NC		 5362 {
5363 warn (_("Internal error: not enough buffer room for section flag info"));
5364 return _("<unknown>");
5365 }
8d5ff12c
L		 5366 size -= 2;
5367 *p++ = ',';
5368 *p++ = ' ';
5369 }
5370 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5371 (unsigned long) proc_flags);
5372 p += 7 + field_size;
5373 }
5374 if (unknown_flags)
5375 {
5376 size -= 10 + field_size;
5377 if (p != buff + field_size + 4)
5378 {
5379 if (size < (2 + 1))
bee0ee85
NC		 5380 {
5381 warn (_("Internal error: not enough buffer room for section flag info"));
5382 return _("<unknown>");
5383 }
8d5ff12c
L		 5384 size -= 2;
5385 *p++ = ',';
5386 *p++ = ' ';
5387 }
2b692964 5388 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 5389 (unsigned long) unknown_flags);
5390 p += 10 + field_size;
5391 }
5392 }
5393
e9e44622 5394 *p = '\0';
d1133906
NC		 5395 return buff;
5396}
5397
77115a4a
L		 5398static unsigned int
5399get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf)
5400{
5401 if (is_32bit_elf)
5402 {
5403 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5404 chdr->ch_type = BYTE_GET (echdr->ch_type);
5405 chdr->ch_size = BYTE_GET (echdr->ch_size);
5406 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5407 return sizeof (*echdr);
5408 }
5409 else
5410 {
5411 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5412 chdr->ch_type = BYTE_GET (echdr->ch_type);
5413 chdr->ch_size = BYTE_GET (echdr->ch_size);
5414 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5415 return sizeof (*echdr);
5416 }
5417}
5418
252b5132 5419static int
2cf0635d 5420process_section_headers (FILE * file)
252b5132 5421{
2cf0635d 5422 Elf_Internal_Shdr * section;
b34976b6 5423 unsigned int i;
252b5132
RH		 5424
5425 section_headers = NULL;
5426
5427 if (elf_header.e_shnum == 0)
5428 {
82f2dbf7
NC		 5429 /* PR binutils/12467. */
5430 if (elf_header.e_shoff != 0)
5431 warn (_("possibly corrupt ELF file header - it has a non-zero"
5432 " section header offset, but no section headers\n"));
5433 else if (do_sections)
252b5132
RH		 5434 printf (_("\nThere are no sections in this file.\n"));
5435
5436 return 1;
5437 }
5438
5439 if (do_sections && !do_header)
9ea033b2 5440 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 5441 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5442
9ea033b2
NC		 5443 if (is_32bit_elf)
5444 {
049b0c3a 5445 if (! get_32bit_section_headers (file, FALSE))
9ea033b2
NC		 5446 return 0;
5447 }
049b0c3a 5448 else if (! get_64bit_section_headers (file, FALSE))
252b5132
RH		 5449 return 0;
5450
5451 /* Read in the string table, so that we have names to display. */
0b49d371 5452 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 5453 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 5454 {
4fbb74a6 5455 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 5456
c256ffe7
JJ		 5457 if (section->sh_size != 0)
5458 {
3f5e193b
NC		 5459 string_table = (char *) get_data (NULL, file, section->sh_offset,
5460 1, section->sh_size,
5461 _("string table"));
0de14b54 5462
c256ffe7
JJ		 5463 string_table_length = string_table != NULL ? section->sh_size : 0;
5464 }
252b5132
RH		 5465 }
5466
5467 /* Scan the sections for the dynamic symbol table
e3c8793a 5468 and dynamic string table and debug sections. */
252b5132
RH		 5469 dynamic_symbols = NULL;
5470 dynamic_strings = NULL;
5471 dynamic_syminfo = NULL;
f1ef08cb 5472 symtab_shndx_hdr = NULL;
103f02d3 5473
89fac5e3
RS		 5474 eh_addr_size = is_32bit_elf ? 4 : 8;
5475 switch (elf_header.e_machine)
5476 {
5477 case EM_MIPS:
5478 case EM_MIPS_RS3_LE:
5479 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5480 FDE addresses. However, the ABI also has a semi-official ILP32
5481 variant for which the normal FDE address size rules apply.
5482
5483 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5484 section, where XX is the size of longs in bits. Unfortunately,
5485 earlier compilers provided no way of distinguishing ILP32 objects
5486 from LP64 objects, so if there's any doubt, we should assume that
5487 the official LP64 form is being used. */
5488 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5489 && find_section (".gcc_compiled_long32") == NULL)
5490 eh_addr_size = 8;
5491 break;
0f56a26a
DD		 5492
5493 case EM_H8_300:
5494 case EM_H8_300H:
5495 switch (elf_header.e_flags & EF_H8_MACH)
5496 {
5497 case E_H8_MACH_H8300:
5498 case E_H8_MACH_H8300HN:
5499 case E_H8_MACH_H8300SN:
5500 case E_H8_MACH_H8300SXN:
5501 eh_addr_size = 2;
5502 break;
5503 case E_H8_MACH_H8300H:
5504 case E_H8_MACH_H8300S:
5505 case E_H8_MACH_H8300SX:
5506 eh_addr_size = 4;
5507 break;
5508 }
f4236fe4
DD		 5509 break;
5510
ff7eeb89 5511 case EM_M32C_OLD:
f4236fe4
DD		 5512 case EM_M32C:
5513 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5514 {
5515 case EF_M32C_CPU_M16C:
5516 eh_addr_size = 2;
5517 break;
5518 }
5519 break;
89fac5e3
RS		 5520 }
5521
76ca31c0
NC		 5522#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5523 do \
5524 { \
5525 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5526 if (section->sh_entsize != expected_entsize) \
9dd3a467 5527 { \
76ca31c0
NC		 5528 char buf[40]; \
5529 sprintf_vma (buf, section->sh_entsize); \
5530 /* Note: coded this way so that there is a single string for \
5531 translation. */ \
5532 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5533 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5534 (unsigned) expected_entsize); \
9dd3a467 5535 section->sh_entsize = expected_entsize; \
76ca31c0
NC		 5536 } \
5537 } \
08d8fa11 5538 while (0)
9dd3a467
NC		 5539
5540#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 5541 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5542 sizeof (Elf64_External_##type))
5543
252b5132
RH		 5544 for (i = 0, section = section_headers;
5545 i < elf_header.e_shnum;
b34976b6 5546 i++, section++)
252b5132 5547 {
2cf0635d 5548 char * name = SECTION_NAME (section);
252b5132
RH		 5549
5550 if (section->sh_type == SHT_DYNSYM)
5551 {
5552 if (dynamic_symbols != NULL)
5553 {
5554 error (_("File contains multiple dynamic symbol tables\n"));
5555 continue;
5556 }
5557
08d8fa11 5558 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 5559 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 5560 }
5561 else if (section->sh_type == SHT_STRTAB
18bd398b 5562 && streq (name, ".dynstr"))
252b5132
RH		 5563 {
5564 if (dynamic_strings != NULL)
5565 {
5566 error (_("File contains multiple dynamic string tables\n"));
5567 continue;
5568 }
5569
3f5e193b
NC		 5570 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5571 1, section->sh_size,
5572 _("dynamic strings"));
59245841 5573 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 5574 }
9ad5cbcf
AM		 5575 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5576 {
5577 if (symtab_shndx_hdr != NULL)
5578 {
5579 error (_("File contains multiple symtab shndx tables\n"));
5580 continue;
5581 }
5582 symtab_shndx_hdr = section;
5583 }
08d8fa11
JJ		 5584 else if (section->sh_type == SHT_SYMTAB)
5585 CHECK_ENTSIZE (section, i, Sym);
5586 else if (section->sh_type == SHT_GROUP)
5587 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5588 else if (section->sh_type == SHT_REL)
5589 CHECK_ENTSIZE (section, i, Rel);
5590 else if (section->sh_type == SHT_RELA)
5591 CHECK_ENTSIZE (section, i, Rela);
252b5132 5592 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 5593 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 5594 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 5595 || do_debug_str || do_debug_loc || do_debug_ranges
5596 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 5597 && (const_strneq (name, ".debug_")
5598 || const_strneq (name, ".zdebug_")))
252b5132 5599 {
1b315056
CS		 5600 if (name[1] == 'z')
5601 name += sizeof (".zdebug_") - 1;
5602 else
5603 name += sizeof (".debug_") - 1;
252b5132
RH		 5604
5605 if (do_debugging
4723351a
CC		 5606 || (do_debug_info && const_strneq (name, "info"))
5607 || (do_debug_info && const_strneq (name, "types"))
5608 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 5609 || (do_debug_lines && strcmp (name, "line") == 0)
5610 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 5611 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5612 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
459d52c8
DE		 5613 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5614 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4723351a
CC		 5615 || (do_debug_aranges && const_strneq (name, "aranges"))
5616 || (do_debug_ranges && const_strneq (name, "ranges"))
5617 || (do_debug_frames && const_strneq (name, "frame"))
5618 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5619 || (do_debug_macinfo && const_strneq (name, "macro"))
5620 || (do_debug_str && const_strneq (name, "str"))
5621 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 5622 || (do_debug_addr && const_strneq (name, "addr"))
5623 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5624 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 5625 )
09c11c86 5626 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 5627 }
a262ae96 5628 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 5629 else if ((do_debugging || do_debug_info)
0112cd26 5630 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 5631 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 5632 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 5633 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 5634 else if (do_gdb_index && streq (name, ".gdb_index"))
5635 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 5636 /* Trace sections for Itanium VMS. */
5637 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5638 || do_trace_aranges)
5639 && const_strneq (name, ".trace_"))
5640 {
5641 name += sizeof (".trace_") - 1;
5642
5643 if (do_debugging
5644 || (do_trace_info && streq (name, "info"))
5645 || (do_trace_abbrevs && streq (name, "abbrev"))
5646 || (do_trace_aranges && streq (name, "aranges"))
5647 )
5648 request_dump_bynumber (i, DEBUG_DUMP);
5649 }
252b5132
RH		 5650 }
5651
5652 if (! do_sections)
5653 return 1;
5654
3a1a2036
NC		 5655 if (elf_header.e_shnum > 1)
5656 printf (_("\nSection Headers:\n"));
5657 else
5658 printf (_("\nSection Header:\n"));
76da6bbe 5659
f7a99963 5660 if (is_32bit_elf)
595cf52e 5661 {
5477e8a0 5662 if (do_section_details)
595cf52e
L		 5663 {
5664 printf (_(" [Nr] Name\n"));
5477e8a0 5665 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 5666 }
5667 else
5668 printf
5669 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5670 }
d974e256 5671 else if (do_wide)
595cf52e 5672 {
5477e8a0 5673 if (do_section_details)
595cf52e
L		 5674 {
5675 printf (_(" [Nr] Name\n"));
5477e8a0 5676 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 5677 }
5678 else
5679 printf
5680 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5681 }
f7a99963
NC		 5682 else
5683 {
5477e8a0 5684 if (do_section_details)
595cf52e
L		 5685 {
5686 printf (_(" [Nr] Name\n"));
5477e8a0
L		 5687 printf (_(" Type Address Offset Link\n"));
5688 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 5689 }
5690 else
5691 {
5692 printf (_(" [Nr] Name Type Address Offset\n"));
5693 printf (_(" Size EntSize Flags Link Info Align\n"));
5694 }
f7a99963 5695 }
252b5132 5696
5477e8a0
L		 5697 if (do_section_details)
5698 printf (_(" Flags\n"));
5699
252b5132
RH		 5700 for (i = 0, section = section_headers;
5701 i < elf_header.e_shnum;
b34976b6 5702 i++, section++)
252b5132 5703 {
7bfd842d 5704 printf (" [%2u] ", i);
5477e8a0 5705 if (do_section_details)
74e1a04b 5706 printf ("%s\n ", printable_section_name (section));
595cf52e 5707 else
74e1a04b 5708 print_symbol (-17, SECTION_NAME (section));
0b4362b0 5709
ea52a088
NC		 5710 printf (do_wide ? " %-15s " : " %-15.15s ",
5711 get_section_type_name (section->sh_type));
0b4362b0 5712
f7a99963
NC		 5713 if (is_32bit_elf)
5714 {
cfcac11d
NC		 5715 const char * link_too_big = NULL;
5716
f7a99963 5717 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 5718
f7a99963
NC		 5719 printf ( " %6.6lx %6.6lx %2.2lx",
5720 (unsigned long) section->sh_offset,
5721 (unsigned long) section->sh_size,
5722 (unsigned long) section->sh_entsize);
d1133906 5723
5477e8a0
L		 5724 if (do_section_details)
5725 fputs (" ", stdout);
5726 else
5727 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5728
cfcac11d
NC		 5729 if (section->sh_link >= elf_header.e_shnum)
5730 {
5731 link_too_big = "";
5732 /* The sh_link value is out of range. Normally this indicates
caa83f8b 5733 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 5734 switch (elf_header.e_machine)
5735 {
caa83f8b
NC		 5736 case EM_386:
5737 case EM_486:
5738 case EM_X86_64:
7f502d6c 5739 case EM_L1OM:
7a9068fe 5740 case EM_K1OM:
cfcac11d
NC		 5741 case EM_OLD_SPARCV9:
5742 case EM_SPARC32PLUS:
5743 case EM_SPARCV9:
5744 case EM_SPARC:
5745 if (section->sh_link == (SHN_BEFORE & 0xffff))
5746 link_too_big = "BEFORE";
5747 else if (section->sh_link == (SHN_AFTER & 0xffff))
5748 link_too_big = "AFTER";
5749 break;
5750 default:
5751 break;
5752 }
5753 }
5754
5755 if (do_section_details)
5756 {
5757 if (link_too_big != NULL && * link_too_big)
5758 printf ("<%s> ", link_too_big);
5759 else
5760 printf ("%2u ", section->sh_link);
5761 printf ("%3u %2lu\n", section->sh_info,
5762 (unsigned long) section->sh_addralign);
5763 }
5764 else
5765 printf ("%2u %3u %2lu\n",
5766 section->sh_link,
5767 section->sh_info,
5768 (unsigned long) section->sh_addralign);
5769
5770 if (link_too_big && ! * link_too_big)
5771 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5772 i, section->sh_link);
f7a99963 5773 }
d974e256
JJ		 5774 else if (do_wide)
5775 {
5776 print_vma (section->sh_addr, LONG_HEX);
5777
5778 if ((long) section->sh_offset == section->sh_offset)
5779 printf (" %6.6lx", (unsigned long) section->sh_offset);
5780 else
5781 {
5782 putchar (' ');
5783 print_vma (section->sh_offset, LONG_HEX);
5784 }
5785
5786 if ((unsigned long) section->sh_size == section->sh_size)
5787 printf (" %6.6lx", (unsigned long) section->sh_size);
5788 else
5789 {
5790 putchar (' ');
5791 print_vma (section->sh_size, LONG_HEX);
5792 }
5793
5794 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5795 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5796 else
5797 {
5798 putchar (' ');
5799 print_vma (section->sh_entsize, LONG_HEX);
5800 }
5801
5477e8a0
L		 5802 if (do_section_details)
5803 fputs (" ", stdout);
5804 else
5805 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 5806
72de5009 5807 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 5808
5809 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 5810 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 5811 else
5812 {
5813 print_vma (section->sh_addralign, DEC);
5814 putchar ('\n');
5815 }
5816 }
5477e8a0 5817 else if (do_section_details)
595cf52e 5818 {
5477e8a0 5819 printf (" %-15.15s ",
595cf52e 5820 get_section_type_name (section->sh_type));
595cf52e
L		 5821 print_vma (section->sh_addr, LONG_HEX);
5822 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 5823 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 5824 else
5825 {
5826 printf (" ");
5827 print_vma (section->sh_offset, LONG_HEX);
5828 }
72de5009 5829 printf (" %u\n ", section->sh_link);
595cf52e 5830 print_vma (section->sh_size, LONG_HEX);
5477e8a0 5831 putchar (' ');
595cf52e
L		 5832 print_vma (section->sh_entsize, LONG_HEX);
5833
72de5009
AM		 5834 printf (" %-16u %lu\n",
5835 section->sh_info,
595cf52e
L		 5836 (unsigned long) section->sh_addralign);
5837 }
f7a99963
NC		 5838 else
5839 {
5840 putchar (' ');
5841 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 5842 if ((long) section->sh_offset == section->sh_offset)
5843 printf (" %8.8lx", (unsigned long) section->sh_offset);
5844 else
5845 {
5846 printf (" ");
5847 print_vma (section->sh_offset, LONG_HEX);
5848 }
f7a99963
NC		 5849 printf ("\n ");
5850 print_vma (section->sh_size, LONG_HEX);
5851 printf (" ");
5852 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 5853
d1133906 5854 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5855
72de5009
AM		 5856 printf (" %2u %3u %lu\n",
5857 section->sh_link,
5858 section->sh_info,
f7a99963
NC		 5859 (unsigned long) section->sh_addralign);
5860 }
5477e8a0
L		 5861
5862 if (do_section_details)
77115a4a
L		 5863 {
5864 printf (" %s\n", get_elf_section_flags (section->sh_flags));
5865 if ((section->sh_flags & SHF_COMPRESSED) != 0)
5866 {
5867 /* Minimum section size is 12 bytes for 32-bit compression
5868 header + 12 bytes for compressed data header. */
5869 unsigned char buf[24];
5870 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
5871 if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
5872 sizeof (buf), _("compression header")))
5873 {
5874 Elf_Internal_Chdr chdr;
5875 get_compression_header (&chdr, buf);
5876 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
5877 printf (" ZLIB, ");
5878 else
5879 printf (_(" [<unknown>: 0x%x], "),
5880 chdr.ch_type);
5881 print_vma (chdr.ch_size, LONG_HEX);
5882 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
5883 }
5884 }
5885 }
252b5132
RH		 5886 }
5887
5477e8a0 5888 if (!do_section_details)
3dbcc61d
NC		 5889 {
5890 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 5891 || elf_header.e_machine == EM_L1OM
5892 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 5893 printf (_("Key to Flags:\n\
5894 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5895 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5896 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5897 else
5898 printf (_("Key to Flags:\n\
e3c8793a 5899 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 5900 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 5901 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
0b4362b0 5902 }
d1133906 5903
252b5132
RH		 5904 return 1;
5905}
5906
f5842774
L		 5907static const char *
5908get_group_flags (unsigned int flags)
5909{
5910 static char buff[32];
5911 switch (flags)
5912 {
220453ec
AM		 5913 case 0:
5914 return "";
5915
f5842774 5916 case GRP_COMDAT:
220453ec 5917 return "COMDAT ";
f5842774
L		 5918
5919 default:
220453ec 5920 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 5921 break;
5922 }
5923 return buff;
5924}
5925
5926static int
2cf0635d 5927process_section_groups (FILE * file)
f5842774 5928{
2cf0635d 5929 Elf_Internal_Shdr * section;
f5842774 5930 unsigned int i;
2cf0635d
NC		 5931 struct group * group;
5932 Elf_Internal_Shdr * symtab_sec;
5933 Elf_Internal_Shdr * strtab_sec;
5934 Elf_Internal_Sym * symtab;
ba5cdace 5935 unsigned long num_syms;
2cf0635d 5936 char * strtab;
c256ffe7 5937 size_t strtab_size;
d1f5c6e3
L		 5938
5939 /* Don't process section groups unless needed. */
5940 if (!do_unwind && !do_section_groups)
5941 return 1;
f5842774
L		 5942
5943 if (elf_header.e_shnum == 0)
5944 {
5945 if (do_section_groups)
82f2dbf7 5946 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 5947
5948 return 1;
5949 }
5950
5951 if (section_headers == NULL)
5952 {
5953 error (_("Section headers are not available!\n"));
fa1908fd
NC		 5954 /* PR 13622: This can happen with a corrupt ELF header. */
5955 return 0;
f5842774
L		 5956 }
5957
3f5e193b
NC		 5958 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5959 sizeof (struct group *));
e4b17d5c
L		 5960
5961 if (section_headers_groups == NULL)
5962 {
8b73c356
NC		 5963 error (_("Out of memory reading %u section group headers\n"),
5964 elf_header.e_shnum);
e4b17d5c
L		 5965 return 0;
5966 }
5967
f5842774 5968 /* Scan the sections for the group section. */
d1f5c6e3 5969 group_count = 0;
f5842774
L		 5970 for (i = 0, section = section_headers;
5971 i < elf_header.e_shnum;
5972 i++, section++)
e4b17d5c
L		 5973 if (section->sh_type == SHT_GROUP)
5974 group_count++;
5975
d1f5c6e3
L		 5976 if (group_count == 0)
5977 {
5978 if (do_section_groups)
5979 printf (_("\nThere are no section groups in this file.\n"));
5980
5981 return 1;
5982 }
5983
3f5e193b 5984 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 5985
5986 if (section_groups == NULL)
5987 {
8b73c356
NC		 5988 error (_("Out of memory reading %lu groups\n"),
5989 (unsigned long) group_count);
e4b17d5c
L		 5990 return 0;
5991 }
5992
d1f5c6e3
L		 5993 symtab_sec = NULL;
5994 strtab_sec = NULL;
5995 symtab = NULL;
ba5cdace 5996 num_syms = 0;
d1f5c6e3 5997 strtab = NULL;
c256ffe7 5998 strtab_size = 0;
e4b17d5c
L		 5999 for (i = 0, section = section_headers, group = section_groups;
6000 i < elf_header.e_shnum;
6001 i++, section++)
f5842774
L		 6002 {
6003 if (section->sh_type == SHT_GROUP)
6004 {
74e1a04b
NC		 6005 const char * name = printable_section_name (section);
6006 const char * group_name;
2cf0635d
NC		 6007 unsigned char * start;
6008 unsigned char * indices;
f5842774 6009 unsigned int entry, j, size;
2cf0635d
NC		 6010 Elf_Internal_Shdr * sec;
6011 Elf_Internal_Sym * sym;
f5842774
L		 6012
6013 /* Get the symbol table. */
4fbb74a6
AM		 6014 if (section->sh_link >= elf_header.e_shnum
6015 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 6016 != SHT_SYMTAB))
f5842774
L		 6017 {
6018 error (_("Bad sh_link in group section `%s'\n"), name);
6019 continue;
6020 }
d1f5c6e3
L		 6021
6022 if (symtab_sec != sec)
6023 {
6024 symtab_sec = sec;
6025 if (symtab)
6026 free (symtab);
ba5cdace 6027 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 6028 }
f5842774 6029
dd24e3da
NC		 6030 if (symtab == NULL)
6031 {
6032 error (_("Corrupt header in group section `%s'\n"), name);
6033 continue;
6034 }
6035
ba5cdace
NC		 6036 if (section->sh_info >= num_syms)
6037 {
6038 error (_("Bad sh_info in group section `%s'\n"), name);
6039 continue;
6040 }
6041
f5842774
L		 6042 sym = symtab + section->sh_info;
6043
6044 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6045 {
4fbb74a6
AM		 6046 if (sym->st_shndx == 0
6047 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 6048 {
6049 error (_("Bad sh_info in group section `%s'\n"), name);
6050 continue;
6051 }
ba2685cc 6052
4fbb74a6 6053 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 6054 strtab_sec = NULL;
6055 if (strtab)
6056 free (strtab);
f5842774 6057 strtab = NULL;
c256ffe7 6058 strtab_size = 0;
f5842774
L		 6059 }
6060 else
6061 {
6062 /* Get the string table. */
4fbb74a6 6063 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 6064 {
6065 strtab_sec = NULL;
6066 if (strtab)
6067 free (strtab);
6068 strtab = NULL;
6069 strtab_size = 0;
6070 }
6071 else if (strtab_sec
4fbb74a6 6072 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 6073 {
6074 strtab_sec = sec;
6075 if (strtab)
6076 free (strtab);
071436c6 6077
3f5e193b 6078 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
071436c6
NC		 6079 1, strtab_sec->sh_size,
6080 _("string table"));
c256ffe7 6081 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 6082 }
c256ffe7 6083 group_name = sym->st_name < strtab_size
2b692964 6084 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 6085 }
6086
c9c1d674
EG		 6087 /* PR 17531: file: loop. */
6088 if (section->sh_entsize > section->sh_size)
6089 {
6090 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6091 printable_section_name (section),
8066deb1
AM		 6092 (unsigned long) section->sh_entsize,
6093 (unsigned long) section->sh_size);
c9c1d674
EG		 6094 break;
6095 }
6096
3f5e193b
NC		 6097 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6098 1, section->sh_size,
6099 _("section data"));
59245841
NC		 6100 if (start == NULL)
6101 continue;
f5842774
L		 6102
6103 indices = start;
6104 size = (section->sh_size / section->sh_entsize) - 1;
6105 entry = byte_get (indices, 4);
6106 indices += 4;
e4b17d5c
L		 6107
6108 if (do_section_groups)
6109 {
2b692964 6110 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 6111 get_group_flags (entry), i, name, group_name, size);
ba2685cc 6112
e4b17d5c
L		 6113 printf (_(" [Index] Name\n"));
6114 }
6115
6116 group->group_index = i;
6117
f5842774
L		 6118 for (j = 0; j < size; j++)
6119 {
2cf0635d 6120 struct group_list * g;
e4b17d5c 6121
f5842774
L		 6122 entry = byte_get (indices, 4);
6123 indices += 4;
6124
4fbb74a6 6125 if (entry >= elf_header.e_shnum)
391cb864 6126 {
57028622
NC		 6127 static unsigned num_group_errors = 0;
6128
6129 if (num_group_errors ++ < 10)
6130 {
6131 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6132 entry, i, elf_header.e_shnum - 1);
6133 if (num_group_errors == 10)
6134 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6135 }
391cb864
L		 6136 continue;
6137 }
391cb864 6138
4fbb74a6 6139 if (section_headers_groups [entry] != NULL)
e4b17d5c 6140 {
d1f5c6e3
L		 6141 if (entry)
6142 {
57028622
NC		 6143 static unsigned num_errs = 0;
6144
6145 if (num_errs ++ < 10)
6146 {
6147 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6148 entry, i,
6149 section_headers_groups [entry]->group_index);
6150 if (num_errs == 10)
6151 warn (_("Further error messages about already contained group sections suppressed\n"));
6152 }
d1f5c6e3
L		 6153 continue;
6154 }
6155 else
6156 {
6157 /* Intel C/C++ compiler may put section 0 in a
6158 section group. We just warn it the first time
6159 and ignore it afterwards. */
6160 static int warned = 0;
6161 if (!warned)
6162 {
6163 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 6164 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 6165 warned++;
6166 }
6167 }
e4b17d5c
L		 6168 }
6169
4fbb74a6 6170 section_headers_groups [entry] = group;
e4b17d5c
L		 6171
6172 if (do_section_groups)
6173 {
4fbb74a6 6174 sec = section_headers + entry;
74e1a04b 6175 printf (" [%5u] %s\n", entry, printable_section_name (sec));
ba2685cc
AM		 6176 }
6177
3f5e193b 6178 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 6179 g->section_index = entry;
6180 g->next = group->root;
6181 group->root = g;
f5842774
L		 6182 }
6183
f5842774
L		 6184 if (start)
6185 free (start);
e4b17d5c
L		 6186
6187 group++;
f5842774
L		 6188 }
6189 }
6190
d1f5c6e3
L		 6191 if (symtab)
6192 free (symtab);
6193 if (strtab)
6194 free (strtab);
f5842774
L		 6195 return 1;
6196}
6197
28f997cf
TG		 6198/* Data used to display dynamic fixups. */
6199
6200struct ia64_vms_dynfixup
6201{
6202 bfd_vma needed_ident; /* Library ident number. */
6203 bfd_vma needed; /* Index in the dstrtab of the library name. */
6204 bfd_vma fixup_needed; /* Index of the library. */
6205 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6206 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6207};
6208
6209/* Data used to display dynamic relocations. */
6210
6211struct ia64_vms_dynimgrela
6212{
6213 bfd_vma img_rela_cnt; /* Number of relocations. */
6214 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6215};
6216
6217/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6218 library). */
6219
6220static void
6221dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6222 const char *strtab, unsigned int strtab_sz)
6223{
6224 Elf64_External_VMS_IMAGE_FIXUP *imfs;
6225 long i;
6226 const char *lib_name;
6227
6228 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6229 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6230 _("dynamic section image fixups"));
6231 if (!imfs)
6232 return;
6233
6234 if (fixup->needed < strtab_sz)
6235 lib_name = strtab + fixup->needed;
6236 else
6237 {
6238 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 6239 (unsigned long) fixup->needed);
28f997cf
TG		 6240 lib_name = "???";
6241 }
6242 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6243 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6244 printf
6245 (_("Seg Offset Type SymVec DataType\n"));
6246
6247 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6248 {
6249 unsigned int type;
6250 const char *rtype;
6251
6252 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6253 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6254 type = BYTE_GET (imfs [i].type);
6255 rtype = elf_ia64_reloc_type (type);
6256 if (rtype == NULL)
6257 printf (" 0x%08x ", type);
6258 else
6259 printf (" %-32s ", rtype);
6260 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6261 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6262 }
6263
6264 free (imfs);
6265}
6266
6267/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6268
6269static void
6270dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6271{
6272 Elf64_External_VMS_IMAGE_RELA *imrs;
6273 long i;
6274
6275 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6276 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 6277 _("dynamic section image relocations"));
28f997cf
TG		 6278 if (!imrs)
6279 return;
6280
6281 printf (_("\nImage relocs\n"));
6282 printf
6283 (_("Seg Offset Type Addend Seg Sym Off\n"));
6284
6285 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6286 {
6287 unsigned int type;
6288 const char *rtype;
6289
6290 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6291 printf ("%08" BFD_VMA_FMT "x ",
6292 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6293 type = BYTE_GET (imrs [i].type);
6294 rtype = elf_ia64_reloc_type (type);
6295 if (rtype == NULL)
6296 printf ("0x%08x ", type);
6297 else
6298 printf ("%-31s ", rtype);
6299 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6300 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6301 printf ("%08" BFD_VMA_FMT "x\n",
6302 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6303 }
6304
6305 free (imrs);
6306}
6307
6308/* Display IA-64 OpenVMS dynamic relocations and fixups. */
6309
6310static int
6311process_ia64_vms_dynamic_relocs (FILE *file)
6312{
6313 struct ia64_vms_dynfixup fixup;
6314 struct ia64_vms_dynimgrela imgrela;
6315 Elf_Internal_Dyn *entry;
6316 int res = 0;
6317 bfd_vma strtab_off = 0;
6318 bfd_vma strtab_sz = 0;
6319 char *strtab = NULL;
6320
6321 memset (&fixup, 0, sizeof (fixup));
6322 memset (&imgrela, 0, sizeof (imgrela));
6323
6324 /* Note: the order of the entries is specified by the OpenVMS specs. */
6325 for (entry = dynamic_section;
6326 entry < dynamic_section + dynamic_nent;
6327 entry++)
6328 {
6329 switch (entry->d_tag)
6330 {
6331 case DT_IA_64_VMS_STRTAB_OFFSET:
6332 strtab_off = entry->d_un.d_val;
6333 break;
6334 case DT_STRSZ:
6335 strtab_sz = entry->d_un.d_val;
6336 if (strtab == NULL)
6337 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6338 1, strtab_sz, _("dynamic string section"));
6339 break;
6340
6341 case DT_IA_64_VMS_NEEDED_IDENT:
6342 fixup.needed_ident = entry->d_un.d_val;
6343 break;
6344 case DT_NEEDED:
6345 fixup.needed = entry->d_un.d_val;
6346 break;
6347 case DT_IA_64_VMS_FIXUP_NEEDED:
6348 fixup.fixup_needed = entry->d_un.d_val;
6349 break;
6350 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6351 fixup.fixup_rela_cnt = entry->d_un.d_val;
6352 break;
6353 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6354 fixup.fixup_rela_off = entry->d_un.d_val;
6355 res++;
6356 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6357 break;
6358
6359 case DT_IA_64_VMS_IMG_RELA_CNT:
6360 imgrela.img_rela_cnt = entry->d_un.d_val;
6361 break;
6362 case DT_IA_64_VMS_IMG_RELA_OFF:
6363 imgrela.img_rela_off = entry->d_un.d_val;
6364 res++;
6365 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6366 break;
6367
6368 default:
6369 break;
6370 }
6371 }
6372
6373 if (strtab != NULL)
6374 free (strtab);
6375
6376 return res;
6377}
6378
85b1c36d 6379static struct
566b0d53 6380{
2cf0635d 6381 const char * name;
566b0d53
L		 6382 int reloc;
6383 int size;
6384 int rela;
6385} dynamic_relocations [] =
6386{
6387 { "REL", DT_REL, DT_RELSZ, FALSE },
6388 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6389 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6390};
6391
252b5132 6392/* Process the reloc section. */
18bd398b 6393
252b5132 6394static int
2cf0635d 6395process_relocs (FILE * file)
252b5132 6396{
b34976b6
AM		 6397 unsigned long rel_size;
6398 unsigned long rel_offset;
252b5132
RH		 6399
6400
6401 if (!do_reloc)
6402 return 1;
6403
6404 if (do_using_dynamic)
6405 {
566b0d53 6406 int is_rela;
2cf0635d 6407 const char * name;
566b0d53
L		 6408 int has_dynamic_reloc;
6409 unsigned int i;
0de14b54 6410
566b0d53 6411 has_dynamic_reloc = 0;
252b5132 6412
566b0d53 6413 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 6414 {
566b0d53
L		 6415 is_rela = dynamic_relocations [i].rela;
6416 name = dynamic_relocations [i].name;
6417 rel_size = dynamic_info [dynamic_relocations [i].size];
6418 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 6419
566b0d53
L		 6420 has_dynamic_reloc |= rel_size;
6421
6422 if (is_rela == UNKNOWN)
aa903cfb 6423 {
566b0d53
L		 6424 if (dynamic_relocations [i].reloc == DT_JMPREL)
6425 switch (dynamic_info[DT_PLTREL])
6426 {
6427 case DT_REL:
6428 is_rela = FALSE;
6429 break;
6430 case DT_RELA:
6431 is_rela = TRUE;
6432 break;
6433 }
aa903cfb 6434 }
252b5132 6435
566b0d53
L		 6436 if (rel_size)
6437 {
6438 printf
6439 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6440 name, rel_offset, rel_size);
252b5132 6441
d93f0186
NC		 6442 dump_relocations (file,
6443 offset_from_vma (file, rel_offset, rel_size),
6444 rel_size,
566b0d53 6445 dynamic_symbols, num_dynamic_syms,
bb4d2ac2
L		 6446 dynamic_strings, dynamic_strings_length,
6447 is_rela, 1);
566b0d53 6448 }
252b5132 6449 }
566b0d53 6450
28f997cf
TG		 6451 if (is_ia64_vms ())
6452 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6453
566b0d53 6454 if (! has_dynamic_reloc)
252b5132
RH		 6455 printf (_("\nThere are no dynamic relocations in this file.\n"));
6456 }
6457 else
6458 {
2cf0635d 6459 Elf_Internal_Shdr * section;
b34976b6
AM		 6460 unsigned long i;
6461 int found = 0;
252b5132
RH		 6462
6463 for (i = 0, section = section_headers;
6464 i < elf_header.e_shnum;
b34976b6 6465 i++, section++)
252b5132
RH		 6466 {
6467 if ( section->sh_type != SHT_RELA
6468 && section->sh_type != SHT_REL)
6469 continue;
6470
6471 rel_offset = section->sh_offset;
6472 rel_size = section->sh_size;
6473
6474 if (rel_size)
6475 {
2cf0635d 6476 Elf_Internal_Shdr * strsec;
b34976b6 6477 int is_rela;
103f02d3 6478
252b5132
RH		 6479 printf (_("\nRelocation section "));
6480
6481 if (string_table == NULL)
19936277 6482 printf ("%d", section->sh_name);
252b5132 6483 else
74e1a04b 6484 printf ("'%s'", printable_section_name (section));
252b5132
RH		 6485
6486 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6487 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6488
d79b3d50
NC		 6489 is_rela = section->sh_type == SHT_RELA;
6490
4fbb74a6
AM		 6491 if (section->sh_link != 0
6492 && section->sh_link < elf_header.e_shnum)
af3fc3bc 6493 {
2cf0635d
NC		 6494 Elf_Internal_Shdr * symsec;
6495 Elf_Internal_Sym * symtab;
d79b3d50 6496 unsigned long nsyms;
c256ffe7 6497 unsigned long strtablen = 0;
2cf0635d 6498 char * strtab = NULL;
57346661 6499
4fbb74a6 6500 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 6501 if (symsec->sh_type != SHT_SYMTAB
6502 && symsec->sh_type != SHT_DYNSYM)
6503 continue;
6504
ba5cdace 6505 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 6506
af3fc3bc
AM		 6507 if (symtab == NULL)
6508 continue;
252b5132 6509
4fbb74a6
AM		 6510 if (symsec->sh_link != 0
6511 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 6512 {
4fbb74a6 6513 strsec = section_headers + symsec->sh_link;
103f02d3 6514
3f5e193b 6515 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
071436c6
NC		 6516 1, strsec->sh_size,
6517 _("string table"));
c256ffe7
JJ		 6518 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6519 }
252b5132 6520
d79b3d50 6521 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2
L		 6522 symtab, nsyms, strtab, strtablen,
6523 is_rela,
6524 symsec->sh_type == SHT_DYNSYM);
d79b3d50
NC		 6525 if (strtab)
6526 free (strtab);
6527 free (symtab);
6528 }
6529 else
6530 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2 6531 NULL, 0, NULL, 0, is_rela, 0);
252b5132
RH		 6532
6533 found = 1;
6534 }
6535 }
6536
6537 if (! found)
6538 printf (_("\nThere are no relocations in this file.\n"));
6539 }
6540
6541 return 1;
6542}
6543
4d6ed7c8
NC		 6544/* An absolute address consists of a section and an offset. If the
6545 section is NULL, the offset itself is the address, otherwise, the
6546 address equals to LOAD_ADDRESS(section) + offset. */
6547
6548struct absaddr
948f632f
DA		 6549{
6550 unsigned short section;
6551 bfd_vma offset;
6552};
4d6ed7c8 6553
1949de15
L		 6554#define ABSADDR(a) \
6555 ((a).section \
6556 ? section_headers [(a).section].sh_addr + (a).offset \
6557 : (a).offset)
6558
948f632f
DA		 6559/* Find the nearest symbol at or below ADDR. Returns the symbol
6560 name, if found, and the offset from the symbol to ADDR. */
4d6ed7c8 6561
4d6ed7c8 6562static void
2cf0635d 6563find_symbol_for_address (Elf_Internal_Sym * symtab,
948f632f
DA		 6564 unsigned long nsyms,
6565 const char * strtab,
6566 unsigned long strtab_size,
6567 struct absaddr addr,
6568 const char ** symname,
6569 bfd_vma * offset)
4d6ed7c8 6570{
d3ba0551 6571 bfd_vma dist = 0x100000;
2cf0635d 6572 Elf_Internal_Sym * sym;
948f632f
DA		 6573 Elf_Internal_Sym * beg;
6574 Elf_Internal_Sym * end;
2cf0635d 6575 Elf_Internal_Sym * best = NULL;
4d6ed7c8 6576
0b6ae522 6577 REMOVE_ARCH_BITS (addr.offset);
948f632f
DA		 6578 beg = symtab;
6579 end = symtab + nsyms;
0b6ae522 6580
948f632f 6581 while (beg < end)
4d6ed7c8 6582 {
948f632f
DA		 6583 bfd_vma value;
6584
6585 sym = beg + (end - beg) / 2;
0b6ae522 6586
948f632f 6587 value = sym->st_value;
0b6ae522
DJ		 6588 REMOVE_ARCH_BITS (value);
6589
948f632f 6590 if (sym->st_name != 0
4d6ed7c8 6591 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 6592 && addr.offset >= value
6593 && addr.offset - value < dist)
4d6ed7c8
NC		 6594 {
6595 best = sym;
0b6ae522 6596 dist = addr.offset - value;
4d6ed7c8
NC		 6597 if (!dist)
6598 break;
6599 }
948f632f
DA		 6600
6601 if (addr.offset < value)
6602 end = sym;
6603 else
6604 beg = sym + 1;
4d6ed7c8 6605 }
1b31d05e 6606
4d6ed7c8
NC		 6607 if (best)
6608 {
57346661 6609 *symname = (best->st_name >= strtab_size
2b692964 6610 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 6611 *offset = dist;
6612 return;
6613 }
1b31d05e 6614
4d6ed7c8
NC		 6615 *symname = NULL;
6616 *offset = addr.offset;
6617}
6618
948f632f
DA		 6619static int
6620symcmp (const void *p, const void *q)
6621{
6622 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
6623 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
6624
6625 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
6626}
6627
6628/* Process the unwind section. */
6629
6630#include "unwind-ia64.h"
6631
6632struct ia64_unw_table_entry
6633{
6634 struct absaddr start;
6635 struct absaddr end;
6636 struct absaddr info;
6637};
6638
6639struct ia64_unw_aux_info
6640{
6641 struct ia64_unw_table_entry *table; /* Unwind table. */
6642 unsigned long table_len; /* Length of unwind table. */
6643 unsigned char * info; /* Unwind info. */
6644 unsigned long info_size; /* Size of unwind info. */
6645 bfd_vma info_addr; /* Starting address of unwind info. */
6646 bfd_vma seg_base; /* Starting address of segment. */
6647 Elf_Internal_Sym * symtab; /* The symbol table. */
6648 unsigned long nsyms; /* Number of symbols. */
6649 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
6650 unsigned long nfuns; /* Number of entries in funtab. */
6651 char * strtab; /* The string table. */
6652 unsigned long strtab_size; /* Size of string table. */
6653};
6654
4d6ed7c8 6655static void
2cf0635d 6656dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 6657{
2cf0635d 6658 struct ia64_unw_table_entry * tp;
948f632f 6659 unsigned long j, nfuns;
4d6ed7c8 6660 int in_body;
7036c0e1 6661
948f632f
DA		 6662 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
6663 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
6664 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
6665 aux->funtab[nfuns++] = aux->symtab[j];
6666 aux->nfuns = nfuns;
6667 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
6668
4d6ed7c8
NC		 6669 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6670 {
6671 bfd_vma stamp;
6672 bfd_vma offset;
2cf0635d
NC		 6673 const unsigned char * dp;
6674 const unsigned char * head;
53774b7e 6675 const unsigned char * end;
2cf0635d 6676 const char * procname;
4d6ed7c8 6677
948f632f 6678 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661 6679 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 6680
6681 fputs ("\n<", stdout);
6682
6683 if (procname)
6684 {
6685 fputs (procname, stdout);
6686
6687 if (offset)
6688 printf ("+%lx", (unsigned long) offset);
6689 }
6690
6691 fputs (">: [", stdout);
6692 print_vma (tp->start.offset, PREFIX_HEX);
6693 fputc ('-', stdout);
6694 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 6695 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 6696 (unsigned long) (tp->info.offset - aux->seg_base));
6697
53774b7e
NC		 6698 /* PR 17531: file: 86232b32. */
6699 if (aux->info == NULL)
6700 continue;
6701
6702 /* PR 17531: file: 0997b4d1. */
6703 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6704 {
6705 warn (_("Invalid offset %lx in table entry %ld\n"),
6706 (long) tp->info.offset, (long) (tp - aux->table));
6707 continue;
6708 }
6709
1949de15 6710 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 6711 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 6712
86f55779 6713 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 6714 (unsigned) UNW_VER (stamp),
6715 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6716 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6717 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 6718 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 6719
6720 if (UNW_VER (stamp) != 1)
6721 {
2b692964 6722 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 6723 continue;
6724 }
6725
6726 in_body = 0;
53774b7e
NC		 6727 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6728 /* PR 17531: file: 16ceda89. */
6729 if (end > aux->info + aux->info_size)
6730 end = aux->info + aux->info_size;
6731 for (dp = head + 8; dp < end;)
4d6ed7c8
NC		 6732 dp = unw_decode (dp, in_body, & in_body);
6733 }
948f632f
DA		 6734
6735 free (aux->funtab);
4d6ed7c8
NC		 6736}
6737
53774b7e 6738static bfd_boolean
2cf0635d
NC		 6739slurp_ia64_unwind_table (FILE * file,
6740 struct ia64_unw_aux_info * aux,
6741 Elf_Internal_Shdr * sec)
4d6ed7c8 6742{
89fac5e3 6743 unsigned long size, nrelas, i;
2cf0635d
NC		 6744 Elf_Internal_Phdr * seg;
6745 struct ia64_unw_table_entry * tep;
6746 Elf_Internal_Shdr * relsec;
6747 Elf_Internal_Rela * rela;
6748 Elf_Internal_Rela * rp;
6749 unsigned char * table;
6750 unsigned char * tp;
6751 Elf_Internal_Sym * sym;
6752 const char * relname;
4d6ed7c8 6753
53774b7e
NC		 6754 aux->table_len = 0;
6755
4d6ed7c8
NC		 6756 /* First, find the starting address of the segment that includes
6757 this section: */
6758
6759 if (elf_header.e_phnum)
6760 {
d93f0186 6761 if (! get_program_headers (file))
53774b7e 6762 return FALSE;
4d6ed7c8 6763
d93f0186
NC		 6764 for (seg = program_headers;
6765 seg < program_headers + elf_header.e_phnum;
6766 ++seg)
4d6ed7c8
NC		 6767 {
6768 if (seg->p_type != PT_LOAD)
6769 continue;
6770
6771 if (sec->sh_addr >= seg->p_vaddr
6772 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6773 {
6774 aux->seg_base = seg->p_vaddr;
6775 break;
6776 }
6777 }
4d6ed7c8
NC		 6778 }
6779
6780 /* Second, build the unwind table from the contents of the unwind section: */
6781 size = sec->sh_size;
3f5e193b
NC		 6782 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6783 _("unwind table"));
a6e9f9df 6784 if (!table)
53774b7e 6785 return FALSE;
4d6ed7c8 6786
53774b7e 6787 aux->table_len = size / (3 * eh_addr_size);
3f5e193b 6788 aux->table = (struct ia64_unw_table_entry *)
53774b7e 6789 xcmalloc (aux->table_len, sizeof (aux->table[0]));
89fac5e3 6790 tep = aux->table;
53774b7e
NC		 6791
6792 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
4d6ed7c8
NC		 6793 {
6794 tep->start.section = SHN_UNDEF;
6795 tep->end.section = SHN_UNDEF;
6796 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 6797 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6798 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6799 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 6800 tep->start.offset += aux->seg_base;
6801 tep->end.offset += aux->seg_base;
6802 tep->info.offset += aux->seg_base;
6803 }
6804 free (table);
6805
41e92641 6806 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 6807 for (relsec = section_headers;
6808 relsec < section_headers + elf_header.e_shnum;
6809 ++relsec)
6810 {
6811 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6812 || relsec->sh_info >= elf_header.e_shnum
6813 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 6814 continue;
6815
6816 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6817 & rela, & nrelas))
53774b7e
NC		 6818 {
6819 free (aux->table);
6820 aux->table = NULL;
6821 aux->table_len = 0;
6822 return FALSE;
6823 }
4d6ed7c8
NC		 6824
6825 for (rp = rela; rp < rela + nrelas; ++rp)
6826 {
aca88567
NC		 6827 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6828 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 6829
82b1b41b
NC		 6830 /* PR 17531: file: 9fa67536. */
6831 if (relname == NULL)
6832 {
6833 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
6834 continue;
6835 }
948f632f 6836
0112cd26 6837 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 6838 {
82b1b41b 6839 warn (_("Skipping unexpected relocation type: %s\n"), relname);
4d6ed7c8
NC		 6840 continue;
6841 }
6842
89fac5e3 6843 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 6844
53774b7e
NC		 6845 /* PR 17531: file: 5bc8d9bf. */
6846 if (i >= aux->table_len)
6847 {
6848 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
6849 continue;
6850 }
6851
6852 switch (rp->r_offset / eh_addr_size % 3)
4d6ed7c8
NC		 6853 {
6854 case 0:
6855 aux->table[i].start.section = sym->st_shndx;
e466bc6e 6856 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6857 break;
6858 case 1:
6859 aux->table[i].end.section = sym->st_shndx;
e466bc6e 6860 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6861 break;
6862 case 2:
6863 aux->table[i].info.section = sym->st_shndx;
e466bc6e 6864 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6865 break;
6866 default:
6867 break;
6868 }
6869 }
6870
6871 free (rela);
6872 }
6873
53774b7e 6874 return TRUE;
4d6ed7c8
NC		 6875}
6876
1b31d05e 6877static void
2cf0635d 6878ia64_process_unwind (FILE * file)
4d6ed7c8 6879{
2cf0635d
NC		 6880 Elf_Internal_Shdr * sec;
6881 Elf_Internal_Shdr * unwsec = NULL;
6882 Elf_Internal_Shdr * strsec;
89fac5e3 6883 unsigned long i, unwcount = 0, unwstart = 0;
57346661 6884 struct ia64_unw_aux_info aux;
f1467e33 6885
4d6ed7c8
NC		 6886 memset (& aux, 0, sizeof (aux));
6887
4d6ed7c8
NC		 6888 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6889 {
c256ffe7 6890 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6891 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 6892 {
ba5cdace 6893 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 6894
4fbb74a6 6895 strsec = section_headers + sec->sh_link;
4082ef84
NC		 6896 if (aux.strtab != NULL)
6897 {
6898 error (_("Multiple auxillary string tables encountered\n"));
6899 free (aux.strtab);
6900 }
3f5e193b
NC		 6901 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6902 1, strsec->sh_size,
6903 _("string table"));
c256ffe7 6904 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 6905 }
6906 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 6907 unwcount++;
6908 }
6909
6910 if (!unwcount)
6911 printf (_("\nThere are no unwind sections in this file.\n"));
6912
6913 while (unwcount-- > 0)
6914 {
2cf0635d 6915 char * suffix;
579f31ac
JJ		 6916 size_t len, len2;
6917
4082ef84 6918 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
579f31ac
JJ		 6919 i < elf_header.e_shnum; ++i, ++sec)
6920 if (sec->sh_type == SHT_IA_64_UNWIND)
6921 {
6922 unwsec = sec;
6923 break;
6924 }
4082ef84
NC		 6925 /* We have already counted the number of SHT_IA64_UNWIND
6926 sections so the loop above should never fail. */
6927 assert (unwsec != NULL);
579f31ac
JJ		 6928
6929 unwstart = i + 1;
6930 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6931
e4b17d5c
L		 6932 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6933 {
6934 /* We need to find which section group it is in. */
4082ef84 6935 struct group_list * g;
e4b17d5c 6936
4082ef84
NC		 6937 if (section_headers_groups == NULL
6938 || section_headers_groups [i] == NULL)
6939 i = elf_header.e_shnum;
6940 else
e4b17d5c 6941 {
4082ef84 6942 g = section_headers_groups [i]->root;
18bd398b 6943
4082ef84
NC		 6944 for (; g != NULL; g = g->next)
6945 {
6946 sec = section_headers + g->section_index;
e4b17d5c 6947
4082ef84
NC		 6948 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6949 break;
6950 }
6951
6952 if (g == NULL)
6953 i = elf_header.e_shnum;
6954 }
e4b17d5c 6955 }
18bd398b 6956 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 6957 {
18bd398b 6958 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 6959 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6960 suffix = SECTION_NAME (unwsec) + len;
6961 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6962 ++i, ++sec)
18bd398b
NC		 6963 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6964 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6965 break;
6966 }
6967 else
6968 {
6969 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 6970 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 6971 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6972 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6973 suffix = "";
18bd398b 6974 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 6975 suffix = SECTION_NAME (unwsec) + len;
6976 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6977 ++i, ++sec)
18bd398b
NC		 6978 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6979 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6980 break;
6981 }
6982
6983 if (i == elf_header.e_shnum)
6984 {
6985 printf (_("\nCould not find unwind info section for "));
6986
6987 if (string_table == NULL)
6988 printf ("%d", unwsec->sh_name);
6989 else
74e1a04b 6990 printf ("'%s'", printable_section_name (unwsec));
579f31ac
JJ		 6991 }
6992 else
4d6ed7c8 6993 {
4d6ed7c8 6994 aux.info_addr = sec->sh_addr;
3f5e193b 6995 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
4082ef84
NC		 6996 sec->sh_size,
6997 _("unwind info"));
59245841 6998 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 6999
579f31ac 7000 printf (_("\nUnwind section "));
4d6ed7c8 7001
579f31ac
JJ		 7002 if (string_table == NULL)
7003 printf ("%d", unwsec->sh_name);
7004 else
74e1a04b 7005 printf ("'%s'", printable_section_name (unwsec));
4d6ed7c8 7006
579f31ac 7007 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 7008 (unsigned long) unwsec->sh_offset,
89fac5e3 7009 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 7010
53774b7e
NC		 7011 if (slurp_ia64_unwind_table (file, & aux, unwsec)
7012 && aux.table_len > 0)
579f31ac
JJ		 7013 dump_ia64_unwind (& aux);
7014
7015 if (aux.table)
7016 free ((char *) aux.table);
7017 if (aux.info)
7018 free ((char *) aux.info);
7019 aux.table = NULL;
7020 aux.info = NULL;
7021 }
4d6ed7c8 7022 }
4d6ed7c8 7023
4d6ed7c8
NC		 7024 if (aux.symtab)
7025 free (aux.symtab);
7026 if (aux.strtab)
7027 free ((char *) aux.strtab);
4d6ed7c8
NC		 7028}
7029
3f5e193b
NC		 7030struct hppa_unw_table_entry
7031 {
7032 struct absaddr start;
7033 struct absaddr end;
948f632f 7034 unsigned int Cannot_unwind:1; /* 0 */
3f5e193b
NC		 7035 unsigned int Millicode:1; /* 1 */
7036 unsigned int Millicode_save_sr0:1; /* 2 */
7037 unsigned int Region_description:2; /* 3..4 */
7038 unsigned int reserved1:1; /* 5 */
7039 unsigned int Entry_SR:1; /* 6 */
7040 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
7041 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
7042 unsigned int Args_stored:1; /* 16 */
948f632f
DA		 7043 unsigned int Variable_Frame:1; /* 17 */
7044 unsigned int Separate_Package_Body:1; /* 18 */
3f5e193b 7045 unsigned int Frame_Extension_Millicode:1; /* 19 */
948f632f
DA		 7046 unsigned int Stack_Overflow_Check:1; /* 20 */
7047 unsigned int Two_Instruction_SP_Increment:1;/* 21 */
3f5e193b
NC		 7048 unsigned int Ada_Region:1; /* 22 */
7049 unsigned int cxx_info:1; /* 23 */
948f632f
DA		 7050 unsigned int cxx_try_catch:1; /* 24 */
7051 unsigned int sched_entry_seq:1; /* 25 */
3f5e193b 7052 unsigned int reserved2:1; /* 26 */
948f632f
DA		 7053 unsigned int Save_SP:1; /* 27 */
7054 unsigned int Save_RP:1; /* 28 */
3f5e193b
NC		 7055 unsigned int Save_MRP_in_frame:1; /* 29 */
7056 unsigned int extn_ptr_defined:1; /* 30 */
948f632f 7057 unsigned int Cleanup_defined:1; /* 31 */
3f5e193b 7058
948f632f
DA		 7059 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7060 unsigned int HP_UX_interrupt_marker:1; /* 1 */
3f5e193b 7061 unsigned int Large_frame:1; /* 2 */
948f632f 7062 unsigned int Pseudo_SP_Set:1; /* 3 */
3f5e193b
NC		 7063 unsigned int reserved4:1; /* 4 */
7064 unsigned int Total_frame_size:27; /* 5..31 */
7065 };
7066
57346661 7067struct hppa_unw_aux_info
948f632f
DA		 7068{
7069 struct hppa_unw_table_entry * table; /* Unwind table. */
7070 unsigned long table_len; /* Length of unwind table. */
7071 bfd_vma seg_base; /* Starting address of segment. */
7072 Elf_Internal_Sym * symtab; /* The symbol table. */
7073 unsigned long nsyms; /* Number of symbols. */
7074 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7075 unsigned long nfuns; /* Number of entries in funtab. */
7076 char * strtab; /* The string table. */
7077 unsigned long strtab_size; /* Size of string table. */
7078};
57346661
AM		 7079
7080static void
2cf0635d 7081dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 7082{
2cf0635d 7083 struct hppa_unw_table_entry * tp;
948f632f
DA		 7084 unsigned long j, nfuns;
7085
7086 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7087 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7088 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7089 aux->funtab[nfuns++] = aux->symtab[j];
7090 aux->nfuns = nfuns;
7091 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
57346661 7092
57346661
AM		 7093 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7094 {
7095 bfd_vma offset;
2cf0635d 7096 const char * procname;
57346661 7097
948f632f 7098 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661
AM		 7099 aux->strtab_size, tp->start, &procname,
7100 &offset);
7101
7102 fputs ("\n<", stdout);
7103
7104 if (procname)
7105 {
7106 fputs (procname, stdout);
7107
7108 if (offset)
7109 printf ("+%lx", (unsigned long) offset);
7110 }
7111
7112 fputs (">: [", stdout);
7113 print_vma (tp->start.offset, PREFIX_HEX);
7114 fputc ('-', stdout);
7115 print_vma (tp->end.offset, PREFIX_HEX);
7116 printf ("]\n\t");
7117
18bd398b
NC		 7118#define PF(_m) if (tp->_m) printf (#_m " ");
7119#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 7120 PF(Cannot_unwind);
7121 PF(Millicode);
7122 PF(Millicode_save_sr0);
18bd398b 7123 /* PV(Region_description); */
57346661
AM		 7124 PF(Entry_SR);
7125 PV(Entry_FR);
7126 PV(Entry_GR);
7127 PF(Args_stored);
7128 PF(Variable_Frame);
7129 PF(Separate_Package_Body);
7130 PF(Frame_Extension_Millicode);
7131 PF(Stack_Overflow_Check);
7132 PF(Two_Instruction_SP_Increment);
7133 PF(Ada_Region);
7134 PF(cxx_info);
7135 PF(cxx_try_catch);
7136 PF(sched_entry_seq);
7137 PF(Save_SP);
7138 PF(Save_RP);
7139 PF(Save_MRP_in_frame);
7140 PF(extn_ptr_defined);
7141 PF(Cleanup_defined);
7142 PF(MPE_XL_interrupt_marker);
7143 PF(HP_UX_interrupt_marker);
7144 PF(Large_frame);
7145 PF(Pseudo_SP_Set);
7146 PV(Total_frame_size);
7147#undef PF
7148#undef PV
7149 }
7150
18bd398b 7151 printf ("\n");
948f632f
DA		 7152
7153 free (aux->funtab);
57346661
AM		 7154}
7155
7156static int
2cf0635d
NC		 7157slurp_hppa_unwind_table (FILE * file,
7158 struct hppa_unw_aux_info * aux,
7159 Elf_Internal_Shdr * sec)
57346661 7160{
1c0751b2 7161 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 7162 Elf_Internal_Phdr * seg;
7163 struct hppa_unw_table_entry * tep;
7164 Elf_Internal_Shdr * relsec;
7165 Elf_Internal_Rela * rela;
7166 Elf_Internal_Rela * rp;
7167 unsigned char * table;
7168 unsigned char * tp;
7169 Elf_Internal_Sym * sym;
7170 const char * relname;
57346661 7171
57346661
AM		 7172 /* First, find the starting address of the segment that includes
7173 this section. */
7174
7175 if (elf_header.e_phnum)
7176 {
7177 if (! get_program_headers (file))
7178 return 0;
7179
7180 for (seg = program_headers;
7181 seg < program_headers + elf_header.e_phnum;
7182 ++seg)
7183 {
7184 if (seg->p_type != PT_LOAD)
7185 continue;
7186
7187 if (sec->sh_addr >= seg->p_vaddr
7188 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7189 {
7190 aux->seg_base = seg->p_vaddr;
7191 break;
7192 }
7193 }
7194 }
7195
7196 /* Second, build the unwind table from the contents of the unwind
7197 section. */
7198 size = sec->sh_size;
3f5e193b
NC		 7199 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7200 _("unwind table"));
57346661
AM		 7201 if (!table)
7202 return 0;
7203
1c0751b2
DA		 7204 unw_ent_size = 16;
7205 nentries = size / unw_ent_size;
7206 size = unw_ent_size * nentries;
57346661 7207
3f5e193b
NC		 7208 tep = aux->table = (struct hppa_unw_table_entry *)
7209 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 7210
1c0751b2 7211 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 7212 {
7213 unsigned int tmp1, tmp2;
7214
7215 tep->start.section = SHN_UNDEF;
7216 tep->end.section = SHN_UNDEF;
7217
1c0751b2
DA		 7218 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7219 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7220 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7221 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7222
7223 tep->start.offset += aux->seg_base;
7224 tep->end.offset += aux->seg_base;
57346661
AM		 7225
7226 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7227 tep->Millicode = (tmp1 >> 30) & 0x1;
7228 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7229 tep->Region_description = (tmp1 >> 27) & 0x3;
7230 tep->reserved1 = (tmp1 >> 26) & 0x1;
7231 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7232 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7233 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7234 tep->Args_stored = (tmp1 >> 15) & 0x1;
7235 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7236 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7237 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7238 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7239 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7240 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7241 tep->cxx_info = (tmp1 >> 8) & 0x1;
7242 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7243 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7244 tep->reserved2 = (tmp1 >> 5) & 0x1;
7245 tep->Save_SP = (tmp1 >> 4) & 0x1;
7246 tep->Save_RP = (tmp1 >> 3) & 0x1;
7247 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7248 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7249 tep->Cleanup_defined = tmp1 & 0x1;
7250
7251 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7252 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7253 tep->Large_frame = (tmp2 >> 29) & 0x1;
7254 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7255 tep->reserved4 = (tmp2 >> 27) & 0x1;
7256 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 7257 }
7258 free (table);
7259
7260 /* Third, apply any relocations to the unwind table. */
57346661
AM		 7261 for (relsec = section_headers;
7262 relsec < section_headers + elf_header.e_shnum;
7263 ++relsec)
7264 {
7265 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7266 || relsec->sh_info >= elf_header.e_shnum
7267 || section_headers + relsec->sh_info != sec)
57346661
AM		 7268 continue;
7269
7270 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7271 & rela, & nrelas))
7272 return 0;
7273
7274 for (rp = rela; rp < rela + nrelas; ++rp)
7275 {
aca88567
NC		 7276 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7277 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 7278
7279 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 7280 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 7281 {
7282 warn (_("Skipping unexpected relocation type %s\n"), relname);
7283 continue;
7284 }
7285
7286 i = rp->r_offset / unw_ent_size;
7287
89fac5e3 7288 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 7289 {
7290 case 0:
7291 aux->table[i].start.section = sym->st_shndx;
1e456d54 7292 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 7293 break;
7294 case 1:
7295 aux->table[i].end.section = sym->st_shndx;
1e456d54 7296 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 7297 break;
7298 default:
7299 break;
7300 }
7301 }
7302
7303 free (rela);
7304 }
7305
1c0751b2 7306 aux->table_len = nentries;
57346661
AM		 7307
7308 return 1;
7309}
7310
1b31d05e 7311static void
2cf0635d 7312hppa_process_unwind (FILE * file)
57346661 7313{
57346661 7314 struct hppa_unw_aux_info aux;
2cf0635d
NC		 7315 Elf_Internal_Shdr * unwsec = NULL;
7316 Elf_Internal_Shdr * strsec;
7317 Elf_Internal_Shdr * sec;
18bd398b 7318 unsigned long i;
57346661 7319
c256ffe7 7320 if (string_table == NULL)
1b31d05e
NC		 7321 return;
7322
7323 memset (& aux, 0, sizeof (aux));
57346661
AM		 7324
7325 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7326 {
c256ffe7 7327 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7328 && sec->sh_link < elf_header.e_shnum)
57346661 7329 {
ba5cdace 7330 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 7331
4fbb74a6 7332 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7333 if (aux.strtab != NULL)
7334 {
7335 error (_("Multiple auxillary string tables encountered\n"));
7336 free (aux.strtab);
7337 }
3f5e193b
NC		 7338 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7339 1, strsec->sh_size,
7340 _("string table"));
c256ffe7 7341 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 7342 }
18bd398b 7343 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 7344 unwsec = sec;
7345 }
7346
7347 if (!unwsec)
7348 printf (_("\nThere are no unwind sections in this file.\n"));
7349
7350 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7351 {
18bd398b 7352 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 7353 {
74e1a04b
NC		 7354 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7355 printable_section_name (sec),
57346661 7356 (unsigned long) sec->sh_offset,
89fac5e3 7357 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 7358
7359 slurp_hppa_unwind_table (file, &aux, sec);
7360 if (aux.table_len > 0)
7361 dump_hppa_unwind (&aux);
7362
7363 if (aux.table)
7364 free ((char *) aux.table);
7365 aux.table = NULL;
7366 }
7367 }
7368
7369 if (aux.symtab)
7370 free (aux.symtab);
7371 if (aux.strtab)
7372 free ((char *) aux.strtab);
57346661
AM		 7373}
7374
0b6ae522
DJ		 7375struct arm_section
7376{
a734115a
NC		 7377 unsigned char * data; /* The unwind data. */
7378 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7379 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7380 unsigned long nrelas; /* The number of relocations. */
7381 unsigned int rel_type; /* REL or RELA ? */
7382 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 7383};
7384
7385struct arm_unw_aux_info
7386{
a734115a
NC		 7387 FILE * file; /* The file containing the unwind sections. */
7388 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7389 unsigned long nsyms; /* Number of symbols. */
948f632f
DA		 7390 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7391 unsigned long nfuns; /* Number of these symbols. */
a734115a
NC		 7392 char * strtab; /* The file's string table. */
7393 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 7394};
7395
7396static const char *
7397arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7398 bfd_vma fn, struct absaddr addr)
7399{
7400 const char *procname;
7401 bfd_vma sym_offset;
7402
7403 if (addr.section == SHN_UNDEF)
7404 addr.offset = fn;
7405
948f632f 7406 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
0b6ae522
DJ		 7407 aux->strtab_size, addr, &procname,
7408 &sym_offset);
7409
7410 print_vma (fn, PREFIX_HEX);
7411
7412 if (procname)
7413 {
7414 fputs (" <", stdout);
7415 fputs (procname, stdout);
7416
7417 if (sym_offset)
7418 printf ("+0x%lx", (unsigned long) sym_offset);
7419 fputc ('>', stdout);
7420 }
7421
7422 return procname;
7423}
7424
7425static void
7426arm_free_section (struct arm_section *arm_sec)
7427{
7428 if (arm_sec->data != NULL)
7429 free (arm_sec->data);
7430
7431 if (arm_sec->rela != NULL)
7432 free (arm_sec->rela);
7433}
7434
a734115a
NC		 7435/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7436 cached section and install SEC instead.
7437 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7438 and return its valued in * WORDP, relocating if necessary.
1b31d05e 7439 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 7440 relocation's offset in ADDR.
1b31d05e
NC		 7441 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7442 into the string table of the symbol associated with the reloc. If no
7443 reloc was applied store -1 there.
7444 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 7445
7446static bfd_boolean
1b31d05e
NC		 7447get_unwind_section_word (struct arm_unw_aux_info * aux,
7448 struct arm_section * arm_sec,
7449 Elf_Internal_Shdr * sec,
7450 bfd_vma word_offset,
7451 unsigned int * wordp,
7452 struct absaddr * addr,
7453 bfd_vma * sym_name)
0b6ae522
DJ		 7454{
7455 Elf_Internal_Rela *rp;
7456 Elf_Internal_Sym *sym;
7457 const char * relname;
7458 unsigned int word;
7459 bfd_boolean wrapped;
7460
e0a31db1
NC		 7461 if (sec == NULL || arm_sec == NULL)
7462 return FALSE;
7463
0b6ae522
DJ		 7464 addr->section = SHN_UNDEF;
7465 addr->offset = 0;
7466
1b31d05e
NC		 7467 if (sym_name != NULL)
7468 *sym_name = (bfd_vma) -1;
7469
a734115a 7470 /* If necessary, update the section cache. */
0b6ae522
DJ		 7471 if (sec != arm_sec->sec)
7472 {
7473 Elf_Internal_Shdr *relsec;
7474
7475 arm_free_section (arm_sec);
7476
7477 arm_sec->sec = sec;
7478 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7479 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 7480 arm_sec->rela = NULL;
7481 arm_sec->nrelas = 0;
7482
7483 for (relsec = section_headers;
7484 relsec < section_headers + elf_header.e_shnum;
7485 ++relsec)
7486 {
7487 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 7488 || section_headers + relsec->sh_info != sec
7489 /* PR 15745: Check the section type as well. */
7490 || (relsec->sh_type != SHT_REL
7491 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 7492 continue;
7493
a734115a 7494 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 7495 if (relsec->sh_type == SHT_REL)
7496 {
7497 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7498 relsec->sh_size,
7499 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7500 return FALSE;
0b6ae522 7501 }
1ae40aa4 7502 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 7503 {
7504 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7505 relsec->sh_size,
7506 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7507 return FALSE;
0b6ae522 7508 }
1ae40aa4 7509 break;
0b6ae522
DJ		 7510 }
7511
7512 arm_sec->next_rela = arm_sec->rela;
7513 }
7514
a734115a 7515 /* If there is no unwind data we can do nothing. */
0b6ae522 7516 if (arm_sec->data == NULL)
a734115a 7517 return FALSE;
0b6ae522 7518
e0a31db1
NC		 7519 /* If the offset is invalid then fail. */
7520 if (word_offset > sec->sh_size - 4)
7521 return FALSE;
7522
a734115a 7523 /* Get the word at the required offset. */
0b6ae522
DJ		 7524 word = byte_get (arm_sec->data + word_offset, 4);
7525
0eff7165
NC		 7526 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7527 if (arm_sec->rela == NULL)
7528 {
7529 * wordp = word;
7530 return TRUE;
7531 }
7532
a734115a 7533 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 7534 wrapped = FALSE;
7535 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7536 {
7537 bfd_vma prelval, offset;
7538
7539 if (rp->r_offset > word_offset && !wrapped)
7540 {
7541 rp = arm_sec->rela;
7542 wrapped = TRUE;
7543 }
7544 if (rp->r_offset > word_offset)
7545 break;
7546
7547 if (rp->r_offset & 3)
7548 {
7549 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7550 (unsigned long) rp->r_offset);
7551 continue;
7552 }
7553
7554 if (rp->r_offset < word_offset)
7555 continue;
7556
74e1a04b
NC		 7557 /* PR 17531: file: 027-161405-0.004 */
7558 if (aux->symtab == NULL)
7559 continue;
7560
0b6ae522
DJ		 7561 if (arm_sec->rel_type == SHT_REL)
7562 {
7563 offset = word & 0x7fffffff;
7564 if (offset & 0x40000000)
7565 offset |= ~ (bfd_vma) 0x7fffffff;
7566 }
a734115a 7567 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 7568 offset = rp->r_addend;
a734115a 7569 else
74e1a04b
NC		 7570 {
7571 error (_("Unknown section relocation type %d encountered\n"),
7572 arm_sec->rel_type);
7573 break;
7574 }
0b6ae522 7575
071436c6
NC		 7576 /* PR 17531 file: 027-1241568-0.004. */
7577 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7578 {
7579 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7580 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7581 break;
7582 }
7583
7584 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
0b6ae522
DJ		 7585 offset += sym->st_value;
7586 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7587
a734115a
NC		 7588 /* Check that we are processing the expected reloc type. */
7589 if (elf_header.e_machine == EM_ARM)
7590 {
7591 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7592 if (relname == NULL)
7593 {
7594 warn (_("Skipping unknown ARM relocation type: %d\n"),
7595 (int) ELF32_R_TYPE (rp->r_info));
7596 continue;
7597 }
a734115a
NC		 7598
7599 if (streq (relname, "R_ARM_NONE"))
7600 continue;
0b4362b0 7601
a734115a
NC		 7602 if (! streq (relname, "R_ARM_PREL31"))
7603 {
071436c6 7604 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
a734115a
NC		 7605 continue;
7606 }
7607 }
7608 else if (elf_header.e_machine == EM_TI_C6000)
7609 {
7610 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7611 if (relname == NULL)
7612 {
7613 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7614 (int) ELF32_R_TYPE (rp->r_info));
7615 continue;
7616 }
0b4362b0 7617
a734115a
NC		 7618 if (streq (relname, "R_C6000_NONE"))
7619 continue;
7620
7621 if (! streq (relname, "R_C6000_PREL31"))
7622 {
071436c6 7623 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
a734115a
NC		 7624 continue;
7625 }
7626
7627 prelval >>= 1;
7628 }
7629 else
74e1a04b
NC		 7630 {
7631 /* This function currently only supports ARM and TI unwinders. */
7632 warn (_("Only TI and ARM unwinders are currently supported\n"));
7633 break;
7634 }
fa197c1c 7635
0b6ae522
DJ		 7636 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7637 addr->section = sym->st_shndx;
7638 addr->offset = offset;
74e1a04b 7639
1b31d05e
NC		 7640 if (sym_name)
7641 * sym_name = sym->st_name;
0b6ae522
DJ		 7642 break;
7643 }
7644
7645 *wordp = word;
7646 arm_sec->next_rela = rp;
7647
a734115a 7648 return TRUE;
0b6ae522
DJ		 7649}
7650
a734115a
NC		 7651static const char *tic6x_unwind_regnames[16] =
7652{
0b4362b0
RM		 7653 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7654 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 7655 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7656};
fa197c1c 7657
0b6ae522 7658static void
fa197c1c 7659decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 7660{
fa197c1c
PB		 7661 int i;
7662
7663 for (i = 12; mask; mask >>= 1, i--)
7664 {
7665 if (mask & 1)
7666 {
7667 fputs (tic6x_unwind_regnames[i], stdout);
7668 if (mask > 1)
7669 fputs (", ", stdout);
7670 }
7671 }
7672}
0b6ae522
DJ		 7673
7674#define ADVANCE \
7675 if (remaining == 0 && more_words) \
7676 { \
7677 data_offset += 4; \
1b31d05e
NC		 7678 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7679 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 7680 return; \
7681 remaining = 4; \
7682 more_words--; \
7683 } \
7684
7685#define GET_OP(OP) \
7686 ADVANCE; \
7687 if (remaining) \
7688 { \
7689 remaining--; \
7690 (OP) = word >> 24; \
7691 word <<= 8; \
7692 } \
7693 else \
7694 { \
2b692964 7695 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 7696 return; \
7697 } \
cc5914eb 7698 printf ("0x%02x ", OP)
0b6ae522 7699
fa197c1c 7700static void
948f632f
DA		 7701decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
7702 unsigned int word,
7703 unsigned int remaining,
7704 unsigned int more_words,
7705 bfd_vma data_offset,
7706 Elf_Internal_Shdr * data_sec,
7707 struct arm_section * data_arm_sec)
fa197c1c
PB		 7708{
7709 struct absaddr addr;
0b6ae522
DJ		 7710
7711 /* Decode the unwinding instructions. */
7712 while (1)
7713 {
7714 unsigned int op, op2;
7715
7716 ADVANCE;
7717 if (remaining == 0)
7718 break;
7719 remaining--;
7720 op = word >> 24;
7721 word <<= 8;
7722
cc5914eb 7723 printf (" 0x%02x ", op);
0b6ae522
DJ		 7724
7725 if ((op & 0xc0) == 0x00)
7726 {
7727 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7728
cc5914eb 7729 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 7730 }
7731 else if ((op & 0xc0) == 0x40)
7732 {
7733 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7734
cc5914eb 7735 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 7736 }
7737 else if ((op & 0xf0) == 0x80)
7738 {
7739 GET_OP (op2);
7740 if (op == 0x80 && op2 == 0)
7741 printf (_("Refuse to unwind"));
7742 else
7743 {
7744 unsigned int mask = ((op & 0x0f) << 8) | op2;
7745 int first = 1;
7746 int i;
2b692964 7747
0b6ae522
DJ		 7748 printf ("pop {");
7749 for (i = 0; i < 12; i++)
7750 if (mask & (1 << i))
7751 {
7752 if (first)
7753 first = 0;
7754 else
7755 printf (", ");
7756 printf ("r%d", 4 + i);
7757 }
7758 printf ("}");
7759 }
7760 }
7761 else if ((op & 0xf0) == 0x90)
7762 {
7763 if (op == 0x9d || op == 0x9f)
7764 printf (_(" [Reserved]"));
7765 else
cc5914eb 7766 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 7767 }
7768 else if ((op & 0xf0) == 0xa0)
7769 {
7770 int end = 4 + (op & 0x07);
7771 int first = 1;
7772 int i;
61865e30 7773
0b6ae522
DJ		 7774 printf (" pop {");
7775 for (i = 4; i <= end; i++)
7776 {
7777 if (first)
7778 first = 0;
7779 else
7780 printf (", ");
7781 printf ("r%d", i);
7782 }
7783 if (op & 0x08)
7784 {
1b31d05e 7785 if (!first)
0b6ae522
DJ		 7786 printf (", ");
7787 printf ("r14");
7788 }
7789 printf ("}");
7790 }
7791 else if (op == 0xb0)
7792 printf (_(" finish"));
7793 else if (op == 0xb1)
7794 {
7795 GET_OP (op2);
7796 if (op2 == 0 || (op2 & 0xf0) != 0)
7797 printf (_("[Spare]"));
7798 else
7799 {
7800 unsigned int mask = op2 & 0x0f;
7801 int first = 1;
7802 int i;
61865e30 7803
0b6ae522
DJ		 7804 printf ("pop {");
7805 for (i = 0; i < 12; i++)
7806 if (mask & (1 << i))
7807 {
7808 if (first)
7809 first = 0;
7810 else
7811 printf (", ");
7812 printf ("r%d", i);
7813 }
7814 printf ("}");
7815 }
7816 }
7817 else if (op == 0xb2)
7818 {
b115cf96 7819 unsigned char buf[9];
0b6ae522
DJ		 7820 unsigned int i, len;
7821 unsigned long offset;
61865e30 7822
b115cf96 7823 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 7824 {
7825 GET_OP (buf[i]);
7826 if ((buf[i] & 0x80) == 0)
7827 break;
7828 }
4082ef84
NC		 7829 if (i == sizeof (buf))
7830 printf (_("corrupt change to vsp"));
7831 else
7832 {
7833 offset = read_uleb128 (buf, &len, buf + i + 1);
7834 assert (len == i + 1);
7835 offset = offset * 4 + 0x204;
7836 printf ("vsp = vsp + %ld", offset);
7837 }
0b6ae522 7838 }
61865e30 7839 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 7840 {
61865e30
NC		 7841 unsigned int first, last;
7842
7843 GET_OP (op2);
7844 first = op2 >> 4;
7845 last = op2 & 0x0f;
7846 if (op == 0xc8)
7847 first = first + 16;
7848 printf ("pop {D%d", first);
7849 if (last)
7850 printf ("-D%d", first + last);
7851 printf ("}");
7852 }
7853 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7854 {
7855 unsigned int count = op & 0x07;
7856
7857 printf ("pop {D8");
7858 if (count)
7859 printf ("-D%d", 8 + count);
7860 printf ("}");
7861 }
7862 else if (op >= 0xc0 && op <= 0xc5)
7863 {
7864 unsigned int count = op & 0x07;
7865
7866 printf (" pop {wR10");
7867 if (count)
7868 printf ("-wR%d", 10 + count);
7869 printf ("}");
7870 }
7871 else if (op == 0xc6)
7872 {
7873 unsigned int first, last;
7874
7875 GET_OP (op2);
7876 first = op2 >> 4;
7877 last = op2 & 0x0f;
7878 printf ("pop {wR%d", first);
7879 if (last)
7880 printf ("-wR%d", first + last);
7881 printf ("}");
7882 }
7883 else if (op == 0xc7)
7884 {
7885 GET_OP (op2);
7886 if (op2 == 0 || (op2 & 0xf0) != 0)
7887 printf (_("[Spare]"));
0b6ae522
DJ		 7888 else
7889 {
61865e30
NC		 7890 unsigned int mask = op2 & 0x0f;
7891 int first = 1;
7892 int i;
7893
7894 printf ("pop {");
7895 for (i = 0; i < 4; i++)
7896 if (mask & (1 << i))
7897 {
7898 if (first)
7899 first = 0;
7900 else
7901 printf (", ");
7902 printf ("wCGR%d", i);
7903 }
7904 printf ("}");
0b6ae522
DJ		 7905 }
7906 }
61865e30
NC		 7907 else
7908 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 7909 printf ("\n");
7910 }
fa197c1c
PB		 7911}
7912
7913static void
948f632f
DA		 7914decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
7915 unsigned int word,
7916 unsigned int remaining,
7917 unsigned int more_words,
7918 bfd_vma data_offset,
7919 Elf_Internal_Shdr * data_sec,
7920 struct arm_section * data_arm_sec)
fa197c1c
PB		 7921{
7922 struct absaddr addr;
7923
7924 /* Decode the unwinding instructions. */
7925 while (1)
7926 {
7927 unsigned int op, op2;
7928
7929 ADVANCE;
7930 if (remaining == 0)
7931 break;
7932 remaining--;
7933 op = word >> 24;
7934 word <<= 8;
7935
9cf03b7e 7936 printf (" 0x%02x ", op);
fa197c1c
PB		 7937
7938 if ((op & 0xc0) == 0x00)
7939 {
7940 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 7941 printf (" sp = sp + %d", offset);
fa197c1c
PB		 7942 }
7943 else if ((op & 0xc0) == 0x80)
7944 {
7945 GET_OP (op2);
7946 if (op == 0x80 && op2 == 0)
7947 printf (_("Refuse to unwind"));
7948 else
7949 {
7950 unsigned int mask = ((op & 0x1f) << 8) | op2;
7951 if (op & 0x20)
7952 printf ("pop compact {");
7953 else
7954 printf ("pop {");
7955
7956 decode_tic6x_unwind_regmask (mask);
7957 printf("}");
7958 }
7959 }
7960 else if ((op & 0xf0) == 0xc0)
7961 {
7962 unsigned int reg;
7963 unsigned int nregs;
7964 unsigned int i;
7965 const char *name;
a734115a
NC		 7966 struct
7967 {
fa197c1c
PB		 7968 unsigned int offset;
7969 unsigned int reg;
7970 } regpos[16];
7971
7972 /* Scan entire instruction first so that GET_OP output is not
7973 interleaved with disassembly. */
7974 nregs = 0;
7975 for (i = 0; nregs < (op & 0xf); i++)
7976 {
7977 GET_OP (op2);
7978 reg = op2 >> 4;
7979 if (reg != 0xf)
7980 {
7981 regpos[nregs].offset = i * 2;
7982 regpos[nregs].reg = reg;
7983 nregs++;
7984 }
7985
7986 reg = op2 & 0xf;
7987 if (reg != 0xf)
7988 {
7989 regpos[nregs].offset = i * 2 + 1;
7990 regpos[nregs].reg = reg;
7991 nregs++;
7992 }
7993 }
7994
7995 printf (_("pop frame {"));
7996 reg = nregs - 1;
7997 for (i = i * 2; i > 0; i--)
7998 {
7999 if (regpos[reg].offset == i - 1)
8000 {
8001 name = tic6x_unwind_regnames[regpos[reg].reg];
8002 if (reg > 0)
8003 reg--;
8004 }
8005 else
8006 name = _("[pad]");
8007
8008 fputs (name, stdout);
8009 if (i > 1)
8010 printf (", ");
8011 }
8012
8013 printf ("}");
8014 }
8015 else if (op == 0xd0)
8016 printf (" MOV FP, SP");
8017 else if (op == 0xd1)
8018 printf (" __c6xabi_pop_rts");
8019 else if (op == 0xd2)
8020 {
8021 unsigned char buf[9];
8022 unsigned int i, len;
8023 unsigned long offset;
a734115a 8024
fa197c1c
PB		 8025 for (i = 0; i < sizeof (buf); i++)
8026 {
8027 GET_OP (buf[i]);
8028 if ((buf[i] & 0x80) == 0)
8029 break;
8030 }
0eff7165
NC		 8031 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8032 if (i == sizeof (buf))
8033 {
8034 printf ("<corrupt sp adjust>\n");
8035 warn (_("Corrupt stack pointer adjustment detected\n"));
8036 return;
8037 }
948f632f 8038
f6f0e17b 8039 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 8040 assert (len == i + 1);
8041 offset = offset * 8 + 0x408;
8042 printf (_("sp = sp + %ld"), offset);
8043 }
8044 else if ((op & 0xf0) == 0xe0)
8045 {
8046 if ((op & 0x0f) == 7)
8047 printf (" RETURN");
8048 else
8049 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8050 }
8051 else
8052 {
8053 printf (_(" [unsupported opcode]"));
8054 }
8055 putchar ('\n');
8056 }
8057}
8058
8059static bfd_vma
a734115a 8060arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 8061{
8062 bfd_vma offset;
8063
8064 offset = word & 0x7fffffff;
8065 if (offset & 0x40000000)
8066 offset |= ~ (bfd_vma) 0x7fffffff;
8067
8068 if (elf_header.e_machine == EM_TI_C6000)
8069 offset <<= 1;
8070
8071 return offset + where;
8072}
8073
8074static void
1b31d05e
NC		 8075decode_arm_unwind (struct arm_unw_aux_info * aux,
8076 unsigned int word,
8077 unsigned int remaining,
8078 bfd_vma data_offset,
8079 Elf_Internal_Shdr * data_sec,
8080 struct arm_section * data_arm_sec)
fa197c1c
PB		 8081{
8082 int per_index;
8083 unsigned int more_words = 0;
37e14bc3 8084 struct absaddr addr;
1b31d05e 8085 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 8086
8087 if (remaining == 0)
8088 {
1b31d05e
NC		 8089 /* Fetch the first word.
8090 Note - when decoding an object file the address extracted
8091 here will always be 0. So we also pass in the sym_name
8092 parameter so that we can find the symbol associated with
8093 the personality routine. */
8094 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8095 & word, & addr, & sym_name))
fa197c1c 8096 return;
1b31d05e 8097
fa197c1c
PB		 8098 remaining = 4;
8099 }
8100
8101 if ((word & 0x80000000) == 0)
8102 {
8103 /* Expand prel31 for personality routine. */
8104 bfd_vma fn;
8105 const char *procname;
8106
a734115a 8107 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 8108 printf (_(" Personality routine: "));
1b31d05e
NC		 8109 if (fn == 0
8110 && addr.section == SHN_UNDEF && addr.offset == 0
8111 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8112 {
8113 procname = aux->strtab + sym_name;
8114 print_vma (fn, PREFIX_HEX);
8115 if (procname)
8116 {
8117 fputs (" <", stdout);
8118 fputs (procname, stdout);
8119 fputc ('>', stdout);
8120 }
8121 }
8122 else
8123 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 8124 fputc ('\n', stdout);
8125
8126 /* The GCC personality routines use the standard compact
8127 encoding, starting with one byte giving the number of
8128 words. */
8129 if (procname != NULL
8130 && (const_strneq (procname, "__gcc_personality_v0")
8131 || const_strneq (procname, "__gxx_personality_v0")
8132 || const_strneq (procname, "__gcj_personality_v0")
8133 || const_strneq (procname, "__gnu_objc_personality_v0")))
8134 {
8135 remaining = 0;
8136 more_words = 1;
8137 ADVANCE;
8138 if (!remaining)
8139 {
8140 printf (_(" [Truncated data]\n"));
8141 return;
8142 }
8143 more_words = word >> 24;
8144 word <<= 8;
8145 remaining--;
8146 per_index = -1;
8147 }
8148 else
8149 return;
8150 }
8151 else
8152 {
1b31d05e 8153 /* ARM EHABI Section 6.3:
0b4362b0 8154
1b31d05e 8155 An exception-handling table entry for the compact model looks like:
0b4362b0 8156
1b31d05e
NC		 8157 31 30-28 27-24 23-0
8158 -- ----- ----- ----
8159 1 0 index Data for personalityRoutine[index] */
8160
8161 if (elf_header.e_machine == EM_ARM
8162 && (word & 0x70000000))
83c257ca 8163 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 8164
fa197c1c 8165 per_index = (word >> 24) & 0x7f;
1b31d05e 8166 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 8167 if (per_index == 0)
8168 {
8169 more_words = 0;
8170 word <<= 8;
8171 remaining--;
8172 }
8173 else if (per_index < 3)
8174 {
8175 more_words = (word >> 16) & 0xff;
8176 word <<= 16;
8177 remaining -= 2;
8178 }
8179 }
8180
8181 switch (elf_header.e_machine)
8182 {
8183 case EM_ARM:
8184 if (per_index < 3)
8185 {
8186 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8187 data_offset, data_sec, data_arm_sec);
8188 }
8189 else
1b31d05e
NC		 8190 {
8191 warn (_("Unknown ARM compact model index encountered\n"));
8192 printf (_(" [reserved]\n"));
8193 }
fa197c1c
PB		 8194 break;
8195
8196 case EM_TI_C6000:
8197 if (per_index < 3)
8198 {
8199 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 8200 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 8201 }
8202 else if (per_index < 5)
8203 {
8204 if (((word >> 17) & 0x7f) == 0x7f)
8205 printf (_(" Restore stack from frame pointer\n"));
8206 else
8207 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8208 printf (_(" Registers restored: "));
8209 if (per_index == 4)
8210 printf (" (compact) ");
8211 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8212 putchar ('\n');
8213 printf (_(" Return register: %s\n"),
8214 tic6x_unwind_regnames[word & 0xf]);
8215 }
8216 else
1b31d05e 8217 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 8218 break;
8219
8220 default:
74e1a04b 8221 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
1b31d05e 8222 elf_header.e_machine);
fa197c1c 8223 }
0b6ae522
DJ		 8224
8225 /* Decode the descriptors. Not implemented. */
8226}
8227
8228static void
8229dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8230{
8231 struct arm_section exidx_arm_sec, extab_arm_sec;
8232 unsigned int i, exidx_len;
948f632f 8233 unsigned long j, nfuns;
0b6ae522
DJ		 8234
8235 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8236 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8237 exidx_len = exidx_sec->sh_size / 8;
8238
948f632f
DA		 8239 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8240 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8241 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8242 aux->funtab[nfuns++] = aux->symtab[j];
8243 aux->nfuns = nfuns;
8244 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8245
0b6ae522
DJ		 8246 for (i = 0; i < exidx_len; i++)
8247 {
8248 unsigned int exidx_fn, exidx_entry;
8249 struct absaddr fn_addr, entry_addr;
8250 bfd_vma fn;
8251
8252 fputc ('\n', stdout);
8253
1b31d05e
NC		 8254 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8255 8 * i, & exidx_fn, & fn_addr, NULL)
8256 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8257 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 8258 {
948f632f 8259 free (aux->funtab);
1b31d05e
NC		 8260 arm_free_section (& exidx_arm_sec);
8261 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 8262 return;
8263 }
8264
83c257ca
NC		 8265 /* ARM EHABI, Section 5:
8266 An index table entry consists of 2 words.
8267 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8268 if (exidx_fn & 0x80000000)
8269 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8270
a734115a 8271 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 8272
a734115a 8273 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 8274 fputs (": ", stdout);
8275
8276 if (exidx_entry == 1)
8277 {
8278 print_vma (exidx_entry, PREFIX_HEX);
8279 fputs (" [cantunwind]\n", stdout);
8280 }
8281 else if (exidx_entry & 0x80000000)
8282 {
8283 print_vma (exidx_entry, PREFIX_HEX);
8284 fputc ('\n', stdout);
8285 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8286 }
8287 else
8288 {
8f73510c 8289 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 8290 Elf_Internal_Shdr *table_sec;
8291
8292 fputs ("@", stdout);
a734115a 8293 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 8294 print_vma (table, PREFIX_HEX);
8295 printf ("\n");
8296
8297 /* Locate the matching .ARM.extab. */
8298 if (entry_addr.section != SHN_UNDEF
8299 && entry_addr.section < elf_header.e_shnum)
8300 {
8301 table_sec = section_headers + entry_addr.section;
8302 table_offset = entry_addr.offset;
8303 }
8304 else
8305 {
8306 table_sec = find_section_by_address (table);
8307 if (table_sec != NULL)
8308 table_offset = table - table_sec->sh_addr;
8309 }
8310 if (table_sec == NULL)
8311 {
8312 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8313 (unsigned long) table);
8314 continue;
8315 }
8316 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8317 &extab_arm_sec);
8318 }
8319 }
8320
8321 printf ("\n");
8322
948f632f 8323 free (aux->funtab);
0b6ae522
DJ		 8324 arm_free_section (&exidx_arm_sec);
8325 arm_free_section (&extab_arm_sec);
8326}
8327
fa197c1c 8328/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 8329
8330static void
0b6ae522
DJ		 8331arm_process_unwind (FILE *file)
8332{
8333 struct arm_unw_aux_info aux;
8334 Elf_Internal_Shdr *unwsec = NULL;
8335 Elf_Internal_Shdr *strsec;
8336 Elf_Internal_Shdr *sec;
8337 unsigned long i;
fa197c1c 8338 unsigned int sec_type;
0b6ae522 8339
fa197c1c
PB		 8340 switch (elf_header.e_machine)
8341 {
8342 case EM_ARM:
8343 sec_type = SHT_ARM_EXIDX;
8344 break;
8345
8346 case EM_TI_C6000:
8347 sec_type = SHT_C6000_UNWIND;
8348 break;
8349
0b4362b0 8350 default:
74e1a04b 8351 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
1b31d05e
NC		 8352 elf_header.e_machine);
8353 return;
fa197c1c
PB		 8354 }
8355
0b6ae522 8356 if (string_table == NULL)
1b31d05e
NC		 8357 return;
8358
8359 memset (& aux, 0, sizeof (aux));
8360 aux.file = file;
0b6ae522
DJ		 8361
8362 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8363 {
8364 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8365 {
ba5cdace 8366 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 8367
8368 strsec = section_headers + sec->sh_link;
74e1a04b
NC		 8369
8370 /* PR binutils/17531 file: 011-12666-0.004. */
8371 if (aux.strtab != NULL)
8372 {
4082ef84 8373 error (_("Multiple string tables found in file.\n"));
74e1a04b
NC		 8374 free (aux.strtab);
8375 }
0b6ae522
DJ		 8376 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8377 1, strsec->sh_size, _("string table"));
8378 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8379 }
fa197c1c 8380 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 8381 unwsec = sec;
8382 }
8383
1b31d05e 8384 if (unwsec == NULL)
0b6ae522 8385 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 8386 else
8387 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8388 {
8389 if (sec->sh_type == sec_type)
8390 {
8391 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
74e1a04b 8392 printable_section_name (sec),
1b31d05e
NC		 8393 (unsigned long) sec->sh_offset,
8394 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 8395
1b31d05e
NC		 8396 dump_arm_unwind (&aux, sec);
8397 }
8398 }
0b6ae522
DJ		 8399
8400 if (aux.symtab)
8401 free (aux.symtab);
8402 if (aux.strtab)
8403 free ((char *) aux.strtab);
0b6ae522
DJ		 8404}
8405
1b31d05e 8406static void
2cf0635d 8407process_unwind (FILE * file)
57346661 8408{
2cf0635d
NC		 8409 struct unwind_handler
8410 {
57346661 8411 int machtype;
1b31d05e 8412 void (* handler)(FILE *);
2cf0635d
NC		 8413 } handlers[] =
8414 {
0b6ae522 8415 { EM_ARM, arm_process_unwind },
57346661
AM		 8416 { EM_IA_64, ia64_process_unwind },
8417 { EM_PARISC, hppa_process_unwind },
fa197c1c 8418 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 8419 { 0, 0 }
8420 };
8421 int i;
8422
8423 if (!do_unwind)
1b31d05e 8424 return;
57346661
AM		 8425
8426 for (i = 0; handlers[i].handler != NULL; i++)
8427 if (elf_header.e_machine == handlers[i].machtype)
9f758fdc
NC		 8428 {
8429 handlers[i].handler (file);
8430 return;
8431 }
57346661 8432
1b31d05e
NC		 8433 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8434 get_machine_name (elf_header.e_machine));
57346661
AM		 8435}
8436
252b5132 8437static void
2cf0635d 8438dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 8439{
8440 switch (entry->d_tag)
8441 {
8442 case DT_MIPS_FLAGS:
8443 if (entry->d_un.d_val == 0)
4b68bca3 8444 printf (_("NONE"));
252b5132
RH		 8445 else
8446 {
8447 static const char * opts[] =
8448 {
8449 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8450 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8451 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8452 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8453 "RLD_ORDER_SAFE"
8454 };
8455 unsigned int cnt;
8456 int first = 1;
2b692964 8457
60bca95a 8458 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 8459 if (entry->d_un.d_val & (1 << cnt))
8460 {
8461 printf ("%s%s", first ? "" : " ", opts[cnt]);
8462 first = 0;
8463 }
252b5132
RH		 8464 }
8465 break;
103f02d3 8466
252b5132 8467 case DT_MIPS_IVERSION:
d79b3d50 8468 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 8469 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8470 else
76ca31c0
NC		 8471 {
8472 char buf[40];
8473 sprintf_vma (buf, entry->d_un.d_ptr);
8474 /* Note: coded this way so that there is a single string for translation. */
8475 printf (_("<corrupt: %s>"), buf);
8476 }
252b5132 8477 break;
103f02d3 8478
252b5132
RH		 8479 case DT_MIPS_TIME_STAMP:
8480 {
8481 char timebuf[20];
2cf0635d 8482 struct tm * tmp;
91d6fa6a 8483 time_t atime = entry->d_un.d_val;
82b1b41b 8484
91d6fa6a 8485 tmp = gmtime (&atime);
82b1b41b
NC		 8486 /* PR 17531: file: 6accc532. */
8487 if (tmp == NULL)
8488 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8489 else
8490 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8491 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8492 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 8493 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 8494 }
8495 break;
103f02d3 8496
252b5132
RH		 8497 case DT_MIPS_RLD_VERSION:
8498 case DT_MIPS_LOCAL_GOTNO:
8499 case DT_MIPS_CONFLICTNO:
8500 case DT_MIPS_LIBLISTNO:
8501 case DT_MIPS_SYMTABNO:
8502 case DT_MIPS_UNREFEXTNO:
8503 case DT_MIPS_HIPAGENO:
8504 case DT_MIPS_DELTA_CLASS_NO:
8505 case DT_MIPS_DELTA_INSTANCE_NO:
8506 case DT_MIPS_DELTA_RELOC_NO:
8507 case DT_MIPS_DELTA_SYM_NO:
8508 case DT_MIPS_DELTA_CLASSSYM_NO:
8509 case DT_MIPS_COMPACT_SIZE:
4b68bca3 8510 print_vma (entry->d_un.d_ptr, DEC);
252b5132 8511 break;
103f02d3
UD		 8512
8513 default:
4b68bca3 8514 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 8515 }
4b68bca3 8516 putchar ('\n');
103f02d3
UD		 8517}
8518
103f02d3 8519static void
2cf0635d 8520dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 8521{
8522 switch (entry->d_tag)
8523 {
8524 case DT_HP_DLD_FLAGS:
8525 {
8526 static struct
8527 {
8528 long int bit;
2cf0635d 8529 const char * str;
5e220199
NC		 8530 }
8531 flags[] =
8532 {
8533 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8534 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8535 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8536 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8537 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8538 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8539 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8540 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8541 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8542 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 8543 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8544 { DT_HP_GST, "HP_GST" },
8545 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8546 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8547 { DT_HP_NODELETE, "HP_NODELETE" },
8548 { DT_HP_GROUP, "HP_GROUP" },
8549 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 8550 };
103f02d3 8551 int first = 1;
5e220199 8552 size_t cnt;
f7a99963 8553 bfd_vma val = entry->d_un.d_val;
103f02d3 8554
60bca95a 8555 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 8556 if (val & flags[cnt].bit)
30800947
NC		 8557 {
8558 if (! first)
8559 putchar (' ');
8560 fputs (flags[cnt].str, stdout);
8561 first = 0;
8562 val ^= flags[cnt].bit;
8563 }
76da6bbe 8564
103f02d3 8565 if (val != 0 || first)
f7a99963
NC		 8566 {
8567 if (! first)
8568 putchar (' ');
8569 print_vma (val, HEX);
8570 }
103f02d3
UD		 8571 }
8572 break;
76da6bbe 8573
252b5132 8574 default:
f7a99963
NC		 8575 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8576 break;
252b5132 8577 }
35b1837e 8578 putchar ('\n');
252b5132
RH		 8579}
8580
28f997cf
TG		 8581#ifdef BFD64
8582
8583/* VMS vs Unix time offset and factor. */
8584
8585#define VMS_EPOCH_OFFSET 35067168000000000LL
8586#define VMS_GRANULARITY_FACTOR 10000000
8587
8588/* Display a VMS time in a human readable format. */
8589
8590static void
8591print_vms_time (bfd_int64_t vmstime)
8592{
8593 struct tm *tm;
8594 time_t unxtime;
8595
8596 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8597 tm = gmtime (&unxtime);
8598 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8599 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8600 tm->tm_hour, tm->tm_min, tm->tm_sec);
8601}
8602#endif /* BFD64 */
8603
ecc51f48 8604static void
2cf0635d 8605dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 8606{
8607 switch (entry->d_tag)
8608 {
0de14b54 8609 case DT_IA_64_PLT_RESERVE:
bdf4d63a 8610 /* First 3 slots reserved. */
ecc51f48
NC		 8611 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8612 printf (" -- ");
8613 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 8614 break;
8615
28f997cf
TG		 8616 case DT_IA_64_VMS_LINKTIME:
8617#ifdef BFD64
8618 print_vms_time (entry->d_un.d_val);
8619#endif
8620 break;
8621
8622 case DT_IA_64_VMS_LNKFLAGS:
8623 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8624 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8625 printf (" CALL_DEBUG");
8626 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8627 printf (" NOP0BUFS");
8628 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8629 printf (" P0IMAGE");
8630 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8631 printf (" MKTHREADS");
8632 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8633 printf (" UPCALLS");
8634 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8635 printf (" IMGSTA");
8636 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8637 printf (" INITIALIZE");
8638 if (entry->d_un.d_val & VMS_LF_MAIN)
8639 printf (" MAIN");
8640 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8641 printf (" EXE_INIT");
8642 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8643 printf (" TBK_IN_IMG");
8644 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8645 printf (" DBG_IN_IMG");
8646 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8647 printf (" TBK_IN_DSF");
8648 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8649 printf (" DBG_IN_DSF");
8650 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8651 printf (" SIGNATURES");
8652 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8653 printf (" REL_SEG_OFF");
8654 break;
8655
bdf4d63a
JJ		 8656 default:
8657 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8658 break;
ecc51f48 8659 }
bdf4d63a 8660 putchar ('\n');
ecc51f48
NC		 8661}
8662
252b5132 8663static int
2cf0635d 8664get_32bit_dynamic_section (FILE * file)
252b5132 8665{
2cf0635d
NC		 8666 Elf32_External_Dyn * edyn;
8667 Elf32_External_Dyn * ext;
8668 Elf_Internal_Dyn * entry;
103f02d3 8669
3f5e193b
NC		 8670 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8671 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8672 if (!edyn)
8673 return 0;
103f02d3 8674
071436c6
NC		 8675 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8676 might not have the luxury of section headers. Look for the DT_NULL
8677 terminator to determine the number of entries. */
ba2685cc 8678 for (ext = edyn, dynamic_nent = 0;
071436c6 8679 (char *) ext < (char *) edyn + dynamic_size - sizeof (* entry);
ba2685cc
AM		 8680 ext++)
8681 {
8682 dynamic_nent++;
8683 if (BYTE_GET (ext->d_tag) == DT_NULL)
8684 break;
8685 }
252b5132 8686
3f5e193b
NC		 8687 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8688 sizeof (* entry));
b2d38a17 8689 if (dynamic_section == NULL)
252b5132 8690 {
8b73c356
NC		 8691 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8692 (unsigned long) dynamic_nent);
9ea033b2
NC		 8693 free (edyn);
8694 return 0;
8695 }
252b5132 8696
fb514b26 8697 for (ext = edyn, entry = dynamic_section;
ba2685cc 8698 entry < dynamic_section + dynamic_nent;
fb514b26 8699 ext++, entry++)
9ea033b2 8700 {
fb514b26
AM		 8701 entry->d_tag = BYTE_GET (ext->d_tag);
8702 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8703 }
8704
9ea033b2
NC		 8705 free (edyn);
8706
8707 return 1;
8708}
8709
8710static int
2cf0635d 8711get_64bit_dynamic_section (FILE * file)
9ea033b2 8712{
2cf0635d
NC		 8713 Elf64_External_Dyn * edyn;
8714 Elf64_External_Dyn * ext;
8715 Elf_Internal_Dyn * entry;
103f02d3 8716
071436c6 8717 /* Read in the data. */
3f5e193b
NC		 8718 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8719 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8720 if (!edyn)
8721 return 0;
103f02d3 8722
071436c6
NC		 8723 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8724 might not have the luxury of section headers. Look for the DT_NULL
8725 terminator to determine the number of entries. */
ba2685cc 8726 for (ext = edyn, dynamic_nent = 0;
071436c6
NC		 8727 /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer. */
8728 (char *) ext < ((char *) edyn) + dynamic_size - sizeof (* ext);
ba2685cc
AM		 8729 ext++)
8730 {
8731 dynamic_nent++;
66543521 8732 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 8733 break;
8734 }
252b5132 8735
3f5e193b
NC		 8736 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8737 sizeof (* entry));
b2d38a17 8738 if (dynamic_section == NULL)
252b5132 8739 {
8b73c356
NC		 8740 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8741 (unsigned long) dynamic_nent);
252b5132
RH		 8742 free (edyn);
8743 return 0;
8744 }
8745
071436c6 8746 /* Convert from external to internal formats. */
fb514b26 8747 for (ext = edyn, entry = dynamic_section;
ba2685cc 8748 entry < dynamic_section + dynamic_nent;
fb514b26 8749 ext++, entry++)
252b5132 8750 {
66543521
AM		 8751 entry->d_tag = BYTE_GET (ext->d_tag);
8752 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8753 }
8754
8755 free (edyn);
8756
9ea033b2
NC		 8757 return 1;
8758}
8759
e9e44622
JJ		 8760static void
8761print_dynamic_flags (bfd_vma flags)
d1133906 8762{
e9e44622 8763 int first = 1;
13ae64f3 8764
d1133906
NC		 8765 while (flags)
8766 {
8767 bfd_vma flag;
8768
8769 flag = flags & - flags;
8770 flags &= ~ flag;
8771
e9e44622
JJ		 8772 if (first)
8773 first = 0;
8774 else
8775 putc (' ', stdout);
13ae64f3 8776
d1133906
NC		 8777 switch (flag)
8778 {
e9e44622
JJ		 8779 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
8780 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
8781 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
8782 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
8783 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 8784 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 8785 }
8786 }
e9e44622 8787 puts ("");
d1133906
NC		 8788}
8789
b2d38a17
NC		 8790/* Parse and display the contents of the dynamic section. */
8791
9ea033b2 8792static int
2cf0635d 8793process_dynamic_section (FILE * file)
9ea033b2 8794{
2cf0635d 8795 Elf_Internal_Dyn * entry;
9ea033b2
NC		 8796
8797 if (dynamic_size == 0)
8798 {
8799 if (do_dynamic)
b2d38a17 8800 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 8801
8802 return 1;
8803 }
8804
8805 if (is_32bit_elf)
8806 {
b2d38a17 8807 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 8808 return 0;
8809 }
b2d38a17 8810 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 8811 return 0;
8812
252b5132
RH		 8813 /* Find the appropriate symbol table. */
8814 if (dynamic_symbols == NULL)
8815 {
86dba8ee
AM		 8816 for (entry = dynamic_section;
8817 entry < dynamic_section + dynamic_nent;
8818 ++entry)
252b5132 8819 {
c8286bd1 8820 Elf_Internal_Shdr section;
252b5132
RH		 8821
8822 if (entry->d_tag != DT_SYMTAB)
8823 continue;
8824
8825 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8826
8827 /* Since we do not know how big the symbol table is,
8828 we default to reading in the entire file (!) and
8829 processing that. This is overkill, I know, but it
e3c8793a 8830 should work. */
d93f0186 8831 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 8832
fb52b2f4
NC		 8833 if (archive_file_offset != 0)
8834 section.sh_size = archive_file_size - section.sh_offset;
8835 else
8836 {
8837 if (fseek (file, 0, SEEK_END))
591a748a 8838 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 8839
8840 section.sh_size = ftell (file) - section.sh_offset;
8841 }
252b5132 8842
9ea033b2 8843 if (is_32bit_elf)
9ad5cbcf 8844 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 8845 else
9ad5cbcf 8846 section.sh_entsize = sizeof (Elf64_External_Sym);
071436c6 8847 section.sh_name = string_table_length;
252b5132 8848
ba5cdace 8849 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 8850 if (num_dynamic_syms < 1)
252b5132
RH		 8851 {
8852 error (_("Unable to determine the number of symbols to load\n"));
8853 continue;
8854 }
252b5132
RH		 8855 }
8856 }
8857
8858 /* Similarly find a string table. */
8859 if (dynamic_strings == NULL)
8860 {
86dba8ee
AM		 8861 for (entry = dynamic_section;
8862 entry < dynamic_section + dynamic_nent;
8863 ++entry)
252b5132
RH		 8864 {
8865 unsigned long offset;
b34976b6 8866 long str_tab_len;
252b5132
RH		 8867
8868 if (entry->d_tag != DT_STRTAB)
8869 continue;
8870
8871 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8872
8873 /* Since we do not know how big the string table is,
8874 we default to reading in the entire file (!) and
8875 processing that. This is overkill, I know, but it
e3c8793a 8876 should work. */
252b5132 8877
d93f0186 8878 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 8879
8880 if (archive_file_offset != 0)
8881 str_tab_len = archive_file_size - offset;
8882 else
8883 {
8884 if (fseek (file, 0, SEEK_END))
8885 error (_("Unable to seek to end of file\n"));
8886 str_tab_len = ftell (file) - offset;
8887 }
252b5132
RH		 8888
8889 if (str_tab_len < 1)
8890 {
8891 error
8892 (_("Unable to determine the length of the dynamic string table\n"));
8893 continue;
8894 }
8895
3f5e193b
NC		 8896 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8897 str_tab_len,
8898 _("dynamic string table"));
59245841 8899 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 8900 break;
8901 }
8902 }
8903
8904 /* And find the syminfo section if available. */
8905 if (dynamic_syminfo == NULL)
8906 {
3e8bba36 8907 unsigned long syminsz = 0;
252b5132 8908
86dba8ee
AM		 8909 for (entry = dynamic_section;
8910 entry < dynamic_section + dynamic_nent;
8911 ++entry)
252b5132
RH		 8912 {
8913 if (entry->d_tag == DT_SYMINENT)
8914 {
8915 /* Note: these braces are necessary to avoid a syntax
8916 error from the SunOS4 C compiler. */
049b0c3a
NC		 8917 /* PR binutils/17531: A corrupt file can trigger this test.
8918 So do not use an assert, instead generate an error message. */
8919 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
071436c6 8920 error (_("Bad value (%d) for SYMINENT entry\n"),
049b0c3a 8921 (int) entry->d_un.d_val);
252b5132
RH		 8922 }
8923 else if (entry->d_tag == DT_SYMINSZ)
8924 syminsz = entry->d_un.d_val;
8925 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 8926 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8927 syminsz);
252b5132
RH		 8928 }
8929
8930 if (dynamic_syminfo_offset != 0 && syminsz != 0)
8931 {
2cf0635d
NC		 8932 Elf_External_Syminfo * extsyminfo;
8933 Elf_External_Syminfo * extsym;
8934 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 8935
8936 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 8937 extsyminfo = (Elf_External_Syminfo *)
8938 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8939 _("symbol information"));
a6e9f9df
AM		 8940 if (!extsyminfo)
8941 return 0;
252b5132 8942
3f5e193b 8943 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 8944 if (dynamic_syminfo == NULL)
8945 {
8b73c356
NC		 8946 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8947 (unsigned long) syminsz);
252b5132
RH		 8948 return 0;
8949 }
8950
8951 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 8952 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8953 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8954 ++syminfo, ++extsym)
252b5132 8955 {
86dba8ee
AM		 8956 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8957 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 8958 }
8959
8960 free (extsyminfo);
8961 }
8962 }
8963
8964 if (do_dynamic && dynamic_addr)
8b73c356
NC		 8965 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8966 dynamic_addr, (unsigned long) dynamic_nent);
252b5132
RH		 8967 if (do_dynamic)
8968 printf (_(" Tag Type Name/Value\n"));
8969
86dba8ee
AM		 8970 for (entry = dynamic_section;
8971 entry < dynamic_section + dynamic_nent;
8972 entry++)
252b5132
RH		 8973 {
8974 if (do_dynamic)
f7a99963 8975 {
2cf0635d 8976 const char * dtype;
e699b9ff 8977
f7a99963
NC		 8978 putchar (' ');
8979 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 8980 dtype = get_dynamic_type (entry->d_tag);
8981 printf (" (%s)%*s", dtype,
8982 ((is_32bit_elf ? 27 : 19)
8983 - (int) strlen (dtype)),
f7a99963
NC		 8984 " ");
8985 }
252b5132
RH		 8986
8987 switch (entry->d_tag)
8988 {
d1133906
NC		 8989 case DT_FLAGS:
8990 if (do_dynamic)
e9e44622 8991 print_dynamic_flags (entry->d_un.d_val);
d1133906 8992 break;
76da6bbe 8993
252b5132
RH		 8994 case DT_AUXILIARY:
8995 case DT_FILTER:
019148e4
L		 8996 case DT_CONFIG:
8997 case DT_DEPAUDIT:
8998 case DT_AUDIT:
252b5132
RH		 8999 if (do_dynamic)
9000 {
019148e4 9001 switch (entry->d_tag)
b34976b6 9002 {
019148e4
L		 9003 case DT_AUXILIARY:
9004 printf (_("Auxiliary library"));
9005 break;
9006
9007 case DT_FILTER:
9008 printf (_("Filter library"));
9009 break;
9010
b34976b6 9011 case DT_CONFIG:
019148e4
L		 9012 printf (_("Configuration file"));
9013 break;
9014
9015 case DT_DEPAUDIT:
9016 printf (_("Dependency audit library"));
9017 break;
9018
9019 case DT_AUDIT:
9020 printf (_("Audit library"));
9021 break;
9022 }
252b5132 9023
d79b3d50
NC		 9024 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9025 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 9026 else
f7a99963
NC		 9027 {
9028 printf (": ");
9029 print_vma (entry->d_un.d_val, PREFIX_HEX);
9030 putchar ('\n');
9031 }
252b5132
RH		 9032 }
9033 break;
9034
dcefbbbd 9035 case DT_FEATURE:
252b5132
RH		 9036 if (do_dynamic)
9037 {
9038 printf (_("Flags:"));
86f55779 9039
252b5132
RH		 9040 if (entry->d_un.d_val == 0)
9041 printf (_(" None\n"));
9042 else
9043 {
9044 unsigned long int val = entry->d_un.d_val;
86f55779 9045
252b5132
RH		 9046 if (val & DTF_1_PARINIT)
9047 {
9048 printf (" PARINIT");
9049 val ^= DTF_1_PARINIT;
9050 }
dcefbbbd
L		 9051 if (val & DTF_1_CONFEXP)
9052 {
9053 printf (" CONFEXP");
9054 val ^= DTF_1_CONFEXP;
9055 }
252b5132
RH		 9056 if (val != 0)
9057 printf (" %lx", val);
9058 puts ("");
9059 }
9060 }
9061 break;
9062
9063 case DT_POSFLAG_1:
9064 if (do_dynamic)
9065 {
9066 printf (_("Flags:"));
86f55779 9067
252b5132
RH		 9068 if (entry->d_un.d_val == 0)
9069 printf (_(" None\n"));
9070 else
9071 {
9072 unsigned long int val = entry->d_un.d_val;
86f55779 9073
252b5132
RH		 9074 if (val & DF_P1_LAZYLOAD)
9075 {
9076 printf (" LAZYLOAD");
9077 val ^= DF_P1_LAZYLOAD;
9078 }
9079 if (val & DF_P1_GROUPPERM)
9080 {
9081 printf (" GROUPPERM");
9082 val ^= DF_P1_GROUPPERM;
9083 }
9084 if (val != 0)
9085 printf (" %lx", val);
9086 puts ("");
9087 }
9088 }
9089 break;
9090
9091 case DT_FLAGS_1:
9092 if (do_dynamic)
9093 {
9094 printf (_("Flags:"));
9095 if (entry->d_un.d_val == 0)
9096 printf (_(" None\n"));
9097 else
9098 {
9099 unsigned long int val = entry->d_un.d_val;
86f55779 9100
252b5132
RH		 9101 if (val & DF_1_NOW)
9102 {
9103 printf (" NOW");
9104 val ^= DF_1_NOW;
9105 }
9106 if (val & DF_1_GLOBAL)
9107 {
9108 printf (" GLOBAL");
9109 val ^= DF_1_GLOBAL;
9110 }
9111 if (val & DF_1_GROUP)
9112 {
9113 printf (" GROUP");
9114 val ^= DF_1_GROUP;
9115 }
9116 if (val & DF_1_NODELETE)
9117 {
9118 printf (" NODELETE");
9119 val ^= DF_1_NODELETE;
9120 }
9121 if (val & DF_1_LOADFLTR)
9122 {
9123 printf (" LOADFLTR");
9124 val ^= DF_1_LOADFLTR;
9125 }
9126 if (val & DF_1_INITFIRST)
9127 {
9128 printf (" INITFIRST");
9129 val ^= DF_1_INITFIRST;
9130 }
9131 if (val & DF_1_NOOPEN)
9132 {
9133 printf (" NOOPEN");
9134 val ^= DF_1_NOOPEN;
9135 }
9136 if (val & DF_1_ORIGIN)
9137 {
9138 printf (" ORIGIN");
9139 val ^= DF_1_ORIGIN;
9140 }
9141 if (val & DF_1_DIRECT)
9142 {
9143 printf (" DIRECT");
9144 val ^= DF_1_DIRECT;
9145 }
9146 if (val & DF_1_TRANS)
9147 {
9148 printf (" TRANS");
9149 val ^= DF_1_TRANS;
9150 }
9151 if (val & DF_1_INTERPOSE)
9152 {
9153 printf (" INTERPOSE");
9154 val ^= DF_1_INTERPOSE;
9155 }
f7db6139 9156 if (val & DF_1_NODEFLIB)
dcefbbbd 9157 {
f7db6139
L		 9158 printf (" NODEFLIB");
9159 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 9160 }
9161 if (val & DF_1_NODUMP)
9162 {
9163 printf (" NODUMP");
9164 val ^= DF_1_NODUMP;
9165 }
34b60028 9166 if (val & DF_1_CONFALT)
dcefbbbd 9167 {
34b60028
L		 9168 printf (" CONFALT");
9169 val ^= DF_1_CONFALT;
9170 }
9171 if (val & DF_1_ENDFILTEE)
9172 {
9173 printf (" ENDFILTEE");
9174 val ^= DF_1_ENDFILTEE;
9175 }
9176 if (val & DF_1_DISPRELDNE)
9177 {
9178 printf (" DISPRELDNE");
9179 val ^= DF_1_DISPRELDNE;
9180 }
9181 if (val & DF_1_DISPRELPND)
9182 {
9183 printf (" DISPRELPND");
9184 val ^= DF_1_DISPRELPND;
9185 }
9186 if (val & DF_1_NODIRECT)
9187 {
9188 printf (" NODIRECT");
9189 val ^= DF_1_NODIRECT;
9190 }
9191 if (val & DF_1_IGNMULDEF)
9192 {
9193 printf (" IGNMULDEF");
9194 val ^= DF_1_IGNMULDEF;
9195 }
9196 if (val & DF_1_NOKSYMS)
9197 {
9198 printf (" NOKSYMS");
9199 val ^= DF_1_NOKSYMS;
9200 }
9201 if (val & DF_1_NOHDR)
9202 {
9203 printf (" NOHDR");
9204 val ^= DF_1_NOHDR;
9205 }
9206 if (val & DF_1_EDITED)
9207 {
9208 printf (" EDITED");
9209 val ^= DF_1_EDITED;
9210 }
9211 if (val & DF_1_NORELOC)
9212 {
9213 printf (" NORELOC");
9214 val ^= DF_1_NORELOC;
9215 }
9216 if (val & DF_1_SYMINTPOSE)
9217 {
9218 printf (" SYMINTPOSE");
9219 val ^= DF_1_SYMINTPOSE;
9220 }
9221 if (val & DF_1_GLOBAUDIT)
9222 {
9223 printf (" GLOBAUDIT");
9224 val ^= DF_1_GLOBAUDIT;
9225 }
9226 if (val & DF_1_SINGLETON)
9227 {
9228 printf (" SINGLETON");
9229 val ^= DF_1_SINGLETON;
dcefbbbd 9230 }
252b5132
RH		 9231 if (val != 0)
9232 printf (" %lx", val);
9233 puts ("");
9234 }
9235 }
9236 break;
9237
9238 case DT_PLTREL:
566b0d53 9239 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9240 if (do_dynamic)
9241 puts (get_dynamic_type (entry->d_un.d_val));
9242 break;
9243
9244 case DT_NULL :
9245 case DT_NEEDED :
9246 case DT_PLTGOT :
9247 case DT_HASH :
9248 case DT_STRTAB :
9249 case DT_SYMTAB :
9250 case DT_RELA :
9251 case DT_INIT :
9252 case DT_FINI :
9253 case DT_SONAME :
9254 case DT_RPATH :
9255 case DT_SYMBOLIC:
9256 case DT_REL :
9257 case DT_DEBUG :
9258 case DT_TEXTREL :
9259 case DT_JMPREL :
019148e4 9260 case DT_RUNPATH :
252b5132
RH		 9261 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9262
9263 if (do_dynamic)
9264 {
2cf0635d 9265 char * name;
252b5132 9266
d79b3d50
NC		 9267 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9268 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9269 else
d79b3d50 9270 name = NULL;
252b5132
RH		 9271
9272 if (name)
9273 {
9274 switch (entry->d_tag)
9275 {
9276 case DT_NEEDED:
9277 printf (_("Shared library: [%s]"), name);
9278
18bd398b 9279 if (streq (name, program_interpreter))
f7a99963 9280 printf (_(" program interpreter"));
252b5132
RH		 9281 break;
9282
9283 case DT_SONAME:
f7a99963 9284 printf (_("Library soname: [%s]"), name);
252b5132
RH		 9285 break;
9286
9287 case DT_RPATH:
f7a99963 9288 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 9289 break;
9290
019148e4
L		 9291 case DT_RUNPATH:
9292 printf (_("Library runpath: [%s]"), name);
9293 break;
9294
252b5132 9295 default:
f7a99963
NC		 9296 print_vma (entry->d_un.d_val, PREFIX_HEX);
9297 break;
252b5132
RH		 9298 }
9299 }
9300 else
f7a99963
NC		 9301 print_vma (entry->d_un.d_val, PREFIX_HEX);
9302
9303 putchar ('\n');
252b5132
RH		 9304 }
9305 break;
9306
9307 case DT_PLTRELSZ:
9308 case DT_RELASZ :
9309 case DT_STRSZ :
9310 case DT_RELSZ :
9311 case DT_RELAENT :
9312 case DT_SYMENT :
9313 case DT_RELENT :
566b0d53 9314 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9315 case DT_PLTPADSZ:
9316 case DT_MOVEENT :
9317 case DT_MOVESZ :
9318 case DT_INIT_ARRAYSZ:
9319 case DT_FINI_ARRAYSZ:
047b2264
JJ		 9320 case DT_GNU_CONFLICTSZ:
9321 case DT_GNU_LIBLISTSZ:
252b5132 9322 if (do_dynamic)
f7a99963
NC		 9323 {
9324 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 9325 printf (_(" (bytes)\n"));
f7a99963 9326 }
252b5132
RH		 9327 break;
9328
9329 case DT_VERDEFNUM:
9330 case DT_VERNEEDNUM:
9331 case DT_RELACOUNT:
9332 case DT_RELCOUNT:
9333 if (do_dynamic)
f7a99963
NC		 9334 {
9335 print_vma (entry->d_un.d_val, UNSIGNED);
9336 putchar ('\n');
9337 }
252b5132
RH		 9338 break;
9339
9340 case DT_SYMINSZ:
9341 case DT_SYMINENT:
9342 case DT_SYMINFO:
9343 case DT_USED:
9344 case DT_INIT_ARRAY:
9345 case DT_FINI_ARRAY:
9346 if (do_dynamic)
9347 {
d79b3d50
NC		 9348 if (entry->d_tag == DT_USED
9349 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 9350 {
2cf0635d 9351 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9352
b34976b6 9353 if (*name)
252b5132
RH		 9354 {
9355 printf (_("Not needed object: [%s]\n"), name);
9356 break;
9357 }
9358 }
103f02d3 9359
f7a99963
NC		 9360 print_vma (entry->d_un.d_val, PREFIX_HEX);
9361 putchar ('\n');
252b5132
RH		 9362 }
9363 break;
9364
9365 case DT_BIND_NOW:
9366 /* The value of this entry is ignored. */
35b1837e
AM		 9367 if (do_dynamic)
9368 putchar ('\n');
252b5132 9369 break;
103f02d3 9370
047b2264
JJ		 9371 case DT_GNU_PRELINKED:
9372 if (do_dynamic)
9373 {
2cf0635d 9374 struct tm * tmp;
91d6fa6a 9375 time_t atime = entry->d_un.d_val;
047b2264 9376
91d6fa6a 9377 tmp = gmtime (&atime);
071436c6
NC		 9378 /* PR 17533 file: 041-1244816-0.004. */
9379 if (tmp == NULL)
5a2cbcf4
L		 9380 printf (_("<corrupt time val: %lx"),
9381 (unsigned long) atime);
071436c6
NC		 9382 else
9383 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9384 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9385 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 9386
9387 }
9388 break;
9389
fdc90cb4
JJ		 9390 case DT_GNU_HASH:
9391 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9392 if (do_dynamic)
9393 {
9394 print_vma (entry->d_un.d_val, PREFIX_HEX);
9395 putchar ('\n');
9396 }
9397 break;
9398
252b5132
RH		 9399 default:
9400 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 9401 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 9402 entry->d_un.d_val;
9403
9404 if (do_dynamic)
9405 {
9406 switch (elf_header.e_machine)
9407 {
9408 case EM_MIPS:
4fe85591 9409 case EM_MIPS_RS3_LE:
b2d38a17 9410 dynamic_section_mips_val (entry);
252b5132 9411 break;
103f02d3 9412 case EM_PARISC:
b2d38a17 9413 dynamic_section_parisc_val (entry);
103f02d3 9414 break;
ecc51f48 9415 case EM_IA_64:
b2d38a17 9416 dynamic_section_ia64_val (entry);
ecc51f48 9417 break;
252b5132 9418 default:
f7a99963
NC		 9419 print_vma (entry->d_un.d_val, PREFIX_HEX);
9420 putchar ('\n');
252b5132
RH		 9421 }
9422 }
9423 break;
9424 }
9425 }
9426
9427 return 1;
9428}
9429
9430static char *
d3ba0551 9431get_ver_flags (unsigned int flags)
252b5132 9432{
b34976b6 9433 static char buff[32];
252b5132
RH		 9434
9435 buff[0] = 0;
9436
9437 if (flags == 0)
9438 return _("none");
9439
9440 if (flags & VER_FLG_BASE)
9441 strcat (buff, "BASE ");
9442
9443 if (flags & VER_FLG_WEAK)
9444 {
9445 if (flags & VER_FLG_BASE)
9446 strcat (buff, "| ");
9447
9448 strcat (buff, "WEAK ");
9449 }
9450
44ec90b9
RO		 9451 if (flags & VER_FLG_INFO)
9452 {
9453 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9454 strcat (buff, "| ");
9455
9456 strcat (buff, "INFO ");
9457 }
9458
9459 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 9460 strcat (buff, _("| <unknown>"));
252b5132
RH		 9461
9462 return buff;
9463}
9464
9465/* Display the contents of the version sections. */
98fb390a 9466
252b5132 9467static int
2cf0635d 9468process_version_sections (FILE * file)
252b5132 9469{
2cf0635d 9470 Elf_Internal_Shdr * section;
b34976b6
AM		 9471 unsigned i;
9472 int found = 0;
252b5132
RH		 9473
9474 if (! do_version)
9475 return 1;
9476
9477 for (i = 0, section = section_headers;
9478 i < elf_header.e_shnum;
b34976b6 9479 i++, section++)
252b5132
RH		 9480 {
9481 switch (section->sh_type)
9482 {
9483 case SHT_GNU_verdef:
9484 {
2cf0635d 9485 Elf_External_Verdef * edefs;
b34976b6
AM		 9486 unsigned int idx;
9487 unsigned int cnt;
2cf0635d 9488 char * endbuf;
252b5132
RH		 9489
9490 found = 1;
9491
74e1a04b
NC		 9492 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9493 printable_section_name (section),
9494 section->sh_info);
252b5132
RH		 9495
9496 printf (_(" Addr: 0x"));
9497 printf_vma (section->sh_addr);
74e1a04b 9498 printf (_(" Offset: %#08lx Link: %u (%s)"),
1b228002 9499 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9500 printable_section_name_from_index (section->sh_link));
252b5132 9501
3f5e193b
NC		 9502 edefs = (Elf_External_Verdef *)
9503 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9504 _("version definition section"));
a6e9f9df
AM		 9505 if (!edefs)
9506 break;
59245841 9507 endbuf = (char *) edefs + section->sh_size;
252b5132 9508
b34976b6 9509 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 9510 {
2cf0635d
NC		 9511 char * vstart;
9512 Elf_External_Verdef * edef;
b34976b6 9513 Elf_Internal_Verdef ent;
2cf0635d 9514 Elf_External_Verdaux * eaux;
b34976b6
AM		 9515 Elf_Internal_Verdaux aux;
9516 int j;
9517 int isum;
103f02d3 9518
7e26601c
NC		 9519 /* Check for very large indicies. */
9520 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 9521 break;
9522
252b5132 9523 vstart = ((char *) edefs) + idx;
54806181
AM		 9524 if (vstart + sizeof (*edef) > endbuf)
9525 break;
252b5132
RH		 9526
9527 edef = (Elf_External_Verdef *) vstart;
9528
9529 ent.vd_version = BYTE_GET (edef->vd_version);
9530 ent.vd_flags = BYTE_GET (edef->vd_flags);
9531 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9532 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9533 ent.vd_hash = BYTE_GET (edef->vd_hash);
9534 ent.vd_aux = BYTE_GET (edef->vd_aux);
9535 ent.vd_next = BYTE_GET (edef->vd_next);
9536
9537 printf (_(" %#06x: Rev: %d Flags: %s"),
9538 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9539
9540 printf (_(" Index: %d Cnt: %d "),
9541 ent.vd_ndx, ent.vd_cnt);
9542
dd24e3da 9543 /* Check for overflow. */
7e26601c 9544 if (ent.vd_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 9545 break;
9546
252b5132
RH		 9547 vstart += ent.vd_aux;
9548
9549 eaux = (Elf_External_Verdaux *) vstart;
9550
9551 aux.vda_name = BYTE_GET (eaux->vda_name);
9552 aux.vda_next = BYTE_GET (eaux->vda_next);
9553
d79b3d50
NC		 9554 if (VALID_DYNAMIC_NAME (aux.vda_name))
9555 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9556 else
9557 printf (_("Name index: %ld\n"), aux.vda_name);
9558
9559 isum = idx + ent.vd_aux;
9560
b34976b6 9561 for (j = 1; j < ent.vd_cnt; j++)
252b5132 9562 {
dd24e3da 9563 /* Check for overflow. */
7e26601c 9564 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 9565 break;
9566
252b5132
RH		 9567 isum += aux.vda_next;
9568 vstart += aux.vda_next;
9569
9570 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 9571 if (vstart + sizeof (*eaux) > endbuf)
9572 break;
252b5132
RH		 9573
9574 aux.vda_name = BYTE_GET (eaux->vda_name);
9575 aux.vda_next = BYTE_GET (eaux->vda_next);
9576
d79b3d50 9577 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 9578 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 9579 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9580 else
9581 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9582 isum, j, aux.vda_name);
9583 }
dd24e3da 9584
54806181
AM		 9585 if (j < ent.vd_cnt)
9586 printf (_(" Version def aux past end of section\n"));
252b5132 9587
5d921cbd
NC		 9588 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9589 if (idx + ent.vd_next <= idx)
9590 break;
9591
252b5132
RH		 9592 idx += ent.vd_next;
9593 }
dd24e3da 9594
54806181
AM		 9595 if (cnt < section->sh_info)
9596 printf (_(" Version definition past end of section\n"));
252b5132
RH		 9597
9598 free (edefs);
9599 }
9600 break;
103f02d3 9601
252b5132
RH		 9602 case SHT_GNU_verneed:
9603 {
2cf0635d 9604 Elf_External_Verneed * eneed;
b34976b6
AM		 9605 unsigned int idx;
9606 unsigned int cnt;
2cf0635d 9607 char * endbuf;
252b5132
RH		 9608
9609 found = 1;
9610
72de5009 9611 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
74e1a04b 9612 printable_section_name (section), section->sh_info);
252b5132
RH		 9613
9614 printf (_(" Addr: 0x"));
9615 printf_vma (section->sh_addr);
72de5009 9616 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9617 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9618 printable_section_name_from_index (section->sh_link));
252b5132 9619
3f5e193b
NC		 9620 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9621 section->sh_offset, 1,
9622 section->sh_size,
9cf03b7e 9623 _("Version Needs section"));
a6e9f9df
AM		 9624 if (!eneed)
9625 break;
59245841 9626 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 9627
9628 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9629 {
2cf0635d 9630 Elf_External_Verneed * entry;
b34976b6
AM		 9631 Elf_Internal_Verneed ent;
9632 int j;
9633 int isum;
2cf0635d 9634 char * vstart;
252b5132 9635
7e26601c 9636 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 9637 break;
9638
252b5132 9639 vstart = ((char *) eneed) + idx;
54806181
AM		 9640 if (vstart + sizeof (*entry) > endbuf)
9641 break;
252b5132
RH		 9642
9643 entry = (Elf_External_Verneed *) vstart;
9644
9645 ent.vn_version = BYTE_GET (entry->vn_version);
9646 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
9647 ent.vn_file = BYTE_GET (entry->vn_file);
9648 ent.vn_aux = BYTE_GET (entry->vn_aux);
9649 ent.vn_next = BYTE_GET (entry->vn_next);
9650
9651 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
9652
d79b3d50
NC		 9653 if (VALID_DYNAMIC_NAME (ent.vn_file))
9654 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 9655 else
9656 printf (_(" File: %lx"), ent.vn_file);
9657
9658 printf (_(" Cnt: %d\n"), ent.vn_cnt);
9659
dd24e3da 9660 /* Check for overflow. */
7e26601c 9661 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da 9662 break;
252b5132
RH		 9663 vstart += ent.vn_aux;
9664
9665 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9666 {
2cf0635d 9667 Elf_External_Vernaux * eaux;
b34976b6 9668 Elf_Internal_Vernaux aux;
252b5132 9669
54806181
AM		 9670 if (vstart + sizeof (*eaux) > endbuf)
9671 break;
252b5132
RH		 9672 eaux = (Elf_External_Vernaux *) vstart;
9673
9674 aux.vna_hash = BYTE_GET (eaux->vna_hash);
9675 aux.vna_flags = BYTE_GET (eaux->vna_flags);
9676 aux.vna_other = BYTE_GET (eaux->vna_other);
9677 aux.vna_name = BYTE_GET (eaux->vna_name);
9678 aux.vna_next = BYTE_GET (eaux->vna_next);
9679
d79b3d50 9680 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 9681 printf (_(" %#06x: Name: %s"),
d79b3d50 9682 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 9683 else
ecc2063b 9684 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 9685 isum, aux.vna_name);
9686
9687 printf (_(" Flags: %s Version: %d\n"),
9688 get_ver_flags (aux.vna_flags), aux.vna_other);
9689
dd24e3da 9690 /* Check for overflow. */
53774b7e
NC		 9691 if (aux.vna_next > (size_t) (endbuf - vstart)
9692 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9693 {
9694 warn (_("Invalid vna_next field of %lx\n"),
9695 aux.vna_next);
9696 j = ent.vn_cnt;
9697 break;
9698 }
252b5132
RH		 9699 isum += aux.vna_next;
9700 vstart += aux.vna_next;
9701 }
9cf03b7e 9702
54806181 9703 if (j < ent.vn_cnt)
9cf03b7e 9704 warn (_("Missing Version Needs auxillary information\n"));
252b5132 9705
bcf83b2a 9706 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
c24cf8b6
NC		 9707 {
9708 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9709 cnt = section->sh_info;
9710 break;
9711 }
252b5132
RH		 9712 idx += ent.vn_next;
9713 }
9cf03b7e 9714
54806181 9715 if (cnt < section->sh_info)
9cf03b7e 9716 warn (_("Missing Version Needs information\n"));
103f02d3 9717
252b5132
RH		 9718 free (eneed);
9719 }
9720 break;
9721
9722 case SHT_GNU_versym:
9723 {
2cf0635d 9724 Elf_Internal_Shdr * link_section;
8b73c356
NC		 9725 size_t total;
9726 unsigned int cnt;
2cf0635d
NC		 9727 unsigned char * edata;
9728 unsigned short * data;
9729 char * strtab;
9730 Elf_Internal_Sym * symbols;
9731 Elf_Internal_Shdr * string_sec;
ba5cdace 9732 unsigned long num_syms;
d3ba0551 9733 long off;
252b5132 9734
4fbb74a6 9735 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9736 break;
9737
4fbb74a6 9738 link_section = section_headers + section->sh_link;
08d8fa11 9739 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 9740
4fbb74a6 9741 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9742 break;
9743
252b5132
RH		 9744 found = 1;
9745
ba5cdace 9746 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 9747 if (symbols == NULL)
9748 break;
252b5132 9749
4fbb74a6 9750 string_sec = section_headers + link_section->sh_link;
252b5132 9751
3f5e193b
NC		 9752 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9753 string_sec->sh_size,
9754 _("version string table"));
a6e9f9df 9755 if (!strtab)
0429c154
MS		 9756 {
9757 free (symbols);
9758 break;
9759 }
252b5132 9760
8b73c356
NC		 9761 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9762 printable_section_name (section), (unsigned long) total);
252b5132
RH		 9763
9764 printf (_(" Addr: "));
9765 printf_vma (section->sh_addr);
72de5009 9766 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9767 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9768 printable_section_name (link_section));
252b5132 9769
d3ba0551
AM		 9770 off = offset_from_vma (file,
9771 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9772 total * sizeof (short));
3f5e193b
NC		 9773 edata = (unsigned char *) get_data (NULL, file, off, total,
9774 sizeof (short),
9775 _("version symbol data"));
a6e9f9df
AM		 9776 if (!edata)
9777 {
9778 free (strtab);
0429c154 9779 free (symbols);
a6e9f9df
AM		 9780 break;
9781 }
252b5132 9782
3f5e193b 9783 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 9784
9785 for (cnt = total; cnt --;)
b34976b6
AM		 9786 data[cnt] = byte_get (edata + cnt * sizeof (short),
9787 sizeof (short));
252b5132
RH		 9788
9789 free (edata);
9790
9791 for (cnt = 0; cnt < total; cnt += 4)
9792 {
9793 int j, nn;
00d93f34 9794 int check_def, check_need;
2cf0635d 9795 char * name;
252b5132
RH		 9796
9797 printf (" %03x:", cnt);
9798
9799 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 9800 switch (data[cnt + j])
252b5132
RH		 9801 {
9802 case 0:
9803 fputs (_(" 0 (*local*) "), stdout);
9804 break;
9805
9806 case 1:
9807 fputs (_(" 1 (*global*) "), stdout);
9808 break;
9809
9810 default:
c244d050
NC		 9811 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9812 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 9813
dd24e3da 9814 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 9815 array, break to avoid an out-of-bounds read. */
9816 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 9817 {
9818 warn (_("invalid index into symbol array\n"));
9819 break;
9820 }
9821
00d93f34
JJ		 9822 check_def = 1;
9823 check_need = 1;
4fbb74a6
AM		 9824 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9825 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 9826 != SHT_NOBITS)
252b5132 9827 {
b34976b6 9828 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 9829 check_def = 0;
9830 else
9831 check_need = 0;
252b5132 9832 }
00d93f34
JJ		 9833
9834 if (check_need
b34976b6 9835 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 9836 {
b34976b6
AM		 9837 Elf_Internal_Verneed ivn;
9838 unsigned long offset;
252b5132 9839
d93f0186
NC		 9840 offset = offset_from_vma
9841 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9842 sizeof (Elf_External_Verneed));
252b5132 9843
b34976b6 9844 do
252b5132 9845 {
b34976b6
AM		 9846 Elf_Internal_Vernaux ivna;
9847 Elf_External_Verneed evn;
9848 Elf_External_Vernaux evna;
9849 unsigned long a_off;
252b5132 9850
59245841
NC		 9851 if (get_data (&evn, file, offset, sizeof (evn), 1,
9852 _("version need")) == NULL)
9853 break;
0b4362b0 9854
252b5132
RH		 9855 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9856 ivn.vn_next = BYTE_GET (evn.vn_next);
9857
9858 a_off = offset + ivn.vn_aux;
9859
9860 do
9861 {
59245841
NC		 9862 if (get_data (&evna, file, a_off, sizeof (evna),
9863 1, _("version need aux (2)")) == NULL)
9864 {
9865 ivna.vna_next = 0;
9866 ivna.vna_other = 0;
9867 }
9868 else
9869 {
9870 ivna.vna_next = BYTE_GET (evna.vna_next);
9871 ivna.vna_other = BYTE_GET (evna.vna_other);
9872 }
252b5132
RH		 9873
9874 a_off += ivna.vna_next;
9875 }
b34976b6 9876 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 9877 && ivna.vna_next != 0);
9878
b34976b6 9879 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 9880 {
9881 ivna.vna_name = BYTE_GET (evna.vna_name);
9882
54806181
AM		 9883 if (ivna.vna_name >= string_sec->sh_size)
9884 name = _("*invalid*");
9885 else
9886 name = strtab + ivna.vna_name;
252b5132 9887 nn += printf ("(%s%-*s",
16062207
ILT		 9888 name,
9889 12 - (int) strlen (name),
252b5132 9890 ")");
00d93f34 9891 check_def = 0;
252b5132
RH		 9892 break;
9893 }
9894
9895 offset += ivn.vn_next;
9896 }
9897 while (ivn.vn_next);
9898 }
00d93f34 9899
b34976b6
AM		 9900 if (check_def && data[cnt + j] != 0x8001
9901 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9902 {
b34976b6
AM		 9903 Elf_Internal_Verdef ivd;
9904 Elf_External_Verdef evd;
9905 unsigned long offset;
252b5132 9906
d93f0186
NC		 9907 offset = offset_from_vma
9908 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9909 sizeof evd);
252b5132
RH		 9910
9911 do
9912 {
59245841
NC		 9913 if (get_data (&evd, file, offset, sizeof (evd), 1,
9914 _("version def")) == NULL)
9915 {
9916 ivd.vd_next = 0;
948f632f 9917 /* PR 17531: file: 046-1082287-0.004. */
3102e897
NC		 9918 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
9919 break;
59245841
NC		 9920 }
9921 else
9922 {
9923 ivd.vd_next = BYTE_GET (evd.vd_next);
9924 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9925 }
252b5132
RH		 9926
9927 offset += ivd.vd_next;
9928 }
c244d050 9929 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 9930 && ivd.vd_next != 0);
9931
c244d050 9932 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 9933 {
b34976b6
AM		 9934 Elf_External_Verdaux evda;
9935 Elf_Internal_Verdaux ivda;
252b5132
RH		 9936
9937 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9938
59245841
NC		 9939 if (get_data (&evda, file,
9940 offset - ivd.vd_next + ivd.vd_aux,
9941 sizeof (evda), 1,
9942 _("version def aux")) == NULL)
9943 break;
252b5132
RH		 9944
9945 ivda.vda_name = BYTE_GET (evda.vda_name);
9946
54806181
AM		 9947 if (ivda.vda_name >= string_sec->sh_size)
9948 name = _("*invalid*");
9949 else
9950 name = strtab + ivda.vda_name;
252b5132 9951 nn += printf ("(%s%-*s",
16062207
ILT		 9952 name,
9953 12 - (int) strlen (name),
252b5132
RH		 9954 ")");
9955 }
9956 }
9957
9958 if (nn < 18)
9959 printf ("%*c", 18 - nn, ' ');
9960 }
9961
9962 putchar ('\n');
9963 }
9964
9965 free (data);
9966 free (strtab);
9967 free (symbols);
9968 }
9969 break;
103f02d3 9970
252b5132
RH		 9971 default:
9972 break;
9973 }
9974 }
9975
9976 if (! found)
9977 printf (_("\nNo version information found in this file.\n"));
9978
9979 return 1;
9980}
9981
d1133906 9982static const char *
d3ba0551 9983get_symbol_binding (unsigned int binding)
252b5132 9984{
b34976b6 9985 static char buff[32];
252b5132
RH		 9986
9987 switch (binding)
9988 {
b34976b6
AM		 9989 case STB_LOCAL: return "LOCAL";
9990 case STB_GLOBAL: return "GLOBAL";
9991 case STB_WEAK: return "WEAK";
252b5132
RH		 9992 default:
9993 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 9994 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9995 binding);
252b5132 9996 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 9997 {
9998 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 9999 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10000 /* GNU is still using the default value 0. */
3e7a7d11
NC		 10001 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10002 return "UNIQUE";
10003 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10004 }
252b5132 10005 else
e9e44622 10006 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 10007 return buff;
10008 }
10009}
10010
d1133906 10011static const char *
d3ba0551 10012get_symbol_type (unsigned int type)
252b5132 10013{
b34976b6 10014 static char buff[32];
252b5132
RH		 10015
10016 switch (type)
10017 {
b34976b6
AM		 10018 case STT_NOTYPE: return "NOTYPE";
10019 case STT_OBJECT: return "OBJECT";
10020 case STT_FUNC: return "FUNC";
10021 case STT_SECTION: return "SECTION";
10022 case STT_FILE: return "FILE";
10023 case STT_COMMON: return "COMMON";
10024 case STT_TLS: return "TLS";
15ab5209
DB		 10025 case STT_RELC: return "RELC";
10026 case STT_SRELC: return "SRELC";
252b5132
RH		 10027 default:
10028 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 10029 {
3510a7b8
NC		 10030 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10031 return "THUMB_FUNC";
103f02d3 10032
351b4b40 10033 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 10034 return "REGISTER";
10035
10036 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10037 return "PARISC_MILLI";
10038
e9e44622 10039 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 10040 }
252b5132 10041 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 10042 {
10043 if (elf_header.e_machine == EM_PARISC)
10044 {
10045 if (type == STT_HP_OPAQUE)
10046 return "HP_OPAQUE";
10047 if (type == STT_HP_STUB)
10048 return "HP_STUB";
10049 }
10050
d8045f23 10051 if (type == STT_GNU_IFUNC
9c55345c 10052 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 10053 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 10054 /* GNU is still using the default value 0. */
d8045f23
NC		 10055 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10056 return "IFUNC";
10057
e9e44622 10058 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 10059 }
252b5132 10060 else
e9e44622 10061 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 10062 return buff;
10063 }
10064}
10065
d1133906 10066static const char *
d3ba0551 10067get_symbol_visibility (unsigned int visibility)
d1133906
NC		 10068{
10069 switch (visibility)
10070 {
b34976b6
AM		 10071 case STV_DEFAULT: return "DEFAULT";
10072 case STV_INTERNAL: return "INTERNAL";
10073 case STV_HIDDEN: return "HIDDEN";
d1133906 10074 case STV_PROTECTED: return "PROTECTED";
bee0ee85
NC		 10075 default:
10076 error (_("Unrecognized visibility value: %u"), visibility);
10077 return _("<unknown>");
d1133906
NC		 10078 }
10079}
10080
5e2b0d47
NC		 10081static const char *
10082get_mips_symbol_other (unsigned int other)
10083{
10084 switch (other)
10085 {
df58fc94
RS		 10086 case STO_OPTIONAL:
10087 return "OPTIONAL";
10088 case STO_MIPS_PLT:
10089 return "MIPS PLT";
10090 case STO_MIPS_PIC:
10091 return "MIPS PIC";
10092 case STO_MICROMIPS:
10093 return "MICROMIPS";
10094 case STO_MICROMIPS | STO_MIPS_PIC:
10095 return "MICROMIPS, MIPS PIC";
10096 case STO_MIPS16:
10097 return "MIPS16";
10098 default:
10099 return NULL;
5e2b0d47
NC		 10100 }
10101}
10102
28f997cf
TG		 10103static const char *
10104get_ia64_symbol_other (unsigned int other)
10105{
10106 if (is_ia64_vms ())
10107 {
10108 static char res[32];
10109
10110 res[0] = 0;
10111
10112 /* Function types is for images and .STB files only. */
10113 switch (elf_header.e_type)
10114 {
10115 case ET_DYN:
10116 case ET_EXEC:
10117 switch (VMS_ST_FUNC_TYPE (other))
10118 {
10119 case VMS_SFT_CODE_ADDR:
10120 strcat (res, " CA");
10121 break;
10122 case VMS_SFT_SYMV_IDX:
10123 strcat (res, " VEC");
10124 break;
10125 case VMS_SFT_FD:
10126 strcat (res, " FD");
10127 break;
10128 case VMS_SFT_RESERVE:
10129 strcat (res, " RSV");
10130 break;
10131 default:
bee0ee85
NC		 10132 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10133 VMS_ST_FUNC_TYPE (other));
10134 strcat (res, " <unknown>");
10135 break;
28f997cf
TG		 10136 }
10137 break;
10138 default:
10139 break;
10140 }
10141 switch (VMS_ST_LINKAGE (other))
10142 {
10143 case VMS_STL_IGNORE:
10144 strcat (res, " IGN");
10145 break;
10146 case VMS_STL_RESERVE:
10147 strcat (res, " RSV");
10148 break;
10149 case VMS_STL_STD:
10150 strcat (res, " STD");
10151 break;
10152 case VMS_STL_LNK:
10153 strcat (res, " LNK");
10154 break;
10155 default:
bee0ee85
NC		 10156 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10157 VMS_ST_LINKAGE (other));
10158 strcat (res, " <unknown>");
10159 break;
28f997cf
TG		 10160 }
10161
10162 if (res[0] != 0)
10163 return res + 1;
10164 else
10165 return res;
10166 }
10167 return NULL;
10168}
10169
6911b7dc
AM		 10170static const char *
10171get_ppc64_symbol_other (unsigned int other)
10172{
10173 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10174 {
10175 static char buf[32];
10176 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10177 PPC64_LOCAL_ENTRY_OFFSET (other));
10178 return buf;
10179 }
10180 return NULL;
10181}
10182
5e2b0d47
NC		 10183static const char *
10184get_symbol_other (unsigned int other)
10185{
10186 const char * result = NULL;
10187 static char buff [32];
10188
10189 if (other == 0)
10190 return "";
10191
10192 switch (elf_header.e_machine)
10193 {
10194 case EM_MIPS:
10195 result = get_mips_symbol_other (other);
28f997cf
TG		 10196 break;
10197 case EM_IA_64:
10198 result = get_ia64_symbol_other (other);
10199 break;
6911b7dc
AM		 10200 case EM_PPC64:
10201 result = get_ppc64_symbol_other (other);
10202 break;
5e2b0d47
NC		 10203 default:
10204 break;
10205 }
10206
10207 if (result)
10208 return result;
10209
10210 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10211 return buff;
10212}
10213
d1133906 10214static const char *
d3ba0551 10215get_symbol_index_type (unsigned int type)
252b5132 10216{
b34976b6 10217 static char buff[32];
5cf1065c 10218
252b5132
RH		 10219 switch (type)
10220 {
b34976b6
AM		 10221 case SHN_UNDEF: return "UND";
10222 case SHN_ABS: return "ABS";
10223 case SHN_COMMON: return "COM";
252b5132 10224 default:
9ce701e2
L		 10225 if (type == SHN_IA_64_ANSI_COMMON
10226 && elf_header.e_machine == EM_IA_64
10227 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10228 return "ANSI_COM";
8a9036a4 10229 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 10230 || elf_header.e_machine == EM_L1OM
10231 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 10232 && type == SHN_X86_64_LCOMMON)
10233 return "LARGE_COM";
ac145307
BS		 10234 else if ((type == SHN_MIPS_SCOMMON
10235 && elf_header.e_machine == EM_MIPS)
10236 || (type == SHN_TIC6X_SCOMMON
10237 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 10238 return "SCOM";
10239 else if (type == SHN_MIPS_SUNDEFINED
10240 && elf_header.e_machine == EM_MIPS)
10241 return "SUND";
9ce701e2 10242 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 10243 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 10244 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 10245 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10246 else if (type >= SHN_LORESERVE)
10247 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4 10248 else if (type >= elf_header.e_shnum)
e0a31db1 10249 sprintf (buff, _("bad section index[%3d]"), type);
252b5132 10250 else
232e7cb8 10251 sprintf (buff, "%3d", type);
5cf1065c 10252 break;
252b5132 10253 }
5cf1065c
NC		 10254
10255 return buff;
252b5132
RH		 10256}
10257
66543521 10258static bfd_vma *
57028622 10259get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
252b5132 10260{
2cf0635d
NC		 10261 unsigned char * e_data;
10262 bfd_vma * i_data;
252b5132 10263
57028622
NC		 10264 /* If the size_t type is smaller than the bfd_size_type, eg because
10265 you are building a 32-bit tool on a 64-bit host, then make sure
10266 that when (number) is cast to (size_t) no information is lost. */
10267 if (sizeof (size_t) < sizeof (bfd_size_type)
10268 && (bfd_size_type) ((size_t) number) != number)
10269 {
10270 error (_("Size truncation prevents reading %llu elements of size %u\n"),
10271 (unsigned long long) number, ent_size);
10272 return NULL;
10273 }
948f632f 10274
3102e897
NC		 10275 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10276 attempting to allocate memory when the read is bound to fail. */
10277 if (ent_size * number > current_file_size)
10278 {
57028622
NC		 10279 error (_("Invalid number of dynamic entries: %llu\n"),
10280 (unsigned long long) number);
3102e897
NC		 10281 return NULL;
10282 }
10283
57028622 10284 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
252b5132
RH		 10285 if (e_data == NULL)
10286 {
57028622
NC		 10287 error (_("Out of memory reading %llu dynamic entries\n"),
10288 (unsigned long long) number);
252b5132
RH		 10289 return NULL;
10290 }
10291
57028622 10292 if (fread (e_data, ent_size, (size_t) number, file) != number)
252b5132 10293 {
57028622
NC		 10294 error (_("Unable to read in %llu bytes of dynamic data\n"),
10295 (unsigned long long) (number * ent_size));
3102e897 10296 free (e_data);
252b5132
RH		 10297 return NULL;
10298 }
10299
57028622 10300 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
252b5132
RH		 10301 if (i_data == NULL)
10302 {
57028622
NC		 10303 error (_("Out of memory allocating space for %llu dynamic entries\n"),
10304 (unsigned long long) number);
252b5132
RH		 10305 free (e_data);
10306 return NULL;
10307 }
10308
10309 while (number--)
66543521 10310 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 10311
10312 free (e_data);
10313
10314 return i_data;
10315}
10316
6bd1a22c
L		 10317static void
10318print_dynamic_symbol (bfd_vma si, unsigned long hn)
10319{
2cf0635d 10320 Elf_Internal_Sym * psym;
6bd1a22c
L		 10321 int n;
10322
6bd1a22c
L		 10323 n = print_vma (si, DEC_5);
10324 if (n < 5)
0b4362b0 10325 fputs (&" "[n], stdout);
6bd1a22c 10326 printf (" %3lu: ", hn);
e0a31db1
NC		 10327
10328 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10329 {
3102e897
NC		 10330 printf (_("<No info available for dynamic symbol number %lu>\n"),
10331 (unsigned long) si);
e0a31db1
NC		 10332 return;
10333 }
10334
10335 psym = dynamic_symbols + si;
6bd1a22c
L		 10336 print_vma (psym->st_value, LONG_HEX);
10337 putchar (' ');
10338 print_vma (psym->st_size, DEC_5);
10339
f4be36b3
AM		 10340 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10341 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10342 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 10343 /* Check to see if any other bits in the st_other field are set.
10344 Note - displaying this information disrupts the layout of the
10345 table being generated, but for the moment this case is very
10346 rare. */
10347 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10348 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10349 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10350 if (VALID_DYNAMIC_NAME (psym->st_name))
10351 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10352 else
2b692964 10353 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 10354 putchar ('\n');
10355}
10356
bb4d2ac2
L		 10357static const char *
10358get_symbol_version_string (FILE *file, int is_dynsym,
10359 const char *strtab,
10360 unsigned long int strtab_size,
10361 unsigned int si, Elf_Internal_Sym *psym,
10362 enum versioned_symbol_info *sym_info,
10363 unsigned short *vna_other)
10364{
10365 const char *version_string = NULL;
10366
10367 if (is_dynsym
10368 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
10369 {
10370 unsigned char data[2];
10371 unsigned short vers_data;
10372 unsigned long offset;
10373 int is_nobits;
10374 int check_def;
10375
10376 offset = offset_from_vma
10377 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10378 sizeof data + si * sizeof (vers_data));
10379
10380 if (get_data (&data, file, offset + si * sizeof (vers_data),
10381 sizeof (data), 1, _("version data")) == NULL)
10382 return NULL;
10383
10384 vers_data = byte_get (data, 2);
10385
53774b7e
NC		 10386 is_nobits = (section_headers != NULL
10387 && psym->st_shndx < elf_header.e_shnum
bb4d2ac2
L		 10388 && section_headers[psym->st_shndx].sh_type
10389 == SHT_NOBITS);
10390
10391 check_def = (psym->st_shndx != SHN_UNDEF);
10392
10393 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
10394 {
10395 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
10396 && (is_nobits || ! check_def))
10397 {
10398 Elf_External_Verneed evn;
10399 Elf_Internal_Verneed ivn;
10400 Elf_Internal_Vernaux ivna;
10401
10402 /* We must test both. */
10403 offset = offset_from_vma
10404 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10405 sizeof evn);
10406
10407 do
10408 {
10409 unsigned long vna_off;
10410
10411 if (get_data (&evn, file, offset, sizeof (evn), 1,
10412 _("version need")) == NULL)
10413 {
10414 ivna.vna_next = 0;
10415 ivna.vna_other = 0;
10416 ivna.vna_name = 0;
10417 break;
10418 }
10419
10420 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10421 ivn.vn_next = BYTE_GET (evn.vn_next);
10422
10423 vna_off = offset + ivn.vn_aux;
10424
10425 do
10426 {
10427 Elf_External_Vernaux evna;
10428
10429 if (get_data (&evna, file, vna_off,
10430 sizeof (evna), 1,
10431 _("version need aux (3)")) == NULL)
10432 {
10433 ivna.vna_next = 0;
10434 ivna.vna_other = 0;
10435 ivna.vna_name = 0;
10436 }
10437 else
10438 {
10439 ivna.vna_other = BYTE_GET (evna.vna_other);
10440 ivna.vna_next = BYTE_GET (evna.vna_next);
10441 ivna.vna_name = BYTE_GET (evna.vna_name);
10442 }
10443
10444 vna_off += ivna.vna_next;
10445 }
10446 while (ivna.vna_other != vers_data
10447 && ivna.vna_next != 0);
10448
10449 if (ivna.vna_other == vers_data)
10450 break;
10451
10452 offset += ivn.vn_next;
10453 }
10454 while (ivn.vn_next != 0);
10455
10456 if (ivna.vna_other == vers_data)
10457 {
10458 *sym_info = symbol_undefined;
10459 *vna_other = ivna.vna_other;
10460 version_string = (ivna.vna_name < strtab_size
10461 ? strtab + ivna.vna_name
10462 : _("<corrupt>"));
10463 check_def = 0;
10464 }
10465 else if (! is_nobits)
10466 error (_("bad dynamic symbol\n"));
10467 else
10468 check_def = 1;
10469 }
10470
10471 if (check_def)
10472 {
10473 if (vers_data != 0x8001
10474 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10475 {
10476 Elf_Internal_Verdef ivd;
10477 Elf_Internal_Verdaux ivda;
10478 Elf_External_Verdaux evda;
10479 unsigned long off;
10480
10481 off = offset_from_vma
10482 (file,
10483 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10484 sizeof (Elf_External_Verdef));
10485
10486 do
10487 {
10488 Elf_External_Verdef evd;
10489
10490 if (get_data (&evd, file, off, sizeof (evd),
10491 1, _("version def")) == NULL)
10492 {
10493 ivd.vd_ndx = 0;
10494 ivd.vd_aux = 0;
10495 ivd.vd_next = 0;
10496 }
10497 else
10498 {
10499 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10500 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10501 ivd.vd_next = BYTE_GET (evd.vd_next);
10502 }
10503
10504 off += ivd.vd_next;
10505 }
10506 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10507 && ivd.vd_next != 0);
10508
10509 off -= ivd.vd_next;
10510 off += ivd.vd_aux;
10511
10512 if (get_data (&evda, file, off, sizeof (evda),
10513 1, _("version def aux")) == NULL)
10514 return version_string;
10515
10516 ivda.vda_name = BYTE_GET (evda.vda_name);
10517
10518 if (psym->st_name != ivda.vda_name)
10519 {
10520 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10521 ? symbol_hidden : symbol_public);
10522 version_string = (ivda.vda_name < strtab_size
10523 ? strtab + ivda.vda_name
10524 : _("<corrupt>"));
10525 }
10526 }
10527 }
10528 }
10529 }
10530 return version_string;
10531}
10532
e3c8793a 10533/* Dump the symbol table. */
252b5132 10534static int
2cf0635d 10535process_symbol_table (FILE * file)
252b5132 10536{
2cf0635d 10537 Elf_Internal_Shdr * section;
8b73c356
NC		 10538 bfd_size_type nbuckets = 0;
10539 bfd_size_type nchains = 0;
2cf0635d
NC		 10540 bfd_vma * buckets = NULL;
10541 bfd_vma * chains = NULL;
fdc90cb4 10542 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 10543 bfd_vma * gnubuckets = NULL;
10544 bfd_vma * gnuchains = NULL;
6bd1a22c 10545 bfd_vma gnusymidx = 0;
071436c6 10546 bfd_size_type ngnuchains = 0;
252b5132 10547
2c610e4b 10548 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 10549 return 1;
10550
6bd1a22c
L		 10551 if (dynamic_info[DT_HASH]
10552 && (do_histogram
2c610e4b
L		 10553 || (do_using_dynamic
10554 && !do_dyn_syms
10555 && dynamic_strings != NULL)))
252b5132 10556 {
66543521
AM		 10557 unsigned char nb[8];
10558 unsigned char nc[8];
8b73c356 10559 unsigned int hash_ent_size = 4;
66543521
AM		 10560
10561 if ((elf_header.e_machine == EM_ALPHA
10562 || elf_header.e_machine == EM_S390
10563 || elf_header.e_machine == EM_S390_OLD)
10564 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10565 hash_ent_size = 8;
10566
fb52b2f4
NC		 10567 if (fseek (file,
10568 (archive_file_offset
10569 + offset_from_vma (file, dynamic_info[DT_HASH],
10570 sizeof nb + sizeof nc)),
d93f0186 10571 SEEK_SET))
252b5132 10572 {
591a748a 10573 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10574 goto no_hash;
252b5132
RH		 10575 }
10576
66543521 10577 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 10578 {
10579 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10580 goto no_hash;
252b5132
RH		 10581 }
10582
66543521 10583 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 10584 {
10585 error (_("Failed to read in number of chains\n"));
d3a44ec6 10586 goto no_hash;
252b5132
RH		 10587 }
10588
66543521
AM		 10589 nbuckets = byte_get (nb, hash_ent_size);
10590 nchains = byte_get (nc, hash_ent_size);
252b5132 10591
66543521
AM		 10592 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10593 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 10594
d3a44ec6 10595 no_hash:
252b5132 10596 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 10597 {
10598 if (do_using_dynamic)
10599 return 0;
10600 free (buckets);
10601 free (chains);
10602 buckets = NULL;
10603 chains = NULL;
10604 nbuckets = 0;
10605 nchains = 0;
10606 }
252b5132
RH		 10607 }
10608
6bd1a22c
L		 10609 if (dynamic_info_DT_GNU_HASH
10610 && (do_histogram
2c610e4b
L		 10611 || (do_using_dynamic
10612 && !do_dyn_syms
10613 && dynamic_strings != NULL)))
252b5132 10614 {
6bd1a22c
L		 10615 unsigned char nb[16];
10616 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10617 bfd_vma buckets_vma;
10618
10619 if (fseek (file,
10620 (archive_file_offset
10621 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10622 sizeof nb)),
10623 SEEK_SET))
10624 {
10625 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10626 goto no_gnu_hash;
6bd1a22c 10627 }
252b5132 10628
6bd1a22c
L		 10629 if (fread (nb, 16, 1, file) != 1)
10630 {
10631 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10632 goto no_gnu_hash;
6bd1a22c
L		 10633 }
10634
10635 ngnubuckets = byte_get (nb, 4);
10636 gnusymidx = byte_get (nb + 4, 4);
10637 bitmaskwords = byte_get (nb + 8, 4);
10638 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 10639 if (is_32bit_elf)
6bd1a22c 10640 buckets_vma += bitmaskwords * 4;
f7a99963 10641 else
6bd1a22c 10642 buckets_vma += bitmaskwords * 8;
252b5132 10643
6bd1a22c
L		 10644 if (fseek (file,
10645 (archive_file_offset
10646 + offset_from_vma (file, buckets_vma, 4)),
10647 SEEK_SET))
252b5132 10648 {
6bd1a22c 10649 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10650 goto no_gnu_hash;
6bd1a22c
L		 10651 }
10652
10653 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 10654
6bd1a22c 10655 if (gnubuckets == NULL)
d3a44ec6 10656 goto no_gnu_hash;
6bd1a22c
L		 10657
10658 for (i = 0; i < ngnubuckets; i++)
10659 if (gnubuckets[i] != 0)
10660 {
10661 if (gnubuckets[i] < gnusymidx)
10662 return 0;
10663
10664 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10665 maxchain = gnubuckets[i];
10666 }
10667
10668 if (maxchain == 0xffffffff)
d3a44ec6 10669 goto no_gnu_hash;
6bd1a22c
L		 10670
10671 maxchain -= gnusymidx;
10672
10673 if (fseek (file,
10674 (archive_file_offset
10675 + offset_from_vma (file, buckets_vma
10676 + 4 * (ngnubuckets + maxchain), 4)),
10677 SEEK_SET))
10678 {
10679 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10680 goto no_gnu_hash;
6bd1a22c
L		 10681 }
10682
10683 do
10684 {
10685 if (fread (nb, 4, 1, file) != 1)
252b5132 10686 {
6bd1a22c 10687 error (_("Failed to determine last chain length\n"));
d3a44ec6 10688 goto no_gnu_hash;
6bd1a22c 10689 }
252b5132 10690
6bd1a22c 10691 if (maxchain + 1 == 0)
d3a44ec6 10692 goto no_gnu_hash;
252b5132 10693
6bd1a22c
L		 10694 ++maxchain;
10695 }
10696 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 10697
6bd1a22c
L		 10698 if (fseek (file,
10699 (archive_file_offset
10700 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10701 SEEK_SET))
10702 {
10703 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10704 goto no_gnu_hash;
6bd1a22c
L		 10705 }
10706
10707 gnuchains = get_dynamic_data (file, maxchain, 4);
071436c6 10708 ngnuchains = maxchain;
6bd1a22c 10709
d3a44ec6 10710 no_gnu_hash:
6bd1a22c 10711 if (gnuchains == NULL)
d3a44ec6
JJ		 10712 {
10713 free (gnubuckets);
d3a44ec6
JJ		 10714 gnubuckets = NULL;
10715 ngnubuckets = 0;
f64fddf1
NC		 10716 if (do_using_dynamic)
10717 return 0;
d3a44ec6 10718 }
6bd1a22c
L		 10719 }
10720
10721 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10722 && do_syms
10723 && do_using_dynamic
3102e897
NC		 10724 && dynamic_strings != NULL
10725 && dynamic_symbols != NULL)
6bd1a22c
L		 10726 {
10727 unsigned long hn;
10728
10729 if (dynamic_info[DT_HASH])
10730 {
10731 bfd_vma si;
10732
10733 printf (_("\nSymbol table for image:\n"));
10734 if (is_32bit_elf)
10735 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10736 else
10737 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10738
10739 for (hn = 0; hn < nbuckets; hn++)
10740 {
10741 if (! buckets[hn])
10742 continue;
10743
10744 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10745 print_dynamic_symbol (si, hn);
252b5132
RH		 10746 }
10747 }
6bd1a22c
L		 10748
10749 if (dynamic_info_DT_GNU_HASH)
10750 {
10751 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10752 if (is_32bit_elf)
10753 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10754 else
10755 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10756
10757 for (hn = 0; hn < ngnubuckets; ++hn)
10758 if (gnubuckets[hn] != 0)
10759 {
10760 bfd_vma si = gnubuckets[hn];
10761 bfd_vma off = si - gnusymidx;
10762
10763 do
10764 {
10765 print_dynamic_symbol (si, hn);
10766 si++;
10767 }
071436c6 10768 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
6bd1a22c
L		 10769 }
10770 }
252b5132 10771 }
8b73c356
NC		 10772 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10773 && section_headers != NULL)
252b5132 10774 {
b34976b6 10775 unsigned int i;
252b5132
RH		 10776
10777 for (i = 0, section = section_headers;
10778 i < elf_header.e_shnum;
10779 i++, section++)
10780 {
b34976b6 10781 unsigned int si;
2cf0635d 10782 char * strtab = NULL;
c256ffe7 10783 unsigned long int strtab_size = 0;
2cf0635d
NC		 10784 Elf_Internal_Sym * symtab;
10785 Elf_Internal_Sym * psym;
ba5cdace 10786 unsigned long num_syms;
252b5132 10787
2c610e4b
L		 10788 if ((section->sh_type != SHT_SYMTAB
10789 && section->sh_type != SHT_DYNSYM)
10790 || (!do_syms
10791 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 10792 continue;
10793
dd24e3da
NC		 10794 if (section->sh_entsize == 0)
10795 {
10796 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
74e1a04b 10797 printable_section_name (section));
dd24e3da
NC		 10798 continue;
10799 }
10800
252b5132 10801 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
74e1a04b 10802 printable_section_name (section),
252b5132 10803 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 10804
f7a99963 10805 if (is_32bit_elf)
ca47b30c 10806 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 10807 else
ca47b30c 10808 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 10809
ba5cdace 10810 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 10811 if (symtab == NULL)
10812 continue;
10813
10814 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 10815 {
10816 strtab = string_table;
10817 strtab_size = string_table_length;
10818 }
4fbb74a6 10819 else if (section->sh_link < elf_header.e_shnum)
252b5132 10820 {
2cf0635d 10821 Elf_Internal_Shdr * string_sec;
252b5132 10822
4fbb74a6 10823 string_sec = section_headers + section->sh_link;
252b5132 10824
3f5e193b
NC		 10825 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10826 1, string_sec->sh_size,
10827 _("string table"));
c256ffe7 10828 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 10829 }
10830
ba5cdace 10831 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 10832 {
bb4d2ac2
L		 10833 const char *version_string;
10834 enum versioned_symbol_info sym_info;
10835 unsigned short vna_other;
10836
5e220199 10837 printf ("%6d: ", si);
f7a99963
NC		 10838 print_vma (psym->st_value, LONG_HEX);
10839 putchar (' ');
10840 print_vma (psym->st_size, DEC_5);
d1133906
NC		 10841 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10842 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 10843 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 10844 /* Check to see if any other bits in the st_other field are set.
10845 Note - displaying this information disrupts the layout of the
10846 table being generated, but for the moment this case is very rare. */
10847 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10848 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 10849 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 10850 print_symbol (25, psym->st_name < strtab_size
2b692964 10851 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 10852
bb4d2ac2
L		 10853 version_string
10854 = get_symbol_version_string (file,
10855 section->sh_type == SHT_DYNSYM,
10856 strtab, strtab_size, si,
10857 psym, &sym_info, &vna_other);
10858 if (version_string)
252b5132 10859 {
bb4d2ac2
L		 10860 if (sym_info == symbol_undefined)
10861 printf ("@%s (%d)", version_string, vna_other);
10862 else
10863 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10864 version_string);
252b5132
RH		 10865 }
10866
10867 putchar ('\n');
10868 }
10869
10870 free (symtab);
10871 if (strtab != string_table)
10872 free (strtab);
10873 }
10874 }
10875 else if (do_syms)
10876 printf
10877 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10878
10879 if (do_histogram && buckets != NULL)
10880 {
2cf0635d
NC		 10881 unsigned long * lengths;
10882 unsigned long * counts;
66543521
AM		 10883 unsigned long hn;
10884 bfd_vma si;
10885 unsigned long maxlength = 0;
10886 unsigned long nzero_counts = 0;
10887 unsigned long nsyms = 0;
94d15024 10888 unsigned long chained;
252b5132 10889
66543521
AM		 10890 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10891 (unsigned long) nbuckets);
252b5132 10892
3f5e193b 10893 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 10894 if (lengths == NULL)
10895 {
8b73c356 10896 error (_("Out of memory allocating space for histogram buckets\n"));
252b5132
RH		 10897 return 0;
10898 }
8b73c356
NC		 10899
10900 printf (_(" Length Number %% of total Coverage\n"));
252b5132
RH		 10901 for (hn = 0; hn < nbuckets; ++hn)
10902 {
94d15024
MF		 10903 for (si = buckets[hn], chained = 0;
10904 si > 0 && si < nchains && si < nbuckets && chained <= nchains;
10905 si = chains[si], ++chained)
252b5132 10906 {
b34976b6 10907 ++nsyms;
252b5132 10908 if (maxlength < ++lengths[hn])
b34976b6 10909 ++maxlength;
252b5132 10910 }
94d15024
MF		 10911
10912 /* PR binutils/17531: A corrupt binary could contain broken
10913 histogram data. Do not go into an infinite loop trying
10914 to process it. */
10915 if (chained > nchains)
10916 {
10917 error (_("histogram chain is corrupt\n"));
10918 break;
10919 }
252b5132
RH		 10920 }
10921
3f5e193b 10922 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 10923 if (counts == NULL)
10924 {
b2e951ec 10925 free (lengths);
8b73c356 10926 error (_("Out of memory allocating space for histogram counts\n"));
252b5132
RH		 10927 return 0;
10928 }
10929
10930 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 10931 ++counts[lengths[hn]];
252b5132 10932
103f02d3 10933 if (nbuckets > 0)
252b5132 10934 {
66543521
AM		 10935 unsigned long i;
10936 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 10937 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 10938 for (i = 1; i <= maxlength; ++i)
103f02d3 10939 {
66543521
AM		 10940 nzero_counts += counts[i] * i;
10941 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10942 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 10943 (nzero_counts * 100.0) / nsyms);
10944 }
252b5132
RH		 10945 }
10946
10947 free (counts);
10948 free (lengths);
10949 }
10950
10951 if (buckets != NULL)
10952 {
10953 free (buckets);
10954 free (chains);
10955 }
10956
d3a44ec6 10957 if (do_histogram && gnubuckets != NULL)
fdc90cb4 10958 {
2cf0635d
NC		 10959 unsigned long * lengths;
10960 unsigned long * counts;
fdc90cb4
JJ		 10961 unsigned long hn;
10962 unsigned long maxlength = 0;
10963 unsigned long nzero_counts = 0;
10964 unsigned long nsyms = 0;
fdc90cb4 10965
8b73c356
NC		 10966 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10967 (unsigned long) ngnubuckets);
10968
3f5e193b 10969 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 10970 if (lengths == NULL)
10971 {
8b73c356 10972 error (_("Out of memory allocating space for gnu histogram buckets\n"));
fdc90cb4
JJ		 10973 return 0;
10974 }
10975
fdc90cb4
JJ		 10976 printf (_(" Length Number %% of total Coverage\n"));
10977
10978 for (hn = 0; hn < ngnubuckets; ++hn)
10979 if (gnubuckets[hn] != 0)
10980 {
10981 bfd_vma off, length = 1;
10982
6bd1a22c 10983 for (off = gnubuckets[hn] - gnusymidx;
071436c6
NC		 10984 /* PR 17531 file: 010-77222-0.004. */
10985 off < ngnuchains && (gnuchains[off] & 1) == 0;
10986 ++off)
fdc90cb4
JJ		 10987 ++length;
10988 lengths[hn] = length;
10989 if (length > maxlength)
10990 maxlength = length;
10991 nsyms += length;
10992 }
10993
3f5e193b 10994 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 10995 if (counts == NULL)
10996 {
b2e951ec 10997 free (lengths);
8b73c356 10998 error (_("Out of memory allocating space for gnu histogram counts\n"));
fdc90cb4
JJ		 10999 return 0;
11000 }
11001
11002 for (hn = 0; hn < ngnubuckets; ++hn)
11003 ++counts[lengths[hn]];
11004
11005 if (ngnubuckets > 0)
11006 {
11007 unsigned long j;
11008 printf (" 0 %-10lu (%5.1f%%)\n",
11009 counts[0], (counts[0] * 100.0) / ngnubuckets);
11010 for (j = 1; j <= maxlength; ++j)
11011 {
11012 nzero_counts += counts[j] * j;
11013 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11014 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11015 (nzero_counts * 100.0) / nsyms);
11016 }
11017 }
11018
11019 free (counts);
11020 free (lengths);
11021 free (gnubuckets);
11022 free (gnuchains);
11023 }
11024
252b5132
RH		 11025 return 1;
11026}
11027
11028static int
2cf0635d 11029process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 11030{
b4c96d0d 11031 unsigned int i;
252b5132
RH		 11032
11033 if (dynamic_syminfo == NULL
11034 || !do_dynamic)
11035 /* No syminfo, this is ok. */
11036 return 1;
11037
11038 /* There better should be a dynamic symbol section. */
11039 if (dynamic_symbols == NULL || dynamic_strings == NULL)
11040 return 0;
11041
11042 if (dynamic_addr)
11043 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11044 dynamic_syminfo_offset, dynamic_syminfo_nent);
11045
11046 printf (_(" Num: Name BoundTo Flags\n"));
11047 for (i = 0; i < dynamic_syminfo_nent; ++i)
11048 {
11049 unsigned short int flags = dynamic_syminfo[i].si_flags;
11050
31104126 11051 printf ("%4d: ", i);
4082ef84
NC		 11052 if (i >= num_dynamic_syms)
11053 printf (_("<corrupt index>"));
11054 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
d79b3d50
NC		 11055 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11056 else
2b692964 11057 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 11058 putchar (' ');
252b5132
RH		 11059
11060 switch (dynamic_syminfo[i].si_boundto)
11061 {
11062 case SYMINFO_BT_SELF:
11063 fputs ("SELF ", stdout);
11064 break;
11065 case SYMINFO_BT_PARENT:
11066 fputs ("PARENT ", stdout);
11067 break;
11068 default:
11069 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 11070 && dynamic_syminfo[i].si_boundto < dynamic_nent
11071 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 11072 {
d79b3d50 11073 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 11074 putchar (' ' );
11075 }
252b5132
RH		 11076 else
11077 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11078 break;
11079 }
11080
11081 if (flags & SYMINFO_FLG_DIRECT)
11082 printf (" DIRECT");
11083 if (flags & SYMINFO_FLG_PASSTHRU)
11084 printf (" PASSTHRU");
11085 if (flags & SYMINFO_FLG_COPY)
11086 printf (" COPY");
11087 if (flags & SYMINFO_FLG_LAZYLOAD)
11088 printf (" LAZYLOAD");
11089
11090 puts ("");
11091 }
11092
11093 return 1;
11094}
11095
cf13d699
NC		 11096/* Check to see if the given reloc needs to be handled in a target specific
11097 manner. If so then process the reloc and return TRUE otherwise return
11098 FALSE. */
09c11c86 11099
cf13d699
NC		 11100static bfd_boolean
11101target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11102 unsigned char * start,
11103 Elf_Internal_Sym * symtab)
252b5132 11104{
cf13d699 11105 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 11106
cf13d699 11107 switch (elf_header.e_machine)
252b5132 11108 {
13761a11
NC		 11109 case EM_MSP430:
11110 case EM_MSP430_OLD:
11111 {
11112 static Elf_Internal_Sym * saved_sym = NULL;
11113
11114 switch (reloc_type)
11115 {
11116 case 10: /* R_MSP430_SYM_DIFF */
11117 if (uses_msp430x_relocs ())
11118 break;
11119 case 21: /* R_MSP430X_SYM_DIFF */
11120 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11121 return TRUE;
11122
11123 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11124 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11125 goto handle_sym_diff;
0b4362b0 11126
13761a11
NC		 11127 case 5: /* R_MSP430_16_BYTE */
11128 case 9: /* R_MSP430_8 */
11129 if (uses_msp430x_relocs ())
11130 break;
11131 goto handle_sym_diff;
11132
11133 case 2: /* R_MSP430_ABS16 */
11134 case 15: /* R_MSP430X_ABS16 */
11135 if (! uses_msp430x_relocs ())
11136 break;
11137 goto handle_sym_diff;
0b4362b0 11138
13761a11
NC		 11139 handle_sym_diff:
11140 if (saved_sym != NULL)
11141 {
11142 bfd_vma value;
11143
11144 value = reloc->r_addend
11145 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11146 - saved_sym->st_value);
11147
11148 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11149
11150 saved_sym = NULL;
11151 return TRUE;
11152 }
11153 break;
11154
11155 default:
11156 if (saved_sym != NULL)
071436c6 11157 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13761a11
NC		 11158 break;
11159 }
11160 break;
11161 }
11162
cf13d699
NC		 11163 case EM_MN10300:
11164 case EM_CYGNUS_MN10300:
11165 {
11166 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 11167
cf13d699
NC		 11168 switch (reloc_type)
11169 {
11170 case 34: /* R_MN10300_ALIGN */
11171 return TRUE;
11172 case 33: /* R_MN10300_SYM_DIFF */
11173 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11174 return TRUE;
11175 case 1: /* R_MN10300_32 */
11176 case 2: /* R_MN10300_16 */
11177 if (saved_sym != NULL)
11178 {
11179 bfd_vma value;
252b5132 11180
cf13d699
NC		 11181 value = reloc->r_addend
11182 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11183 - saved_sym->st_value);
252b5132 11184
cf13d699 11185 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 11186
cf13d699
NC		 11187 saved_sym = NULL;
11188 return TRUE;
11189 }
11190 break;
11191 default:
11192 if (saved_sym != NULL)
071436c6 11193 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
cf13d699
NC		 11194 break;
11195 }
11196 break;
11197 }
6ff71e76
NC		 11198
11199 case EM_RL78:
11200 {
11201 static bfd_vma saved_sym1 = 0;
11202 static bfd_vma saved_sym2 = 0;
11203 static bfd_vma value;
11204
11205 switch (reloc_type)
11206 {
11207 case 0x80: /* R_RL78_SYM. */
11208 saved_sym1 = saved_sym2;
11209 saved_sym2 = symtab[get_reloc_symindex (reloc->r_info)].st_value;
11210 saved_sym2 += reloc->r_addend;
11211 return TRUE;
11212
11213 case 0x83: /* R_RL78_OPsub. */
11214 value = saved_sym1 - saved_sym2;
11215 saved_sym2 = saved_sym1 = 0;
11216 return TRUE;
11217 break;
11218
11219 case 0x41: /* R_RL78_ABS32. */
11220 byte_put (start + reloc->r_offset, value, 4);
11221 value = 0;
11222 return TRUE;
11223
11224 case 0x43: /* R_RL78_ABS16. */
11225 byte_put (start + reloc->r_offset, value, 2);
11226 value = 0;
11227 return TRUE;
11228
11229 default:
11230 break;
11231 }
11232 break;
11233 }
252b5132
RH		 11234 }
11235
cf13d699 11236 return FALSE;
252b5132
RH		 11237}
11238
aca88567
NC		 11239/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11240 DWARF debug sections. This is a target specific test. Note - we do not
11241 go through the whole including-target-headers-multiple-times route, (as
11242 we have already done with <elf/h8.h>) because this would become very
11243 messy and even then this function would have to contain target specific
11244 information (the names of the relocs instead of their numeric values).
11245 FIXME: This is not the correct way to solve this problem. The proper way
11246 is to have target specific reloc sizing and typing functions created by
11247 the reloc-macros.h header, in the same way that it already creates the
11248 reloc naming functions. */
11249
11250static bfd_boolean
11251is_32bit_abs_reloc (unsigned int reloc_type)
11252{
11253 switch (elf_header.e_machine)
11254 {
41e92641
NC		 11255 case EM_386:
11256 case EM_486:
11257 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 11258 case EM_68K:
11259 return reloc_type == 1; /* R_68K_32. */
11260 case EM_860:
11261 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 11262 case EM_960:
11263 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 11264 case EM_AARCH64:
11265 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 11266 case EM_ALPHA:
137b6b5f 11267 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 11268 case EM_ARC:
11269 return reloc_type == 1; /* R_ARC_32. */
11270 case EM_ARM:
11271 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 11272 case EM_AVR_OLD:
aca88567
NC		 11273 case EM_AVR:
11274 return reloc_type == 1;
cfb8c092
NC		 11275 case EM_ADAPTEVA_EPIPHANY:
11276 return reloc_type == 3;
aca88567
NC		 11277 case EM_BLACKFIN:
11278 return reloc_type == 0x12; /* R_byte4_data. */
11279 case EM_CRIS:
11280 return reloc_type == 3; /* R_CRIS_32. */
11281 case EM_CR16:
11282 return reloc_type == 3; /* R_CR16_NUM32. */
11283 case EM_CRX:
11284 return reloc_type == 15; /* R_CRX_NUM32. */
11285 case EM_CYGNUS_FRV:
11286 return reloc_type == 1;
41e92641
NC		 11287 case EM_CYGNUS_D10V:
11288 case EM_D10V:
11289 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 11290 case EM_CYGNUS_D30V:
11291 case EM_D30V:
11292 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 11293 case EM_DLX:
11294 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 11295 case EM_CYGNUS_FR30:
11296 case EM_FR30:
11297 return reloc_type == 3; /* R_FR30_32. */
3f8107ab
AM		 11298 case EM_FT32:
11299 return reloc_type == 1; /* R_FT32_32. */
aca88567
NC		 11300 case EM_H8S:
11301 case EM_H8_300:
11302 case EM_H8_300H:
11303 return reloc_type == 1; /* R_H8_DIR32. */
3730236a
NC		 11304 case EM_IA_64:
11305 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
aca88567
NC		 11306 case EM_IP2K_OLD:
11307 case EM_IP2K:
11308 return reloc_type == 2; /* R_IP2K_32. */
11309 case EM_IQ2000:
11310 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 11311 case EM_LATTICEMICO32:
11312 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 11313 case EM_M32C_OLD:
aca88567
NC		 11314 case EM_M32C:
11315 return reloc_type == 3; /* R_M32C_32. */
11316 case EM_M32R:
11317 return reloc_type == 34; /* R_M32R_32_RELA. */
11318 case EM_MCORE:
11319 return reloc_type == 1; /* R_MCORE_ADDR32. */
11320 case EM_CYGNUS_MEP:
11321 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 11322 case EM_METAG:
11323 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 11324 case EM_MICROBLAZE:
11325 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 11326 case EM_MIPS:
11327 return reloc_type == 2; /* R_MIPS_32. */
11328 case EM_MMIX:
11329 return reloc_type == 4; /* R_MMIX_32. */
11330 case EM_CYGNUS_MN10200:
11331 case EM_MN10200:
11332 return reloc_type == 1; /* R_MN10200_32. */
11333 case EM_CYGNUS_MN10300:
11334 case EM_MN10300:
11335 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 11336 case EM_MOXIE:
11337 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 11338 case EM_MSP430_OLD:
11339 case EM_MSP430:
13761a11 11340 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 11341 case EM_MT:
11342 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 11343 case EM_NDS32:
11344 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 11345 case EM_ALTERA_NIOS2:
36591ba1 11346 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 11347 case EM_NIOS32:
11348 return reloc_type == 1; /* R_NIOS_32. */
73589c9d
CS		 11349 case EM_OR1K:
11350 return reloc_type == 1; /* R_OR1K_32. */
aca88567 11351 case EM_PARISC:
5fda8eca
NC		 11352 return (reloc_type == 1 /* R_PARISC_DIR32. */
11353 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 11354 case EM_PJ:
11355 case EM_PJ_OLD:
11356 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
11357 case EM_PPC64:
11358 return reloc_type == 1; /* R_PPC64_ADDR32. */
11359 case EM_PPC:
11360 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 11361 case EM_RL78:
11362 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 11363 case EM_RX:
11364 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 11365 case EM_S370:
11366 return reloc_type == 1; /* R_I370_ADDR31. */
11367 case EM_S390_OLD:
11368 case EM_S390:
11369 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 11370 case EM_SCORE:
11371 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 11372 case EM_SH:
11373 return reloc_type == 1; /* R_SH_DIR32. */
11374 case EM_SPARC32PLUS:
11375 case EM_SPARCV9:
11376 case EM_SPARC:
11377 return reloc_type == 3 /* R_SPARC_32. */
11378 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 11379 case EM_SPU:
11380 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 11381 case EM_TI_C6000:
11382 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 11383 case EM_TILEGX:
11384 return reloc_type == 2; /* R_TILEGX_32. */
11385 case EM_TILEPRO:
11386 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 11387 case EM_CYGNUS_V850:
11388 case EM_V850:
11389 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 11390 case EM_V800:
11391 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 11392 case EM_VAX:
11393 return reloc_type == 1; /* R_VAX_32. */
619ed720
EB		 11394 case EM_VISIUM:
11395 return reloc_type == 3; /* R_VISIUM_32. */
aca88567 11396 case EM_X86_64:
8a9036a4 11397 case EM_L1OM:
7a9068fe 11398 case EM_K1OM:
aca88567 11399 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 11400 case EM_XC16X:
11401 case EM_C166:
11402 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 11403 case EM_XGATE:
11404 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 11405 case EM_XSTORMY16:
11406 return reloc_type == 1; /* R_XSTROMY16_32. */
11407 case EM_XTENSA_OLD:
11408 case EM_XTENSA:
11409 return reloc_type == 1; /* R_XTENSA_32. */
aca88567 11410 default:
bee0ee85
NC		 11411 {
11412 static unsigned int prev_warn = 0;
11413
11414 /* Avoid repeating the same warning multiple times. */
11415 if (prev_warn != elf_header.e_machine)
11416 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11417 elf_header.e_machine);
11418 prev_warn = elf_header.e_machine;
11419 return FALSE;
11420 }
aca88567
NC		 11421 }
11422}
11423
11424/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11425 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11426
11427static bfd_boolean
11428is_32bit_pcrel_reloc (unsigned int reloc_type)
11429{
11430 switch (elf_header.e_machine)
11431 {
41e92641
NC		 11432 case EM_386:
11433 case EM_486:
3e0873ac 11434 return reloc_type == 2; /* R_386_PC32. */
aca88567 11435 case EM_68K:
3e0873ac 11436 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 11437 case EM_AARCH64:
11438 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 11439 case EM_ADAPTEVA_EPIPHANY:
11440 return reloc_type == 6;
aca88567
NC		 11441 case EM_ALPHA:
11442 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 11443 case EM_ARM:
3e0873ac 11444 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 11445 case EM_MICROBLAZE:
11446 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
73589c9d
CS		 11447 case EM_OR1K:
11448 return reloc_type == 9; /* R_OR1K_32_PCREL. */
aca88567 11449 case EM_PARISC:
85acf597 11450 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 11451 case EM_PPC:
11452 return reloc_type == 26; /* R_PPC_REL32. */
11453 case EM_PPC64:
3e0873ac 11454 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 11455 case EM_S390_OLD:
11456 case EM_S390:
3e0873ac 11457 return reloc_type == 5; /* R_390_PC32. */
aca88567 11458 case EM_SH:
3e0873ac 11459 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 11460 case EM_SPARC32PLUS:
11461 case EM_SPARCV9:
11462 case EM_SPARC:
3e0873ac 11463 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 11464 case EM_SPU:
11465 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 11466 case EM_TILEGX:
11467 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
11468 case EM_TILEPRO:
11469 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
619ed720
EB		 11470 case EM_VISIUM:
11471 return reloc_type == 6; /* R_VISIUM_32_PCREL */
aca88567 11472 case EM_X86_64:
8a9036a4 11473 case EM_L1OM:
7a9068fe 11474 case EM_K1OM:
3e0873ac 11475 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 11476 case EM_XTENSA_OLD:
11477 case EM_XTENSA:
11478 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 11479 default:
11480 /* Do not abort or issue an error message here. Not all targets use
11481 pc-relative 32-bit relocs in their DWARF debug information and we
11482 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 11483 more helpful warning message will be generated by apply_relocations
11484 anyway, so just return. */
aca88567
NC		 11485 return FALSE;
11486 }
11487}
11488
11489/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11490 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11491
11492static bfd_boolean
11493is_64bit_abs_reloc (unsigned int reloc_type)
11494{
11495 switch (elf_header.e_machine)
11496 {
a06ea964
NC		 11497 case EM_AARCH64:
11498 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 11499 case EM_ALPHA:
11500 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 11501 case EM_IA_64:
11502 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 11503 case EM_PARISC:
11504 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 11505 case EM_PPC64:
11506 return reloc_type == 38; /* R_PPC64_ADDR64. */
11507 case EM_SPARC32PLUS:
11508 case EM_SPARCV9:
11509 case EM_SPARC:
11510 return reloc_type == 54; /* R_SPARC_UA64. */
11511 case EM_X86_64:
8a9036a4 11512 case EM_L1OM:
7a9068fe 11513 case EM_K1OM:
aca88567 11514 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 11515 case EM_S390_OLD:
11516 case EM_S390:
aa137e4d
NC		 11517 return reloc_type == 22; /* R_S390_64. */
11518 case EM_TILEGX:
11519 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 11520 case EM_MIPS:
aa137e4d 11521 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 11522 default:
11523 return FALSE;
11524 }
11525}
11526
85acf597
RH		 11527/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11528 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11529
11530static bfd_boolean
11531is_64bit_pcrel_reloc (unsigned int reloc_type)
11532{
11533 switch (elf_header.e_machine)
11534 {
a06ea964
NC		 11535 case EM_AARCH64:
11536 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 11537 case EM_ALPHA:
aa137e4d 11538 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 11539 case EM_IA_64:
aa137e4d 11540 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 11541 case EM_PARISC:
aa137e4d 11542 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 11543 case EM_PPC64:
aa137e4d 11544 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 11545 case EM_SPARC32PLUS:
11546 case EM_SPARCV9:
11547 case EM_SPARC:
aa137e4d 11548 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 11549 case EM_X86_64:
8a9036a4 11550 case EM_L1OM:
7a9068fe 11551 case EM_K1OM:
aa137e4d 11552 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 11553 case EM_S390_OLD:
11554 case EM_S390:
aa137e4d
NC		 11555 return reloc_type == 23; /* R_S390_PC64. */
11556 case EM_TILEGX:
11557 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 11558 default:
11559 return FALSE;
11560 }
11561}
11562
4dc3c23d
AM		 11563/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11564 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11565
11566static bfd_boolean
11567is_24bit_abs_reloc (unsigned int reloc_type)
11568{
11569 switch (elf_header.e_machine)
11570 {
11571 case EM_CYGNUS_MN10200:
11572 case EM_MN10200:
11573 return reloc_type == 4; /* R_MN10200_24. */
11574 default:
11575 return FALSE;
11576 }
11577}
11578
aca88567
NC		 11579/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11580 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11581
11582static bfd_boolean
11583is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 11584{
11585 switch (elf_header.e_machine)
11586 {
aca88567
NC		 11587 case EM_AVR_OLD:
11588 case EM_AVR:
11589 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 11590 case EM_ADAPTEVA_EPIPHANY:
11591 return reloc_type == 5;
41e92641
NC		 11592 case EM_CYGNUS_D10V:
11593 case EM_D10V:
11594 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 11595 case EM_H8S:
11596 case EM_H8_300:
11597 case EM_H8_300H:
aca88567
NC		 11598 return reloc_type == R_H8_DIR16;
11599 case EM_IP2K_OLD:
11600 case EM_IP2K:
11601 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 11602 case EM_M32C_OLD:
f4236fe4
DD		 11603 case EM_M32C:
11604 return reloc_type == 1; /* R_M32C_16 */
aca88567 11605 case EM_MSP430:
13761a11
NC		 11606 if (uses_msp430x_relocs ())
11607 return reloc_type == 2; /* R_MSP430_ABS16. */
78c8d46c 11608 case EM_MSP430_OLD:
aca88567 11609 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 11610 case EM_NDS32:
11611 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 11612 case EM_ALTERA_NIOS2:
36591ba1 11613 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 11614 case EM_NIOS32:
11615 return reloc_type == 9; /* R_NIOS_16. */
73589c9d
CS		 11616 case EM_OR1K:
11617 return reloc_type == 2; /* R_OR1K_16. */
40b36596
JM		 11618 case EM_TI_C6000:
11619 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 11620 case EM_XC16X:
11621 case EM_C166:
11622 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 11623 case EM_CYGNUS_MN10200:
11624 case EM_MN10200:
11625 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 11626 case EM_CYGNUS_MN10300:
11627 case EM_MN10300:
11628 return reloc_type == 2; /* R_MN10300_16. */
619ed720
EB		 11629 case EM_VISIUM:
11630 return reloc_type == 2; /* R_VISIUM_16. */
f6c1a2d5
NC		 11631 case EM_XGATE:
11632 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 11633 default:
aca88567 11634 return FALSE;
4b78141a
NC		 11635 }
11636}
11637
2a7b2e88
JK		 11638/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11639 relocation entries (possibly formerly used for SHT_GROUP sections). */
11640
11641static bfd_boolean
11642is_none_reloc (unsigned int reloc_type)
11643{
11644 switch (elf_header.e_machine)
11645 {
cb8f3167
NC		 11646 case EM_68K: /* R_68K_NONE. */
11647 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 11648 case EM_SPARC32PLUS:
11649 case EM_SPARCV9:
cb8f3167
NC		 11650 case EM_SPARC: /* R_SPARC_NONE. */
11651 case EM_MIPS: /* R_MIPS_NONE. */
11652 case EM_PARISC: /* R_PARISC_NONE. */
11653 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 11654 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 11655 case EM_PPC: /* R_PPC_NONE. */
11656 case EM_PPC64: /* R_PPC64_NONE. */
11657 case EM_ARM: /* R_ARM_NONE. */
11658 case EM_IA_64: /* R_IA64_NONE. */
11659 case EM_SH: /* R_SH_NONE. */
2a7b2e88 11660 case EM_S390_OLD:
cb8f3167
NC		 11661 case EM_S390: /* R_390_NONE. */
11662 case EM_CRIS: /* R_CRIS_NONE. */
11663 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 11664 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 11665 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 11666 case EM_MN10300: /* R_MN10300_NONE. */
3f8107ab 11667 case EM_FT32: /* R_FT32_NONE. */
5506d11a 11668 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 11669 case EM_M32R: /* R_M32R_NONE. */
40b36596 11670 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 11671 case EM_TILEGX: /* R_TILEGX_NONE. */
11672 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 11673 case EM_XC16X:
11674 case EM_C166: /* R_XC16X_NONE. */
36591ba1
SL		 11675 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
11676 case EM_NIOS32: /* R_NIOS_NONE. */
73589c9d 11677 case EM_OR1K: /* R_OR1K_NONE. */
cb8f3167 11678 return reloc_type == 0;
a06ea964
NC		 11679 case EM_AARCH64:
11680 return reloc_type == 0 || reloc_type == 256;
35c08157
KLC		 11681 case EM_NDS32:
11682 return (reloc_type == 0 /* R_XTENSA_NONE. */
11683 || reloc_type == 204 /* R_NDS32_DIFF8. */
11684 || reloc_type == 205 /* R_NDS32_DIFF16. */
11685 || reloc_type == 206 /* R_NDS32_DIFF32. */
11686 || reloc_type == 207 /* R_NDS32_ULEB128. */);
58332dda
JK		 11687 case EM_XTENSA_OLD:
11688 case EM_XTENSA:
4dc3c23d
AM		 11689 return (reloc_type == 0 /* R_XTENSA_NONE. */
11690 || reloc_type == 17 /* R_XTENSA_DIFF8. */
11691 || reloc_type == 18 /* R_XTENSA_DIFF16. */
11692 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
a3c62988
NC		 11693 case EM_METAG:
11694 return reloc_type == 3; /* R_METAG_NONE. */
2a7b2e88
JK		 11695 }
11696 return FALSE;
11697}
11698
cf13d699
NC		 11699/* Apply relocations to a section.
11700 Note: So far support has been added only for those relocations
11701 which can be found in debug sections.
11702 FIXME: Add support for more relocations ? */
1b315056 11703
cf13d699
NC		 11704static void
11705apply_relocations (void * file,
0d2a7a93
DE		 11706 const Elf_Internal_Shdr * section,
11707 unsigned char * start, bfd_size_type size)
1b315056 11708{
cf13d699 11709 Elf_Internal_Shdr * relsec;
0d2a7a93 11710 unsigned char * end = start + size;
cb8f3167 11711
cf13d699
NC		 11712 if (elf_header.e_type != ET_REL)
11713 return;
1b315056 11714
cf13d699 11715 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 11716 for (relsec = section_headers;
11717 relsec < section_headers + elf_header.e_shnum;
11718 ++relsec)
252b5132 11719 {
41e92641
NC		 11720 bfd_boolean is_rela;
11721 unsigned long num_relocs;
2cf0635d
NC		 11722 Elf_Internal_Rela * relocs;
11723 Elf_Internal_Rela * rp;
11724 Elf_Internal_Shdr * symsec;
11725 Elf_Internal_Sym * symtab;
ba5cdace 11726 unsigned long num_syms;
2cf0635d 11727 Elf_Internal_Sym * sym;
252b5132 11728
41e92641 11729 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 11730 || relsec->sh_info >= elf_header.e_shnum
11731 || section_headers + relsec->sh_info != section
c256ffe7 11732 || relsec->sh_size == 0
4fbb74a6 11733 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 11734 continue;
428409d5 11735
41e92641
NC		 11736 is_rela = relsec->sh_type == SHT_RELA;
11737
11738 if (is_rela)
11739 {
3f5e193b
NC		 11740 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11741 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11742 return;
11743 }
11744 else
11745 {
3f5e193b
NC		 11746 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11747 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11748 return;
11749 }
11750
11751 /* SH uses RELA but uses in place value instead of the addend field. */
11752 if (elf_header.e_machine == EM_SH)
11753 is_rela = FALSE;
428409d5 11754
4fbb74a6 11755 symsec = section_headers + relsec->sh_link;
ba5cdace 11756 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 11757
41e92641 11758 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 11759 {
41e92641
NC		 11760 bfd_vma addend;
11761 unsigned int reloc_type;
11762 unsigned int reloc_size;
91d6fa6a 11763 unsigned char * rloc;
ba5cdace 11764 unsigned long sym_index;
4b78141a 11765
aca88567 11766 reloc_type = get_reloc_type (rp->r_info);
41e92641 11767
98fb390a 11768 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 11769 continue;
98fb390a
NC		 11770 else if (is_none_reloc (reloc_type))
11771 continue;
11772 else if (is_32bit_abs_reloc (reloc_type)
11773 || is_32bit_pcrel_reloc (reloc_type))
aca88567 11774 reloc_size = 4;
85acf597
RH		 11775 else if (is_64bit_abs_reloc (reloc_type)
11776 || is_64bit_pcrel_reloc (reloc_type))
aca88567 11777 reloc_size = 8;
4dc3c23d
AM		 11778 else if (is_24bit_abs_reloc (reloc_type))
11779 reloc_size = 3;
aca88567
NC		 11780 else if (is_16bit_abs_reloc (reloc_type))
11781 reloc_size = 2;
11782 else
4b78141a 11783 {
bee0ee85
NC		 11784 static unsigned int prev_reloc = 0;
11785 if (reloc_type != prev_reloc)
11786 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11787 reloc_type, printable_section_name (section));
11788 prev_reloc = reloc_type;
4b78141a
NC		 11789 continue;
11790 }
103f02d3 11791
91d6fa6a 11792 rloc = start + rp->r_offset;
c8da6823 11793 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 11794 {
11795 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11796 (unsigned long) rp->r_offset,
74e1a04b 11797 printable_section_name (section));
700dd8b7
L		 11798 continue;
11799 }
103f02d3 11800
ba5cdace
NC		 11801 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11802 if (sym_index >= num_syms)
11803 {
11804 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
74e1a04b 11805 sym_index, printable_section_name (section));
ba5cdace
NC		 11806 continue;
11807 }
11808 sym = symtab + sym_index;
41e92641
NC		 11809
11810 /* If the reloc has a symbol associated with it,
55f25fc3
L		 11811 make sure that it is of an appropriate type.
11812
11813 Relocations against symbols without type can happen.
11814 Gcc -feliminate-dwarf2-dups may generate symbols
11815 without type for debug info.
11816
11817 Icc generates relocations against function symbols
11818 instead of local labels.
11819
11820 Relocations against object symbols can happen, eg when
11821 referencing a global array. For an example of this see
11822 the _clz.o binary in libgcc.a. */
aca88567 11823 if (sym != symtab
55f25fc3 11824 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 11825 {
41e92641 11826 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 11827 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 11828 (long int)(rp - relocs),
74e1a04b 11829 printable_section_name (relsec));
aca88567 11830 continue;
5b18a4bc 11831 }
252b5132 11832
4dc3c23d
AM		 11833 addend = 0;
11834 if (is_rela)
11835 addend += rp->r_addend;
c47320c3
AM		 11836 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11837 partial_inplace. */
4dc3c23d
AM		 11838 if (!is_rela
11839 || (elf_header.e_machine == EM_XTENSA
11840 && reloc_type == 1)
11841 || ((elf_header.e_machine == EM_PJ
11842 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 11843 && reloc_type == 1)
11844 || ((elf_header.e_machine == EM_D30V
11845 || elf_header.e_machine == EM_CYGNUS_D30V)
11846 && reloc_type == 12))
91d6fa6a 11847 addend += byte_get (rloc, reloc_size);
cb8f3167 11848
85acf597
RH		 11849 if (is_32bit_pcrel_reloc (reloc_type)
11850 || is_64bit_pcrel_reloc (reloc_type))
11851 {
11852 /* On HPPA, all pc-relative relocations are biased by 8. */
11853 if (elf_header.e_machine == EM_PARISC)
11854 addend -= 8;
91d6fa6a 11855 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 11856 reloc_size);
11857 }
41e92641 11858 else
91d6fa6a 11859 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 11860 }
252b5132 11861
5b18a4bc 11862 free (symtab);
41e92641 11863 free (relocs);
5b18a4bc
NC		 11864 break;
11865 }
5b18a4bc 11866}
103f02d3 11867
cf13d699
NC		 11868#ifdef SUPPORT_DISASSEMBLY
11869static int
11870disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11871{
74e1a04b 11872 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
cf13d699 11873
74e1a04b 11874 /* FIXME: XXX -- to be done --- XXX */
cf13d699
NC		 11875
11876 return 1;
11877}
11878#endif
11879
11880/* Reads in the contents of SECTION from FILE, returning a pointer
11881 to a malloc'ed buffer or NULL if something went wrong. */
11882
11883static char *
11884get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11885{
11886 bfd_size_type num_bytes;
11887
11888 num_bytes = section->sh_size;
11889
11890 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11891 {
11892 printf (_("\nSection '%s' has no data to dump.\n"),
74e1a04b 11893 printable_section_name (section));
cf13d699
NC		 11894 return NULL;
11895 }
11896
3f5e193b
NC		 11897 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11898 _("section contents"));
cf13d699
NC		 11899}
11900
dd24e3da 11901
cf13d699
NC		 11902static void
11903dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
11904{
11905 Elf_Internal_Shdr * relsec;
11906 bfd_size_type num_bytes;
cf13d699
NC		 11907 char * data;
11908 char * end;
11909 char * start;
cf13d699
NC		 11910 bfd_boolean some_strings_shown;
11911
11912 start = get_section_contents (section, file);
11913 if (start == NULL)
11914 return;
11915
74e1a04b 11916 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
cf13d699
NC		 11917
11918 /* If the section being dumped has relocations against it the user might
11919 be expecting these relocations to have been applied. Check for this
11920 case and issue a warning message in order to avoid confusion.
11921 FIXME: Maybe we ought to have an option that dumps a section with
11922 relocs applied ? */
11923 for (relsec = section_headers;
11924 relsec < section_headers + elf_header.e_shnum;
11925 ++relsec)
11926 {
11927 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11928 || relsec->sh_info >= elf_header.e_shnum
11929 || section_headers + relsec->sh_info != section
11930 || relsec->sh_size == 0
11931 || relsec->sh_link >= elf_header.e_shnum)
11932 continue;
11933
11934 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11935 break;
11936 }
11937
11938 num_bytes = section->sh_size;
cf13d699
NC		 11939 data = start;
11940 end = start + num_bytes;
11941 some_strings_shown = FALSE;
11942
11943 while (data < end)
11944 {
11945 while (!ISPRINT (* data))
11946 if (++ data >= end)
11947 break;
11948
11949 if (data < end)
11950 {
071436c6
NC		 11951 size_t maxlen = end - data;
11952
cf13d699 11953#ifndef __MSVCRT__
c975cc98
NC		 11954 /* PR 11128: Use two separate invocations in order to work
11955 around bugs in the Solaris 8 implementation of printf. */
11956 printf (" [%6tx] ", data - start);
cf13d699 11957#else
071436c6 11958 printf (" [%6Ix] ", (size_t) (data - start));
cf13d699 11959#endif
4082ef84
NC		 11960 if (maxlen > 0)
11961 {
11962 print_symbol ((int) maxlen, data);
11963 putchar ('\n');
11964 data += strnlen (data, maxlen);
11965 }
11966 else
11967 {
11968 printf (_("<corrupt>\n"));
11969 data = end;
11970 }
cf13d699
NC		 11971 some_strings_shown = TRUE;
11972 }
11973 }
11974
11975 if (! some_strings_shown)
11976 printf (_(" No strings found in this section."));
11977
11978 free (start);
11979
11980 putchar ('\n');
11981}
11982
11983static void
11984dump_section_as_bytes (Elf_Internal_Shdr * section,
11985 FILE * file,
11986 bfd_boolean relocate)
11987{
11988 Elf_Internal_Shdr * relsec;
11989 bfd_size_type bytes;
11990 bfd_vma addr;
11991 unsigned char * data;
11992 unsigned char * start;
11993
11994 start = (unsigned char *) get_section_contents (section, file);
11995 if (start == NULL)
11996 return;
11997
74e1a04b 11998 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
cf13d699
NC		 11999
12000 if (relocate)
12001 {
0d2a7a93 12002 apply_relocations (file, section, start, section->sh_size);
cf13d699
NC		 12003 }
12004 else
12005 {
12006 /* If the section being dumped has relocations against it the user might
12007 be expecting these relocations to have been applied. Check for this
12008 case and issue a warning message in order to avoid confusion.
12009 FIXME: Maybe we ought to have an option that dumps a section with
12010 relocs applied ? */
12011 for (relsec = section_headers;
12012 relsec < section_headers + elf_header.e_shnum;
12013 ++relsec)
12014 {
12015 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12016 || relsec->sh_info >= elf_header.e_shnum
12017 || section_headers + relsec->sh_info != section
12018 || relsec->sh_size == 0
12019 || relsec->sh_link >= elf_header.e_shnum)
12020 continue;
12021
12022 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12023 break;
12024 }
12025 }
12026
12027 addr = section->sh_addr;
12028 bytes = section->sh_size;
12029 data = start;
12030
12031 while (bytes)
12032 {
12033 int j;
12034 int k;
12035 int lbytes;
12036
12037 lbytes = (bytes > 16 ? 16 : bytes);
12038
12039 printf (" 0x%8.8lx ", (unsigned long) addr);
12040
12041 for (j = 0; j < 16; j++)
12042 {
12043 if (j < lbytes)
12044 printf ("%2.2x", data[j]);
12045 else
12046 printf (" ");
12047
12048 if ((j & 3) == 3)
12049 printf (" ");
12050 }
12051
12052 for (j = 0; j < lbytes; j++)
12053 {
12054 k = data[j];
12055 if (k >= ' ' && k < 0x7f)
12056 printf ("%c", k);
12057 else
12058 printf (".");
12059 }
12060
12061 putchar ('\n');
12062
12063 data += lbytes;
12064 addr += lbytes;
12065 bytes -= lbytes;
12066 }
12067
12068 free (start);
12069
12070 putchar ('\n');
12071}
12072
4a114e3e 12073/* Uncompresses a section that was compressed using zlib, in place. */
cf13d699
NC		 12074
12075static int
0ee42ecd
L		 12076uncompress_section_contents (unsigned char **buffer,
12077 dwarf_size_type *size)
cf13d699 12078{
cf13d699
NC		 12079 dwarf_size_type compressed_size = *size;
12080 unsigned char * compressed_buffer = *buffer;
12081 dwarf_size_type uncompressed_size;
12082 unsigned char * uncompressed_buffer;
12083 z_stream strm;
12084 int rc;
12085 dwarf_size_type header_size = 12;
12086
12087 /* Read the zlib header. In this case, it should be "ZLIB" followed
12088 by the uncompressed section size, 8 bytes in big-endian order. */
12089 if (compressed_size < header_size
12090 || ! streq ((char *) compressed_buffer, "ZLIB"))
12091 return 0;
12092
12093 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
12094 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
12095 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
12096 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
12097 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
12098 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
12099 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
12100 uncompressed_size += compressed_buffer[11];
12101
12102 /* It is possible the section consists of several compressed
12103 buffers concatenated together, so we uncompress in a loop. */
de13ef81
NC		 12104 /* PR 18313: The state field in the z_stream structure is supposed
12105 to be invisible to the user (ie us), but some compilers will
12106 still complain about it being used without initialisation. So
12107 we first zero the entire z_stream structure and then set the fields
12108 that we need. */
12109 memset (& strm, 0, sizeof strm);
cf13d699
NC		 12110 strm.avail_in = compressed_size - header_size;
12111 strm.next_in = (Bytef *) compressed_buffer + header_size;
12112 strm.avail_out = uncompressed_size;
3f5e193b 12113 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
cf13d699
NC		 12114
12115 rc = inflateInit (& strm);
12116 while (strm.avail_in > 0)
12117 {
12118 if (rc != Z_OK)
12119 goto fail;
12120 strm.next_out = ((Bytef *) uncompressed_buffer
12121 + (uncompressed_size - strm.avail_out));
12122 rc = inflate (&strm, Z_FINISH);
12123 if (rc != Z_STREAM_END)
12124 goto fail;
12125 rc = inflateReset (& strm);
12126 }
12127 rc = inflateEnd (& strm);
12128 if (rc != Z_OK
12129 || strm.avail_out != 0)
12130 goto fail;
12131
cf13d699
NC		 12132 *buffer = uncompressed_buffer;
12133 *size = uncompressed_size;
12134 return 1;
12135
12136 fail:
12137 free (uncompressed_buffer);
4a114e3e
L		 12138 /* Indicate decompression failure. */
12139 *buffer = NULL;
cf13d699 12140 return 0;
cf13d699
NC		 12141}
12142
d966045b
DJ		 12143static int
12144load_specific_debug_section (enum dwarf_section_display_enum debug,
0d2a7a93 12145 const Elf_Internal_Shdr * sec, void * file)
1007acb3 12146{
2cf0635d 12147 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 12148 char buf [64];
1007acb3 12149
19e6b90e
L		 12150 /* If it is already loaded, do nothing. */
12151 if (section->start != NULL)
12152 return 1;
1007acb3 12153
19e6b90e
L		 12154 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12155 section->address = sec->sh_addr;
06614111 12156 section->user_data = NULL;
3f5e193b
NC		 12157 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12158 sec->sh_offset, 1,
12159 sec->sh_size, buf);
59245841
NC		 12160 if (section->start == NULL)
12161 section->size = 0;
12162 else
12163 {
77115a4a
L		 12164 unsigned char *start = section->start;
12165 dwarf_size_type size = sec->sh_size;
12166
12167 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12168 {
12169 Elf_Internal_Chdr chdr;
12170 unsigned int compression_header_size
12171 = get_compression_header (&chdr, start);
12172 if (chdr.ch_type != ELFCOMPRESS_ZLIB
12173 || chdr.ch_addralign != sec->sh_addralign)
12174 return 0;
12175 start += compression_header_size;
12176 size -= compression_header_size;
12177 }
12178
12179 if (uncompress_section_contents (&start, &size))
12180 {
12181 /* Free the compressed buffer, update the section buffer
12182 and the section size if uncompress is successful. */
12183 free (section->start);
12184 section->start = start;
77115a4a
L		 12185 }
12186 section->size = size;
59245841 12187 }
4a114e3e 12188
1b315056
CS		 12189 if (section->start == NULL)
12190 return 0;
12191
19e6b90e 12192 if (debug_displays [debug].relocate)
0d2a7a93 12193 apply_relocations ((FILE *) file, sec, section->start, section->size);
1007acb3 12194
1b315056 12195 return 1;
1007acb3
L		 12196}
12197
657d0d47
CC		 12198/* If this is not NULL, load_debug_section will only look for sections
12199 within the list of sections given here. */
12200unsigned int *section_subset = NULL;
12201
d966045b 12202int
2cf0635d 12203load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 12204{
2cf0635d
NC		 12205 struct dwarf_section * section = &debug_displays [debug].section;
12206 Elf_Internal_Shdr * sec;
d966045b
DJ		 12207
12208 /* Locate the debug section. */
657d0d47 12209 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 12210 if (sec != NULL)
12211 section->name = section->uncompressed_name;
12212 else
12213 {
657d0d47 12214 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 12215 if (sec != NULL)
12216 section->name = section->compressed_name;
12217 }
12218 if (sec == NULL)
12219 return 0;
12220
657d0d47
CC		 12221 /* If we're loading from a subset of sections, and we've loaded
12222 a section matching this name before, it's likely that it's a
12223 different one. */
12224 if (section_subset != NULL)
12225 free_debug_section (debug);
12226
3f5e193b 12227 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 12228}
12229
19e6b90e
L		 12230void
12231free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 12232{
2cf0635d 12233 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 12234
19e6b90e
L		 12235 if (section->start == NULL)
12236 return;
1007acb3 12237
19e6b90e
L		 12238 free ((char *) section->start);
12239 section->start = NULL;
12240 section->address = 0;
12241 section->size = 0;
1007acb3
L		 12242}
12243
1007acb3 12244static int
657d0d47 12245display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 12246{
2cf0635d 12247 char * name = SECTION_NAME (section);
74e1a04b 12248 const char * print_name = printable_section_name (section);
19e6b90e
L		 12249 bfd_size_type length;
12250 int result = 1;
3f5e193b 12251 int i;
1007acb3 12252
19e6b90e
L		 12253 length = section->sh_size;
12254 if (length == 0)
1007acb3 12255 {
74e1a04b 12256 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
19e6b90e 12257 return 0;
1007acb3 12258 }
5dff79d8
NC		 12259 if (section->sh_type == SHT_NOBITS)
12260 {
12261 /* There is no point in dumping the contents of a debugging section
12262 which has the NOBITS type - the bits in the file will be random.
12263 This can happen when a file containing a .eh_frame section is
12264 stripped with the --only-keep-debug command line option. */
74e1a04b
NC		 12265 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12266 print_name);
5dff79d8
NC		 12267 return 0;
12268 }
1007acb3 12269
0112cd26 12270 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 12271 name = ".debug_info";
1007acb3 12272
19e6b90e
L		 12273 /* See if we know how to display the contents of this section. */
12274 for (i = 0; i < max; i++)
1b315056 12275 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 12276 || (i == line && const_strneq (name, ".debug_line."))
1b315056 12277 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 12278 {
2cf0635d 12279 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 12280 int secondary = (section != find_section (name));
12281
12282 if (secondary)
3f5e193b 12283 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 12284
b40bf0a2
NC		 12285 if (i == line && const_strneq (name, ".debug_line."))
12286 sec->name = name;
12287 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 12288 sec->name = sec->uncompressed_name;
12289 else
12290 sec->name = sec->compressed_name;
3f5e193b
NC		 12291 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12292 section, file))
19e6b90e 12293 {
657d0d47
CC		 12294 /* If this debug section is part of a CU/TU set in a .dwp file,
12295 restrict load_debug_section to the sections in that set. */
12296 section_subset = find_cu_tu_set (file, shndx);
12297
19e6b90e 12298 result &= debug_displays[i].display (sec, file);
1007acb3 12299
657d0d47
CC		 12300 section_subset = NULL;
12301
d966045b 12302 if (secondary || (i != info && i != abbrev))
3f5e193b 12303 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 12304 }
1007acb3 12305
19e6b90e
L		 12306 break;
12307 }
1007acb3 12308
19e6b90e 12309 if (i == max)
1007acb3 12310 {
74e1a04b 12311 printf (_("Unrecognized debug section: %s\n"), print_name);
19e6b90e 12312 result = 0;
1007acb3
L		 12313 }
12314
19e6b90e 12315 return result;
5b18a4bc 12316}
103f02d3 12317
aef1f6d0
DJ		 12318/* Set DUMP_SECTS for all sections where dumps were requested
12319 based on section name. */
12320
12321static void
12322initialise_dumps_byname (void)
12323{
2cf0635d 12324 struct dump_list_entry * cur;
aef1f6d0
DJ		 12325
12326 for (cur = dump_sects_byname; cur; cur = cur->next)
12327 {
12328 unsigned int i;
12329 int any;
12330
12331 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12332 if (streq (SECTION_NAME (section_headers + i), cur->name))
12333 {
09c11c86 12334 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 12335 any = 1;
12336 }
12337
12338 if (!any)
12339 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12340 cur->name);
12341 }
12342}
12343
5b18a4bc 12344static void
2cf0635d 12345process_section_contents (FILE * file)
5b18a4bc 12346{
2cf0635d 12347 Elf_Internal_Shdr * section;
19e6b90e 12348 unsigned int i;
103f02d3 12349
19e6b90e
L		 12350 if (! do_dump)
12351 return;
103f02d3 12352
aef1f6d0
DJ		 12353 initialise_dumps_byname ();
12354
19e6b90e
L		 12355 for (i = 0, section = section_headers;
12356 i < elf_header.e_shnum && i < num_dump_sects;
12357 i++, section++)
12358 {
12359#ifdef SUPPORT_DISASSEMBLY
12360 if (dump_sects[i] & DISASS_DUMP)
12361 disassemble_section (section, file);
12362#endif
12363 if (dump_sects[i] & HEX_DUMP)
cf13d699 12364 dump_section_as_bytes (section, file, FALSE);
103f02d3 12365
cf13d699
NC		 12366 if (dump_sects[i] & RELOC_DUMP)
12367 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 12368
12369 if (dump_sects[i] & STRING_DUMP)
12370 dump_section_as_strings (section, file);
cf13d699
NC		 12371
12372 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 12373 display_debug_section (i, section, file);
5b18a4bc 12374 }
103f02d3 12375
19e6b90e
L		 12376 /* Check to see if the user requested a
12377 dump of a section that does not exist. */
12378 while (i++ < num_dump_sects)
12379 if (dump_sects[i])
12380 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 12381}
103f02d3 12382
5b18a4bc 12383static void
19e6b90e 12384process_mips_fpe_exception (int mask)
5b18a4bc 12385{
19e6b90e
L		 12386 if (mask)
12387 {
12388 int first = 1;
12389 if (mask & OEX_FPU_INEX)
12390 fputs ("INEX", stdout), first = 0;
12391 if (mask & OEX_FPU_UFLO)
12392 printf ("%sUFLO", first ? "" : "|"), first = 0;
12393 if (mask & OEX_FPU_OFLO)
12394 printf ("%sOFLO", first ? "" : "|"), first = 0;
12395 if (mask & OEX_FPU_DIV0)
12396 printf ("%sDIV0", first ? "" : "|"), first = 0;
12397 if (mask & OEX_FPU_INVAL)
12398 printf ("%sINVAL", first ? "" : "|");
12399 }
5b18a4bc 12400 else
19e6b90e 12401 fputs ("0", stdout);
5b18a4bc 12402}
103f02d3 12403
f6f0e17b
NC		 12404/* Display's the value of TAG at location P. If TAG is
12405 greater than 0 it is assumed to be an unknown tag, and
12406 a message is printed to this effect. Otherwise it is
12407 assumed that a message has already been printed.
12408
12409 If the bottom bit of TAG is set it assumed to have a
12410 string value, otherwise it is assumed to have an integer
12411 value.
12412
12413 Returns an updated P pointing to the first unread byte
12414 beyond the end of TAG's value.
12415
12416 Reads at or beyond END will not be made. */
12417
12418static unsigned char *
12419display_tag_value (int tag,
12420 unsigned char * p,
12421 const unsigned char * const end)
12422{
12423 unsigned long val;
12424
12425 if (tag > 0)
12426 printf (" Tag_unknown_%d: ", tag);
12427
12428 if (p >= end)
12429 {
4082ef84 12430 warn (_("<corrupt tag>\n"));
f6f0e17b
NC		 12431 }
12432 else if (tag & 1)
12433 {
071436c6
NC		 12434 /* PR 17531 file: 027-19978-0.004. */
12435 size_t maxlen = (end - p) - 1;
12436
12437 putchar ('"');
4082ef84
NC		 12438 if (maxlen > 0)
12439 {
12440 print_symbol ((int) maxlen, (const char *) p);
12441 p += strnlen ((char *) p, maxlen) + 1;
12442 }
12443 else
12444 {
12445 printf (_("<corrupt string tag>"));
12446 p = (unsigned char *) end;
12447 }
071436c6 12448 printf ("\"\n");
f6f0e17b
NC		 12449 }
12450 else
12451 {
12452 unsigned int len;
12453
12454 val = read_uleb128 (p, &len, end);
12455 p += len;
12456 printf ("%ld (0x%lx)\n", val, val);
12457 }
12458
4082ef84 12459 assert (p <= end);
f6f0e17b
NC		 12460 return p;
12461}
12462
11c1ff18
PB		 12463/* ARM EABI attributes section. */
12464typedef struct
12465{
70e99720 12466 unsigned int tag;
2cf0635d 12467 const char * name;
11c1ff18 12468 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 12469 unsigned int type;
2cf0635d 12470 const char ** table;
11c1ff18
PB		 12471} arm_attr_public_tag;
12472
2cf0635d 12473static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 12474 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 12475 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 12476static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12477static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 12478 {"No", "Thumb-1", "Thumb-2"};
75375b3e 12479static const char * arm_attr_tag_FP_arch[] =
bca38921 12480 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
a715796b 12481 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
2cf0635d 12482static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 12483static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 12484 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 12485static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 12486 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12487 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 12488static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 12489 {"V6", "SB", "TLS", "Unused"};
2cf0635d 12490static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 12491 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 12492static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 12493 {"Absolute", "PC-relative", "None"};
2cf0635d 12494static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 12495 {"None", "direct", "GOT-indirect"};
2cf0635d 12496static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 12497 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 12498static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12499static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 12500 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 12501static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12502static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12503static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 12504 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 12505static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 12506 {"Unused", "small", "int", "forced to int"};
2cf0635d 12507static const char * arm_attr_tag_ABI_HardFP_use[] =
99654aaf 12508 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
2cf0635d 12509static const char * arm_attr_tag_ABI_VFP_args[] =
5c294fee 12510 {"AAPCS", "VFP registers", "custom", "compatible"};
2cf0635d 12511static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 12512 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 12513static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 12514 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12515 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 12516static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 12517 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12518 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 12519static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 12520static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 12521 {"Not Allowed", "Allowed"};
2cf0635d 12522static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 12523 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 12524static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 12525 {"Not Allowed", "Allowed"};
12526static const char * arm_attr_tag_DIV_use[] =
dd24e3da 12527 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 12528 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 12529static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12530static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 12531 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 12532 "TrustZone and Virtualization Extensions"};
dd24e3da 12533static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 12534 {"Not Allowed", "Allowed"};
11c1ff18
PB		 12535
12536#define LOOKUP(id, name) \
12537 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 12538static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 12539{
12540 {4, "CPU_raw_name", 1, NULL},
12541 {5, "CPU_name", 1, NULL},
12542 LOOKUP(6, CPU_arch),
12543 {7, "CPU_arch_profile", 0, NULL},
12544 LOOKUP(8, ARM_ISA_use),
12545 LOOKUP(9, THUMB_ISA_use),
75375b3e 12546 LOOKUP(10, FP_arch),
11c1ff18 12547 LOOKUP(11, WMMX_arch),
f5f53991
AS		 12548 LOOKUP(12, Advanced_SIMD_arch),
12549 LOOKUP(13, PCS_config),
11c1ff18
PB		 12550 LOOKUP(14, ABI_PCS_R9_use),
12551 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 12552 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 12553 LOOKUP(17, ABI_PCS_GOT_use),
12554 LOOKUP(18, ABI_PCS_wchar_t),
12555 LOOKUP(19, ABI_FP_rounding),
12556 LOOKUP(20, ABI_FP_denormal),
12557 LOOKUP(21, ABI_FP_exceptions),
12558 LOOKUP(22, ABI_FP_user_exceptions),
12559 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 12560 {24, "ABI_align_needed", 0, NULL},
12561 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 12562 LOOKUP(26, ABI_enum_size),
12563 LOOKUP(27, ABI_HardFP_use),
12564 LOOKUP(28, ABI_VFP_args),
12565 LOOKUP(29, ABI_WMMX_args),
12566 LOOKUP(30, ABI_optimization_goals),
12567 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 12568 {32, "compatibility", 0, NULL},
f5f53991 12569 LOOKUP(34, CPU_unaligned_access),
75375b3e 12570 LOOKUP(36, FP_HP_extension),
8e79c3df 12571 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 12572 LOOKUP(42, MPextension_use),
12573 LOOKUP(44, DIV_use),
f5f53991
AS		 12574 {64, "nodefaults", 0, NULL},
12575 {65, "also_compatible_with", 0, NULL},
12576 LOOKUP(66, T2EE_use),
12577 {67, "conformance", 1, NULL},
12578 LOOKUP(68, Virtualization_use),
cd21e546 12579 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 12580};
12581#undef LOOKUP
12582
11c1ff18 12583static unsigned char *
f6f0e17b
NC		 12584display_arm_attribute (unsigned char * p,
12585 const unsigned char * const end)
11c1ff18 12586{
70e99720 12587 unsigned int tag;
11c1ff18 12588 unsigned int len;
70e99720 12589 unsigned int val;
2cf0635d 12590 arm_attr_public_tag * attr;
11c1ff18 12591 unsigned i;
70e99720 12592 unsigned int type;
11c1ff18 12593
f6f0e17b 12594 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 12595 p += len;
12596 attr = NULL;
2cf0635d 12597 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 12598 {
12599 if (arm_attr_public_tags[i].tag == tag)
12600 {
12601 attr = &arm_attr_public_tags[i];
12602 break;
12603 }
12604 }
12605
12606 if (attr)
12607 {
12608 printf (" Tag_%s: ", attr->name);
12609 switch (attr->type)
12610 {
12611 case 0:
12612 switch (tag)
12613 {
12614 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 12615 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12616 p += len;
12617 switch (val)
12618 {
2b692964
NC		 12619 case 0: printf (_("None\n")); break;
12620 case 'A': printf (_("Application\n")); break;
12621 case 'R': printf (_("Realtime\n")); break;
12622 case 'M': printf (_("Microcontroller\n")); break;
12623 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 12624 default: printf ("??? (%d)\n", val); break;
12625 }
12626 break;
12627
75375b3e 12628 case 24: /* Tag_align_needed. */
f6f0e17b 12629 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12630 p += len;
12631 switch (val)
12632 {
2b692964
NC		 12633 case 0: printf (_("None\n")); break;
12634 case 1: printf (_("8-byte\n")); break;
12635 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 12636 case 3: printf ("??? 3\n"); break;
12637 default:
12638 if (val <= 12)
dd24e3da 12639 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12640 1 << val);
12641 else
12642 printf ("??? (%d)\n", val);
12643 break;
12644 }
12645 break;
12646
12647 case 25: /* Tag_align_preserved. */
f6f0e17b 12648 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12649 p += len;
12650 switch (val)
12651 {
2b692964
NC		 12652 case 0: printf (_("None\n")); break;
12653 case 1: printf (_("8-byte, except leaf SP\n")); break;
12654 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 12655 case 3: printf ("??? 3\n"); break;
12656 default:
12657 if (val <= 12)
dd24e3da 12658 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12659 1 << val);
12660 else
12661 printf ("??? (%d)\n", val);
12662 break;
12663 }
12664 break;
12665
11c1ff18 12666 case 32: /* Tag_compatibility. */
071436c6 12667 {
071436c6
NC		 12668 val = read_uleb128 (p, &len, end);
12669 p += len;
071436c6 12670 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 12671 if (p < end - 1)
12672 {
12673 size_t maxlen = (end - p) - 1;
12674
12675 print_symbol ((int) maxlen, (const char *) p);
12676 p += strnlen ((char *) p, maxlen) + 1;
12677 }
12678 else
12679 {
12680 printf (_("<corrupt>"));
12681 p = (unsigned char *) end;
12682 }
071436c6 12683 putchar ('\n');
071436c6 12684 }
11c1ff18
PB		 12685 break;
12686
f5f53991 12687 case 64: /* Tag_nodefaults. */
541a3cbd
NC		 12688 /* PR 17531: file: 001-505008-0.01. */
12689 if (p < end)
12690 p++;
2b692964 12691 printf (_("True\n"));
f5f53991
AS		 12692 break;
12693
12694 case 65: /* Tag_also_compatible_with. */
f6f0e17b 12695 val = read_uleb128 (p, &len, end);
f5f53991
AS		 12696 p += len;
12697 if (val == 6 /* Tag_CPU_arch. */)
12698 {
f6f0e17b 12699 val = read_uleb128 (p, &len, end);
f5f53991 12700 p += len;
071436c6 12701 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 12702 printf ("??? (%d)\n", val);
12703 else
12704 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12705 }
12706 else
12707 printf ("???\n");
071436c6
NC		 12708 while (p < end && *(p++) != '\0' /* NUL terminator. */)
12709 ;
f5f53991
AS		 12710 break;
12711
11c1ff18 12712 default:
bee0ee85
NC		 12713 printf (_("<unknown: %d>\n"), tag);
12714 break;
11c1ff18
PB		 12715 }
12716 return p;
12717
12718 case 1:
f6f0e17b 12719 return display_tag_value (-1, p, end);
11c1ff18 12720 case 2:
f6f0e17b 12721 return display_tag_value (0, p, end);
11c1ff18
PB		 12722
12723 default:
12724 assert (attr->type & 0x80);
f6f0e17b 12725 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12726 p += len;
12727 type = attr->type & 0x7f;
12728 if (val >= type)
12729 printf ("??? (%d)\n", val);
12730 else
12731 printf ("%s\n", attr->table[val]);
12732 return p;
12733 }
12734 }
11c1ff18 12735
f6f0e17b 12736 return display_tag_value (tag, p, end);
11c1ff18
PB		 12737}
12738
104d59d1 12739static unsigned char *
60bca95a 12740display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 12741 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12742 const unsigned char * const end)
104d59d1
JM		 12743{
12744 int tag;
12745 unsigned int len;
12746 int val;
104d59d1 12747
f6f0e17b 12748 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 12749 p += len;
12750
12751 /* Tag_compatibility is the only generic GNU attribute defined at
12752 present. */
12753 if (tag == 32)
12754 {
f6f0e17b 12755 val = read_uleb128 (p, &len, end);
104d59d1 12756 p += len;
071436c6
NC		 12757
12758 printf (_("flag = %d, vendor = "), val);
f6f0e17b
NC		 12759 if (p == end)
12760 {
071436c6 12761 printf (_("<corrupt>\n"));
f6f0e17b
NC		 12762 warn (_("corrupt vendor attribute\n"));
12763 }
12764 else
12765 {
4082ef84
NC		 12766 if (p < end - 1)
12767 {
12768 size_t maxlen = (end - p) - 1;
071436c6 12769
4082ef84
NC		 12770 print_symbol ((int) maxlen, (const char *) p);
12771 p += strnlen ((char *) p, maxlen) + 1;
12772 }
12773 else
12774 {
12775 printf (_("<corrupt>"));
12776 p = (unsigned char *) end;
12777 }
071436c6 12778 putchar ('\n');
f6f0e17b 12779 }
104d59d1
JM		 12780 return p;
12781 }
12782
12783 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 12784 return display_proc_gnu_attribute (p, tag, end);
104d59d1 12785
f6f0e17b 12786 return display_tag_value (tag, p, end);
104d59d1
JM		 12787}
12788
34c8bcba 12789static unsigned char *
f6f0e17b
NC		 12790display_power_gnu_attribute (unsigned char * p,
12791 int tag,
12792 const unsigned char * const end)
34c8bcba 12793{
34c8bcba
JM		 12794 unsigned int len;
12795 int val;
12796
12797 if (tag == Tag_GNU_Power_ABI_FP)
12798 {
f6f0e17b 12799 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 12800 p += len;
12801 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 12802
34c8bcba
JM		 12803 switch (val)
12804 {
12805 case 0:
2b692964 12806 printf (_("Hard or soft float\n"));
34c8bcba
JM		 12807 break;
12808 case 1:
2b692964 12809 printf (_("Hard float\n"));
34c8bcba
JM		 12810 break;
12811 case 2:
2b692964 12812 printf (_("Soft float\n"));
34c8bcba 12813 break;
3c7b9897 12814 case 3:
2b692964 12815 printf (_("Single-precision hard float\n"));
3c7b9897 12816 break;
34c8bcba
JM		 12817 default:
12818 printf ("??? (%d)\n", val);
12819 break;
12820 }
12821 return p;
12822 }
12823
c6e65352
DJ		 12824 if (tag == Tag_GNU_Power_ABI_Vector)
12825 {
f6f0e17b 12826 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 12827 p += len;
12828 printf (" Tag_GNU_Power_ABI_Vector: ");
12829 switch (val)
12830 {
12831 case 0:
2b692964 12832 printf (_("Any\n"));
c6e65352
DJ		 12833 break;
12834 case 1:
2b692964 12835 printf (_("Generic\n"));
c6e65352
DJ		 12836 break;
12837 case 2:
12838 printf ("AltiVec\n");
12839 break;
12840 case 3:
12841 printf ("SPE\n");
12842 break;
12843 default:
12844 printf ("??? (%d)\n", val);
12845 break;
12846 }
12847 return p;
12848 }
12849
f82e0623
NF		 12850 if (tag == Tag_GNU_Power_ABI_Struct_Return)
12851 {
f6f0e17b
NC		 12852 if (p == end)
12853 {
071436c6 12854 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
f6f0e17b
NC		 12855 return p;
12856 }
0b4362b0 12857
f6f0e17b 12858 val = read_uleb128 (p, &len, end);
f82e0623
NF		 12859 p += len;
12860 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
12861 switch (val)
12862 {
12863 case 0:
2b692964 12864 printf (_("Any\n"));
f82e0623
NF		 12865 break;
12866 case 1:
12867 printf ("r3/r4\n");
12868 break;
12869 case 2:
2b692964 12870 printf (_("Memory\n"));
f82e0623
NF		 12871 break;
12872 default:
12873 printf ("??? (%d)\n", val);
12874 break;
12875 }
12876 return p;
12877 }
12878
f6f0e17b 12879 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 12880}
12881
643f7afb
AK		 12882static unsigned char *
12883display_s390_gnu_attribute (unsigned char * p,
12884 int tag,
12885 const unsigned char * const end)
12886{
12887 unsigned int len;
12888 int val;
12889
12890 if (tag == Tag_GNU_S390_ABI_Vector)
12891 {
12892 val = read_uleb128 (p, &len, end);
12893 p += len;
12894 printf (" Tag_GNU_S390_ABI_Vector: ");
12895
12896 switch (val)
12897 {
12898 case 0:
12899 printf (_("any\n"));
12900 break;
12901 case 1:
12902 printf (_("software\n"));
12903 break;
12904 case 2:
12905 printf (_("hardware\n"));
12906 break;
12907 default:
12908 printf ("??? (%d)\n", val);
12909 break;
12910 }
12911 return p;
12912 }
12913
12914 return display_tag_value (tag & 1, p, end);
12915}
12916
9e8c70f9
DM		 12917static void
12918display_sparc_hwcaps (int mask)
12919{
12920 if (mask)
12921 {
12922 int first = 1;
071436c6 12923
9e8c70f9
DM		 12924 if (mask & ELF_SPARC_HWCAP_MUL32)
12925 fputs ("mul32", stdout), first = 0;
12926 if (mask & ELF_SPARC_HWCAP_DIV32)
12927 printf ("%sdiv32", first ? "" : "|"), first = 0;
12928 if (mask & ELF_SPARC_HWCAP_FSMULD)
12929 printf ("%sfsmuld", first ? "" : "|"), first = 0;
12930 if (mask & ELF_SPARC_HWCAP_V8PLUS)
12931 printf ("%sv8plus", first ? "" : "|"), first = 0;
12932 if (mask & ELF_SPARC_HWCAP_POPC)
12933 printf ("%spopc", first ? "" : "|"), first = 0;
12934 if (mask & ELF_SPARC_HWCAP_VIS)
12935 printf ("%svis", first ? "" : "|"), first = 0;
12936 if (mask & ELF_SPARC_HWCAP_VIS2)
12937 printf ("%svis2", first ? "" : "|"), first = 0;
12938 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
12939 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
12940 if (mask & ELF_SPARC_HWCAP_FMAF)
12941 printf ("%sfmaf", first ? "" : "|"), first = 0;
12942 if (mask & ELF_SPARC_HWCAP_VIS3)
12943 printf ("%svis3", first ? "" : "|"), first = 0;
12944 if (mask & ELF_SPARC_HWCAP_HPC)
12945 printf ("%shpc", first ? "" : "|"), first = 0;
12946 if (mask & ELF_SPARC_HWCAP_RANDOM)
12947 printf ("%srandom", first ? "" : "|"), first = 0;
12948 if (mask & ELF_SPARC_HWCAP_TRANS)
12949 printf ("%strans", first ? "" : "|"), first = 0;
12950 if (mask & ELF_SPARC_HWCAP_FJFMAU)
12951 printf ("%sfjfmau", first ? "" : "|"), first = 0;
12952 if (mask & ELF_SPARC_HWCAP_IMA)
12953 printf ("%sima", first ? "" : "|"), first = 0;
12954 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
12955 printf ("%scspare", first ? "" : "|"), first = 0;
12956 }
12957 else
071436c6
NC		 12958 fputc ('0', stdout);
12959 fputc ('\n', stdout);
9e8c70f9
DM		 12960}
12961
3d68f91c
JM		 12962static void
12963display_sparc_hwcaps2 (int mask)
12964{
12965 if (mask)
12966 {
12967 int first = 1;
071436c6 12968
3d68f91c
JM		 12969 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
12970 fputs ("fjathplus", stdout), first = 0;
12971 if (mask & ELF_SPARC_HWCAP2_VIS3B)
12972 printf ("%svis3b", first ? "" : "|"), first = 0;
12973 if (mask & ELF_SPARC_HWCAP2_ADP)
12974 printf ("%sadp", first ? "" : "|"), first = 0;
12975 if (mask & ELF_SPARC_HWCAP2_SPARC5)
12976 printf ("%ssparc5", first ? "" : "|"), first = 0;
12977 if (mask & ELF_SPARC_HWCAP2_MWAIT)
12978 printf ("%smwait", first ? "" : "|"), first = 0;
12979 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
12980 printf ("%sxmpmul", first ? "" : "|"), first = 0;
12981 if (mask & ELF_SPARC_HWCAP2_XMONT)
12982 printf ("%sxmont2", first ? "" : "|"), first = 0;
12983 if (mask & ELF_SPARC_HWCAP2_NSEC)
12984 printf ("%snsec", first ? "" : "|"), first = 0;
12985 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
12986 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
12987 if (mask & ELF_SPARC_HWCAP2_FJDES)
12988 printf ("%sfjdes", first ? "" : "|"), first = 0;
12989 if (mask & ELF_SPARC_HWCAP2_FJAES)
12990 printf ("%sfjaes", first ? "" : "|"), first = 0;
12991 }
12992 else
071436c6
NC		 12993 fputc ('0', stdout);
12994 fputc ('\n', stdout);
3d68f91c
JM		 12995}
12996
9e8c70f9 12997static unsigned char *
f6f0e17b
NC		 12998display_sparc_gnu_attribute (unsigned char * p,
12999 int tag,
13000 const unsigned char * const end)
9e8c70f9 13001{
3d68f91c
JM		 13002 unsigned int len;
13003 int val;
13004
9e8c70f9
DM		 13005 if (tag == Tag_GNU_Sparc_HWCAPS)
13006 {
f6f0e17b 13007 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 13008 p += len;
13009 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 13010 display_sparc_hwcaps (val);
13011 return p;
3d68f91c
JM		 13012 }
13013 if (tag == Tag_GNU_Sparc_HWCAPS2)
13014 {
13015 val = read_uleb128 (p, &len, end);
13016 p += len;
13017 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13018 display_sparc_hwcaps2 (val);
13019 return p;
13020 }
9e8c70f9 13021
f6f0e17b 13022 return display_tag_value (tag, p, end);
9e8c70f9
DM		 13023}
13024
351cdf24
MF		 13025static void
13026print_mips_fp_abi_value (int val)
13027{
13028 switch (val)
13029 {
13030 case Val_GNU_MIPS_ABI_FP_ANY:
13031 printf (_("Hard or soft float\n"));
13032 break;
13033 case Val_GNU_MIPS_ABI_FP_DOUBLE:
13034 printf (_("Hard float (double precision)\n"));
13035 break;
13036 case Val_GNU_MIPS_ABI_FP_SINGLE:
13037 printf (_("Hard float (single precision)\n"));
13038 break;
13039 case Val_GNU_MIPS_ABI_FP_SOFT:
13040 printf (_("Soft float\n"));
13041 break;
13042 case Val_GNU_MIPS_ABI_FP_OLD_64:
13043 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13044 break;
13045 case Val_GNU_MIPS_ABI_FP_XX:
13046 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13047 break;
13048 case Val_GNU_MIPS_ABI_FP_64:
13049 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13050 break;
13051 case Val_GNU_MIPS_ABI_FP_64A:
13052 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13053 break;
13054 default:
13055 printf ("??? (%d)\n", val);
13056 break;
13057 }
13058}
13059
2cf19d5c 13060static unsigned char *
f6f0e17b
NC		 13061display_mips_gnu_attribute (unsigned char * p,
13062 int tag,
13063 const unsigned char * const end)
2cf19d5c 13064{
2cf19d5c
JM		 13065 if (tag == Tag_GNU_MIPS_ABI_FP)
13066 {
f6f0e17b
NC		 13067 unsigned int len;
13068 int val;
13069
13070 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 13071 p += len;
13072 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 13073
351cdf24
MF		 13074 print_mips_fp_abi_value (val);
13075
2cf19d5c
JM		 13076 return p;
13077 }
13078
a9f58168
CF		 13079 if (tag == Tag_GNU_MIPS_ABI_MSA)
13080 {
13081 unsigned int len;
13082 int val;
13083
13084 val = read_uleb128 (p, &len, end);
13085 p += len;
13086 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13087
13088 switch (val)
13089 {
13090 case Val_GNU_MIPS_ABI_MSA_ANY:
13091 printf (_("Any MSA or not\n"));
13092 break;
13093 case Val_GNU_MIPS_ABI_MSA_128:
13094 printf (_("128-bit MSA\n"));
13095 break;
13096 default:
13097 printf ("??? (%d)\n", val);
13098 break;
13099 }
13100 return p;
13101 }
13102
f6f0e17b 13103 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 13104}
13105
59e6276b 13106static unsigned char *
f6f0e17b
NC		 13107display_tic6x_attribute (unsigned char * p,
13108 const unsigned char * const end)
59e6276b
JM		 13109{
13110 int tag;
13111 unsigned int len;
13112 int val;
13113
f6f0e17b 13114 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 13115 p += len;
13116
13117 switch (tag)
13118 {
75fa6dc1 13119 case Tag_ISA:
f6f0e17b 13120 val = read_uleb128 (p, &len, end);
59e6276b 13121 p += len;
75fa6dc1 13122 printf (" Tag_ISA: ");
59e6276b
JM		 13123
13124 switch (val)
13125 {
75fa6dc1 13126 case C6XABI_Tag_ISA_none:
59e6276b
JM		 13127 printf (_("None\n"));
13128 break;
75fa6dc1 13129 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 13130 printf ("C62x\n");
13131 break;
75fa6dc1 13132 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 13133 printf ("C67x\n");
13134 break;
75fa6dc1 13135 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 13136 printf ("C67x+\n");
13137 break;
75fa6dc1 13138 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 13139 printf ("C64x\n");
13140 break;
75fa6dc1 13141 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 13142 printf ("C64x+\n");
13143 break;
75fa6dc1 13144 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 13145 printf ("C674x\n");
13146 break;
13147 default:
13148 printf ("??? (%d)\n", val);
13149 break;
13150 }
13151 return p;
13152
87779176 13153 case Tag_ABI_wchar_t:
f6f0e17b 13154 val = read_uleb128 (p, &len, end);
87779176
JM		 13155 p += len;
13156 printf (" Tag_ABI_wchar_t: ");
13157 switch (val)
13158 {
13159 case 0:
13160 printf (_("Not used\n"));
13161 break;
13162 case 1:
13163 printf (_("2 bytes\n"));
13164 break;
13165 case 2:
13166 printf (_("4 bytes\n"));
13167 break;
13168 default:
13169 printf ("??? (%d)\n", val);
13170 break;
13171 }
13172 return p;
13173
13174 case Tag_ABI_stack_align_needed:
f6f0e17b 13175 val = read_uleb128 (p, &len, end);
87779176
JM		 13176 p += len;
13177 printf (" Tag_ABI_stack_align_needed: ");
13178 switch (val)
13179 {
13180 case 0:
13181 printf (_("8-byte\n"));
13182 break;
13183 case 1:
13184 printf (_("16-byte\n"));
13185 break;
13186 default:
13187 printf ("??? (%d)\n", val);
13188 break;
13189 }
13190 return p;
13191
13192 case Tag_ABI_stack_align_preserved:
f6f0e17b 13193 val = read_uleb128 (p, &len, end);
87779176
JM		 13194 p += len;
13195 printf (" Tag_ABI_stack_align_preserved: ");
13196 switch (val)
13197 {
13198 case 0:
13199 printf (_("8-byte\n"));
13200 break;
13201 case 1:
13202 printf (_("16-byte\n"));
13203 break;
13204 default:
13205 printf ("??? (%d)\n", val);
13206 break;
13207 }
13208 return p;
13209
b5593623 13210 case Tag_ABI_DSBT:
f6f0e17b 13211 val = read_uleb128 (p, &len, end);
b5593623
JM		 13212 p += len;
13213 printf (" Tag_ABI_DSBT: ");
13214 switch (val)
13215 {
13216 case 0:
13217 printf (_("DSBT addressing not used\n"));
13218 break;
13219 case 1:
13220 printf (_("DSBT addressing used\n"));
13221 break;
13222 default:
13223 printf ("??? (%d)\n", val);
13224 break;
13225 }
13226 return p;
13227
87779176 13228 case Tag_ABI_PID:
f6f0e17b 13229 val = read_uleb128 (p, &len, end);
87779176
JM		 13230 p += len;
13231 printf (" Tag_ABI_PID: ");
13232 switch (val)
13233 {
13234 case 0:
13235 printf (_("Data addressing position-dependent\n"));
13236 break;
13237 case 1:
13238 printf (_("Data addressing position-independent, GOT near DP\n"));
13239 break;
13240 case 2:
13241 printf (_("Data addressing position-independent, GOT far from DP\n"));
13242 break;
13243 default:
13244 printf ("??? (%d)\n", val);
13245 break;
13246 }
13247 return p;
13248
13249 case Tag_ABI_PIC:
f6f0e17b 13250 val = read_uleb128 (p, &len, end);
87779176
JM		 13251 p += len;
13252 printf (" Tag_ABI_PIC: ");
13253 switch (val)
13254 {
13255 case 0:
13256 printf (_("Code addressing position-dependent\n"));
13257 break;
13258 case 1:
13259 printf (_("Code addressing position-independent\n"));
13260 break;
13261 default:
13262 printf ("??? (%d)\n", val);
13263 break;
13264 }
13265 return p;
13266
13267 case Tag_ABI_array_object_alignment:
f6f0e17b 13268 val = read_uleb128 (p, &len, end);
87779176
JM		 13269 p += len;
13270 printf (" Tag_ABI_array_object_alignment: ");
13271 switch (val)
13272 {
13273 case 0:
13274 printf (_("8-byte\n"));
13275 break;
13276 case 1:
13277 printf (_("4-byte\n"));
13278 break;
13279 case 2:
13280 printf (_("16-byte\n"));
13281 break;
13282 default:
13283 printf ("??? (%d)\n", val);
13284 break;
13285 }
13286 return p;
13287
13288 case Tag_ABI_array_object_align_expected:
f6f0e17b 13289 val = read_uleb128 (p, &len, end);
87779176
JM		 13290 p += len;
13291 printf (" Tag_ABI_array_object_align_expected: ");
13292 switch (val)
13293 {
13294 case 0:
13295 printf (_("8-byte\n"));
13296 break;
13297 case 1:
13298 printf (_("4-byte\n"));
13299 break;
13300 case 2:
13301 printf (_("16-byte\n"));
13302 break;
13303 default:
13304 printf ("??? (%d)\n", val);
13305 break;
13306 }
13307 return p;
13308
3cbd1c06 13309 case Tag_ABI_compatibility:
071436c6 13310 {
071436c6
NC		 13311 val = read_uleb128 (p, &len, end);
13312 p += len;
13313 printf (" Tag_ABI_compatibility: ");
071436c6 13314 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13315 if (p < end - 1)
13316 {
13317 size_t maxlen = (end - p) - 1;
13318
13319 print_symbol ((int) maxlen, (const char *) p);
13320 p += strnlen ((char *) p, maxlen) + 1;
13321 }
13322 else
13323 {
13324 printf (_("<corrupt>"));
13325 p = (unsigned char *) end;
13326 }
071436c6 13327 putchar ('\n');
071436c6
NC		 13328 return p;
13329 }
87779176
JM		 13330
13331 case Tag_ABI_conformance:
071436c6 13332 {
4082ef84
NC		 13333 printf (" Tag_ABI_conformance: \"");
13334 if (p < end - 1)
13335 {
13336 size_t maxlen = (end - p) - 1;
071436c6 13337
4082ef84
NC		 13338 print_symbol ((int) maxlen, (const char *) p);
13339 p += strnlen ((char *) p, maxlen) + 1;
13340 }
13341 else
13342 {
13343 printf (_("<corrupt>"));
13344 p = (unsigned char *) end;
13345 }
071436c6 13346 printf ("\"\n");
071436c6
NC		 13347 return p;
13348 }
59e6276b
JM		 13349 }
13350
f6f0e17b
NC		 13351 return display_tag_value (tag, p, end);
13352}
59e6276b 13353
f6f0e17b
NC		 13354static void
13355display_raw_attribute (unsigned char * p, unsigned char * end)
13356{
13357 unsigned long addr = 0;
13358 size_t bytes = end - p;
13359
e0a31db1 13360 assert (end > p);
f6f0e17b 13361 while (bytes)
87779176 13362 {
f6f0e17b
NC		 13363 int j;
13364 int k;
13365 int lbytes = (bytes > 16 ? 16 : bytes);
13366
13367 printf (" 0x%8.8lx ", addr);
13368
13369 for (j = 0; j < 16; j++)
13370 {
13371 if (j < lbytes)
13372 printf ("%2.2x", p[j]);
13373 else
13374 printf (" ");
13375
13376 if ((j & 3) == 3)
13377 printf (" ");
13378 }
13379
13380 for (j = 0; j < lbytes; j++)
13381 {
13382 k = p[j];
13383 if (k >= ' ' && k < 0x7f)
13384 printf ("%c", k);
13385 else
13386 printf (".");
13387 }
13388
13389 putchar ('\n');
13390
13391 p += lbytes;
13392 bytes -= lbytes;
13393 addr += lbytes;
87779176 13394 }
59e6276b 13395
f6f0e17b 13396 putchar ('\n');
59e6276b
JM		 13397}
13398
13761a11
NC		 13399static unsigned char *
13400display_msp430x_attribute (unsigned char * p,
13401 const unsigned char * const end)
13402{
13403 unsigned int len;
13404 int val;
13405 int tag;
13406
13407 tag = read_uleb128 (p, & len, end);
13408 p += len;
0b4362b0 13409
13761a11
NC		 13410 switch (tag)
13411 {
13412 case OFBA_MSPABI_Tag_ISA:
13413 val = read_uleb128 (p, &len, end);
13414 p += len;
13415 printf (" Tag_ISA: ");
13416 switch (val)
13417 {
13418 case 0: printf (_("None\n")); break;
13419 case 1: printf (_("MSP430\n")); break;
13420 case 2: printf (_("MSP430X\n")); break;
13421 default: printf ("??? (%d)\n", val); break;
13422 }
13423 break;
13424
13425 case OFBA_MSPABI_Tag_Code_Model:
13426 val = read_uleb128 (p, &len, end);
13427 p += len;
13428 printf (" Tag_Code_Model: ");
13429 switch (val)
13430 {
13431 case 0: printf (_("None\n")); break;
13432 case 1: printf (_("Small\n")); break;
13433 case 2: printf (_("Large\n")); break;
13434 default: printf ("??? (%d)\n", val); break;
13435 }
13436 break;
13437
13438 case OFBA_MSPABI_Tag_Data_Model:
13439 val = read_uleb128 (p, &len, end);
13440 p += len;
13441 printf (" Tag_Data_Model: ");
13442 switch (val)
13443 {
13444 case 0: printf (_("None\n")); break;
13445 case 1: printf (_("Small\n")); break;
13446 case 2: printf (_("Large\n")); break;
13447 case 3: printf (_("Restricted Large\n")); break;
13448 default: printf ("??? (%d)\n", val); break;
13449 }
13450 break;
13451
13452 default:
13453 printf (_(" <unknown tag %d>: "), tag);
13454
13455 if (tag & 1)
13456 {
071436c6 13457 putchar ('"');
4082ef84
NC		 13458 if (p < end - 1)
13459 {
13460 size_t maxlen = (end - p) - 1;
13461
13462 print_symbol ((int) maxlen, (const char *) p);
13463 p += strnlen ((char *) p, maxlen) + 1;
13464 }
13465 else
13466 {
13467 printf (_("<corrupt>"));
13468 p = (unsigned char *) end;
13469 }
071436c6 13470 printf ("\"\n");
13761a11
NC		 13471 }
13472 else
13473 {
13474 val = read_uleb128 (p, &len, end);
13475 p += len;
13476 printf ("%d (0x%x)\n", val, val);
13477 }
13478 break;
13479 }
13480
4082ef84 13481 assert (p <= end);
13761a11
NC		 13482 return p;
13483}
13484
11c1ff18 13485static int
60bca95a
NC		 13486process_attributes (FILE * file,
13487 const char * public_name,
104d59d1 13488 unsigned int proc_type,
f6f0e17b
NC		 13489 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13490 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 13491{
2cf0635d 13492 Elf_Internal_Shdr * sect;
11c1ff18
PB		 13493 unsigned i;
13494
13495 /* Find the section header so that we get the size. */
13496 for (i = 0, sect = section_headers;
13497 i < elf_header.e_shnum;
13498 i++, sect++)
13499 {
071436c6
NC		 13500 unsigned char * contents;
13501 unsigned char * p;
13502
104d59d1 13503 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 13504 continue;
13505
3f5e193b
NC		 13506 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13507 sect->sh_size, _("attributes"));
60bca95a 13508 if (contents == NULL)
11c1ff18 13509 continue;
60bca95a 13510
11c1ff18
PB		 13511 p = contents;
13512 if (*p == 'A')
13513 {
071436c6
NC		 13514 bfd_vma section_len;
13515
13516 section_len = sect->sh_size - 1;
11c1ff18 13517 p++;
60bca95a 13518
071436c6 13519 while (section_len > 0)
11c1ff18 13520 {
071436c6 13521 bfd_vma attr_len;
e9847026 13522 unsigned int namelen;
11c1ff18 13523 bfd_boolean public_section;
104d59d1 13524 bfd_boolean gnu_section;
11c1ff18 13525
071436c6 13526 if (section_len <= 4)
e0a31db1
NC		 13527 {
13528 error (_("Tag section ends prematurely\n"));
13529 break;
13530 }
071436c6 13531 attr_len = byte_get (p, 4);
11c1ff18 13532 p += 4;
60bca95a 13533
071436c6 13534 if (attr_len > section_len)
11c1ff18 13535 {
071436c6
NC		 13536 error (_("Bad attribute length (%u > %u)\n"),
13537 (unsigned) attr_len, (unsigned) section_len);
13538 attr_len = section_len;
11c1ff18 13539 }
74e1a04b 13540 /* PR 17531: file: 001-101425-0.004 */
071436c6 13541 else if (attr_len < 5)
74e1a04b 13542 {
071436c6 13543 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
74e1a04b
NC		 13544 break;
13545 }
e9847026 13546
071436c6
NC		 13547 section_len -= attr_len;
13548 attr_len -= 4;
13549
13550 namelen = strnlen ((char *) p, attr_len) + 1;
13551 if (namelen == 0 || namelen >= attr_len)
e9847026
NC		 13552 {
13553 error (_("Corrupt attribute section name\n"));
13554 break;
13555 }
13556
071436c6
NC		 13557 printf (_("Attribute Section: "));
13558 print_symbol (INT_MAX, (const char *) p);
13559 putchar ('\n');
60bca95a
NC		 13560
13561 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 13562 public_section = TRUE;
13563 else
13564 public_section = FALSE;
60bca95a
NC		 13565
13566 if (streq ((char *) p, "gnu"))
104d59d1
JM		 13567 gnu_section = TRUE;
13568 else
13569 gnu_section = FALSE;
60bca95a 13570
11c1ff18 13571 p += namelen;
071436c6 13572 attr_len -= namelen;
e0a31db1 13573
071436c6 13574 while (attr_len > 0 && p < contents + sect->sh_size)
11c1ff18 13575 {
e0a31db1 13576 int tag;
11c1ff18
PB		 13577 int val;
13578 bfd_vma size;
071436c6 13579 unsigned char * end;
60bca95a 13580
e0a31db1 13581 /* PR binutils/17531: Safe handling of corrupt files. */
071436c6 13582 if (attr_len < 6)
e0a31db1
NC		 13583 {
13584 error (_("Unused bytes at end of section\n"));
13585 section_len = 0;
13586 break;
13587 }
13588
13589 tag = *(p++);
11c1ff18 13590 size = byte_get (p, 4);
071436c6 13591 if (size > attr_len)
11c1ff18 13592 {
e9847026 13593 error (_("Bad subsection length (%u > %u)\n"),
071436c6
NC		 13594 (unsigned) size, (unsigned) attr_len);
13595 size = attr_len;
11c1ff18 13596 }
e0a31db1
NC		 13597 /* PR binutils/17531: Safe handling of corrupt files. */
13598 if (size < 6)
13599 {
13600 error (_("Bad subsection length (%u < 6)\n"),
13601 (unsigned) size);
13602 section_len = 0;
13603 break;
13604 }
60bca95a 13605
071436c6 13606 attr_len -= size;
11c1ff18 13607 end = p + size - 1;
071436c6 13608 assert (end <= contents + sect->sh_size);
11c1ff18 13609 p += 4;
60bca95a 13610
11c1ff18
PB		 13611 switch (tag)
13612 {
13613 case 1:
2b692964 13614 printf (_("File Attributes\n"));
11c1ff18
PB		 13615 break;
13616 case 2:
2b692964 13617 printf (_("Section Attributes:"));
11c1ff18
PB		 13618 goto do_numlist;
13619 case 3:
2b692964 13620 printf (_("Symbol Attributes:"));
11c1ff18
PB		 13621 do_numlist:
13622 for (;;)
13623 {
91d6fa6a 13624 unsigned int j;
60bca95a 13625
f6f0e17b 13626 val = read_uleb128 (p, &j, end);
91d6fa6a 13627 p += j;
11c1ff18
PB		 13628 if (val == 0)
13629 break;
13630 printf (" %d", val);
13631 }
13632 printf ("\n");
13633 break;
13634 default:
2b692964 13635 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 13636 public_section = FALSE;
13637 break;
13638 }
60bca95a 13639
071436c6 13640 if (public_section && display_pub_attribute != NULL)
11c1ff18
PB		 13641 {
13642 while (p < end)
f6f0e17b 13643 p = display_pub_attribute (p, end);
071436c6 13644 assert (p <= end);
104d59d1 13645 }
071436c6 13646 else if (gnu_section && display_proc_gnu_attribute != NULL)
104d59d1
JM		 13647 {
13648 while (p < end)
13649 p = display_gnu_attribute (p,
f6f0e17b
NC		 13650 display_proc_gnu_attribute,
13651 end);
071436c6 13652 assert (p <= end);
11c1ff18 13653 }
071436c6 13654 else if (p < end)
11c1ff18 13655 {
071436c6 13656 printf (_(" Unknown attribute:\n"));
f6f0e17b 13657 display_raw_attribute (p, end);
11c1ff18
PB		 13658 p = end;
13659 }
071436c6
NC		 13660 else
13661 attr_len = 0;
11c1ff18
PB		 13662 }
13663 }
13664 }
13665 else
e9847026 13666 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
d70c5fc7 13667
60bca95a 13668 free (contents);
11c1ff18
PB		 13669 }
13670 return 1;
13671}
13672
104d59d1 13673static int
2cf0635d 13674process_arm_specific (FILE * file)
104d59d1
JM		 13675{
13676 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13677 display_arm_attribute, NULL);
13678}
13679
34c8bcba 13680static int
2cf0635d 13681process_power_specific (FILE * file)
34c8bcba
JM		 13682{
13683 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13684 display_power_gnu_attribute);
13685}
13686
643f7afb
AK		 13687static int
13688process_s390_specific (FILE * file)
13689{
13690 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13691 display_s390_gnu_attribute);
13692}
13693
9e8c70f9
DM		 13694static int
13695process_sparc_specific (FILE * file)
13696{
13697 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13698 display_sparc_gnu_attribute);
13699}
13700
59e6276b
JM		 13701static int
13702process_tic6x_specific (FILE * file)
13703{
13704 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13705 display_tic6x_attribute, NULL);
13706}
13707
13761a11
NC		 13708static int
13709process_msp430x_specific (FILE * file)
13710{
13711 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13712 display_msp430x_attribute, NULL);
13713}
13714
ccb4c951
RS		 13715/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13716 Print the Address, Access and Initial fields of an entry at VMA ADDR
82b1b41b
NC		 13717 and return the VMA of the next entry, or -1 if there was a problem.
13718 Does not read from DATA_END or beyond. */
ccb4c951
RS		 13719
13720static bfd_vma
82b1b41b
NC		 13721print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
13722 unsigned char * data_end)
ccb4c951
RS		 13723{
13724 printf (" ");
13725 print_vma (addr, LONG_HEX);
13726 printf (" ");
13727 if (addr < pltgot + 0xfff0)
13728 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13729 else
13730 printf ("%10s", "");
13731 printf (" ");
13732 if (data == NULL)
2b692964 13733 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 13734 else
13735 {
13736 bfd_vma entry;
82b1b41b 13737 unsigned char * from = data + addr - pltgot;
ccb4c951 13738
82b1b41b
NC		 13739 if (from + (is_32bit_elf ? 4 : 8) > data_end)
13740 {
13741 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13742 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
13743 return (bfd_vma) -1;
13744 }
13745 else
13746 {
13747 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13748 print_vma (entry, LONG_HEX);
13749 }
ccb4c951
RS		 13750 }
13751 return addr + (is_32bit_elf ? 4 : 8);
13752}
13753
861fb55a
DJ		 13754/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13755 PLTGOT. Print the Address and Initial fields of an entry at VMA
13756 ADDR and return the VMA of the next entry. */
13757
13758static bfd_vma
2cf0635d 13759print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 13760{
13761 printf (" ");
13762 print_vma (addr, LONG_HEX);
13763 printf (" ");
13764 if (data == NULL)
2b692964 13765 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 13766 else
13767 {
13768 bfd_vma entry;
13769
13770 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13771 print_vma (entry, LONG_HEX);
13772 }
13773 return addr + (is_32bit_elf ? 4 : 8);
13774}
13775
351cdf24
MF		 13776static void
13777print_mips_ases (unsigned int mask)
13778{
13779 if (mask & AFL_ASE_DSP)
13780 fputs ("\n\tDSP ASE", stdout);
13781 if (mask & AFL_ASE_DSPR2)
13782 fputs ("\n\tDSP R2 ASE", stdout);
13783 if (mask & AFL_ASE_EVA)
13784 fputs ("\n\tEnhanced VA Scheme", stdout);
13785 if (mask & AFL_ASE_MCU)
13786 fputs ("\n\tMCU (MicroController) ASE", stdout);
13787 if (mask & AFL_ASE_MDMX)
13788 fputs ("\n\tMDMX ASE", stdout);
13789 if (mask & AFL_ASE_MIPS3D)
13790 fputs ("\n\tMIPS-3D ASE", stdout);
13791 if (mask & AFL_ASE_MT)
13792 fputs ("\n\tMT ASE", stdout);
13793 if (mask & AFL_ASE_SMARTMIPS)
13794 fputs ("\n\tSmartMIPS ASE", stdout);
13795 if (mask & AFL_ASE_VIRT)
13796 fputs ("\n\tVZ ASE", stdout);
13797 if (mask & AFL_ASE_MSA)
13798 fputs ("\n\tMSA ASE", stdout);
13799 if (mask & AFL_ASE_MIPS16)
13800 fputs ("\n\tMIPS16 ASE", stdout);
13801 if (mask & AFL_ASE_MICROMIPS)
13802 fputs ("\n\tMICROMIPS ASE", stdout);
13803 if (mask & AFL_ASE_XPA)
13804 fputs ("\n\tXPA ASE", stdout);
13805 if (mask == 0)
13806 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 13807 else if ((mask & ~AFL_ASE_MASK) != 0)
13808 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 13809}
13810
13811static void
13812print_mips_isa_ext (unsigned int isa_ext)
13813{
13814 switch (isa_ext)
13815 {
13816 case 0:
13817 fputs (_("None"), stdout);
13818 break;
13819 case AFL_EXT_XLR:
13820 fputs ("RMI XLR", stdout);
13821 break;
2c629856
N		 13822 case AFL_EXT_OCTEON3:
13823 fputs ("Cavium Networks Octeon3", stdout);
13824 break;
351cdf24
MF		 13825 case AFL_EXT_OCTEON2:
13826 fputs ("Cavium Networks Octeon2", stdout);
13827 break;
13828 case AFL_EXT_OCTEONP:
13829 fputs ("Cavium Networks OcteonP", stdout);
13830 break;
13831 case AFL_EXT_LOONGSON_3A:
13832 fputs ("Loongson 3A", stdout);
13833 break;
13834 case AFL_EXT_OCTEON:
13835 fputs ("Cavium Networks Octeon", stdout);
13836 break;
13837 case AFL_EXT_5900:
13838 fputs ("Toshiba R5900", stdout);
13839 break;
13840 case AFL_EXT_4650:
13841 fputs ("MIPS R4650", stdout);
13842 break;
13843 case AFL_EXT_4010:
13844 fputs ("LSI R4010", stdout);
13845 break;
13846 case AFL_EXT_4100:
13847 fputs ("NEC VR4100", stdout);
13848 break;
13849 case AFL_EXT_3900:
13850 fputs ("Toshiba R3900", stdout);
13851 break;
13852 case AFL_EXT_10000:
13853 fputs ("MIPS R10000", stdout);
13854 break;
13855 case AFL_EXT_SB1:
13856 fputs ("Broadcom SB-1", stdout);
13857 break;
13858 case AFL_EXT_4111:
13859 fputs ("NEC VR4111/VR4181", stdout);
13860 break;
13861 case AFL_EXT_4120:
13862 fputs ("NEC VR4120", stdout);
13863 break;
13864 case AFL_EXT_5400:
13865 fputs ("NEC VR5400", stdout);
13866 break;
13867 case AFL_EXT_5500:
13868 fputs ("NEC VR5500", stdout);
13869 break;
13870 case AFL_EXT_LOONGSON_2E:
13871 fputs ("ST Microelectronics Loongson 2E", stdout);
13872 break;
13873 case AFL_EXT_LOONGSON_2F:
13874 fputs ("ST Microelectronics Loongson 2F", stdout);
13875 break;
13876 default:
00ac7aa0 13877 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 13878 }
13879}
13880
13881static int
13882get_mips_reg_size (int reg_size)
13883{
13884 return (reg_size == AFL_REG_NONE) ? 0
13885 : (reg_size == AFL_REG_32) ? 32
13886 : (reg_size == AFL_REG_64) ? 64
13887 : (reg_size == AFL_REG_128) ? 128
13888 : -1;
13889}
13890
19e6b90e 13891static int
2cf0635d 13892process_mips_specific (FILE * file)
5b18a4bc 13893{
2cf0635d 13894 Elf_Internal_Dyn * entry;
351cdf24 13895 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 13896 size_t liblist_offset = 0;
13897 size_t liblistno = 0;
13898 size_t conflictsno = 0;
13899 size_t options_offset = 0;
13900 size_t conflicts_offset = 0;
861fb55a
DJ		 13901 size_t pltrelsz = 0;
13902 size_t pltrel = 0;
ccb4c951 13903 bfd_vma pltgot = 0;
861fb55a
DJ		 13904 bfd_vma mips_pltgot = 0;
13905 bfd_vma jmprel = 0;
ccb4c951
RS		 13906 bfd_vma local_gotno = 0;
13907 bfd_vma gotsym = 0;
13908 bfd_vma symtabno = 0;
103f02d3 13909
2cf19d5c
JM		 13910 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13911 display_mips_gnu_attribute);
13912
351cdf24
MF		 13913 sect = find_section (".MIPS.abiflags");
13914
13915 if (sect != NULL)
13916 {
13917 Elf_External_ABIFlags_v0 *abiflags_ext;
13918 Elf_Internal_ABIFlags_v0 abiflags_in;
13919
13920 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
13921 fputs ("\nCorrupt ABI Flags section.\n", stdout);
13922 else
13923 {
13924 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
13925 sect->sh_size, _("MIPS ABI Flags section"));
13926 if (abiflags_ext)
13927 {
13928 abiflags_in.version = BYTE_GET (abiflags_ext->version);
13929 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
13930 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
13931 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
13932 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
13933 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
13934 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
13935 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
13936 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
13937 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
13938 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
13939
13940 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
13941 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
13942 if (abiflags_in.isa_rev > 1)
13943 printf ("r%d", abiflags_in.isa_rev);
13944 printf ("\nGPR size: %d",
13945 get_mips_reg_size (abiflags_in.gpr_size));
13946 printf ("\nCPR1 size: %d",
13947 get_mips_reg_size (abiflags_in.cpr1_size));
13948 printf ("\nCPR2 size: %d",
13949 get_mips_reg_size (abiflags_in.cpr2_size));
13950 fputs ("\nFP ABI: ", stdout);
13951 print_mips_fp_abi_value (abiflags_in.fp_abi);
13952 fputs ("ISA Extension: ", stdout);
13953 print_mips_isa_ext (abiflags_in.isa_ext);
13954 fputs ("\nASEs:", stdout);
13955 print_mips_ases (abiflags_in.ases);
13956 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
13957 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
13958 fputc ('\n', stdout);
13959 free (abiflags_ext);
13960 }
13961 }
13962 }
13963
19e6b90e
L		 13964 /* We have a lot of special sections. Thanks SGI! */
13965 if (dynamic_section == NULL)
13966 /* No information available. */
13967 return 0;
252b5132 13968
071436c6
NC		 13969 for (entry = dynamic_section;
13970 /* PR 17531 file: 012-50589-0.004. */
13971 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
13972 ++entry)
252b5132
RH		 13973 switch (entry->d_tag)
13974 {
13975 case DT_MIPS_LIBLIST:
d93f0186
NC		 13976 liblist_offset
13977 = offset_from_vma (file, entry->d_un.d_val,
13978 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 13979 break;
13980 case DT_MIPS_LIBLISTNO:
13981 liblistno = entry->d_un.d_val;
13982 break;
13983 case DT_MIPS_OPTIONS:
d93f0186 13984 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 13985 break;
13986 case DT_MIPS_CONFLICT:
d93f0186
NC		 13987 conflicts_offset
13988 = offset_from_vma (file, entry->d_un.d_val,
13989 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 13990 break;
13991 case DT_MIPS_CONFLICTNO:
13992 conflictsno = entry->d_un.d_val;
13993 break;
ccb4c951 13994 case DT_PLTGOT:
861fb55a
DJ		 13995 pltgot = entry->d_un.d_ptr;
13996 break;
ccb4c951
RS		 13997 case DT_MIPS_LOCAL_GOTNO:
13998 local_gotno = entry->d_un.d_val;
13999 break;
14000 case DT_MIPS_GOTSYM:
14001 gotsym = entry->d_un.d_val;
14002 break;
14003 case DT_MIPS_SYMTABNO:
14004 symtabno = entry->d_un.d_val;
14005 break;
861fb55a
DJ		 14006 case DT_MIPS_PLTGOT:
14007 mips_pltgot = entry->d_un.d_ptr;
14008 break;
14009 case DT_PLTREL:
14010 pltrel = entry->d_un.d_val;
14011 break;
14012 case DT_PLTRELSZ:
14013 pltrelsz = entry->d_un.d_val;
14014 break;
14015 case DT_JMPREL:
14016 jmprel = entry->d_un.d_ptr;
14017 break;
252b5132
RH		 14018 default:
14019 break;
14020 }
14021
14022 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
14023 {
2cf0635d 14024 Elf32_External_Lib * elib;
252b5132
RH		 14025 size_t cnt;
14026
3f5e193b
NC		 14027 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
14028 liblistno,
14029 sizeof (Elf32_External_Lib),
9cf03b7e 14030 _("liblist section data"));
a6e9f9df 14031 if (elib)
252b5132 14032 {
2b692964 14033 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 14034 (unsigned long) liblistno);
2b692964 14035 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 14036 stdout);
14037
14038 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 14039 {
a6e9f9df 14040 Elf32_Lib liblist;
91d6fa6a 14041 time_t atime;
a6e9f9df 14042 char timebuf[20];
2cf0635d 14043 struct tm * tmp;
a6e9f9df
AM		 14044
14045 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14046 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 14047 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14048 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14049 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14050
91d6fa6a 14051 tmp = gmtime (&atime);
e9e44622
JJ		 14052 snprintf (timebuf, sizeof (timebuf),
14053 "%04u-%02u-%02uT%02u:%02u:%02u",
14054 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14055 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 14056
31104126 14057 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 14058 if (VALID_DYNAMIC_NAME (liblist.l_name))
14059 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
14060 else
2b692964 14061 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 14062 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
14063 liblist.l_version);
a6e9f9df
AM		 14064
14065 if (liblist.l_flags == 0)
2b692964 14066 puts (_(" NONE"));
a6e9f9df
AM		 14067 else
14068 {
14069 static const struct
252b5132 14070 {
2cf0635d 14071 const char * name;
a6e9f9df 14072 int bit;
252b5132 14073 }
a6e9f9df
AM		 14074 l_flags_vals[] =
14075 {
14076 { " EXACT_MATCH", LL_EXACT_MATCH },
14077 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
14078 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
14079 { " EXPORTS", LL_EXPORTS },
14080 { " DELAY_LOAD", LL_DELAY_LOAD },
14081 { " DELTA", LL_DELTA }
14082 };
14083 int flags = liblist.l_flags;
14084 size_t fcnt;
14085
60bca95a 14086 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 14087 if ((flags & l_flags_vals[fcnt].bit) != 0)
14088 {
14089 fputs (l_flags_vals[fcnt].name, stdout);
14090 flags ^= l_flags_vals[fcnt].bit;
14091 }
14092 if (flags != 0)
14093 printf (" %#x", (unsigned int) flags);
252b5132 14094
a6e9f9df
AM		 14095 puts ("");
14096 }
252b5132 14097 }
252b5132 14098
a6e9f9df
AM		 14099 free (elib);
14100 }
252b5132
RH		 14101 }
14102
14103 if (options_offset != 0)
14104 {
2cf0635d 14105 Elf_External_Options * eopt;
2cf0635d
NC		 14106 Elf_Internal_Options * iopt;
14107 Elf_Internal_Options * option;
252b5132
RH		 14108 size_t offset;
14109 int cnt;
351cdf24 14110 sect = section_headers;
252b5132
RH		 14111
14112 /* Find the section header so that we get the size. */
071436c6 14113 sect = find_section_by_type (SHT_MIPS_OPTIONS);
948f632f 14114 /* PR 17533 file: 012-277276-0.004. */
071436c6
NC		 14115 if (sect == NULL)
14116 {
14117 error (_("No MIPS_OPTIONS header found\n"));
14118 return 0;
14119 }
252b5132 14120
3f5e193b
NC		 14121 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14122 sect->sh_size, _("options"));
a6e9f9df 14123 if (eopt)
252b5132 14124 {
3f5e193b
NC		 14125 iopt = (Elf_Internal_Options *)
14126 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 14127 if (iopt == NULL)
14128 {
8b73c356 14129 error (_("Out of memory allocatinf space for MIPS options\n"));
a6e9f9df
AM		 14130 return 0;
14131 }
76da6bbe 14132
a6e9f9df
AM		 14133 offset = cnt = 0;
14134 option = iopt;
252b5132 14135
82b1b41b 14136 while (offset <= sect->sh_size - sizeof (* eopt))
a6e9f9df 14137 {
2cf0635d 14138 Elf_External_Options * eoption;
252b5132 14139
a6e9f9df 14140 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 14141
a6e9f9df
AM		 14142 option->kind = BYTE_GET (eoption->kind);
14143 option->size = BYTE_GET (eoption->size);
14144 option->section = BYTE_GET (eoption->section);
14145 option->info = BYTE_GET (eoption->info);
76da6bbe 14146
82b1b41b
NC		 14147 /* PR 17531: file: ffa0fa3b. */
14148 if (option->size < sizeof (* eopt)
14149 || offset + option->size > sect->sh_size)
14150 {
55325047
NC		 14151 error (_("Invalid size (%u) for MIPS option\n"), option->size);
14152 return 0;
82b1b41b 14153 }
a6e9f9df 14154 offset += option->size;
82b1b41b 14155
a6e9f9df
AM		 14156 ++option;
14157 ++cnt;
14158 }
252b5132 14159
a6e9f9df 14160 printf (_("\nSection '%s' contains %d entries:\n"),
74e1a04b 14161 printable_section_name (sect), cnt);
76da6bbe 14162
a6e9f9df 14163 option = iopt;
82b1b41b 14164 offset = 0;
252b5132 14165
a6e9f9df 14166 while (cnt-- > 0)
252b5132 14167 {
a6e9f9df
AM		 14168 size_t len;
14169
14170 switch (option->kind)
252b5132 14171 {
a6e9f9df
AM		 14172 case ODK_NULL:
14173 /* This shouldn't happen. */
14174 printf (" NULL %d %lx", option->section, option->info);
14175 break;
14176 case ODK_REGINFO:
14177 printf (" REGINFO ");
14178 if (elf_header.e_machine == EM_MIPS)
14179 {
14180 /* 32bit form. */
2cf0635d 14181 Elf32_External_RegInfo * ereg;
b34976b6 14182 Elf32_RegInfo reginfo;
a6e9f9df
AM		 14183
14184 ereg = (Elf32_External_RegInfo *) (option + 1);
14185 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14186 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14187 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14188 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14189 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14190 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14191
14192 printf ("GPR %08lx GP 0x%lx\n",
14193 reginfo.ri_gprmask,
14194 (unsigned long) reginfo.ri_gp_value);
14195 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14196 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14197 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14198 }
14199 else
14200 {
14201 /* 64 bit form. */
2cf0635d 14202 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 14203 Elf64_Internal_RegInfo reginfo;
14204
14205 ereg = (Elf64_External_RegInfo *) (option + 1);
14206 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14207 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14208 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14209 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14210 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 14211 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 14212
14213 printf ("GPR %08lx GP 0x",
14214 reginfo.ri_gprmask);
14215 printf_vma (reginfo.ri_gp_value);
14216 printf ("\n");
14217
14218 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14219 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14220 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14221 }
14222 ++option;
14223 continue;
14224 case ODK_EXCEPTIONS:
14225 fputs (" EXCEPTIONS fpe_min(", stdout);
14226 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14227 fputs (") fpe_max(", stdout);
14228 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14229 fputs (")", stdout);
14230
14231 if (option->info & OEX_PAGE0)
14232 fputs (" PAGE0", stdout);
14233 if (option->info & OEX_SMM)
14234 fputs (" SMM", stdout);
14235 if (option->info & OEX_FPDBUG)
14236 fputs (" FPDBUG", stdout);
14237 if (option->info & OEX_DISMISS)
14238 fputs (" DISMISS", stdout);
14239 break;
14240 case ODK_PAD:
14241 fputs (" PAD ", stdout);
14242 if (option->info & OPAD_PREFIX)
14243 fputs (" PREFIX", stdout);
14244 if (option->info & OPAD_POSTFIX)
14245 fputs (" POSTFIX", stdout);
14246 if (option->info & OPAD_SYMBOL)
14247 fputs (" SYMBOL", stdout);
14248 break;
14249 case ODK_HWPATCH:
14250 fputs (" HWPATCH ", stdout);
14251 if (option->info & OHW_R4KEOP)
14252 fputs (" R4KEOP", stdout);
14253 if (option->info & OHW_R8KPFETCH)
14254 fputs (" R8KPFETCH", stdout);
14255 if (option->info & OHW_R5KEOP)
14256 fputs (" R5KEOP", stdout);
14257 if (option->info & OHW_R5KCVTL)
14258 fputs (" R5KCVTL", stdout);
14259 break;
14260 case ODK_FILL:
14261 fputs (" FILL ", stdout);
14262 /* XXX Print content of info word? */
14263 break;
14264 case ODK_TAGS:
14265 fputs (" TAGS ", stdout);
14266 /* XXX Print content of info word? */
14267 break;
14268 case ODK_HWAND:
14269 fputs (" HWAND ", stdout);
14270 if (option->info & OHWA0_R4KEOP_CHECKED)
14271 fputs (" R4KEOP_CHECKED", stdout);
14272 if (option->info & OHWA0_R4KEOP_CLEAN)
14273 fputs (" R4KEOP_CLEAN", stdout);
14274 break;
14275 case ODK_HWOR:
14276 fputs (" HWOR ", stdout);
14277 if (option->info & OHWA0_R4KEOP_CHECKED)
14278 fputs (" R4KEOP_CHECKED", stdout);
14279 if (option->info & OHWA0_R4KEOP_CLEAN)
14280 fputs (" R4KEOP_CLEAN", stdout);
14281 break;
14282 case ODK_GP_GROUP:
14283 printf (" GP_GROUP %#06lx self-contained %#06lx",
14284 option->info & OGP_GROUP,
14285 (option->info & OGP_SELF) >> 16);
14286 break;
14287 case ODK_IDENT:
14288 printf (" IDENT %#06lx self-contained %#06lx",
14289 option->info & OGP_GROUP,
14290 (option->info & OGP_SELF) >> 16);
14291 break;
14292 default:
14293 /* This shouldn't happen. */
14294 printf (" %3d ??? %d %lx",
14295 option->kind, option->section, option->info);
14296 break;
252b5132 14297 }
a6e9f9df 14298
2cf0635d 14299 len = sizeof (* eopt);
a6e9f9df 14300 while (len < option->size)
82b1b41b
NC		 14301 {
14302 char datum = * ((char *) eopt + offset + len);
a6e9f9df 14303
82b1b41b
NC		 14304 if (ISPRINT (datum))
14305 printf ("%c", datum);
14306 else
14307 printf ("\\%03o", datum);
14308 len ++;
14309 }
a6e9f9df 14310 fputs ("\n", stdout);
82b1b41b
NC		 14311
14312 offset += option->size;
252b5132 14313 ++option;
252b5132
RH		 14314 }
14315
a6e9f9df 14316 free (eopt);
252b5132 14317 }
252b5132
RH		 14318 }
14319
14320 if (conflicts_offset != 0 && conflictsno != 0)
14321 {
2cf0635d 14322 Elf32_Conflict * iconf;
252b5132
RH		 14323 size_t cnt;
14324
14325 if (dynamic_symbols == NULL)
14326 {
591a748a 14327 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 14328 return 0;
14329 }
14330
3f5e193b 14331 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 14332 if (iconf == NULL)
14333 {
8b73c356 14334 error (_("Out of memory allocating space for dynamic conflicts\n"));
252b5132
RH		 14335 return 0;
14336 }
14337
9ea033b2 14338 if (is_32bit_elf)
252b5132 14339 {
2cf0635d 14340 Elf32_External_Conflict * econf32;
a6e9f9df 14341
3f5e193b
NC		 14342 econf32 = (Elf32_External_Conflict *)
14343 get_data (NULL, file, conflicts_offset, conflictsno,
14344 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 14345 if (!econf32)
14346 return 0;
252b5132
RH		 14347
14348 for (cnt = 0; cnt < conflictsno; ++cnt)
14349 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 14350
14351 free (econf32);
252b5132
RH		 14352 }
14353 else
14354 {
2cf0635d 14355 Elf64_External_Conflict * econf64;
a6e9f9df 14356
3f5e193b
NC		 14357 econf64 = (Elf64_External_Conflict *)
14358 get_data (NULL, file, conflicts_offset, conflictsno,
14359 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 14360 if (!econf64)
14361 return 0;
252b5132
RH		 14362
14363 for (cnt = 0; cnt < conflictsno; ++cnt)
14364 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 14365
14366 free (econf64);
252b5132
RH		 14367 }
14368
c7e7ca54
NC		 14369 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14370 (unsigned long) conflictsno);
252b5132
RH		 14371 puts (_(" Num: Index Value Name"));
14372
14373 for (cnt = 0; cnt < conflictsno; ++cnt)
14374 {
b34976b6 14375 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 14376
14377 if (iconf[cnt] >= num_dynamic_syms)
14378 printf (_("<corrupt symbol index>"));
d79b3d50 14379 else
e0a31db1
NC		 14380 {
14381 Elf_Internal_Sym * psym;
14382
14383 psym = & dynamic_symbols[iconf[cnt]];
14384 print_vma (psym->st_value, FULL_HEX);
14385 putchar (' ');
14386 if (VALID_DYNAMIC_NAME (psym->st_name))
14387 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14388 else
14389 printf (_("<corrupt: %14ld>"), psym->st_name);
14390 }
31104126 14391 putchar ('\n');
252b5132
RH		 14392 }
14393
252b5132
RH		 14394 free (iconf);
14395 }
14396
ccb4c951
RS		 14397 if (pltgot != 0 && local_gotno != 0)
14398 {
91d6fa6a 14399 bfd_vma ent, local_end, global_end;
bbeee7ea 14400 size_t i, offset;
2cf0635d 14401 unsigned char * data;
82b1b41b 14402 unsigned char * data_end;
bbeee7ea 14403 int addr_size;
ccb4c951 14404
91d6fa6a 14405 ent = pltgot;
ccb4c951
RS		 14406 addr_size = (is_32bit_elf ? 4 : 8);
14407 local_end = pltgot + local_gotno * addr_size;
ccb4c951 14408
74e1a04b
NC		 14409 /* PR binutils/17533 file: 012-111227-0.004 */
14410 if (symtabno < gotsym)
14411 {
14412 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
82b1b41b 14413 (unsigned long) gotsym, (unsigned long) symtabno);
74e1a04b
NC		 14414 return 0;
14415 }
82b1b41b 14416
74e1a04b 14417 global_end = local_end + (symtabno - gotsym) * addr_size;
82b1b41b
NC		 14418 /* PR 17531: file: 54c91a34. */
14419 if (global_end < local_end)
14420 {
14421 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14422 return 0;
14423 }
948f632f 14424
ccb4c951 14425 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 14426 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 14427 global_end - pltgot, 1,
14428 _("Global Offset Table data"));
59245841
NC		 14429 if (data == NULL)
14430 return 0;
82b1b41b 14431 data_end = data + (global_end - pltgot);
59245841 14432
ccb4c951
RS		 14433 printf (_("\nPrimary GOT:\n"));
14434 printf (_(" Canonical gp value: "));
14435 print_vma (pltgot + 0x7ff0, LONG_HEX);
14436 printf ("\n\n");
14437
14438 printf (_(" Reserved entries:\n"));
14439 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 14440 addr_size * 2, _("Address"), _("Access"),
14441 addr_size * 2, _("Initial"));
82b1b41b 14442 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14443 printf (_(" Lazy resolver\n"));
82b1b41b
NC		 14444 if (ent == (bfd_vma) -1)
14445 goto got_print_fail;
ccb4c951 14446 if (data
91d6fa6a 14447 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 14448 >> (addr_size * 8 - 1)) != 0)
14449 {
82b1b41b 14450 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14451 printf (_(" Module pointer (GNU extension)\n"));
82b1b41b
NC		 14452 if (ent == (bfd_vma) -1)
14453 goto got_print_fail;
ccb4c951
RS		 14454 }
14455 printf ("\n");
14456
91d6fa6a 14457 if (ent < local_end)
ccb4c951
RS		 14458 {
14459 printf (_(" Local entries:\n"));
cc5914eb 14460 printf (" %*s %10s %*s\n",
2b692964
NC		 14461 addr_size * 2, _("Address"), _("Access"),
14462 addr_size * 2, _("Initial"));
91d6fa6a 14463 while (ent < local_end)
ccb4c951 14464 {
82b1b41b 14465 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14466 printf ("\n");
82b1b41b
NC		 14467 if (ent == (bfd_vma) -1)
14468 goto got_print_fail;
ccb4c951
RS		 14469 }
14470 printf ("\n");
14471 }
14472
14473 if (gotsym < symtabno)
14474 {
14475 int sym_width;
14476
14477 printf (_(" Global entries:\n"));
cc5914eb 14478 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 14479 addr_size * 2, _("Address"),
14480 _("Access"),
2b692964 14481 addr_size * 2, _("Initial"),
9cf03b7e
NC		 14482 addr_size * 2, _("Sym.Val."),
14483 _("Type"),
14484 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14485 _("Ndx"), _("Name"));
0b4362b0 14486
ccb4c951 14487 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 14488
ccb4c951
RS		 14489 for (i = gotsym; i < symtabno; i++)
14490 {
82b1b41b 14491 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14492 printf (" ");
e0a31db1
NC		 14493
14494 if (dynamic_symbols == NULL)
14495 printf (_("<no dynamic symbols>"));
14496 else if (i < num_dynamic_syms)
14497 {
14498 Elf_Internal_Sym * psym = dynamic_symbols + i;
14499
14500 print_vma (psym->st_value, LONG_HEX);
14501 printf (" %-7s %3s ",
14502 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14503 get_symbol_index_type (psym->st_shndx));
14504
14505 if (VALID_DYNAMIC_NAME (psym->st_name))
14506 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14507 else
14508 printf (_("<corrupt: %14ld>"), psym->st_name);
14509 }
ccb4c951 14510 else
7fc5ac57
JBG		 14511 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14512 (unsigned long) i);
e0a31db1 14513
ccb4c951 14514 printf ("\n");
82b1b41b
NC		 14515 if (ent == (bfd_vma) -1)
14516 break;
ccb4c951
RS		 14517 }
14518 printf ("\n");
14519 }
14520
82b1b41b 14521 got_print_fail:
ccb4c951
RS		 14522 if (data)
14523 free (data);
14524 }
14525
861fb55a
DJ		 14526 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14527 {
91d6fa6a 14528 bfd_vma ent, end;
861fb55a
DJ		 14529 size_t offset, rel_offset;
14530 unsigned long count, i;
2cf0635d 14531 unsigned char * data;
861fb55a 14532 int addr_size, sym_width;
2cf0635d 14533 Elf_Internal_Rela * rels;
861fb55a
DJ		 14534
14535 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14536 if (pltrel == DT_RELA)
14537 {
14538 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14539 return 0;
14540 }
14541 else
14542 {
14543 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14544 return 0;
14545 }
14546
91d6fa6a 14547 ent = mips_pltgot;
861fb55a
DJ		 14548 addr_size = (is_32bit_elf ? 4 : 8);
14549 end = mips_pltgot + (2 + count) * addr_size;
14550
14551 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 14552 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 14553 1, _("Procedure Linkage Table data"));
59245841
NC		 14554 if (data == NULL)
14555 return 0;
14556
9cf03b7e 14557 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 14558 printf (_(" Reserved entries:\n"));
14559 printf (_(" %*s %*s Purpose\n"),
2b692964 14560 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 14561 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14562 printf (_(" PLT lazy resolver\n"));
91d6fa6a 14563 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14564 printf (_(" Module pointer\n"));
861fb55a
DJ		 14565 printf ("\n");
14566
14567 printf (_(" Entries:\n"));
cc5914eb 14568 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 14569 addr_size * 2, _("Address"),
14570 addr_size * 2, _("Initial"),
14571 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 14572 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14573 for (i = 0; i < count; i++)
14574 {
df97ab2a 14575 unsigned long idx = get_reloc_symindex (rels[i].r_info);
861fb55a 14576
91d6fa6a 14577 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 14578 printf (" ");
e0a31db1 14579
df97ab2a
MF		 14580 if (idx >= num_dynamic_syms)
14581 printf (_("<corrupt symbol index: %lu>"), idx);
861fb55a 14582 else
e0a31db1 14583 {
df97ab2a 14584 Elf_Internal_Sym * psym = dynamic_symbols + idx;
e0a31db1
NC		 14585
14586 print_vma (psym->st_value, LONG_HEX);
14587 printf (" %-7s %3s ",
14588 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14589 get_symbol_index_type (psym->st_shndx));
14590 if (VALID_DYNAMIC_NAME (psym->st_name))
14591 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14592 else
14593 printf (_("<corrupt: %14ld>"), psym->st_name);
14594 }
861fb55a
DJ		 14595 printf ("\n");
14596 }
14597 printf ("\n");
14598
14599 if (data)
14600 free (data);
14601 free (rels);
14602 }
14603
252b5132
RH		 14604 return 1;
14605}
14606
35c08157
KLC		 14607static int
14608process_nds32_specific (FILE * file)
14609{
14610 Elf_Internal_Shdr *sect = NULL;
14611
14612 sect = find_section (".nds32_e_flags");
14613 if (sect != NULL)
14614 {
14615 unsigned int *flag;
14616
14617 printf ("\nNDS32 elf flags section:\n");
14618 flag = get_data (NULL, file, sect->sh_offset, 1,
14619 sect->sh_size, _("NDS32 elf flags section"));
14620
14621 switch ((*flag) & 0x3)
14622 {
14623 case 0:
14624 printf ("(VEC_SIZE):\tNo entry.\n");
14625 break;
14626 case 1:
14627 printf ("(VEC_SIZE):\t4 bytes\n");
14628 break;
14629 case 2:
14630 printf ("(VEC_SIZE):\t16 bytes\n");
14631 break;
14632 case 3:
14633 printf ("(VEC_SIZE):\treserved\n");
14634 break;
14635 }
14636 }
14637
14638 return TRUE;
14639}
14640
047b2264 14641static int
2cf0635d 14642process_gnu_liblist (FILE * file)
047b2264 14643{
2cf0635d
NC		 14644 Elf_Internal_Shdr * section;
14645 Elf_Internal_Shdr * string_sec;
14646 Elf32_External_Lib * elib;
14647 char * strtab;
c256ffe7 14648 size_t strtab_size;
047b2264
JJ		 14649 size_t cnt;
14650 unsigned i;
14651
14652 if (! do_arch)
14653 return 0;
14654
14655 for (i = 0, section = section_headers;
14656 i < elf_header.e_shnum;
b34976b6 14657 i++, section++)
047b2264
JJ		 14658 {
14659 switch (section->sh_type)
14660 {
14661 case SHT_GNU_LIBLIST:
4fbb74a6 14662 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 14663 break;
14664
3f5e193b
NC		 14665 elib = (Elf32_External_Lib *)
14666 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 14667 _("liblist section data"));
047b2264
JJ		 14668
14669 if (elib == NULL)
14670 break;
4fbb74a6 14671 string_sec = section_headers + section->sh_link;
047b2264 14672
3f5e193b
NC		 14673 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14674 string_sec->sh_size,
14675 _("liblist string table"));
047b2264
JJ		 14676 if (strtab == NULL
14677 || section->sh_entsize != sizeof (Elf32_External_Lib))
14678 {
14679 free (elib);
2842702f 14680 free (strtab);
047b2264
JJ		 14681 break;
14682 }
59245841 14683 strtab_size = string_sec->sh_size;
047b2264
JJ		 14684
14685 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
74e1a04b 14686 printable_section_name (section),
0af1713e 14687 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 14688
2b692964 14689 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 14690
14691 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14692 ++cnt)
14693 {
14694 Elf32_Lib liblist;
91d6fa6a 14695 time_t atime;
047b2264 14696 char timebuf[20];
2cf0635d 14697 struct tm * tmp;
047b2264
JJ		 14698
14699 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14700 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 14701 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14702 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14703 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14704
91d6fa6a 14705 tmp = gmtime (&atime);
e9e44622
JJ		 14706 snprintf (timebuf, sizeof (timebuf),
14707 "%04u-%02u-%02uT%02u:%02u:%02u",
14708 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14709 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 14710
14711 printf ("%3lu: ", (unsigned long) cnt);
14712 if (do_wide)
c256ffe7 14713 printf ("%-20s", liblist.l_name < strtab_size
2b692964 14714 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 14715 else
c256ffe7 14716 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 14717 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 14718 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14719 liblist.l_version, liblist.l_flags);
14720 }
14721
14722 free (elib);
2842702f 14723 free (strtab);
047b2264
JJ		 14724 }
14725 }
14726
14727 return 1;
14728}
14729
9437c45b 14730static const char *
d3ba0551 14731get_note_type (unsigned e_type)
779fe533
NC		 14732{
14733 static char buff[64];
103f02d3 14734
1ec5cd37
NC		 14735 if (elf_header.e_type == ET_CORE)
14736 switch (e_type)
14737 {
57346661 14738 case NT_AUXV:
1ec5cd37 14739 return _("NT_AUXV (auxiliary vector)");
57346661 14740 case NT_PRSTATUS:
1ec5cd37 14741 return _("NT_PRSTATUS (prstatus structure)");
57346661 14742 case NT_FPREGSET:
1ec5cd37 14743 return _("NT_FPREGSET (floating point registers)");
57346661 14744 case NT_PRPSINFO:
1ec5cd37 14745 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 14746 case NT_TASKSTRUCT:
1ec5cd37 14747 return _("NT_TASKSTRUCT (task structure)");
57346661 14748 case NT_PRXFPREG:
1ec5cd37 14749 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 14750 case NT_PPC_VMX:
14751 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 14752 case NT_PPC_VSX:
14753 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 14754 case NT_386_TLS:
14755 return _("NT_386_TLS (x86 TLS information)");
14756 case NT_386_IOPERM:
14757 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 14758 case NT_X86_XSTATE:
14759 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 14760 case NT_S390_HIGH_GPRS:
14761 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 14762 case NT_S390_TIMER:
14763 return _("NT_S390_TIMER (s390 timer register)");
14764 case NT_S390_TODCMP:
14765 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14766 case NT_S390_TODPREG:
14767 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14768 case NT_S390_CTRS:
14769 return _("NT_S390_CTRS (s390 control registers)");
14770 case NT_S390_PREFIX:
14771 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 14772 case NT_S390_LAST_BREAK:
14773 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14774 case NT_S390_SYSTEM_CALL:
14775 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 14776 case NT_S390_TDB:
14777 return _("NT_S390_TDB (s390 transaction diagnostic block)");
4ef9f41a
AA		 14778 case NT_S390_VXRS_LOW:
14779 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
14780 case NT_S390_VXRS_HIGH:
14781 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
faa9a424
UW		 14782 case NT_ARM_VFP:
14783 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 14784 case NT_ARM_TLS:
14785 return _("NT_ARM_TLS (AArch TLS registers)");
14786 case NT_ARM_HW_BREAK:
14787 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14788 case NT_ARM_HW_WATCH:
14789 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 14790 case NT_PSTATUS:
1ec5cd37 14791 return _("NT_PSTATUS (pstatus structure)");
57346661 14792 case NT_FPREGS:
1ec5cd37 14793 return _("NT_FPREGS (floating point registers)");
57346661 14794 case NT_PSINFO:
1ec5cd37 14795 return _("NT_PSINFO (psinfo structure)");
57346661 14796 case NT_LWPSTATUS:
1ec5cd37 14797 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 14798 case NT_LWPSINFO:
1ec5cd37 14799 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 14800 case NT_WIN32PSTATUS:
1ec5cd37 14801 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 14802 case NT_SIGINFO:
14803 return _("NT_SIGINFO (siginfo_t data)");
14804 case NT_FILE:
14805 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 14806 default:
14807 break;
14808 }
14809 else
14810 switch (e_type)
14811 {
14812 case NT_VERSION:
14813 return _("NT_VERSION (version)");
14814 case NT_ARCH:
14815 return _("NT_ARCH (architecture)");
14816 default:
14817 break;
14818 }
14819
e9e44622 14820 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 14821 return buff;
779fe533
NC		 14822}
14823
9ece1fa9
TT		 14824static int
14825print_core_note (Elf_Internal_Note *pnote)
14826{
14827 unsigned int addr_size = is_32bit_elf ? 4 : 8;
14828 bfd_vma count, page_size;
14829 unsigned char *descdata, *filenames, *descend;
14830
14831 if (pnote->type != NT_FILE)
14832 return 1;
14833
14834#ifndef BFD64
14835 if (!is_32bit_elf)
14836 {
14837 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
14838 /* Still "successful". */
14839 return 1;
14840 }
14841#endif
14842
14843 if (pnote->descsz < 2 * addr_size)
14844 {
14845 printf (_(" Malformed note - too short for header\n"));
14846 return 0;
14847 }
14848
14849 descdata = (unsigned char *) pnote->descdata;
14850 descend = descdata + pnote->descsz;
14851
14852 if (descdata[pnote->descsz - 1] != '\0')
14853 {
14854 printf (_(" Malformed note - does not end with \\0\n"));
14855 return 0;
14856 }
14857
14858 count = byte_get (descdata, addr_size);
14859 descdata += addr_size;
14860
14861 page_size = byte_get (descdata, addr_size);
14862 descdata += addr_size;
14863
14864 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
14865 {
14866 printf (_(" Malformed note - too short for supplied file count\n"));
14867 return 0;
14868 }
14869
14870 printf (_(" Page size: "));
14871 print_vma (page_size, DEC);
14872 printf ("\n");
14873
14874 printf (_(" %*s%*s%*s\n"),
14875 (int) (2 + 2 * addr_size), _("Start"),
14876 (int) (4 + 2 * addr_size), _("End"),
14877 (int) (4 + 2 * addr_size), _("Page Offset"));
14878 filenames = descdata + count * 3 * addr_size;
14879 while (--count > 0)
14880 {
14881 bfd_vma start, end, file_ofs;
14882
14883 if (filenames == descend)
14884 {
14885 printf (_(" Malformed note - filenames end too early\n"));
14886 return 0;
14887 }
14888
14889 start = byte_get (descdata, addr_size);
14890 descdata += addr_size;
14891 end = byte_get (descdata, addr_size);
14892 descdata += addr_size;
14893 file_ofs = byte_get (descdata, addr_size);
14894 descdata += addr_size;
14895
14896 printf (" ");
14897 print_vma (start, FULL_HEX);
14898 printf (" ");
14899 print_vma (end, FULL_HEX);
14900 printf (" ");
14901 print_vma (file_ofs, FULL_HEX);
14902 printf ("\n %s\n", filenames);
14903
14904 filenames += 1 + strlen ((char *) filenames);
14905 }
14906
14907 return 1;
14908}
14909
1118d252
RM		 14910static const char *
14911get_gnu_elf_note_type (unsigned e_type)
14912{
14913 static char buff[64];
14914
14915 switch (e_type)
14916 {
14917 case NT_GNU_ABI_TAG:
14918 return _("NT_GNU_ABI_TAG (ABI version tag)");
14919 case NT_GNU_HWCAP:
14920 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
14921 case NT_GNU_BUILD_ID:
14922 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 14923 case NT_GNU_GOLD_VERSION:
14924 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 14925 default:
14926 break;
14927 }
14928
14929 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14930 return buff;
14931}
14932
664f90a3
TT		 14933static int
14934print_gnu_note (Elf_Internal_Note *pnote)
14935{
14936 switch (pnote->type)
14937 {
14938 case NT_GNU_BUILD_ID:
14939 {
14940 unsigned long i;
14941
14942 printf (_(" Build ID: "));
14943 for (i = 0; i < pnote->descsz; ++i)
14944 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 14945 printf ("\n");
664f90a3
TT		 14946 }
14947 break;
14948
14949 case NT_GNU_ABI_TAG:
14950 {
14951 unsigned long os, major, minor, subminor;
14952 const char *osname;
14953
3102e897
NC		 14954 /* PR 17531: file: 030-599401-0.004. */
14955 if (pnote->descsz < 16)
14956 {
14957 printf (_(" <corrupt GNU_ABI_TAG>\n"));
14958 break;
14959 }
14960
664f90a3
TT		 14961 os = byte_get ((unsigned char *) pnote->descdata, 4);
14962 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
14963 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
14964 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
14965
14966 switch (os)
14967 {
14968 case GNU_ABI_TAG_LINUX:
14969 osname = "Linux";
14970 break;
14971 case GNU_ABI_TAG_HURD:
14972 osname = "Hurd";
14973 break;
14974 case GNU_ABI_TAG_SOLARIS:
14975 osname = "Solaris";
14976 break;
14977 case GNU_ABI_TAG_FREEBSD:
14978 osname = "FreeBSD";
14979 break;
14980 case GNU_ABI_TAG_NETBSD:
14981 osname = "NetBSD";
14982 break;
14983 default:
14984 osname = "Unknown";
14985 break;
14986 }
14987
14988 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
14989 major, minor, subminor);
14990 }
14991 break;
926c5385
CC		 14992
14993 case NT_GNU_GOLD_VERSION:
14994 {
14995 unsigned long i;
14996
14997 printf (_(" Version: "));
14998 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
14999 printf ("%c", pnote->descdata[i]);
15000 printf ("\n");
15001 }
15002 break;
664f90a3
TT		 15003 }
15004
15005 return 1;
15006}
15007
685080f2
NC		 15008static const char *
15009get_v850_elf_note_type (enum v850_notes n_type)
15010{
15011 static char buff[64];
15012
15013 switch (n_type)
15014 {
15015 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
15016 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
15017 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
15018 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
15019 case V850_NOTE_CACHE_INFO: return _("Use of cache");
15020 case V850_NOTE_MMU_INFO: return _("Use of MMU");
15021 default:
15022 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
15023 return buff;
15024 }
15025}
15026
15027static int
15028print_v850_note (Elf_Internal_Note * pnote)
15029{
15030 unsigned int val;
15031
15032 if (pnote->descsz != 4)
15033 return 0;
15034 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
15035
15036 if (val == 0)
15037 {
15038 printf (_("not set\n"));
15039 return 1;
15040 }
15041
15042 switch (pnote->type)
15043 {
15044 case V850_NOTE_ALIGNMENT:
15045 switch (val)
15046 {
15047 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
15048 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
15049 }
15050 break;
15051
15052 case V850_NOTE_DATA_SIZE:
15053 switch (val)
15054 {
15055 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
15056 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
15057 }
15058 break;
15059
15060 case V850_NOTE_FPU_INFO:
15061 switch (val)
15062 {
15063 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
15064 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
15065 }
15066 break;
15067
15068 case V850_NOTE_MMU_INFO:
15069 case V850_NOTE_CACHE_INFO:
15070 case V850_NOTE_SIMD_INFO:
15071 if (val == EF_RH850_SIMD)
15072 {
15073 printf (_("yes\n"));
15074 return 1;
15075 }
15076 break;
15077
15078 default:
15079 /* An 'unknown note type' message will already have been displayed. */
15080 break;
15081 }
15082
15083 printf (_("unknown value: %x\n"), val);
15084 return 0;
15085}
15086
9437c45b 15087static const char *
d3ba0551 15088get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 15089{
15090 static char buff[64];
15091
b4db1224 15092 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 15093 {
15094 /* NetBSD core "procinfo" structure. */
15095 return _("NetBSD procinfo structure");
15096 }
15097
15098 /* As of Jan 2002 there are no other machine-independent notes
15099 defined for NetBSD core files. If the note type is less
15100 than the start of the machine-dependent note types, we don't
15101 understand it. */
15102
b4db1224 15103 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 15104 {
e9e44622 15105 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 15106 return buff;
15107 }
15108
15109 switch (elf_header.e_machine)
15110 {
15111 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15112 and PT_GETFPREGS == mach+2. */
15113
15114 case EM_OLD_ALPHA:
15115 case EM_ALPHA:
15116 case EM_SPARC:
15117 case EM_SPARC32PLUS:
15118 case EM_SPARCV9:
15119 switch (e_type)
15120 {
2b692964 15121 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 15122 return _("PT_GETREGS (reg structure)");
2b692964 15123 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 15124 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15125 default:
15126 break;
15127 }
15128 break;
15129
15130 /* On all other arch's, PT_GETREGS == mach+1 and
15131 PT_GETFPREGS == mach+3. */
15132 default:
15133 switch (e_type)
15134 {
2b692964 15135 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 15136 return _("PT_GETREGS (reg structure)");
2b692964 15137 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 15138 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15139 default:
15140 break;
15141 }
15142 }
15143
9cf03b7e 15144 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 15145 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 15146 return buff;
15147}
15148
70616151
TT		 15149static const char *
15150get_stapsdt_note_type (unsigned e_type)
15151{
15152 static char buff[64];
15153
15154 switch (e_type)
15155 {
15156 case NT_STAPSDT:
15157 return _("NT_STAPSDT (SystemTap probe descriptors)");
15158
15159 default:
15160 break;
15161 }
15162
15163 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15164 return buff;
15165}
15166
c6a9fc58
TT		 15167static int
15168print_stapsdt_note (Elf_Internal_Note *pnote)
15169{
15170 int addr_size = is_32bit_elf ? 4 : 8;
15171 char *data = pnote->descdata;
15172 char *data_end = pnote->descdata + pnote->descsz;
15173 bfd_vma pc, base_addr, semaphore;
15174 char *provider, *probe, *arg_fmt;
15175
15176 pc = byte_get ((unsigned char *) data, addr_size);
15177 data += addr_size;
15178 base_addr = byte_get ((unsigned char *) data, addr_size);
15179 data += addr_size;
15180 semaphore = byte_get ((unsigned char *) data, addr_size);
15181 data += addr_size;
15182
15183 provider = data;
15184 data += strlen (data) + 1;
15185 probe = data;
15186 data += strlen (data) + 1;
15187 arg_fmt = data;
15188 data += strlen (data) + 1;
15189
15190 printf (_(" Provider: %s\n"), provider);
15191 printf (_(" Name: %s\n"), probe);
15192 printf (_(" Location: "));
15193 print_vma (pc, FULL_HEX);
15194 printf (_(", Base: "));
15195 print_vma (base_addr, FULL_HEX);
15196 printf (_(", Semaphore: "));
15197 print_vma (semaphore, FULL_HEX);
9cf03b7e 15198 printf ("\n");
c6a9fc58
TT		 15199 printf (_(" Arguments: %s\n"), arg_fmt);
15200
15201 return data == data_end;
15202}
15203
00e98fc7
TG		 15204static const char *
15205get_ia64_vms_note_type (unsigned e_type)
15206{
15207 static char buff[64];
15208
15209 switch (e_type)
15210 {
15211 case NT_VMS_MHD:
15212 return _("NT_VMS_MHD (module header)");
15213 case NT_VMS_LNM:
15214 return _("NT_VMS_LNM (language name)");
15215 case NT_VMS_SRC:
15216 return _("NT_VMS_SRC (source files)");
15217 case NT_VMS_TITLE:
9cf03b7e 15218 return "NT_VMS_TITLE";
00e98fc7
TG		 15219 case NT_VMS_EIDC:
15220 return _("NT_VMS_EIDC (consistency check)");
15221 case NT_VMS_FPMODE:
15222 return _("NT_VMS_FPMODE (FP mode)");
15223 case NT_VMS_LINKTIME:
9cf03b7e 15224 return "NT_VMS_LINKTIME";
00e98fc7
TG		 15225 case NT_VMS_IMGNAM:
15226 return _("NT_VMS_IMGNAM (image name)");
15227 case NT_VMS_IMGID:
15228 return _("NT_VMS_IMGID (image id)");
15229 case NT_VMS_LINKID:
15230 return _("NT_VMS_LINKID (link id)");
15231 case NT_VMS_IMGBID:
15232 return _("NT_VMS_IMGBID (build id)");
15233 case NT_VMS_GSTNAM:
15234 return _("NT_VMS_GSTNAM (sym table name)");
15235 case NT_VMS_ORIG_DYN:
9cf03b7e 15236 return "NT_VMS_ORIG_DYN";
00e98fc7 15237 case NT_VMS_PATCHTIME:
9cf03b7e 15238 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 15239 default:
15240 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15241 return buff;
15242 }
15243}
15244
15245static int
15246print_ia64_vms_note (Elf_Internal_Note * pnote)
15247{
15248 switch (pnote->type)
15249 {
15250 case NT_VMS_MHD:
15251 if (pnote->descsz > 36)
15252 {
15253 size_t l = strlen (pnote->descdata + 34);
15254 printf (_(" Creation date : %.17s\n"), pnote->descdata);
15255 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
15256 printf (_(" Module name : %s\n"), pnote->descdata + 34);
15257 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
15258 }
15259 else
15260 printf (_(" Invalid size\n"));
15261 break;
15262 case NT_VMS_LNM:
15263 printf (_(" Language: %s\n"), pnote->descdata);
15264 break;
15265#ifdef BFD64
15266 case NT_VMS_FPMODE:
9cf03b7e 15267 printf (_(" Floating Point mode: "));
4a5cb34f 15268 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15269 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
00e98fc7
TG		 15270 break;
15271 case NT_VMS_LINKTIME:
15272 printf (_(" Link time: "));
15273 print_vms_time
15274 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15275 printf ("\n");
15276 break;
15277 case NT_VMS_PATCHTIME:
15278 printf (_(" Patch time: "));
15279 print_vms_time
15280 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15281 printf ("\n");
15282 break;
15283 case NT_VMS_ORIG_DYN:
15284 printf (_(" Major id: %u, minor id: %u\n"),
15285 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15286 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 15287 printf (_(" Last modified : "));
00e98fc7
TG		 15288 print_vms_time
15289 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 15290 printf (_("\n Link flags : "));
4a5cb34f 15291 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15292 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
00e98fc7 15293 printf (_(" Header flags: 0x%08x\n"),
948f632f 15294 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
00e98fc7
TG		 15295 printf (_(" Image id : %s\n"), pnote->descdata + 32);
15296 break;
15297#endif
15298 case NT_VMS_IMGNAM:
15299 printf (_(" Image name: %s\n"), pnote->descdata);
15300 break;
15301 case NT_VMS_GSTNAM:
15302 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
15303 break;
15304 case NT_VMS_IMGID:
15305 printf (_(" Image id: %s\n"), pnote->descdata);
15306 break;
15307 case NT_VMS_LINKID:
15308 printf (_(" Linker id: %s\n"), pnote->descdata);
15309 break;
15310 default:
15311 break;
15312 }
15313 return 1;
15314}
15315
6d118b09
NC		 15316/* Note that by the ELF standard, the name field is already null byte
15317 terminated, and namesz includes the terminating null byte.
15318 I.E. the value of namesz for the name "FSF" is 4.
15319
e3c8793a 15320 If the value of namesz is zero, there is no name present. */
779fe533 15321static int
2cf0635d 15322process_note (Elf_Internal_Note * pnote)
779fe533 15323{
2cf0635d
NC		 15324 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15325 const char * nt;
9437c45b
JT		 15326
15327 if (pnote->namesz == 0)
1ec5cd37
NC		 15328 /* If there is no note name, then use the default set of
15329 note type strings. */
15330 nt = get_note_type (pnote->type);
15331
1118d252
RM		 15332 else if (const_strneq (pnote->namedata, "GNU"))
15333 /* GNU-specific object file notes. */
15334 nt = get_gnu_elf_note_type (pnote->type);
15335
0112cd26 15336 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 15337 /* NetBSD-specific core file notes. */
15338 nt = get_netbsd_elfcore_note_type (pnote->type);
15339
b15fa79e
AM		 15340 else if (strneq (pnote->namedata, "SPU/", 4))
15341 {
15342 /* SPU-specific core file notes. */
15343 nt = pnote->namedata + 4;
15344 name = "SPU";
15345 }
15346
00e98fc7
TG		 15347 else if (const_strneq (pnote->namedata, "IPF/VMS"))
15348 /* VMS/ia64-specific file notes. */
15349 nt = get_ia64_vms_note_type (pnote->type);
15350
70616151
TT		 15351 else if (const_strneq (pnote->namedata, "stapsdt"))
15352 nt = get_stapsdt_note_type (pnote->type);
15353
9437c45b 15354 else
1ec5cd37
NC		 15355 /* Don't recognize this note name; just use the default set of
15356 note type strings. */
00e98fc7 15357 nt = get_note_type (pnote->type);
9437c45b 15358
2aee03ae 15359 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 15360
15361 if (const_strneq (pnote->namedata, "IPF/VMS"))
15362 return print_ia64_vms_note (pnote);
664f90a3
TT		 15363 else if (const_strneq (pnote->namedata, "GNU"))
15364 return print_gnu_note (pnote);
c6a9fc58
TT		 15365 else if (const_strneq (pnote->namedata, "stapsdt"))
15366 return print_stapsdt_note (pnote);
9ece1fa9
TT		 15367 else if (const_strneq (pnote->namedata, "CORE"))
15368 return print_core_note (pnote);
00e98fc7
TG		 15369 else
15370 return 1;
779fe533
NC		 15371}
15372
6d118b09 15373
779fe533 15374static int
2cf0635d 15375process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 15376{
2cf0635d
NC		 15377 Elf_External_Note * pnotes;
15378 Elf_External_Note * external;
c8071705 15379 char * end;
b34976b6 15380 int res = 1;
103f02d3 15381
779fe533
NC		 15382 if (length <= 0)
15383 return 0;
103f02d3 15384
3f5e193b 15385 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 15386 _("notes"));
dd24e3da 15387 if (pnotes == NULL)
a6e9f9df 15388 return 0;
779fe533 15389
103f02d3 15390 external = pnotes;
103f02d3 15391
9dd3a467 15392 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 15393 (unsigned long) offset, (unsigned long) length);
2aee03ae 15394 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 15395
c8071705
NC		 15396 end = (char *) pnotes + length;
15397 while ((char *) external < end)
779fe533 15398 {
b34976b6 15399 Elf_Internal_Note inote;
15b42fb0
AM		 15400 size_t min_notesz;
15401 char *next;
2cf0635d 15402 char * temp = NULL;
c8071705 15403 size_t data_remaining = end - (char *) external;
6d118b09 15404
00e98fc7 15405 if (!is_ia64_vms ())
15b42fb0 15406 {
9dd3a467
NC		 15407 /* PR binutils/15191
15408 Make sure that there is enough data to read. */
15b42fb0
AM		 15409 min_notesz = offsetof (Elf_External_Note, name);
15410 if (data_remaining < min_notesz)
9dd3a467
NC		 15411 {
15412 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15413 (int) data_remaining);
15414 break;
15415 }
15b42fb0
AM		 15416 inote.type = BYTE_GET (external->type);
15417 inote.namesz = BYTE_GET (external->namesz);
15418 inote.namedata = external->name;
15419 inote.descsz = BYTE_GET (external->descsz);
15420 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
834f871c 15421 /* PR 17531: file: 3443835e. */
c8071705 15422 if (inote.descdata < (char *) pnotes || inote.descdata > end)
834f871c
NC		 15423 {
15424 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15425 inote.descdata = inote.namedata;
15426 inote.namesz = 0;
15427 }
c8071705 15428
15b42fb0
AM		 15429 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15430 next = inote.descdata + align_power (inote.descsz, 2);
15431 }
00e98fc7 15432 else
15b42fb0
AM		 15433 {
15434 Elf64_External_VMS_Note *vms_external;
00e98fc7 15435
9dd3a467
NC		 15436 /* PR binutils/15191
15437 Make sure that there is enough data to read. */
15b42fb0
AM		 15438 min_notesz = offsetof (Elf64_External_VMS_Note, name);
15439 if (data_remaining < min_notesz)
9dd3a467
NC		 15440 {
15441 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15442 (int) data_remaining);
15443 break;
15444 }
3e55a963 15445
15b42fb0
AM		 15446 vms_external = (Elf64_External_VMS_Note *) external;
15447 inote.type = BYTE_GET (vms_external->type);
15448 inote.namesz = BYTE_GET (vms_external->namesz);
15449 inote.namedata = vms_external->name;
15450 inote.descsz = BYTE_GET (vms_external->descsz);
15451 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15452 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15453 next = inote.descdata + align_power (inote.descsz, 3);
15454 }
15455
15456 if (inote.descdata < (char *) external + min_notesz
15457 || next < (char *) external + min_notesz
5d921cbd
NC		 15458 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15459 || inote.namedata + inote.namesz < inote.namedata
15460 || inote.descdata + inote.descsz < inote.descdata
15b42fb0 15461 || data_remaining < (size_t)(next - (char *) external))
3e55a963 15462 {
15b42fb0 15463 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 15464 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 15465 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 15466 inote.type, inote.namesz, inote.descsz);
15467 break;
15468 }
15469
15b42fb0 15470 external = (Elf_External_Note *) next;
dd24e3da 15471
6d118b09
NC		 15472 /* Verify that name is null terminated. It appears that at least
15473 one version of Linux (RedHat 6.0) generates corefiles that don't
15474 comply with the ELF spec by failing to include the null byte in
15475 namesz. */
8b971f9f 15476 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 15477 {
3f5e193b 15478 temp = (char *) malloc (inote.namesz + 1);
6d118b09
NC		 15479 if (temp == NULL)
15480 {
8b73c356 15481 error (_("Out of memory allocating space for inote name\n"));
6d118b09
NC		 15482 res = 0;
15483 break;
15484 }
76da6bbe 15485
6d118b09
NC		 15486 strncpy (temp, inote.namedata, inote.namesz);
15487 temp[inote.namesz] = 0;
76da6bbe 15488
6d118b09
NC		 15489 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15490 inote.namedata = temp;
15491 }
15492
15493 res &= process_note (& inote);
103f02d3 15494
6d118b09
NC		 15495 if (temp != NULL)
15496 {
15497 free (temp);
15498 temp = NULL;
15499 }
779fe533
NC		 15500 }
15501
15502 free (pnotes);
103f02d3 15503
779fe533
NC		 15504 return res;
15505}
15506
15507static int
2cf0635d 15508process_corefile_note_segments (FILE * file)
779fe533 15509{
2cf0635d 15510 Elf_Internal_Phdr * segment;
b34976b6
AM		 15511 unsigned int i;
15512 int res = 1;
103f02d3 15513
d93f0186 15514 if (! get_program_headers (file))
779fe533 15515 return 0;
103f02d3 15516
779fe533
NC		 15517 for (i = 0, segment = program_headers;
15518 i < elf_header.e_phnum;
b34976b6 15519 i++, segment++)
779fe533
NC		 15520 {
15521 if (segment->p_type == PT_NOTE)
103f02d3 15522 res &= process_corefile_note_segment (file,
30800947
NC		 15523 (bfd_vma) segment->p_offset,
15524 (bfd_vma) segment->p_filesz);
779fe533 15525 }
103f02d3 15526
779fe533
NC		 15527 return res;
15528}
15529
685080f2
NC		 15530static int
15531process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
15532{
15533 Elf_External_Note * pnotes;
15534 Elf_External_Note * external;
c8071705 15535 char * end;
685080f2
NC		 15536 int res = 1;
15537
15538 if (length <= 0)
15539 return 0;
15540
15541 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15542 _("v850 notes"));
15543 if (pnotes == NULL)
15544 return 0;
15545
15546 external = pnotes;
c8071705 15547 end = (char*) pnotes + length;
685080f2
NC		 15548
15549 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15550 (unsigned long) offset, (unsigned long) length);
15551
c8071705 15552 while ((char *) external + sizeof (Elf_External_Note) < end)
685080f2
NC		 15553 {
15554 Elf_External_Note * next;
15555 Elf_Internal_Note inote;
15556
15557 inote.type = BYTE_GET (external->type);
15558 inote.namesz = BYTE_GET (external->namesz);
15559 inote.namedata = external->name;
15560 inote.descsz = BYTE_GET (external->descsz);
15561 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15562 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15563
c8071705
NC		 15564 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
15565 {
15566 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15567 inote.descdata = inote.namedata;
15568 inote.namesz = 0;
15569 }
15570
685080f2
NC		 15571 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
15572
c8071705 15573 if ( ((char *) next > end)
685080f2
NC		 15574 || ((char *) next < (char *) pnotes))
15575 {
15576 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15577 (unsigned long) ((char *) external - (char *) pnotes));
15578 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15579 inote.type, inote.namesz, inote.descsz);
15580 break;
15581 }
15582
15583 external = next;
15584
15585 /* Prevent out-of-bounds indexing. */
c8071705 15586 if ( inote.namedata + inote.namesz > end
685080f2
NC		 15587 || inote.namedata + inote.namesz < inote.namedata)
15588 {
15589 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15590 (unsigned long) ((char *) external - (char *) pnotes));
15591 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15592 inote.type, inote.namesz, inote.descsz);
15593 break;
15594 }
15595
15596 printf (" %s: ", get_v850_elf_note_type (inote.type));
15597
15598 if (! print_v850_note (& inote))
15599 {
15600 res = 0;
15601 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15602 inote.namesz, inote.descsz);
15603 }
15604 }
15605
15606 free (pnotes);
15607
15608 return res;
15609}
15610
779fe533 15611static int
2cf0635d 15612process_note_sections (FILE * file)
1ec5cd37 15613{
2cf0635d 15614 Elf_Internal_Shdr * section;
1ec5cd37 15615 unsigned long i;
df565f32 15616 int n = 0;
1ec5cd37
NC		 15617 int res = 1;
15618
15619 for (i = 0, section = section_headers;
fa1908fd 15620 i < elf_header.e_shnum && section != NULL;
1ec5cd37 15621 i++, section++)
685080f2
NC		 15622 {
15623 if (section->sh_type == SHT_NOTE)
15624 {
15625 res &= process_corefile_note_segment (file,
15626 (bfd_vma) section->sh_offset,
15627 (bfd_vma) section->sh_size);
15628 n++;
15629 }
15630
15631 if (( elf_header.e_machine == EM_V800
15632 || elf_header.e_machine == EM_V850
15633 || elf_header.e_machine == EM_CYGNUS_V850)
15634 && section->sh_type == SHT_RENESAS_INFO)
15635 {
15636 res &= process_v850_notes (file,
15637 (bfd_vma) section->sh_offset,
15638 (bfd_vma) section->sh_size);
15639 n++;
15640 }
15641 }
df565f32
NC		 15642
15643 if (n == 0)
15644 /* Try processing NOTE segments instead. */
15645 return process_corefile_note_segments (file);
1ec5cd37
NC		 15646
15647 return res;
15648}
15649
15650static int
2cf0635d 15651process_notes (FILE * file)
779fe533
NC		 15652{
15653 /* If we have not been asked to display the notes then do nothing. */
15654 if (! do_notes)
15655 return 1;
103f02d3 15656
779fe533 15657 if (elf_header.e_type != ET_CORE)
1ec5cd37 15658 return process_note_sections (file);
103f02d3 15659
779fe533 15660 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 15661 if (elf_header.e_phnum > 0)
15662 return process_corefile_note_segments (file);
779fe533 15663
1ec5cd37
NC		 15664 printf (_("No note segments present in the core file.\n"));
15665 return 1;
779fe533
NC		 15666}
15667
252b5132 15668static int
2cf0635d 15669process_arch_specific (FILE * file)
252b5132 15670{
a952a375
NC		 15671 if (! do_arch)
15672 return 1;
15673
252b5132
RH		 15674 switch (elf_header.e_machine)
15675 {
11c1ff18
PB		 15676 case EM_ARM:
15677 return process_arm_specific (file);
252b5132 15678 case EM_MIPS:
4fe85591 15679 case EM_MIPS_RS3_LE:
252b5132
RH		 15680 return process_mips_specific (file);
15681 break;
35c08157
KLC		 15682 case EM_NDS32:
15683 return process_nds32_specific (file);
15684 break;
34c8bcba
JM		 15685 case EM_PPC:
15686 return process_power_specific (file);
15687 break;
643f7afb
AK		 15688 case EM_S390:
15689 case EM_S390_OLD:
15690 return process_s390_specific (file);
15691 break;
9e8c70f9
DM		 15692 case EM_SPARC:
15693 case EM_SPARC32PLUS:
15694 case EM_SPARCV9:
15695 return process_sparc_specific (file);
15696 break;
59e6276b
JM		 15697 case EM_TI_C6000:
15698 return process_tic6x_specific (file);
15699 break;
13761a11
NC		 15700 case EM_MSP430:
15701 return process_msp430x_specific (file);
252b5132
RH		 15702 default:
15703 break;
15704 }
15705 return 1;
15706}
15707
15708static int
2cf0635d 15709get_file_header (FILE * file)
252b5132 15710{
9ea033b2
NC		 15711 /* Read in the identity array. */
15712 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 15713 return 0;
15714
9ea033b2 15715 /* Determine how to read the rest of the header. */
b34976b6 15716 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 15717 {
15718 default: /* fall through */
15719 case ELFDATANONE: /* fall through */
adab8cdc
AO		 15720 case ELFDATA2LSB:
15721 byte_get = byte_get_little_endian;
15722 byte_put = byte_put_little_endian;
15723 break;
15724 case ELFDATA2MSB:
15725 byte_get = byte_get_big_endian;
15726 byte_put = byte_put_big_endian;
15727 break;
9ea033b2
NC		 15728 }
15729
15730 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 15731 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 15732
15733 /* Read in the rest of the header. */
15734 if (is_32bit_elf)
15735 {
15736 Elf32_External_Ehdr ehdr32;
252b5132 15737
9ea033b2
NC		 15738 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
15739 return 0;
103f02d3 15740
9ea033b2
NC		 15741 elf_header.e_type = BYTE_GET (ehdr32.e_type);
15742 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
15743 elf_header.e_version = BYTE_GET (ehdr32.e_version);
15744 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
15745 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
15746 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
15747 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
15748 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
15749 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
15750 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
15751 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
15752 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
15753 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
15754 }
252b5132 15755 else
9ea033b2
NC		 15756 {
15757 Elf64_External_Ehdr ehdr64;
a952a375
NC		 15758
15759 /* If we have been compiled with sizeof (bfd_vma) == 4, then
15760 we will not be able to cope with the 64bit data found in
15761 64 ELF files. Detect this now and abort before we start
50c2245b 15762 overwriting things. */
a952a375
NC		 15763 if (sizeof (bfd_vma) < 8)
15764 {
e3c8793a
NC		 15765 error (_("This instance of readelf has been built without support for a\n\
1576664 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 15767 return 0;
15768 }
103f02d3 15769
9ea033b2
NC		 15770 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
15771 return 0;
103f02d3 15772
9ea033b2
NC		 15773 elf_header.e_type = BYTE_GET (ehdr64.e_type);
15774 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
15775 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 15776 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
15777 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
15778 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 15779 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
15780 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
15781 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
15782 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
15783 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
15784 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
15785 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
15786 }
252b5132 15787
7ece0d85
JJ		 15788 if (elf_header.e_shoff)
15789 {
15790 /* There may be some extensions in the first section header. Don't
15791 bomb if we can't read it. */
15792 if (is_32bit_elf)
049b0c3a 15793 get_32bit_section_headers (file, TRUE);
7ece0d85 15794 else
049b0c3a 15795 get_64bit_section_headers (file, TRUE);
7ece0d85 15796 }
560f3c1c 15797
252b5132
RH		 15798 return 1;
15799}
15800
fb52b2f4
NC		 15801/* Process one ELF object file according to the command line options.
15802 This file may actually be stored in an archive. The file is
15803 positioned at the start of the ELF object. */
15804
ff78d6d6 15805static int
2cf0635d 15806process_object (char * file_name, FILE * file)
252b5132 15807{
252b5132
RH		 15808 unsigned int i;
15809
252b5132
RH		 15810 if (! get_file_header (file))
15811 {
15812 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 15813 return 1;
252b5132
RH		 15814 }
15815
15816 /* Initialise per file variables. */
60bca95a 15817 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 15818 version_info[i] = 0;
15819
60bca95a 15820 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 15821 dynamic_info[i] = 0;
5115b233 15822 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 15823
15824 /* Process the file. */
15825 if (show_name)
15826 printf (_("\nFile: %s\n"), file_name);
15827
18bd398b
NC		 15828 /* Initialise the dump_sects array from the cmdline_dump_sects array.
15829 Note we do this even if cmdline_dump_sects is empty because we
15830 must make sure that the dump_sets array is zeroed out before each
15831 object file is processed. */
15832 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 15833 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 15834
15835 if (num_cmdline_dump_sects > 0)
15836 {
15837 if (num_dump_sects == 0)
15838 /* A sneaky way of allocating the dump_sects array. */
09c11c86 15839 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 15840
15841 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 15842 memcpy (dump_sects, cmdline_dump_sects,
15843 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 15844 }
d70c5fc7 15845
252b5132 15846 if (! process_file_header ())
fb52b2f4 15847 return 1;
252b5132 15848
d1f5c6e3 15849 if (! process_section_headers (file))
2f62977e 15850 {
d1f5c6e3
L		 15851 /* Without loaded section headers we cannot process lots of
15852 things. */
2f62977e 15853 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 15854
2f62977e 15855 if (! do_using_dynamic)
2c610e4b 15856 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 15857 }
252b5132 15858
d1f5c6e3
L		 15859 if (! process_section_groups (file))
15860 {
15861 /* Without loaded section groups we cannot process unwind. */
15862 do_unwind = 0;
15863 }
15864
2f62977e 15865 if (process_program_headers (file))
b2d38a17 15866 process_dynamic_section (file);
252b5132
RH		 15867
15868 process_relocs (file);
15869
4d6ed7c8
NC		 15870 process_unwind (file);
15871
252b5132
RH		 15872 process_symbol_table (file);
15873
15874 process_syminfo (file);
15875
15876 process_version_sections (file);
15877
15878 process_section_contents (file);
f5842774 15879
1ec5cd37 15880 process_notes (file);
103f02d3 15881
047b2264
JJ		 15882 process_gnu_liblist (file);
15883
252b5132
RH		 15884 process_arch_specific (file);
15885
d93f0186
NC		 15886 if (program_headers)
15887 {
15888 free (program_headers);
15889 program_headers = NULL;
15890 }
15891
252b5132
RH		 15892 if (section_headers)
15893 {
15894 free (section_headers);
15895 section_headers = NULL;
15896 }
15897
15898 if (string_table)
15899 {
15900 free (string_table);
15901 string_table = NULL;
d40ac9bd 15902 string_table_length = 0;
252b5132
RH		 15903 }
15904
15905 if (dynamic_strings)
15906 {
15907 free (dynamic_strings);
15908 dynamic_strings = NULL;
d79b3d50 15909 dynamic_strings_length = 0;
252b5132
RH		 15910 }
15911
15912 if (dynamic_symbols)
15913 {
15914 free (dynamic_symbols);
15915 dynamic_symbols = NULL;
19936277 15916 num_dynamic_syms = 0;
252b5132
RH		 15917 }
15918
15919 if (dynamic_syminfo)
15920 {
15921 free (dynamic_syminfo);
15922 dynamic_syminfo = NULL;
15923 }
ff78d6d6 15924
293c573e
MR		 15925 if (dynamic_section)
15926 {
15927 free (dynamic_section);
15928 dynamic_section = NULL;
15929 }
15930
e4b17d5c
L		 15931 if (section_headers_groups)
15932 {
15933 free (section_headers_groups);
15934 section_headers_groups = NULL;
15935 }
15936
15937 if (section_groups)
15938 {
2cf0635d
NC		 15939 struct group_list * g;
15940 struct group_list * next;
e4b17d5c
L		 15941
15942 for (i = 0; i < group_count; i++)
15943 {
15944 for (g = section_groups [i].root; g != NULL; g = next)
15945 {
15946 next = g->next;
15947 free (g);
15948 }
15949 }
15950
15951 free (section_groups);
15952 section_groups = NULL;
15953 }
15954
19e6b90e 15955 free_debug_memory ();
18bd398b 15956
ff78d6d6 15957 return 0;
252b5132
RH		 15958}
15959
2cf0635d
NC		 15960/* Process an ELF archive.
15961 On entry the file is positioned just after the ARMAG string. */
15962
15963static int
15964process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
15965{
15966 struct archive_info arch;
15967 struct archive_info nested_arch;
15968 size_t got;
2cf0635d
NC		 15969 int ret;
15970
15971 show_name = 1;
15972
15973 /* The ARCH structure is used to hold information about this archive. */
15974 arch.file_name = NULL;
15975 arch.file = NULL;
15976 arch.index_array = NULL;
15977 arch.sym_table = NULL;
15978 arch.longnames = NULL;
15979
15980 /* The NESTED_ARCH structure is used as a single-item cache of information
15981 about a nested archive (when members of a thin archive reside within
15982 another regular archive file). */
15983 nested_arch.file_name = NULL;
15984 nested_arch.file = NULL;
15985 nested_arch.index_array = NULL;
15986 nested_arch.sym_table = NULL;
15987 nested_arch.longnames = NULL;
15988
15989 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
15990 {
15991 ret = 1;
15992 goto out;
4145f1d5 15993 }
fb52b2f4 15994
4145f1d5
NC		 15995 if (do_archive_index)
15996 {
2cf0635d 15997 if (arch.sym_table == NULL)
4145f1d5
NC		 15998 error (_("%s: unable to dump the index as none was found\n"), file_name);
15999 else
16000 {
591f7597 16001 unsigned long i, l;
4145f1d5
NC		 16002 unsigned long current_pos;
16003
591f7597
NC		 16004 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16005 file_name, (unsigned long) arch.index_num, arch.sym_size);
4145f1d5
NC		 16006 current_pos = ftell (file);
16007
2cf0635d 16008 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 16009 {
2cf0635d
NC		 16010 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
16011 {
16012 char * member_name;
4145f1d5 16013
2cf0635d
NC		 16014 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
16015
16016 if (member_name != NULL)
16017 {
16018 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
16019
16020 if (qualified_name != NULL)
16021 {
c2a7d3f5
NC		 16022 printf (_("Contents of binary %s at offset "), qualified_name);
16023 (void) print_vma (arch.index_array[i], PREFIX_HEX);
16024 putchar ('\n');
2cf0635d
NC		 16025 free (qualified_name);
16026 }
4145f1d5
NC		 16027 }
16028 }
2cf0635d
NC		 16029
16030 if (l >= arch.sym_size)
4145f1d5
NC		 16031 {
16032 error (_("%s: end of the symbol table reached before the end of the index\n"),
16033 file_name);
cb8f3167 16034 break;
4145f1d5 16035 }
591f7597
NC		 16036 /* PR 17531: file: 0b6630b2. */
16037 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
16038 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
4145f1d5
NC		 16039 }
16040
c2a7d3f5
NC		 16041 if (arch.uses_64bit_indicies)
16042 l = (l + 7) & ~ 7;
16043 else
16044 l += l & 1;
16045
2cf0635d 16046 if (l < arch.sym_size)
c2a7d3f5
NC		 16047 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16048 file_name, arch.sym_size - l);
4145f1d5 16049
4145f1d5
NC		 16050 if (fseek (file, current_pos, SEEK_SET) != 0)
16051 {
16052 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 16053 ret = 1;
16054 goto out;
4145f1d5 16055 }
fb52b2f4 16056 }
4145f1d5
NC		 16057
16058 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
16059 && !do_segments && !do_header && !do_dump && !do_version
16060 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 16061 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 16062 {
16063 ret = 0; /* Archive index only. */
16064 goto out;
16065 }
fb52b2f4
NC		 16066 }
16067
d989285c 16068 ret = 0;
fb52b2f4
NC		 16069
16070 while (1)
16071 {
2cf0635d
NC		 16072 char * name;
16073 size_t namelen;
16074 char * qualified_name;
16075
16076 /* Read the next archive header. */
16077 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
16078 {
16079 error (_("%s: failed to seek to next archive header\n"), file_name);
16080 return 1;
16081 }
16082 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
16083 if (got != sizeof arch.arhdr)
16084 {
16085 if (got == 0)
16086 break;
16087 error (_("%s: failed to read archive header\n"), file_name);
16088 ret = 1;
16089 break;
16090 }
16091 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
16092 {
16093 error (_("%s: did not find a valid archive header\n"), arch.file_name);
16094 ret = 1;
16095 break;
16096 }
16097
16098 arch.next_arhdr_offset += sizeof arch.arhdr;
16099
16100 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
16101 if (archive_file_size & 01)
16102 ++archive_file_size;
16103
16104 name = get_archive_member_name (&arch, &nested_arch);
16105 if (name == NULL)
fb52b2f4 16106 {
0fd3a477 16107 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16108 ret = 1;
16109 break;
fb52b2f4 16110 }
2cf0635d 16111 namelen = strlen (name);
fb52b2f4 16112
2cf0635d
NC		 16113 qualified_name = make_qualified_name (&arch, &nested_arch, name);
16114 if (qualified_name == NULL)
fb52b2f4 16115 {
2cf0635d 16116 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16117 ret = 1;
16118 break;
fb52b2f4
NC		 16119 }
16120
2cf0635d
NC		 16121 if (is_thin_archive && arch.nested_member_origin == 0)
16122 {
16123 /* This is a proxy for an external member of a thin archive. */
16124 FILE * member_file;
16125 char * member_file_name = adjust_relative_path (file_name, name, namelen);
16126 if (member_file_name == NULL)
16127 {
16128 ret = 1;
16129 break;
16130 }
16131
16132 member_file = fopen (member_file_name, "rb");
16133 if (member_file == NULL)
16134 {
16135 error (_("Input file '%s' is not readable.\n"), member_file_name);
16136 free (member_file_name);
16137 ret = 1;
16138 break;
16139 }
16140
16141 archive_file_offset = arch.nested_member_origin;
16142
16143 ret |= process_object (qualified_name, member_file);
16144
16145 fclose (member_file);
16146 free (member_file_name);
16147 }
16148 else if (is_thin_archive)
16149 {
a043396b
NC		 16150 /* PR 15140: Allow for corrupt thin archives. */
16151 if (nested_arch.file == NULL)
16152 {
16153 error (_("%s: contains corrupt thin archive: %s\n"),
16154 file_name, name);
16155 ret = 1;
16156 break;
16157 }
16158
2cf0635d
NC		 16159 /* This is a proxy for a member of a nested archive. */
16160 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
16161
16162 /* The nested archive file will have been opened and setup by
16163 get_archive_member_name. */
16164 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
16165 {
16166 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
16167 ret = 1;
16168 break;
16169 }
16170
16171 ret |= process_object (qualified_name, nested_arch.file);
16172 }
16173 else
16174 {
16175 archive_file_offset = arch.next_arhdr_offset;
16176 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 16177
2cf0635d
NC		 16178 ret |= process_object (qualified_name, file);
16179 }
fb52b2f4 16180
2b52916e
L		 16181 if (dump_sects != NULL)
16182 {
16183 free (dump_sects);
16184 dump_sects = NULL;
16185 num_dump_sects = 0;
16186 }
16187
2cf0635d 16188 free (qualified_name);
fb52b2f4
NC		 16189 }
16190
4145f1d5 16191 out:
2cf0635d
NC		 16192 if (nested_arch.file != NULL)
16193 fclose (nested_arch.file);
16194 release_archive (&nested_arch);
16195 release_archive (&arch);
fb52b2f4 16196
d989285c 16197 return ret;
fb52b2f4
NC		 16198}
16199
16200static int
2cf0635d 16201process_file (char * file_name)
fb52b2f4 16202{
2cf0635d 16203 FILE * file;
fb52b2f4
NC		 16204 struct stat statbuf;
16205 char armag[SARMAG];
16206 int ret;
16207
16208 if (stat (file_name, &statbuf) < 0)
16209 {
f24ddbdd
NC		 16210 if (errno == ENOENT)
16211 error (_("'%s': No such file\n"), file_name);
16212 else
16213 error (_("Could not locate '%s'. System error message: %s\n"),
16214 file_name, strerror (errno));
16215 return 1;
16216 }
16217
16218 if (! S_ISREG (statbuf.st_mode))
16219 {
16220 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 16221 return 1;
16222 }
16223
16224 file = fopen (file_name, "rb");
16225 if (file == NULL)
16226 {
f24ddbdd 16227 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 16228 return 1;
16229 }
16230
16231 if (fread (armag, SARMAG, 1, file) != 1)
16232 {
4145f1d5 16233 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 16234 fclose (file);
16235 return 1;
16236 }
16237
f54498b4
NC		 16238 current_file_size = (bfd_size_type) statbuf.st_size;
16239
fb52b2f4 16240 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 16241 ret = process_archive (file_name, file, FALSE);
16242 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16243 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 16244 else
16245 {
4145f1d5
NC		 16246 if (do_archive_index)
16247 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16248 file_name);
16249
fb52b2f4
NC		 16250 rewind (file);
16251 archive_file_size = archive_file_offset = 0;
16252 ret = process_object (file_name, file);
16253 }
16254
16255 fclose (file);
16256
f54498b4 16257 current_file_size = 0;
fb52b2f4
NC		 16258 return ret;
16259}
16260
252b5132
RH		 16261#ifdef SUPPORT_DISASSEMBLY
16262/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 16263 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 16264 symbols. */
252b5132
RH		 16265
16266void
2cf0635d 16267print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 16268{
16269 fprintf (outfile,"0x%8.8x", addr);
16270}
16271
e3c8793a 16272/* Needed by the i386 disassembler. */
252b5132
RH		 16273void
16274db_task_printsym (unsigned int addr)
16275{
16276 print_address (addr, stderr);
16277}
16278#endif
16279
16280int
2cf0635d 16281main (int argc, char ** argv)
252b5132 16282{
ff78d6d6
L		 16283 int err;
16284
252b5132
RH		 16285#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16286 setlocale (LC_MESSAGES, "");
3882b010
L		 16287#endif
16288#if defined (HAVE_SETLOCALE)
16289 setlocale (LC_CTYPE, "");
252b5132
RH		 16290#endif
16291 bindtextdomain (PACKAGE, LOCALEDIR);
16292 textdomain (PACKAGE);
16293
869b9d07
MM		 16294 expandargv (&argc, &argv);
16295
252b5132
RH		 16296 parse_args (argc, argv);
16297
18bd398b 16298 if (num_dump_sects > 0)
59f14fc0 16299 {
18bd398b 16300 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 16301 cmdline_dump_sects = (dump_type *)
16302 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 16303 if (cmdline_dump_sects == NULL)
591a748a 16304 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 16305 else
16306 {
09c11c86
NC		 16307 memcpy (cmdline_dump_sects, dump_sects,
16308 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 16309 num_cmdline_dump_sects = num_dump_sects;
16310 }
16311 }
16312
18bd398b
NC		 16313 if (optind < (argc - 1))
16314 show_name = 1;
5656ba2c
L		 16315 else if (optind >= argc)
16316 {
16317 warn (_("Nothing to do.\n"));
16318 usage (stderr);
16319 }
18bd398b 16320
ff78d6d6 16321 err = 0;
252b5132 16322 while (optind < argc)
18bd398b 16323 err |= process_file (argv[optind++]);
252b5132
RH		 16324
16325 if (dump_sects != NULL)
16326 free (dump_sects);
59f14fc0
AS		 16327 if (cmdline_dump_sects != NULL)
16328 free (cmdline_dump_sects);
252b5132 16329
ff78d6d6 16330 return err;
252b5132 16331}
A mirror of the official binutils-gdb repository