projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Dwarf assembler: handle one instruction function
[deliverable/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
CS		 46#ifdef HAVE_ZLIB_H
47#include <zlib.h>
48#endif
3bfcb652 49#ifdef HAVE_WCHAR_H
7bfd842d 50#include <wchar.h>
3bfcb652 51#endif
252b5132 52
a952a375 53#if __GNUC__ >= 2
19936277 54/* Define BFD64 here, even if our default architecture is 32 bit ELF
a952a375 55 as this will allow us to read in and parse 64bit and 32bit ELF files.
b34976b6 56 Only do this if we believe that the compiler can support a 64 bit
a952a375 57 data type. For now we only rely on GCC being able to do this. */
19936277 58#define BFD64
a952a375
NC		 59#endif
60
3db64b00
AM		 61#include "bfd.h"
62#include "bucomm.h"
3284fe0c 63#include "elfcomm.h"
19e6b90e 64#include "dwarf.h"
252b5132
RH		 65
66#include "elf/common.h"
67#include "elf/external.h"
68#include "elf/internal.h"
252b5132 69
4b78141a
NC		 70
71/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
72 we can obtain the H8 reloc numbers. We need these for the
73 get_reloc_size() function. We include h8.h again after defining
74 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
75
76#include "elf/h8.h"
77#undef _ELF_H8_H
78
79/* Undo the effects of #including reloc-macros.h. */
80
81#undef START_RELOC_NUMBERS
82#undef RELOC_NUMBER
83#undef FAKE_RELOC
84#undef EMPTY_RELOC
85#undef END_RELOC_NUMBERS
86#undef _RELOC_MACROS_H
87
252b5132
RH		 88/* The following headers use the elf/reloc-macros.h file to
89 automatically generate relocation recognition functions
90 such as elf_mips_reloc_type() */
91
92#define RELOC_MACROS_GEN_FUNC
93
a06ea964 94#include "elf/aarch64.h"
252b5132 95#include "elf/alpha.h"
3b16e843 96#include "elf/arc.h"
252b5132 97#include "elf/arm.h"
3b16e843 98#include "elf/avr.h"
1d65ded4 99#include "elf/bfin.h"
60bca95a 100#include "elf/cr16.h"
3b16e843 101#include "elf/cris.h"
1c0d3aa6 102#include "elf/crx.h"
252b5132
RH		 103#include "elf/d10v.h"
104#include "elf/d30v.h"
d172d4ba 105#include "elf/dlx.h"
cfb8c092 106#include "elf/epiphany.h"
252b5132 107#include "elf/fr30.h"
5c70f934 108#include "elf/frv.h"
3f8107ab 109#include "elf/ft32.h"
3b16e843
NC		 110#include "elf/h8.h"
111#include "elf/hppa.h"
112#include "elf/i386.h"
35b1837e 113#include "elf/i370.h"
3b16e843
NC		 114#include "elf/i860.h"
115#include "elf/i960.h"
116#include "elf/ia64.h"
1e4cf259 117#include "elf/ip2k.h"
84e94c90 118#include "elf/lm32.h"
1c0d3aa6 119#include "elf/iq2000.h"
49f58d10 120#include "elf/m32c.h"
3b16e843
NC		 121#include "elf/m32r.h"
122#include "elf/m68k.h"
75751cd9 123#include "elf/m68hc11.h"
252b5132 124#include "elf/mcore.h"
15ab5209 125#include "elf/mep.h"
a3c62988 126#include "elf/metag.h"
7ba29e2a 127#include "elf/microblaze.h"
3b16e843 128#include "elf/mips.h"
3c3bdf30 129#include "elf/mmix.h"
3b16e843
NC		 130#include "elf/mn10200.h"
131#include "elf/mn10300.h"
5506d11a 132#include "elf/moxie.h"
4970f871 133#include "elf/mt.h"
2469cfa2 134#include "elf/msp430.h"
35c08157 135#include "elf/nds32.h"
13761a11 136#include "elf/nios2.h"
73589c9d 137#include "elf/or1k.h"
7d466069 138#include "elf/pj.h"
3b16e843 139#include "elf/ppc.h"
c833c019 140#include "elf/ppc64.h"
99c513f6 141#include "elf/rl78.h"
c7927a3c 142#include "elf/rx.h"
a85d7ed0 143#include "elf/s390.h"
1c0d3aa6 144#include "elf/score.h"
3b16e843
NC		 145#include "elf/sh.h"
146#include "elf/sparc.h"
e9f53129 147#include "elf/spu.h"
40b36596 148#include "elf/tic6x.h"
aa137e4d
NC		 149#include "elf/tilegx.h"
150#include "elf/tilepro.h"
3b16e843 151#include "elf/v850.h"
179d3252 152#include "elf/vax.h"
619ed720 153#include "elf/visium.h"
3b16e843 154#include "elf/x86-64.h"
c29aca4a 155#include "elf/xc16x.h"
f6c1a2d5 156#include "elf/xgate.h"
93fbbb04 157#include "elf/xstormy16.h"
88da6820 158#include "elf/xtensa.h"
252b5132 159
252b5132 160#include "getopt.h"
566b0d53 161#include "libiberty.h"
09c11c86 162#include "safe-ctype.h"
2cf0635d 163#include "filenames.h"
252b5132 164
15b42fb0
AM		 165#ifndef offsetof
166#define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
167#endif
168
2cf0635d 169char * program_name = "readelf";
c9c1d674 170static unsigned long archive_file_offset;
85b1c36d 171static unsigned long archive_file_size;
f54498b4 172static bfd_size_type current_file_size;
85b1c36d
BE		 173static unsigned long dynamic_addr;
174static bfd_size_type dynamic_size;
8b73c356 175static size_t dynamic_nent;
2cf0635d 176static char * dynamic_strings;
85b1c36d 177static unsigned long dynamic_strings_length;
2cf0635d 178static char * string_table;
85b1c36d
BE		 179static unsigned long string_table_length;
180static unsigned long num_dynamic_syms;
2cf0635d
NC		 181static Elf_Internal_Sym * dynamic_symbols;
182static Elf_Internal_Syminfo * dynamic_syminfo;
85b1c36d
BE		 183static unsigned long dynamic_syminfo_offset;
184static unsigned int dynamic_syminfo_nent;
f8eae8b2 185static char program_interpreter[PATH_MAX];
bb8a0291 186static bfd_vma dynamic_info[DT_ENCODING];
fdc90cb4 187static bfd_vma dynamic_info_DT_GNU_HASH;
85b1c36d
BE		 188static bfd_vma version_info[16];
189static Elf_Internal_Ehdr elf_header;
2cf0635d
NC		 190static Elf_Internal_Shdr * section_headers;
191static Elf_Internal_Phdr * program_headers;
192static Elf_Internal_Dyn * dynamic_section;
193static Elf_Internal_Shdr * symtab_shndx_hdr;
85b1c36d
BE		 194static int show_name;
195static int do_dynamic;
196static int do_syms;
2c610e4b 197static int do_dyn_syms;
85b1c36d
BE		 198static int do_reloc;
199static int do_sections;
200static int do_section_groups;
5477e8a0 201static int do_section_details;
85b1c36d
BE		 202static int do_segments;
203static int do_unwind;
204static int do_using_dynamic;
205static int do_header;
206static int do_dump;
207static int do_version;
85b1c36d
BE		 208static int do_histogram;
209static int do_debugging;
85b1c36d
BE		 210static int do_arch;
211static int do_notes;
4145f1d5 212static int do_archive_index;
85b1c36d 213static int is_32bit_elf;
252b5132 214
e4b17d5c
L		 215struct group_list
216{
2cf0635d 217 struct group_list * next;
e4b17d5c
L		 218 unsigned int section_index;
219};
220
221struct group
222{
2cf0635d 223 struct group_list * root;
e4b17d5c
L		 224 unsigned int group_index;
225};
226
85b1c36d 227static size_t group_count;
2cf0635d
NC		 228static struct group * section_groups;
229static struct group ** section_headers_groups;
e4b17d5c 230
09c11c86
NC		 231
232/* Flag bits indicating particular types of dump. */
233#define HEX_DUMP (1 << 0) /* The -x command line switch. */
234#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
235#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
236#define STRING_DUMP (1 << 3) /* The -p command line switch. */
cf13d699 237#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
09c11c86
NC		 238
239typedef unsigned char dump_type;
240
241/* A linked list of the section names for which dumps were requested. */
aef1f6d0
DJ		 242struct dump_list_entry
243{
2cf0635d 244 char * name;
09c11c86 245 dump_type type;
2cf0635d 246 struct dump_list_entry * next;
aef1f6d0 247};
2cf0635d 248static struct dump_list_entry * dump_sects_byname;
aef1f6d0 249
09c11c86
NC		 250/* A dynamic array of flags indicating for which sections a dump
251 has been requested via command line switches. */
252static dump_type * cmdline_dump_sects = NULL;
253static unsigned int num_cmdline_dump_sects = 0;
18bd398b
NC		 254
255/* A dynamic array of flags indicating for which sections a dump of
256 some kind has been requested. It is reset on a per-object file
aef1f6d0
DJ		 257 basis and then initialised from the cmdline_dump_sects array,
258 the results of interpreting the -w switch, and the
259 dump_sects_byname list. */
09c11c86
NC		 260static dump_type * dump_sects = NULL;
261static unsigned int num_dump_sects = 0;
252b5132 262
252b5132 263
c256ffe7 264/* How to print a vma value. */
843dd992
NC		 265typedef enum print_mode
266{
267 HEX,
268 DEC,
269 DEC_5,
270 UNSIGNED,
271 PREFIX_HEX,
272 FULL_HEX,
273 LONG_HEX
274}
275print_mode;
276
bb4d2ac2
L		 277/* Versioned symbol info. */
278enum versioned_symbol_info
279{
280 symbol_undefined,
281 symbol_hidden,
282 symbol_public
283};
284
285static const char *get_symbol_version_string
286 (FILE *file, int is_dynsym, const char *strtab,
287 unsigned long int strtab_size, unsigned int si,
288 Elf_Internal_Sym *psym, enum versioned_symbol_info *sym_info,
289 unsigned short *vna_other);
290
9c19a809
NC		 291#define UNKNOWN -1
292
2b692964
NC		 293#define SECTION_NAME(X) \
294 ((X) == NULL ? _("<none>") \
295 : string_table == NULL ? _("<no-name>") \
296 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
0b49d371 297 : string_table + (X)->sh_name))
252b5132 298
ee42cf8c 299#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
252b5132 300
ba5cdace
NC		 301#define GET_ELF_SYMBOLS(file, section, sym_count) \
302 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
303 : get_64bit_elf_symbols (file, section, sym_count))
9ea033b2 304
d79b3d50
NC		 305#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
306/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
307 already been called and verified that the string exists. */
308#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
18bd398b 309
61865e30
NC		 310#define REMOVE_ARCH_BITS(ADDR) \
311 do \
312 { \
313 if (elf_header.e_machine == EM_ARM) \
314 (ADDR) &= ~1; \
315 } \
316 while (0)
d79b3d50 317\f
c9c1d674
EG		 318/* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
319 the offset of the current archive member, if we are examining an archive.
59245841
NC		 320 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
321 using malloc and fill that. In either case return the pointer to the start of
322 the retrieved data or NULL if something went wrong. If something does go wrong
c9c1d674
EG		 323 and REASON is not NULL then emit an error message using REASON as part of the
324 context. */
59245841 325
c256ffe7 326static void *
57028622
NC		 327get_data (void * var, FILE * file, unsigned long offset, bfd_size_type size,
328 bfd_size_type nmemb, const char * reason)
a6e9f9df 329{
2cf0635d 330 void * mvar;
57028622 331 bfd_size_type amt = size * nmemb;
a6e9f9df 332
c256ffe7 333 if (size == 0 || nmemb == 0)
a6e9f9df
AM		 334 return NULL;
335
57028622
NC		 336 /* If the size_t type is smaller than the bfd_size_type, eg because
337 you are building a 32-bit tool on a 64-bit host, then make sure
338 that when the sizes are cast to (size_t) no information is lost. */
339 if (sizeof (size_t) < sizeof (bfd_size_type)
340 && ( (bfd_size_type) ((size_t) size) != size
341 || (bfd_size_type) ((size_t) nmemb) != nmemb))
342 {
343 if (reason)
344 error (_("Size truncation prevents reading 0x%llx elements of size 0x%llx for %s\n"),
345 (unsigned long long) nmemb, (unsigned long long) size, reason);
346 return NULL;
347 }
348
349 /* Check for size overflow. */
350 if (amt < nmemb)
351 {
352 if (reason)
353 error (_("Size overflow prevents reading 0x%llx elements of size 0x%llx for %s\n"),
354 (unsigned long long) nmemb, (unsigned long long) size, reason);
355 return NULL;
356 }
357
c9c1d674
EG		 358 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
359 attempting to allocate memory when the read is bound to fail. */
360 if (amt > current_file_size
361 || offset + archive_file_offset + amt > current_file_size)
a6e9f9df 362 {
049b0c3a 363 if (reason)
57028622
NC		 364 error (_("Reading 0x%llx bytes extends past end of file for %s\n"),
365 (unsigned long long) amt, reason);
a6e9f9df
AM		 366 return NULL;
367 }
368
c9c1d674 369 if (fseek (file, archive_file_offset + offset, SEEK_SET))
071436c6
NC		 370 {
371 if (reason)
c9c1d674
EG		 372 error (_("Unable to seek to 0x%lx for %s\n"),
373 (unsigned long) archive_file_offset + offset, reason);
071436c6
NC		 374 return NULL;
375 }
376
a6e9f9df
AM		 377 mvar = var;
378 if (mvar == NULL)
379 {
c256ffe7 380 /* Check for overflow. */
57028622 381 if (nmemb < (~(bfd_size_type) 0 - 1) / size)
c256ffe7 382 /* + 1 so that we can '\0' terminate invalid string table sections. */
57028622 383 mvar = malloc ((size_t) amt + 1);
a6e9f9df
AM		 384
385 if (mvar == NULL)
386 {
049b0c3a 387 if (reason)
57028622
NC		 388 error (_("Out of memory allocating 0x%llx bytes for %s\n"),
389 (unsigned long long) amt, reason);
a6e9f9df
AM		 390 return NULL;
391 }
c256ffe7 392
c9c1d674 393 ((char *) mvar)[amt] = '\0';
a6e9f9df
AM		 394 }
395
57028622 396 if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
a6e9f9df 397 {
049b0c3a 398 if (reason)
57028622
NC		 399 error (_("Unable to read in 0x%llx bytes of %s\n"),
400 (unsigned long long) amt, reason);
a6e9f9df
AM		 401 if (mvar != var)
402 free (mvar);
403 return NULL;
404 }
405
406 return mvar;
407}
408
14a91970 409/* Print a VMA value. */
cb8f3167 410
66543521 411static int
14a91970 412print_vma (bfd_vma vma, print_mode mode)
66543521 413{
66543521
AM		 414 int nc = 0;
415
14a91970 416 switch (mode)
66543521 417 {
14a91970
AM		 418 case FULL_HEX:
419 nc = printf ("0x");
420 /* Drop through. */
66543521 421
14a91970 422 case LONG_HEX:
f7a99963 423#ifdef BFD64
14a91970 424 if (is_32bit_elf)
437c2fb7 425 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
f7a99963 426#endif
14a91970
AM		 427 printf_vma (vma);
428 return nc + 16;
b19aac67 429
14a91970
AM		 430 case DEC_5:
431 if (vma <= 99999)
432 return printf ("%5" BFD_VMA_FMT "d", vma);
433 /* Drop through. */
66543521 434
14a91970
AM		 435 case PREFIX_HEX:
436 nc = printf ("0x");
437 /* Drop through. */
66543521 438
14a91970
AM		 439 case HEX:
440 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 441
14a91970
AM		 442 case DEC:
443 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 444
14a91970
AM		 445 case UNSIGNED:
446 return printf ("%" BFD_VMA_FMT "u", vma);
f7a99963 447 }
66543521 448 return 0;
f7a99963
NC		 449}
450
7bfd842d 451/* Display a symbol on stdout. Handles the display of control characters and
3bfcb652 452 multibye characters (assuming the host environment supports them).
31104126 453
7bfd842d
NC		 454 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
455
456 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
457 padding as necessary.
171191ba
NC		 458
459 Returns the number of emitted characters. */
460
461static unsigned int
7a88bc9c 462print_symbol (int width, const char *symbol)
31104126 463{
171191ba 464 bfd_boolean extra_padding = FALSE;
7bfd842d 465 int num_printed = 0;
3bfcb652 466#ifdef HAVE_MBSTATE_T
7bfd842d 467 mbstate_t state;
3bfcb652 468#endif
7bfd842d 469 int width_remaining;
961c521f 470
7bfd842d 471 if (width < 0)
961c521f 472 {
961c521f
NC		 473 /* Keep the width positive. This also helps. */
474 width = - width;
171191ba 475 extra_padding = TRUE;
0b4362b0 476 }
74e1a04b 477 assert (width != 0);
961c521f 478
7bfd842d
NC		 479 if (do_wide)
480 /* Set the remaining width to a very large value.
481 This simplifies the code below. */
482 width_remaining = INT_MAX;
483 else
484 width_remaining = width;
cb8f3167 485
3bfcb652 486#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 487 /* Initialise the multibyte conversion state. */
488 memset (& state, 0, sizeof (state));
3bfcb652 489#endif
961c521f 490
7bfd842d
NC		 491 while (width_remaining)
492 {
493 size_t n;
7bfd842d 494 const char c = *symbol++;
961c521f 495
7bfd842d 496 if (c == 0)
961c521f
NC		 497 break;
498
7bfd842d
NC		 499 /* Do not print control characters directly as they can affect terminal
500 settings. Such characters usually appear in the names generated
501 by the assembler for local labels. */
502 if (ISCNTRL (c))
961c521f 503 {
7bfd842d 504 if (width_remaining < 2)
961c521f
NC		 505 break;
506
7bfd842d
NC		 507 printf ("^%c", c + 0x40);
508 width_remaining -= 2;
171191ba 509 num_printed += 2;
961c521f 510 }
7bfd842d
NC		 511 else if (ISPRINT (c))
512 {
513 putchar (c);
514 width_remaining --;
515 num_printed ++;
516 }
961c521f
NC		 517 else
518 {
3bfcb652
NC		 519#ifdef HAVE_MBSTATE_T
520 wchar_t w;
521#endif
7bfd842d
NC		 522 /* Let printf do the hard work of displaying multibyte characters. */
523 printf ("%.1s", symbol - 1);
524 width_remaining --;
525 num_printed ++;
526
3bfcb652 527#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 528 /* Try to find out how many bytes made up the character that was
529 just printed. Advance the symbol pointer past the bytes that
530 were displayed. */
531 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
3bfcb652
NC		 532#else
533 n = 1;
534#endif
7bfd842d
NC		 535 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
536 symbol += (n - 1);
961c521f 537 }
961c521f 538 }
171191ba 539
7bfd842d 540 if (extra_padding && num_printed < width)
171191ba
NC		 541 {
542 /* Fill in the remaining spaces. */
7bfd842d
NC		 543 printf ("%-*s", width - num_printed, " ");
544 num_printed = width;
171191ba
NC		 545 }
546
547 return num_printed;
31104126
NC		 548}
549
74e1a04b
NC		 550/* Returns a pointer to a static buffer containing a printable version of
551 the given section's name. Like print_symbol, except that it does not try
552 to print multibyte characters, it just interprets them as hex values. */
553
554static const char *
555printable_section_name (Elf_Internal_Shdr * sec)
556{
557#define MAX_PRINT_SEC_NAME_LEN 128
558 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
559 const char * name = SECTION_NAME (sec);
560 char * buf = sec_name_buf;
561 char c;
562 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
563
564 while ((c = * name ++) != 0)
565 {
566 if (ISCNTRL (c))
567 {
568 if (remaining < 2)
569 break;
948f632f 570
74e1a04b
NC		 571 * buf ++ = '^';
572 * buf ++ = c + 0x40;
573 remaining -= 2;
574 }
575 else if (ISPRINT (c))
576 {
577 * buf ++ = c;
578 remaining -= 1;
579 }
580 else
581 {
582 static char hex[17] = "0123456789ABCDEF";
583
584 if (remaining < 4)
585 break;
586 * buf ++ = '<';
587 * buf ++ = hex[(c & 0xf0) >> 4];
588 * buf ++ = hex[c & 0x0f];
589 * buf ++ = '>';
590 remaining -= 4;
591 }
592
593 if (remaining == 0)
594 break;
595 }
596
597 * buf = 0;
598 return sec_name_buf;
599}
600
601static const char *
602printable_section_name_from_index (unsigned long ndx)
603{
604 if (ndx >= elf_header.e_shnum)
605 return _("<corrupt>");
606
607 return printable_section_name (section_headers + ndx);
608}
609
89fac5e3
RS		 610/* Return a pointer to section NAME, or NULL if no such section exists. */
611
612static Elf_Internal_Shdr *
2cf0635d 613find_section (const char * name)
89fac5e3
RS		 614{
615 unsigned int i;
616
617 for (i = 0; i < elf_header.e_shnum; i++)
618 if (streq (SECTION_NAME (section_headers + i), name))
619 return section_headers + i;
620
621 return NULL;
622}
623
0b6ae522
DJ		 624/* Return a pointer to a section containing ADDR, or NULL if no such
625 section exists. */
626
627static Elf_Internal_Shdr *
628find_section_by_address (bfd_vma addr)
629{
630 unsigned int i;
631
632 for (i = 0; i < elf_header.e_shnum; i++)
633 {
634 Elf_Internal_Shdr *sec = section_headers + i;
635 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
636 return sec;
637 }
638
639 return NULL;
640}
641
071436c6
NC		 642static Elf_Internal_Shdr *
643find_section_by_type (unsigned int type)
644{
645 unsigned int i;
646
647 for (i = 0; i < elf_header.e_shnum; i++)
648 {
649 Elf_Internal_Shdr *sec = section_headers + i;
650 if (sec->sh_type == type)
651 return sec;
652 }
653
654 return NULL;
655}
656
657d0d47
CC		 657/* Return a pointer to section NAME, or NULL if no such section exists,
658 restricted to the list of sections given in SET. */
659
660static Elf_Internal_Shdr *
661find_section_in_set (const char * name, unsigned int * set)
662{
663 unsigned int i;
664
665 if (set != NULL)
666 {
667 while ((i = *set++) > 0)
668 if (streq (SECTION_NAME (section_headers + i), name))
669 return section_headers + i;
670 }
671
672 return find_section (name);
673}
674
0b6ae522
DJ		 675/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
676 bytes read. */
677
f6f0e17b
NC		 678static inline unsigned long
679read_uleb128 (unsigned char *data,
680 unsigned int *length_return,
681 const unsigned char * const end)
0b6ae522 682{
f6f0e17b 683 return read_leb128 (data, length_return, FALSE, end);
0b6ae522
DJ		 684}
685
28f997cf
TG		 686/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
687 This OS has so many departures from the ELF standard that we test it at
688 many places. */
689
690static inline int
691is_ia64_vms (void)
692{
693 return elf_header.e_machine == EM_IA_64
694 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
695}
696
bcedfee6 697/* Guess the relocation size commonly used by the specific machines. */
252b5132 698
252b5132 699static int
2dc4cec1 700guess_is_rela (unsigned int e_machine)
252b5132 701{
9c19a809 702 switch (e_machine)
252b5132
RH		 703 {
704 /* Targets that use REL relocations. */
252b5132
RH		 705 case EM_386:
706 case EM_486:
63fcb9e9 707 case EM_960:
e9f53129 708 case EM_ARM:
2b0337b0 709 case EM_D10V:
252b5132 710 case EM_CYGNUS_D10V:
e9f53129 711 case EM_DLX:
252b5132 712 case EM_MIPS:
4fe85591 713 case EM_MIPS_RS3_LE:
e9f53129 714 case EM_CYGNUS_M32R:
1c0d3aa6 715 case EM_SCORE:
f6c1a2d5 716 case EM_XGATE:
9c19a809 717 return FALSE;
103f02d3 718
252b5132
RH		 719 /* Targets that use RELA relocations. */
720 case EM_68K:
e9f53129 721 case EM_860:
a06ea964 722 case EM_AARCH64:
cfb8c092 723 case EM_ADAPTEVA_EPIPHANY:
e9f53129
AM		 724 case EM_ALPHA:
725 case EM_ALTERA_NIOS2:
726 case EM_AVR:
727 case EM_AVR_OLD:
728 case EM_BLACKFIN:
60bca95a 729 case EM_CR16:
e9f53129
AM		 730 case EM_CRIS:
731 case EM_CRX:
2b0337b0 732 case EM_D30V:
252b5132 733 case EM_CYGNUS_D30V:
2b0337b0 734 case EM_FR30:
3f8107ab 735 case EM_FT32:
252b5132 736 case EM_CYGNUS_FR30:
5c70f934 737 case EM_CYGNUS_FRV:
e9f53129
AM		 738 case EM_H8S:
739 case EM_H8_300:
740 case EM_H8_300H:
800eeca4 741 case EM_IA_64:
1e4cf259
NC		 742 case EM_IP2K:
743 case EM_IP2K_OLD:
3b36097d 744 case EM_IQ2000:
84e94c90 745 case EM_LATTICEMICO32:
ff7eeb89 746 case EM_M32C_OLD:
49f58d10 747 case EM_M32C:
e9f53129
AM		 748 case EM_M32R:
749 case EM_MCORE:
15ab5209 750 case EM_CYGNUS_MEP:
a3c62988 751 case EM_METAG:
e9f53129
AM		 752 case EM_MMIX:
753 case EM_MN10200:
754 case EM_CYGNUS_MN10200:
755 case EM_MN10300:
756 case EM_CYGNUS_MN10300:
5506d11a 757 case EM_MOXIE:
e9f53129
AM		 758 case EM_MSP430:
759 case EM_MSP430_OLD:
d031aafb 760 case EM_MT:
35c08157 761 case EM_NDS32:
64fd6348 762 case EM_NIOS32:
73589c9d 763 case EM_OR1K:
e9f53129
AM		 764 case EM_PPC64:
765 case EM_PPC:
99c513f6 766 case EM_RL78:
c7927a3c 767 case EM_RX:
e9f53129
AM		 768 case EM_S390:
769 case EM_S390_OLD:
770 case EM_SH:
771 case EM_SPARC:
772 case EM_SPARC32PLUS:
773 case EM_SPARCV9:
774 case EM_SPU:
40b36596 775 case EM_TI_C6000:
aa137e4d
NC		 776 case EM_TILEGX:
777 case EM_TILEPRO:
708e2187 778 case EM_V800:
e9f53129
AM		 779 case EM_V850:
780 case EM_CYGNUS_V850:
781 case EM_VAX:
619ed720 782 case EM_VISIUM:
e9f53129 783 case EM_X86_64:
8a9036a4 784 case EM_L1OM:
7a9068fe 785 case EM_K1OM:
e9f53129
AM		 786 case EM_XSTORMY16:
787 case EM_XTENSA:
788 case EM_XTENSA_OLD:
7ba29e2a
NC		 789 case EM_MICROBLAZE:
790 case EM_MICROBLAZE_OLD:
9c19a809 791 return TRUE;
103f02d3 792
e9f53129
AM		 793 case EM_68HC05:
794 case EM_68HC08:
795 case EM_68HC11:
796 case EM_68HC16:
797 case EM_FX66:
798 case EM_ME16:
d1133906 799 case EM_MMA:
d1133906
NC		 800 case EM_NCPU:
801 case EM_NDR1:
e9f53129 802 case EM_PCP:
d1133906 803 case EM_ST100:
e9f53129 804 case EM_ST19:
d1133906 805 case EM_ST7:
e9f53129
AM		 806 case EM_ST9PLUS:
807 case EM_STARCORE:
d1133906 808 case EM_SVX:
e9f53129 809 case EM_TINYJ:
9c19a809
NC		 810 default:
811 warn (_("Don't know about relocations on this machine architecture\n"));
812 return FALSE;
813 }
814}
252b5132 815
9c19a809 816static int
2cf0635d 817slurp_rela_relocs (FILE * file,
d3ba0551
AM		 818 unsigned long rel_offset,
819 unsigned long rel_size,
2cf0635d
NC		 820 Elf_Internal_Rela ** relasp,
821 unsigned long * nrelasp)
9c19a809 822{
2cf0635d 823 Elf_Internal_Rela * relas;
8b73c356 824 size_t nrelas;
4d6ed7c8 825 unsigned int i;
252b5132 826
4d6ed7c8
NC		 827 if (is_32bit_elf)
828 {
2cf0635d 829 Elf32_External_Rela * erelas;
103f02d3 830
3f5e193b 831 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 832 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 833 if (!erelas)
834 return 0;
252b5132 835
4d6ed7c8 836 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 837
3f5e193b
NC		 838 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
839 sizeof (Elf_Internal_Rela));
103f02d3 840
4d6ed7c8
NC		 841 if (relas == NULL)
842 {
c256ffe7 843 free (erelas);
591a748a 844 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 845 return 0;
846 }
103f02d3 847
4d6ed7c8
NC		 848 for (i = 0; i < nrelas; i++)
849 {
850 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
851 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 852 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 853 }
103f02d3 854
4d6ed7c8
NC		 855 free (erelas);
856 }
857 else
858 {
2cf0635d 859 Elf64_External_Rela * erelas;
103f02d3 860
3f5e193b 861 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 862 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 863 if (!erelas)
864 return 0;
4d6ed7c8
NC		 865
866 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 867
3f5e193b
NC		 868 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
869 sizeof (Elf_Internal_Rela));
103f02d3 870
4d6ed7c8
NC		 871 if (relas == NULL)
872 {
c256ffe7 873 free (erelas);
591a748a 874 error (_("out of memory parsing relocs\n"));
4d6ed7c8 875 return 0;
9c19a809 876 }
4d6ed7c8
NC		 877
878 for (i = 0; i < nrelas; i++)
9c19a809 879 {
66543521
AM		 880 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
881 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 882 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 883
884 /* The #ifdef BFD64 below is to prevent a compile time
885 warning. We know that if we do not have a 64 bit data
886 type that we will never execute this code anyway. */
887#ifdef BFD64
888 if (elf_header.e_machine == EM_MIPS
889 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
890 {
891 /* In little-endian objects, r_info isn't really a
892 64-bit little-endian value: it has a 32-bit
893 little-endian symbol index followed by four
894 individual byte fields. Reorder INFO
895 accordingly. */
91d6fa6a
NC		 896 bfd_vma inf = relas[i].r_info;
897 inf = (((inf & 0xffffffff) << 32)
898 | ((inf >> 56) & 0xff)
899 | ((inf >> 40) & 0xff00)
900 | ((inf >> 24) & 0xff0000)
901 | ((inf >> 8) & 0xff000000));
902 relas[i].r_info = inf;
861fb55a
DJ		 903 }
904#endif /* BFD64 */
4d6ed7c8 905 }
103f02d3 906
4d6ed7c8
NC		 907 free (erelas);
908 }
909 *relasp = relas;
910 *nrelasp = nrelas;
911 return 1;
912}
103f02d3 913
4d6ed7c8 914static int
2cf0635d 915slurp_rel_relocs (FILE * file,
d3ba0551
AM		 916 unsigned long rel_offset,
917 unsigned long rel_size,
2cf0635d
NC		 918 Elf_Internal_Rela ** relsp,
919 unsigned long * nrelsp)
4d6ed7c8 920{
2cf0635d 921 Elf_Internal_Rela * rels;
8b73c356 922 size_t nrels;
4d6ed7c8 923 unsigned int i;
103f02d3 924
4d6ed7c8
NC		 925 if (is_32bit_elf)
926 {
2cf0635d 927 Elf32_External_Rel * erels;
103f02d3 928
3f5e193b 929 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 930 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 931 if (!erels)
932 return 0;
103f02d3 933
4d6ed7c8 934 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 935
3f5e193b 936 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 937
4d6ed7c8
NC		 938 if (rels == NULL)
939 {
c256ffe7 940 free (erels);
591a748a 941 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 942 return 0;
943 }
944
945 for (i = 0; i < nrels; i++)
946 {
947 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
948 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 949 rels[i].r_addend = 0;
9ea033b2 950 }
4d6ed7c8
NC		 951
952 free (erels);
9c19a809
NC		 953 }
954 else
955 {
2cf0635d 956 Elf64_External_Rel * erels;
9ea033b2 957
3f5e193b 958 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 959 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 960 if (!erels)
961 return 0;
103f02d3 962
4d6ed7c8 963 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 964
3f5e193b 965 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 966
4d6ed7c8 967 if (rels == NULL)
9c19a809 968 {
c256ffe7 969 free (erels);
591a748a 970 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 971 return 0;
972 }
103f02d3 973
4d6ed7c8
NC		 974 for (i = 0; i < nrels; i++)
975 {
66543521
AM		 976 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
977 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 978 rels[i].r_addend = 0;
861fb55a
DJ		 979
980 /* The #ifdef BFD64 below is to prevent a compile time
981 warning. We know that if we do not have a 64 bit data
982 type that we will never execute this code anyway. */
983#ifdef BFD64
984 if (elf_header.e_machine == EM_MIPS
985 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
986 {
987 /* In little-endian objects, r_info isn't really a
988 64-bit little-endian value: it has a 32-bit
989 little-endian symbol index followed by four
990 individual byte fields. Reorder INFO
991 accordingly. */
91d6fa6a
NC		 992 bfd_vma inf = rels[i].r_info;
993 inf = (((inf & 0xffffffff) << 32)
994 | ((inf >> 56) & 0xff)
995 | ((inf >> 40) & 0xff00)
996 | ((inf >> 24) & 0xff0000)
997 | ((inf >> 8) & 0xff000000));
998 rels[i].r_info = inf;
861fb55a
DJ		 999 }
1000#endif /* BFD64 */
4d6ed7c8 1001 }
103f02d3 1002
4d6ed7c8
NC		 1003 free (erels);
1004 }
1005 *relsp = rels;
1006 *nrelsp = nrels;
1007 return 1;
1008}
103f02d3 1009
aca88567
NC		 1010/* Returns the reloc type extracted from the reloc info field. */
1011
1012static unsigned int
1013get_reloc_type (bfd_vma reloc_info)
1014{
1015 if (is_32bit_elf)
1016 return ELF32_R_TYPE (reloc_info);
1017
1018 switch (elf_header.e_machine)
1019 {
1020 case EM_MIPS:
1021 /* Note: We assume that reloc_info has already been adjusted for us. */
1022 return ELF64_MIPS_R_TYPE (reloc_info);
1023
1024 case EM_SPARCV9:
1025 return ELF64_R_TYPE_ID (reloc_info);
1026
1027 default:
1028 return ELF64_R_TYPE (reloc_info);
1029 }
1030}
1031
1032/* Return the symbol index extracted from the reloc info field. */
1033
1034static bfd_vma
1035get_reloc_symindex (bfd_vma reloc_info)
1036{
1037 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1038}
1039
13761a11
NC		 1040static inline bfd_boolean
1041uses_msp430x_relocs (void)
1042{
1043 return
1044 elf_header.e_machine == EM_MSP430 /* Paranoia. */
1045 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1046 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1047 /* TI compiler uses ELFOSABI_NONE. */
1048 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1049}
1050
d3ba0551
AM		 1051/* Display the contents of the relocation data found at the specified
1052 offset. */
ee42cf8c 1053
41e92641 1054static void
2cf0635d 1055dump_relocations (FILE * file,
d3ba0551
AM		 1056 unsigned long rel_offset,
1057 unsigned long rel_size,
2cf0635d 1058 Elf_Internal_Sym * symtab,
d3ba0551 1059 unsigned long nsyms,
2cf0635d 1060 char * strtab,
d79b3d50 1061 unsigned long strtablen,
bb4d2ac2
L		 1062 int is_rela,
1063 int is_dynsym)
4d6ed7c8 1064{
b34976b6 1065 unsigned int i;
2cf0635d 1066 Elf_Internal_Rela * rels;
103f02d3 1067
4d6ed7c8
NC		 1068 if (is_rela == UNKNOWN)
1069 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 1070
4d6ed7c8
NC		 1071 if (is_rela)
1072 {
c8286bd1 1073 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1074 return;
4d6ed7c8
NC		 1075 }
1076 else
1077 {
1078 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1079 return;
252b5132
RH		 1080 }
1081
410f7a12
L		 1082 if (is_32bit_elf)
1083 {
1084 if (is_rela)
2c71103e
NC		 1085 {
1086 if (do_wide)
1087 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1088 else
1089 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1090 }
410f7a12 1091 else
2c71103e
NC		 1092 {
1093 if (do_wide)
1094 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1095 else
1096 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1097 }
410f7a12 1098 }
252b5132 1099 else
410f7a12
L		 1100 {
1101 if (is_rela)
2c71103e
NC		 1102 {
1103 if (do_wide)
8beeaeb7 1104 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 1105 else
1106 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1107 }
410f7a12 1108 else
2c71103e
NC		 1109 {
1110 if (do_wide)
8beeaeb7 1111 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 1112 else
1113 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1114 }
410f7a12 1115 }
252b5132
RH		 1116
1117 for (i = 0; i < rel_size; i++)
1118 {
2cf0635d 1119 const char * rtype;
b34976b6 1120 bfd_vma offset;
91d6fa6a 1121 bfd_vma inf;
b34976b6
AM		 1122 bfd_vma symtab_index;
1123 bfd_vma type;
103f02d3 1124
b34976b6 1125 offset = rels[i].r_offset;
91d6fa6a 1126 inf = rels[i].r_info;
103f02d3 1127
91d6fa6a
NC		 1128 type = get_reloc_type (inf);
1129 symtab_index = get_reloc_symindex (inf);
252b5132 1130
410f7a12
L		 1131 if (is_32bit_elf)
1132 {
39dbeff8
AM		 1133 printf ("%8.8lx %8.8lx ",
1134 (unsigned long) offset & 0xffffffff,
91d6fa6a 1135 (unsigned long) inf & 0xffffffff);
410f7a12
L		 1136 }
1137 else
1138 {
39dbeff8
AM		 1139#if BFD_HOST_64BIT_LONG
1140 printf (do_wide
1141 ? "%16.16lx %16.16lx "
1142 : "%12.12lx %12.12lx ",
91d6fa6a 1143 offset, inf);
39dbeff8 1144#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 1145#ifndef __MSVCRT__
39dbeff8
AM		 1146 printf (do_wide
1147 ? "%16.16llx %16.16llx "
1148 : "%12.12llx %12.12llx ",
91d6fa6a 1149 offset, inf);
6e3d6dc1
NC		 1150#else
1151 printf (do_wide
1152 ? "%16.16I64x %16.16I64x "
1153 : "%12.12I64x %12.12I64x ",
91d6fa6a 1154 offset, inf);
6e3d6dc1 1155#endif
39dbeff8 1156#else
2c71103e
NC		 1157 printf (do_wide
1158 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1159 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 1160 _bfd_int64_high (offset),
1161 _bfd_int64_low (offset),
91d6fa6a
NC		 1162 _bfd_int64_high (inf),
1163 _bfd_int64_low (inf));
9ea033b2 1164#endif
410f7a12 1165 }
103f02d3 1166
252b5132
RH		 1167 switch (elf_header.e_machine)
1168 {
1169 default:
1170 rtype = NULL;
1171 break;
1172
a06ea964
NC		 1173 case EM_AARCH64:
1174 rtype = elf_aarch64_reloc_type (type);
1175 break;
1176
2b0337b0 1177 case EM_M32R:
252b5132 1178 case EM_CYGNUS_M32R:
9ea033b2 1179 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 1180 break;
1181
1182 case EM_386:
1183 case EM_486:
9ea033b2 1184 rtype = elf_i386_reloc_type (type);
252b5132
RH		 1185 break;
1186
ba2685cc
AM		 1187 case EM_68HC11:
1188 case EM_68HC12:
1189 rtype = elf_m68hc11_reloc_type (type);
1190 break;
75751cd9 1191
252b5132 1192 case EM_68K:
9ea033b2 1193 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1194 break;
1195
63fcb9e9 1196 case EM_960:
9ea033b2 1197 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1198 break;
1199
adde6300 1200 case EM_AVR:
2b0337b0 1201 case EM_AVR_OLD:
adde6300
AM		 1202 rtype = elf_avr_reloc_type (type);
1203 break;
1204
9ea033b2
NC		 1205 case EM_OLD_SPARCV9:
1206 case EM_SPARC32PLUS:
1207 case EM_SPARCV9:
252b5132 1208 case EM_SPARC:
9ea033b2 1209 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1210 break;
1211
e9f53129
AM		 1212 case EM_SPU:
1213 rtype = elf_spu_reloc_type (type);
1214 break;
1215
708e2187
NC		 1216 case EM_V800:
1217 rtype = v800_reloc_type (type);
1218 break;
2b0337b0 1219 case EM_V850:
252b5132 1220 case EM_CYGNUS_V850:
9ea033b2 1221 rtype = v850_reloc_type (type);
252b5132
RH		 1222 break;
1223
2b0337b0 1224 case EM_D10V:
252b5132 1225 case EM_CYGNUS_D10V:
9ea033b2 1226 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1227 break;
1228
2b0337b0 1229 case EM_D30V:
252b5132 1230 case EM_CYGNUS_D30V:
9ea033b2 1231 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1232 break;
1233
d172d4ba
NC		 1234 case EM_DLX:
1235 rtype = elf_dlx_reloc_type (type);
1236 break;
1237
252b5132 1238 case EM_SH:
9ea033b2 1239 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1240 break;
1241
2b0337b0 1242 case EM_MN10300:
252b5132 1243 case EM_CYGNUS_MN10300:
9ea033b2 1244 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1245 break;
1246
2b0337b0 1247 case EM_MN10200:
252b5132 1248 case EM_CYGNUS_MN10200:
9ea033b2 1249 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1250 break;
1251
2b0337b0 1252 case EM_FR30:
252b5132 1253 case EM_CYGNUS_FR30:
9ea033b2 1254 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1255 break;
1256
ba2685cc
AM		 1257 case EM_CYGNUS_FRV:
1258 rtype = elf_frv_reloc_type (type);
1259 break;
5c70f934 1260
3f8107ab
AM		 1261 case EM_FT32:
1262 rtype = elf_ft32_reloc_type (type);
1263 break;
1264
252b5132 1265 case EM_MCORE:
9ea033b2 1266 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1267 break;
1268
3c3bdf30
NC		 1269 case EM_MMIX:
1270 rtype = elf_mmix_reloc_type (type);
1271 break;
1272
5506d11a
AM		 1273 case EM_MOXIE:
1274 rtype = elf_moxie_reloc_type (type);
1275 break;
1276
2469cfa2 1277 case EM_MSP430:
13761a11
NC		 1278 if (uses_msp430x_relocs ())
1279 {
1280 rtype = elf_msp430x_reloc_type (type);
1281 break;
1282 }
2469cfa2
NC		 1283 case EM_MSP430_OLD:
1284 rtype = elf_msp430_reloc_type (type);
1285 break;
1286
35c08157
KLC		 1287 case EM_NDS32:
1288 rtype = elf_nds32_reloc_type (type);
1289 break;
1290
252b5132 1291 case EM_PPC:
9ea033b2 1292 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1293 break;
1294
c833c019
AM		 1295 case EM_PPC64:
1296 rtype = elf_ppc64_reloc_type (type);
1297 break;
1298
252b5132 1299 case EM_MIPS:
4fe85591 1300 case EM_MIPS_RS3_LE:
9ea033b2 1301 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1302 break;
1303
1304 case EM_ALPHA:
9ea033b2 1305 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1306 break;
1307
1308 case EM_ARM:
9ea033b2 1309 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1310 break;
1311
584da044 1312 case EM_ARC:
9ea033b2 1313 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1314 break;
1315
1316 case EM_PARISC:
69e617ca 1317 rtype = elf_hppa_reloc_type (type);
252b5132 1318 break;
7d466069 1319
b8720f9d
JL		 1320 case EM_H8_300:
1321 case EM_H8_300H:
1322 case EM_H8S:
1323 rtype = elf_h8_reloc_type (type);
1324 break;
1325
73589c9d
CS		 1326 case EM_OR1K:
1327 rtype = elf_or1k_reloc_type (type);
3b16e843
NC		 1328 break;
1329
7d466069 1330 case EM_PJ:
2b0337b0 1331 case EM_PJ_OLD:
7d466069
ILT		 1332 rtype = elf_pj_reloc_type (type);
1333 break;
800eeca4
JW		 1334 case EM_IA_64:
1335 rtype = elf_ia64_reloc_type (type);
1336 break;
1b61cf92
HPN		 1337
1338 case EM_CRIS:
1339 rtype = elf_cris_reloc_type (type);
1340 break;
535c37ff
JE		 1341
1342 case EM_860:
1343 rtype = elf_i860_reloc_type (type);
1344 break;
bcedfee6
NC		 1345
1346 case EM_X86_64:
8a9036a4 1347 case EM_L1OM:
7a9068fe 1348 case EM_K1OM:
bcedfee6
NC		 1349 rtype = elf_x86_64_reloc_type (type);
1350 break;
a85d7ed0 1351
35b1837e
AM		 1352 case EM_S370:
1353 rtype = i370_reloc_type (type);
1354 break;
1355
53c7db4b
KH		 1356 case EM_S390_OLD:
1357 case EM_S390:
1358 rtype = elf_s390_reloc_type (type);
1359 break;
93fbbb04 1360
1c0d3aa6
NC		 1361 case EM_SCORE:
1362 rtype = elf_score_reloc_type (type);
1363 break;
1364
93fbbb04
GK		 1365 case EM_XSTORMY16:
1366 rtype = elf_xstormy16_reloc_type (type);
1367 break;
179d3252 1368
1fe1f39c
NC		 1369 case EM_CRX:
1370 rtype = elf_crx_reloc_type (type);
1371 break;
1372
179d3252
JT		 1373 case EM_VAX:
1374 rtype = elf_vax_reloc_type (type);
1375 break;
1e4cf259 1376
619ed720
EB		 1377 case EM_VISIUM:
1378 rtype = elf_visium_reloc_type (type);
1379 break;
1380
cfb8c092
NC		 1381 case EM_ADAPTEVA_EPIPHANY:
1382 rtype = elf_epiphany_reloc_type (type);
1383 break;
1384
1e4cf259
NC		 1385 case EM_IP2K:
1386 case EM_IP2K_OLD:
1387 rtype = elf_ip2k_reloc_type (type);
1388 break;
3b36097d
SC		 1389
1390 case EM_IQ2000:
1391 rtype = elf_iq2000_reloc_type (type);
1392 break;
88da6820
NC		 1393
1394 case EM_XTENSA_OLD:
1395 case EM_XTENSA:
1396 rtype = elf_xtensa_reloc_type (type);
1397 break;
a34e3ecb 1398
84e94c90
NC		 1399 case EM_LATTICEMICO32:
1400 rtype = elf_lm32_reloc_type (type);
1401 break;
1402
ff7eeb89 1403 case EM_M32C_OLD:
49f58d10
JB		 1404 case EM_M32C:
1405 rtype = elf_m32c_reloc_type (type);
1406 break;
1407
d031aafb
NS		 1408 case EM_MT:
1409 rtype = elf_mt_reloc_type (type);
a34e3ecb 1410 break;
1d65ded4
CM		 1411
1412 case EM_BLACKFIN:
1413 rtype = elf_bfin_reloc_type (type);
1414 break;
15ab5209
DB		 1415
1416 case EM_CYGNUS_MEP:
1417 rtype = elf_mep_reloc_type (type);
1418 break;
60bca95a
NC		 1419
1420 case EM_CR16:
1421 rtype = elf_cr16_reloc_type (type);
1422 break;
dd24e3da 1423
7ba29e2a
NC		 1424 case EM_MICROBLAZE:
1425 case EM_MICROBLAZE_OLD:
1426 rtype = elf_microblaze_reloc_type (type);
1427 break;
c7927a3c 1428
99c513f6
DD		 1429 case EM_RL78:
1430 rtype = elf_rl78_reloc_type (type);
1431 break;
1432
c7927a3c
NC		 1433 case EM_RX:
1434 rtype = elf_rx_reloc_type (type);
1435 break;
c29aca4a 1436
a3c62988
NC		 1437 case EM_METAG:
1438 rtype = elf_metag_reloc_type (type);
1439 break;
1440
c29aca4a
NC		 1441 case EM_XC16X:
1442 case EM_C166:
1443 rtype = elf_xc16x_reloc_type (type);
1444 break;
40b36596
JM		 1445
1446 case EM_TI_C6000:
1447 rtype = elf_tic6x_reloc_type (type);
1448 break;
aa137e4d
NC		 1449
1450 case EM_TILEGX:
1451 rtype = elf_tilegx_reloc_type (type);
1452 break;
1453
1454 case EM_TILEPRO:
1455 rtype = elf_tilepro_reloc_type (type);
1456 break;
f6c1a2d5
NC		 1457
1458 case EM_XGATE:
1459 rtype = elf_xgate_reloc_type (type);
1460 break;
36591ba1
SL		 1461
1462 case EM_ALTERA_NIOS2:
1463 rtype = elf_nios2_reloc_type (type);
1464 break;
252b5132
RH		 1465 }
1466
1467 if (rtype == NULL)
39dbeff8 1468 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1469 else
8beeaeb7 1470 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1471
7ace3541 1472 if (elf_header.e_machine == EM_ALPHA
157c2599 1473 && rtype != NULL
7ace3541
RH		 1474 && streq (rtype, "R_ALPHA_LITUSE")
1475 && is_rela)
1476 {
1477 switch (rels[i].r_addend)
1478 {
1479 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1480 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1481 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1482 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1483 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1484 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1485 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1486 default: rtype = NULL;
1487 }
1488 if (rtype)
1489 printf (" (%s)", rtype);
1490 else
1491 {
1492 putchar (' ');
1493 printf (_("<unknown addend: %lx>"),
1494 (unsigned long) rels[i].r_addend);
1495 }
1496 }
1497 else if (symtab_index)
252b5132 1498 {
af3fc3bc 1499 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1500 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1501 else
19936277 1502 {
2cf0635d 1503 Elf_Internal_Sym * psym;
bb4d2ac2
L		 1504 const char * version_string;
1505 enum versioned_symbol_info sym_info;
1506 unsigned short vna_other;
19936277 1507
af3fc3bc 1508 psym = symtab + symtab_index;
103f02d3 1509
bb4d2ac2
L		 1510 version_string
1511 = get_symbol_version_string (file, is_dynsym,
1512 strtab, strtablen,
1513 symtab_index,
1514 psym,
1515 &sym_info,
1516 &vna_other);
1517
af3fc3bc 1518 printf (" ");
171191ba 1519
d8045f23
NC		 1520 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1521 {
1522 const char * name;
1523 unsigned int len;
1524 unsigned int width = is_32bit_elf ? 8 : 14;
1525
1526 /* Relocations against GNU_IFUNC symbols do not use the value
1527 of the symbol as the address to relocate against. Instead
1528 they invoke the function named by the symbol and use its
1529 result as the address for relocation.
1530
1531 To indicate this to the user, do not display the value of
1532 the symbol in the "Symbols's Value" field. Instead show
1533 its name followed by () as a hint that the symbol is
1534 invoked. */
1535
1536 if (strtab == NULL
1537 || psym->st_name == 0
1538 || psym->st_name >= strtablen)
1539 name = "??";
1540 else
1541 name = strtab + psym->st_name;
1542
1543 len = print_symbol (width, name);
bb4d2ac2
L		 1544 if (version_string)
1545 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1546 version_string);
d8045f23
NC		 1547 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1548 }
1549 else
1550 {
1551 print_vma (psym->st_value, LONG_HEX);
171191ba 1552
d8045f23
NC		 1553 printf (is_32bit_elf ? " " : " ");
1554 }
103f02d3 1555
af3fc3bc 1556 if (psym->st_name == 0)
f1ef08cb 1557 {
2cf0635d 1558 const char * sec_name = "<null>";
f1ef08cb
AM		 1559 char name_buf[40];
1560
1561 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1562 {
4fbb74a6 1563 if (psym->st_shndx < elf_header.e_shnum)
74e1a04b 1564 sec_name = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1565 else if (psym->st_shndx == SHN_ABS)
1566 sec_name = "ABS";
1567 else if (psym->st_shndx == SHN_COMMON)
1568 sec_name = "COMMON";
ac145307
BS		 1569 else if ((elf_header.e_machine == EM_MIPS
1570 && psym->st_shndx == SHN_MIPS_SCOMMON)
1571 || (elf_header.e_machine == EM_TI_C6000
1572 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1573 sec_name = "SCOMMON";
1574 else if (elf_header.e_machine == EM_MIPS
1575 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1576 sec_name = "SUNDEF";
8a9036a4 1577 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1578 || elf_header.e_machine == EM_L1OM
1579 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1580 && psym->st_shndx == SHN_X86_64_LCOMMON)
1581 sec_name = "LARGE_COMMON";
9ce701e2
L		 1582 else if (elf_header.e_machine == EM_IA_64
1583 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1584 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1585 sec_name = "ANSI_COM";
28f997cf 1586 else if (is_ia64_vms ()
148b93f2
NC		 1587 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1588 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1589 else
1590 {
1591 sprintf (name_buf, "<section 0x%x>",
1592 (unsigned int) psym->st_shndx);
1593 sec_name = name_buf;
1594 }
1595 }
1596 print_symbol (22, sec_name);
1597 }
af3fc3bc 1598 else if (strtab == NULL)
d79b3d50 1599 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1600 else if (psym->st_name >= strtablen)
d79b3d50 1601 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1602 else
bb4d2ac2
L		 1603 {
1604 print_symbol (22, strtab + psym->st_name);
1605 if (version_string)
1606 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1607 version_string);
1608 }
103f02d3 1609
af3fc3bc 1610 if (is_rela)
171191ba 1611 {
598aaa76 1612 bfd_signed_vma off = rels[i].r_addend;
171191ba 1613
834f871c
NC		 1614 /* PR 17531: file: 2e63226f. */
1615 if (off == ((bfd_signed_vma) 1) << ((sizeof (bfd_signed_vma) * 8) - 1))
1616 printf (" + %" BFD_VMA_FMT "x", off);
1617 else if (off < 0)
598aaa76 1618 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1619 else
598aaa76 1620 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1621 }
19936277 1622 }
252b5132 1623 }
1b228002 1624 else if (is_rela)
f7a99963 1625 {
e04d7088
L		 1626 bfd_signed_vma off = rels[i].r_addend;
1627
1628 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
834f871c
NC		 1629 /* PR 17531: file: 2e63226f. */
1630 if (off == ((bfd_signed_vma) 1) << ((sizeof (bfd_signed_vma) * 8) - 1))
1631 printf ("%" BFD_VMA_FMT "x", off);
1632 else if (off < 0)
e04d7088
L		 1633 printf ("-%" BFD_VMA_FMT "x", - off);
1634 else
1635 printf ("%" BFD_VMA_FMT "x", off);
f7a99963 1636 }
252b5132 1637
157c2599
NC		 1638 if (elf_header.e_machine == EM_SPARCV9
1639 && rtype != NULL
1640 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1641 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1642
252b5132 1643 putchar ('\n');
2c71103e 1644
aca88567 1645#ifdef BFD64
53c7db4b 1646 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1647 {
91d6fa6a
NC		 1648 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1649 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1650 const char * rtype2 = elf_mips_reloc_type (type2);
1651 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1652
2c71103e
NC		 1653 printf (" Type2: ");
1654
1655 if (rtype2 == NULL)
39dbeff8
AM		 1656 printf (_("unrecognized: %-7lx"),
1657 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1658 else
1659 printf ("%-17.17s", rtype2);
1660
18bd398b 1661 printf ("\n Type3: ");
2c71103e
NC		 1662
1663 if (rtype3 == NULL)
39dbeff8
AM		 1664 printf (_("unrecognized: %-7lx"),
1665 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1666 else
1667 printf ("%-17.17s", rtype3);
1668
53c7db4b 1669 putchar ('\n');
2c71103e 1670 }
aca88567 1671#endif /* BFD64 */
252b5132
RH		 1672 }
1673
c8286bd1 1674 free (rels);
252b5132
RH		 1675}
1676
1677static const char *
d3ba0551 1678get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1679{
1680 switch (type)
1681 {
1682 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1683 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1684 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1685 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1686 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1687 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1688 case DT_MIPS_MSYM: return "MIPS_MSYM";
1689 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1690 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1691 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1692 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1693 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1694 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1695 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1696 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1697 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1698 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1699 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1700 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1701 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1702 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1703 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1704 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1705 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1706 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1707 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1708 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1709 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1710 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1711 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1712 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1713 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1714 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1715 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1716 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1717 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1718 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1719 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1720 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1721 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1722 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1723 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1724 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1725 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1726 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1727 default:
1728 return NULL;
1729 }
1730}
1731
9a097730 1732static const char *
d3ba0551 1733get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1734{
1735 switch (type)
1736 {
1737 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1738 default:
1739 return NULL;
1740 }
103f02d3
UD		 1741}
1742
7490d522
AM		 1743static const char *
1744get_ppc_dynamic_type (unsigned long type)
1745{
1746 switch (type)
1747 {
a7f2871e 1748 case DT_PPC_GOT: return "PPC_GOT";
e8910a83 1749 case DT_PPC_OPT: return "PPC_OPT";
7490d522
AM		 1750 default:
1751 return NULL;
1752 }
1753}
1754
f1cb7e17 1755static const char *
d3ba0551 1756get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1757{
1758 switch (type)
1759 {
a7f2871e
AM		 1760 case DT_PPC64_GLINK: return "PPC64_GLINK";
1761 case DT_PPC64_OPD: return "PPC64_OPD";
1762 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
e8910a83 1763 case DT_PPC64_OPT: return "PPC64_OPT";
f1cb7e17
AM		 1764 default:
1765 return NULL;
1766 }
1767}
1768
103f02d3 1769static const char *
d3ba0551 1770get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1771{
1772 switch (type)
1773 {
1774 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1775 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1776 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1777 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1778 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1779 case DT_HP_PREINIT: return "HP_PREINIT";
1780 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1781 case DT_HP_NEEDED: return "HP_NEEDED";
1782 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1783 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1784 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1785 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1786 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1787 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1788 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1789 case DT_HP_FILTERED: return "HP_FILTERED";
1790 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1791 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1792 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1793 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1794 case DT_PLT: return "PLT";
1795 case DT_PLT_SIZE: return "PLT_SIZE";
1796 case DT_DLT: return "DLT";
1797 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1798 default:
1799 return NULL;
1800 }
1801}
9a097730 1802
ecc51f48 1803static const char *
d3ba0551 1804get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1805{
1806 switch (type)
1807 {
148b93f2
NC		 1808 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1809 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1810 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1811 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1812 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1813 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1814 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1815 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1816 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1817 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1818 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1819 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1820 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1821 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1822 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1823 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1824 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1825 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1826 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1827 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1828 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1829 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1830 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1831 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1832 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1833 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1834 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1835 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1836 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1837 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1838 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1839 default:
1840 return NULL;
1841 }
1842}
1843
fabcb361
RH		 1844static const char *
1845get_alpha_dynamic_type (unsigned long type)
1846{
1847 switch (type)
1848 {
1849 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1850 default:
1851 return NULL;
1852 }
1853}
1854
1c0d3aa6
NC		 1855static const char *
1856get_score_dynamic_type (unsigned long type)
1857{
1858 switch (type)
1859 {
1860 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1861 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1862 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1863 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1864 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1865 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1866 default:
1867 return NULL;
1868 }
1869}
1870
40b36596
JM		 1871static const char *
1872get_tic6x_dynamic_type (unsigned long type)
1873{
1874 switch (type)
1875 {
1876 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1877 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1878 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1879 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1880 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1881 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1882 default:
1883 return NULL;
1884 }
1885}
1c0d3aa6 1886
36591ba1
SL		 1887static const char *
1888get_nios2_dynamic_type (unsigned long type)
1889{
1890 switch (type)
1891 {
1892 case DT_NIOS2_GP: return "NIOS2_GP";
1893 default:
1894 return NULL;
1895 }
1896}
1897
252b5132 1898static const char *
d3ba0551 1899get_dynamic_type (unsigned long type)
252b5132 1900{
e9e44622 1901 static char buff[64];
252b5132
RH		 1902
1903 switch (type)
1904 {
1905 case DT_NULL: return "NULL";
1906 case DT_NEEDED: return "NEEDED";
1907 case DT_PLTRELSZ: return "PLTRELSZ";
1908 case DT_PLTGOT: return "PLTGOT";
1909 case DT_HASH: return "HASH";
1910 case DT_STRTAB: return "STRTAB";
1911 case DT_SYMTAB: return "SYMTAB";
1912 case DT_RELA: return "RELA";
1913 case DT_RELASZ: return "RELASZ";
1914 case DT_RELAENT: return "RELAENT";
1915 case DT_STRSZ: return "STRSZ";
1916 case DT_SYMENT: return "SYMENT";
1917 case DT_INIT: return "INIT";
1918 case DT_FINI: return "FINI";
1919 case DT_SONAME: return "SONAME";
1920 case DT_RPATH: return "RPATH";
1921 case DT_SYMBOLIC: return "SYMBOLIC";
1922 case DT_REL: return "REL";
1923 case DT_RELSZ: return "RELSZ";
1924 case DT_RELENT: return "RELENT";
1925 case DT_PLTREL: return "PLTREL";
1926 case DT_DEBUG: return "DEBUG";
1927 case DT_TEXTREL: return "TEXTREL";
1928 case DT_JMPREL: return "JMPREL";
1929 case DT_BIND_NOW: return "BIND_NOW";
1930 case DT_INIT_ARRAY: return "INIT_ARRAY";
1931 case DT_FINI_ARRAY: return "FINI_ARRAY";
1932 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1933 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1934 case DT_RUNPATH: return "RUNPATH";
1935 case DT_FLAGS: return "FLAGS";
2d0e6f43 1936
d1133906
NC		 1937 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1938 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1939
05107a46 1940 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1941 case DT_PLTPADSZ: return "PLTPADSZ";
1942 case DT_MOVEENT: return "MOVEENT";
1943 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1944 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1945 case DT_POSFLAG_1: return "POSFLAG_1";
1946 case DT_SYMINSZ: return "SYMINSZ";
1947 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1948
252b5132 1949 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1950 case DT_CONFIG: return "CONFIG";
1951 case DT_DEPAUDIT: return "DEPAUDIT";
1952 case DT_AUDIT: return "AUDIT";
1953 case DT_PLTPAD: return "PLTPAD";
1954 case DT_MOVETAB: return "MOVETAB";
252b5132 1955 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1956
252b5132 1957 case DT_VERSYM: return "VERSYM";
103f02d3 1958
67a4f2b7
AO		 1959 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1960 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1961 case DT_RELACOUNT: return "RELACOUNT";
1962 case DT_RELCOUNT: return "RELCOUNT";
1963 case DT_FLAGS_1: return "FLAGS_1";
1964 case DT_VERDEF: return "VERDEF";
1965 case DT_VERDEFNUM: return "VERDEFNUM";
1966 case DT_VERNEED: return "VERNEED";
1967 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1968
019148e4 1969 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1970 case DT_USED: return "USED";
1971 case DT_FILTER: return "FILTER";
103f02d3 1972
047b2264
JJ		 1973 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1974 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1975 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1976 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1977 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1978 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1979
252b5132
RH		 1980 default:
1981 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1982 {
2cf0635d 1983 const char * result;
103f02d3 1984
252b5132
RH		 1985 switch (elf_header.e_machine)
1986 {
1987 case EM_MIPS:
4fe85591 1988 case EM_MIPS_RS3_LE:
252b5132
RH		 1989 result = get_mips_dynamic_type (type);
1990 break;
9a097730
RH		 1991 case EM_SPARCV9:
1992 result = get_sparc64_dynamic_type (type);
1993 break;
7490d522
AM		 1994 case EM_PPC:
1995 result = get_ppc_dynamic_type (type);
1996 break;
f1cb7e17
AM		 1997 case EM_PPC64:
1998 result = get_ppc64_dynamic_type (type);
1999 break;
ecc51f48
NC		 2000 case EM_IA_64:
2001 result = get_ia64_dynamic_type (type);
2002 break;
fabcb361
RH		 2003 case EM_ALPHA:
2004 result = get_alpha_dynamic_type (type);
2005 break;
1c0d3aa6
NC		 2006 case EM_SCORE:
2007 result = get_score_dynamic_type (type);
2008 break;
40b36596
JM		 2009 case EM_TI_C6000:
2010 result = get_tic6x_dynamic_type (type);
2011 break;
36591ba1
SL		 2012 case EM_ALTERA_NIOS2:
2013 result = get_nios2_dynamic_type (type);
2014 break;
252b5132
RH		 2015 default:
2016 result = NULL;
2017 break;
2018 }
2019
2020 if (result != NULL)
2021 return result;
2022
e9e44622 2023 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 2024 }
eec8f817
DA		 2025 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2026 || (elf_header.e_machine == EM_PARISC
2027 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 2028 {
2cf0635d 2029 const char * result;
103f02d3
UD		 2030
2031 switch (elf_header.e_machine)
2032 {
2033 case EM_PARISC:
2034 result = get_parisc_dynamic_type (type);
2035 break;
148b93f2
NC		 2036 case EM_IA_64:
2037 result = get_ia64_dynamic_type (type);
2038 break;
103f02d3
UD		 2039 default:
2040 result = NULL;
2041 break;
2042 }
2043
2044 if (result != NULL)
2045 return result;
2046
e9e44622
JJ		 2047 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2048 type);
103f02d3 2049 }
252b5132 2050 else
e9e44622 2051 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 2052
252b5132
RH		 2053 return buff;
2054 }
2055}
2056
2057static char *
d3ba0551 2058get_file_type (unsigned e_type)
252b5132 2059{
b34976b6 2060 static char buff[32];
252b5132
RH		 2061
2062 switch (e_type)
2063 {
2064 case ET_NONE: return _("NONE (None)");
2065 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 2066 case ET_EXEC: return _("EXEC (Executable file)");
2067 case ET_DYN: return _("DYN (Shared object file)");
2068 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 2069
2070 default:
2071 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 2072 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 2073 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 2074 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 2075 else
e9e44622 2076 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 2077 return buff;
2078 }
2079}
2080
2081static char *
d3ba0551 2082get_machine_name (unsigned e_machine)
252b5132 2083{
b34976b6 2084 static char buff[64]; /* XXX */
252b5132
RH		 2085
2086 switch (e_machine)
2087 {
c45021f2 2088 case EM_NONE: return _("None");
a06ea964 2089 case EM_AARCH64: return "AArch64";
c45021f2
NC		 2090 case EM_M32: return "WE32100";
2091 case EM_SPARC: return "Sparc";
e9f53129 2092 case EM_SPU: return "SPU";
c45021f2
NC		 2093 case EM_386: return "Intel 80386";
2094 case EM_68K: return "MC68000";
2095 case EM_88K: return "MC88000";
2096 case EM_486: return "Intel 80486";
2097 case EM_860: return "Intel 80860";
2098 case EM_MIPS: return "MIPS R3000";
2099 case EM_S370: return "IBM System/370";
7036c0e1 2100 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 2101 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 2102 case EM_PARISC: return "HPPA";
252b5132 2103 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 2104 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 2105 case EM_960: return "Intel 90860";
2106 case EM_PPC: return "PowerPC";
285d1771 2107 case EM_PPC64: return "PowerPC64";
c45021f2 2108 case EM_FR20: return "Fujitsu FR20";
3f8107ab 2109 case EM_FT32: return "FTDI FT32";
c45021f2 2110 case EM_RH32: return "TRW RH32";
b34976b6 2111 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 2112 case EM_ARM: return "ARM";
2113 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 2114 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 2115 case EM_SPARCV9: return "Sparc v9";
2116 case EM_TRICORE: return "Siemens Tricore";
584da044 2117 case EM_ARC: return "ARC";
c2dcd04e
NC		 2118 case EM_H8_300: return "Renesas H8/300";
2119 case EM_H8_300H: return "Renesas H8/300H";
2120 case EM_H8S: return "Renesas H8S";
2121 case EM_H8_500: return "Renesas H8/500";
30800947 2122 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 2123 case EM_MIPS_X: return "Stanford MIPS-X";
2124 case EM_COLDFIRE: return "Motorola Coldfire";
c45021f2 2125 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 2126 case EM_CYGNUS_D10V:
2127 case EM_D10V: return "d10v";
2128 case EM_CYGNUS_D30V:
b34976b6 2129 case EM_D30V: return "d30v";
2b0337b0 2130 case EM_CYGNUS_M32R:
26597c86 2131 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 2132 case EM_CYGNUS_V850:
708e2187 2133 case EM_V800: return "Renesas V850 (using RH850 ABI)";
f6c1a2d5 2134 case EM_V850: return "Renesas V850";
2b0337b0
AO		 2135 case EM_CYGNUS_MN10300:
2136 case EM_MN10300: return "mn10300";
2137 case EM_CYGNUS_MN10200:
2138 case EM_MN10200: return "mn10200";
5506d11a 2139 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 2140 case EM_CYGNUS_FR30:
2141 case EM_FR30: return "Fujitsu FR30";
b34976b6 2142 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 2143 case EM_PJ_OLD:
b34976b6 2144 case EM_PJ: return "picoJava";
7036c0e1
AJ		 2145 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2146 case EM_PCP: return "Siemens PCP";
2147 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2148 case EM_NDR1: return "Denso NDR1 microprocesspr";
2149 case EM_STARCORE: return "Motorola Star*Core processor";
2150 case EM_ME16: return "Toyota ME16 processor";
2151 case EM_ST100: return "STMicroelectronics ST100 processor";
2152 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 2153 case EM_PDSP: return "Sony DSP processor";
2154 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2155 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 2156 case EM_FX66: return "Siemens FX66 microcontroller";
2157 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2158 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2159 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
6927f982 2160 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ		 2161 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2162 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2163 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2164 case EM_SVX: return "Silicon Graphics SVx";
2165 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2166 case EM_VAX: return "Digital VAX";
619ed720 2167 case EM_VISIUM: return "CDS VISIUMcore processor";
2b0337b0 2168 case EM_AVR_OLD:
b34976b6 2169 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 2170 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 2171 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2172 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2173 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 2174 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 2175 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 2176 case EM_PRISM: return "Vitesse Prism";
bcedfee6 2177 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 2178 case EM_L1OM: return "Intel L1OM";
7a9068fe 2179 case EM_K1OM: return "Intel K1OM";
b7498e0e 2180 case EM_S390_OLD:
b34976b6 2181 case EM_S390: return "IBM S/390";
1c0d3aa6 2182 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 2183 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
73589c9d 2184 case EM_OR1K: return "OpenRISC 1000";
11636f9e 2185 case EM_ARC_A5: return "ARC International ARCompact processor";
1fe1f39c 2186 case EM_CRX: return "National Semiconductor CRX microprocessor";
cfb8c092 2187 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
d172d4ba 2188 case EM_DLX: return "OpenDLX";
1e4cf259 2189 case EM_IP2K_OLD:
b34976b6 2190 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 2191 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 2192 case EM_XTENSA_OLD:
2193 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 2194 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2195 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2196 case EM_NS32K: return "National Semiconductor 32000 series";
2197 case EM_TPC: return "Tenor Network TPC processor";
2198 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2199 case EM_MAX: return "MAX Processor";
2200 case EM_CR: return "National Semiconductor CompactRISC";
2201 case EM_F2MC16: return "Fujitsu F2MC16";
2202 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 2203 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 2204 case EM_M32C_OLD:
49f58d10 2205 case EM_M32C: return "Renesas M32c";
d031aafb 2206 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 2207 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 2208 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2209 case EM_SEP: return "Sharp embedded microprocessor";
2210 case EM_ARCA: return "Arca RISC microprocessor";
2211 case EM_UNICORE: return "Unicore";
2212 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2213 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 2214 case EM_NIOS32: return "Altera Nios";
2215 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 2216 case EM_C166:
d70c5fc7 2217 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 2218 case EM_M16C: return "Renesas M16C series microprocessors";
2219 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2220 case EM_CE: return "Freescale Communication Engine RISC core";
2221 case EM_TSK3000: return "Altium TSK3000 core";
2222 case EM_RS08: return "Freescale RS08 embedded processor";
2223 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2224 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2225 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2226 case EM_SE_C17: return "Seiko Epson C17 family";
2227 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2228 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2229 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2230 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2231 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2232 case EM_R32C: return "Renesas R32C series microprocessors";
2233 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2234 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2235 case EM_8051: return "Intel 8051 and variants";
2236 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2237 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2238 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2239 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2240 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2241 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2242 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 2243 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 2244 case EM_CR16:
f6c1a2d5 2245 case EM_MICROBLAZE:
7ba29e2a 2246 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
99c513f6 2247 case EM_RL78: return "Renesas RL78";
c7927a3c 2248 case EM_RX: return "Renesas RX";
a3c62988 2249 case EM_METAG: return "Imagination Technologies Meta processor architecture";
11636f9e
JM		 2250 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2251 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2252 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2253 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2254 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2255 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2256 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2257 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 2258 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 2259 case EM_CUDA: return "NVIDIA CUDA architecture";
f6c1a2d5 2260 case EM_XGATE: return "Motorola XGATE embedded processor";
252b5132 2261 default:
35d9dd2f 2262 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2263 return buff;
2264 }
2265}
2266
f3485b74 2267static void
d3ba0551 2268decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2269{
2270 unsigned eabi;
2271 int unknown = 0;
2272
2273 eabi = EF_ARM_EABI_VERSION (e_flags);
2274 e_flags &= ~ EF_ARM_EABIMASK;
2275
2276 /* Handle "generic" ARM flags. */
2277 if (e_flags & EF_ARM_RELEXEC)
2278 {
2279 strcat (buf, ", relocatable executable");
2280 e_flags &= ~ EF_ARM_RELEXEC;
2281 }
76da6bbe 2282
f3485b74
NC		 2283 if (e_flags & EF_ARM_HASENTRY)
2284 {
2285 strcat (buf, ", has entry point");
2286 e_flags &= ~ EF_ARM_HASENTRY;
2287 }
76da6bbe 2288
f3485b74
NC		 2289 /* Now handle EABI specific flags. */
2290 switch (eabi)
2291 {
2292 default:
2c71103e 2293 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2294 if (e_flags)
2295 unknown = 1;
2296 break;
2297
2298 case EF_ARM_EABI_VER1:
a5bcd848 2299 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2300 while (e_flags)
2301 {
2302 unsigned flag;
76da6bbe 2303
f3485b74
NC		 2304 /* Process flags one bit at a time. */
2305 flag = e_flags & - e_flags;
2306 e_flags &= ~ flag;
76da6bbe 2307
f3485b74
NC		 2308 switch (flag)
2309 {
a5bcd848 2310 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2311 strcat (buf, ", sorted symbol tables");
2312 break;
76da6bbe 2313
f3485b74
NC		 2314 default:
2315 unknown = 1;
2316 break;
2317 }
2318 }
2319 break;
76da6bbe 2320
a5bcd848
PB		 2321 case EF_ARM_EABI_VER2:
2322 strcat (buf, ", Version2 EABI");
2323 while (e_flags)
2324 {
2325 unsigned flag;
2326
2327 /* Process flags one bit at a time. */
2328 flag = e_flags & - e_flags;
2329 e_flags &= ~ flag;
2330
2331 switch (flag)
2332 {
2333 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2334 strcat (buf, ", sorted symbol tables");
2335 break;
2336
2337 case EF_ARM_DYNSYMSUSESEGIDX:
2338 strcat (buf, ", dynamic symbols use segment index");
2339 break;
2340
2341 case EF_ARM_MAPSYMSFIRST:
2342 strcat (buf, ", mapping symbols precede others");
2343 break;
2344
2345 default:
2346 unknown = 1;
2347 break;
2348 }
2349 }
2350 break;
2351
d507cf36
PB		 2352 case EF_ARM_EABI_VER3:
2353 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2354 break;
2355
2356 case EF_ARM_EABI_VER4:
2357 strcat (buf, ", Version4 EABI");
3bfcb652
NC		 2358 while (e_flags)
2359 {
2360 unsigned flag;
2361
2362 /* Process flags one bit at a time. */
2363 flag = e_flags & - e_flags;
2364 e_flags &= ~ flag;
2365
2366 switch (flag)
2367 {
2368 case EF_ARM_BE8:
2369 strcat (buf, ", BE8");
2370 break;
2371
2372 case EF_ARM_LE8:
2373 strcat (buf, ", LE8");
2374 break;
2375
2376 default:
2377 unknown = 1;
2378 break;
2379 }
2380 break;
2381 }
2382 break;
3a4a14e9
PB		 2383
2384 case EF_ARM_EABI_VER5:
2385 strcat (buf, ", Version5 EABI");
d507cf36
PB		 2386 while (e_flags)
2387 {
2388 unsigned flag;
2389
2390 /* Process flags one bit at a time. */
2391 flag = e_flags & - e_flags;
2392 e_flags &= ~ flag;
2393
2394 switch (flag)
2395 {
2396 case EF_ARM_BE8:
2397 strcat (buf, ", BE8");
2398 break;
2399
2400 case EF_ARM_LE8:
2401 strcat (buf, ", LE8");
2402 break;
2403
3bfcb652
NC		 2404 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2405 strcat (buf, ", soft-float ABI");
2406 break;
2407
2408 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2409 strcat (buf, ", hard-float ABI");
2410 break;
2411
d507cf36
PB		 2412 default:
2413 unknown = 1;
2414 break;
2415 }
2416 }
2417 break;
2418
f3485b74 2419 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2420 strcat (buf, ", GNU EABI");
f3485b74
NC		 2421 while (e_flags)
2422 {
2423 unsigned flag;
76da6bbe 2424
f3485b74
NC		 2425 /* Process flags one bit at a time. */
2426 flag = e_flags & - e_flags;
2427 e_flags &= ~ flag;
76da6bbe 2428
f3485b74
NC		 2429 switch (flag)
2430 {
a5bcd848 2431 case EF_ARM_INTERWORK:
f3485b74
NC		 2432 strcat (buf, ", interworking enabled");
2433 break;
76da6bbe 2434
a5bcd848 2435 case EF_ARM_APCS_26:
f3485b74
NC		 2436 strcat (buf, ", uses APCS/26");
2437 break;
76da6bbe 2438
a5bcd848 2439 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2440 strcat (buf, ", uses APCS/float");
2441 break;
76da6bbe 2442
a5bcd848 2443 case EF_ARM_PIC:
f3485b74
NC		 2444 strcat (buf, ", position independent");
2445 break;
76da6bbe 2446
a5bcd848 2447 case EF_ARM_ALIGN8:
f3485b74
NC		 2448 strcat (buf, ", 8 bit structure alignment");
2449 break;
76da6bbe 2450
a5bcd848 2451 case EF_ARM_NEW_ABI:
f3485b74
NC		 2452 strcat (buf, ", uses new ABI");
2453 break;
76da6bbe 2454
a5bcd848 2455 case EF_ARM_OLD_ABI:
f3485b74
NC		 2456 strcat (buf, ", uses old ABI");
2457 break;
76da6bbe 2458
a5bcd848 2459 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2460 strcat (buf, ", software FP");
2461 break;
76da6bbe 2462
90e01f86
ILT		 2463 case EF_ARM_VFP_FLOAT:
2464 strcat (buf, ", VFP");
2465 break;
2466
fde78edd
NC		 2467 case EF_ARM_MAVERICK_FLOAT:
2468 strcat (buf, ", Maverick FP");
2469 break;
2470
f3485b74
NC		 2471 default:
2472 unknown = 1;
2473 break;
2474 }
2475 }
2476 }
f3485b74
NC		 2477
2478 if (unknown)
2b692964 2479 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2480}
2481
343433df
AB		 2482static void
2483decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2484{
2485 --size; /* Leave space for null terminator. */
2486
2487 switch (e_flags & EF_AVR_MACH)
2488 {
2489 case E_AVR_MACH_AVR1:
2490 strncat (buf, ", avr:1", size);
2491 break;
2492 case E_AVR_MACH_AVR2:
2493 strncat (buf, ", avr:2", size);
2494 break;
2495 case E_AVR_MACH_AVR25:
2496 strncat (buf, ", avr:25", size);
2497 break;
2498 case E_AVR_MACH_AVR3:
2499 strncat (buf, ", avr:3", size);
2500 break;
2501 case E_AVR_MACH_AVR31:
2502 strncat (buf, ", avr:31", size);
2503 break;
2504 case E_AVR_MACH_AVR35:
2505 strncat (buf, ", avr:35", size);
2506 break;
2507 case E_AVR_MACH_AVR4:
2508 strncat (buf, ", avr:4", size);
2509 break;
2510 case E_AVR_MACH_AVR5:
2511 strncat (buf, ", avr:5", size);
2512 break;
2513 case E_AVR_MACH_AVR51:
2514 strncat (buf, ", avr:51", size);
2515 break;
2516 case E_AVR_MACH_AVR6:
2517 strncat (buf, ", avr:6", size);
2518 break;
2519 case E_AVR_MACH_AVRTINY:
2520 strncat (buf, ", avr:100", size);
2521 break;
2522 case E_AVR_MACH_XMEGA1:
2523 strncat (buf, ", avr:101", size);
2524 break;
2525 case E_AVR_MACH_XMEGA2:
2526 strncat (buf, ", avr:102", size);
2527 break;
2528 case E_AVR_MACH_XMEGA3:
2529 strncat (buf, ", avr:103", size);
2530 break;
2531 case E_AVR_MACH_XMEGA4:
2532 strncat (buf, ", avr:104", size);
2533 break;
2534 case E_AVR_MACH_XMEGA5:
2535 strncat (buf, ", avr:105", size);
2536 break;
2537 case E_AVR_MACH_XMEGA6:
2538 strncat (buf, ", avr:106", size);
2539 break;
2540 case E_AVR_MACH_XMEGA7:
2541 strncat (buf, ", avr:107", size);
2542 break;
2543 default:
2544 strncat (buf, ", avr:<unknown>", size);
2545 break;
2546 }
2547
2548 size -= strlen (buf);
2549 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2550 strncat (buf, ", link-relax", size);
2551}
2552
35c08157
KLC		 2553static void
2554decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2555{
2556 unsigned abi;
2557 unsigned arch;
2558 unsigned config;
2559 unsigned version;
2560 int has_fpu = 0;
2561 int r = 0;
2562
2563 static const char *ABI_STRINGS[] =
2564 {
2565 "ABI v0", /* use r5 as return register; only used in N1213HC */
2566 "ABI v1", /* use r0 as return register */
2567 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2568 "ABI v2fp", /* for FPU */
40c7a7cb
KLC		 2569 "AABI",
2570 "ABI2 FP+"
35c08157
KLC		 2571 };
2572 static const char *VER_STRINGS[] =
2573 {
2574 "Andes ELF V1.3 or older",
2575 "Andes ELF V1.3.1",
2576 "Andes ELF V1.4"
2577 };
2578 static const char *ARCH_STRINGS[] =
2579 {
2580 "",
2581 "Andes Star v1.0",
2582 "Andes Star v2.0",
2583 "Andes Star v3.0",
2584 "Andes Star v3.0m"
2585 };
2586
2587 abi = EF_NDS_ABI & e_flags;
2588 arch = EF_NDS_ARCH & e_flags;
2589 config = EF_NDS_INST & e_flags;
2590 version = EF_NDS32_ELF_VERSION & e_flags;
2591
2592 memset (buf, 0, size);
2593
2594 switch (abi)
2595 {
2596 case E_NDS_ABI_V0:
2597 case E_NDS_ABI_V1:
2598 case E_NDS_ABI_V2:
2599 case E_NDS_ABI_V2FP:
2600 case E_NDS_ABI_AABI:
40c7a7cb 2601 case E_NDS_ABI_V2FP_PLUS:
35c08157
KLC		 2602 /* In case there are holes in the array. */
2603 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2604 break;
2605
2606 default:
2607 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2608 break;
2609 }
2610
2611 switch (version)
2612 {
2613 case E_NDS32_ELF_VER_1_2:
2614 case E_NDS32_ELF_VER_1_3:
2615 case E_NDS32_ELF_VER_1_4:
2616 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2617 break;
2618
2619 default:
2620 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2621 break;
2622 }
2623
2624 if (E_NDS_ABI_V0 == abi)
2625 {
2626 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2627 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2628 if (arch == E_NDS_ARCH_STAR_V1_0)
2629 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2630 return;
2631 }
2632
2633 switch (arch)
2634 {
2635 case E_NDS_ARCH_STAR_V1_0:
2636 case E_NDS_ARCH_STAR_V2_0:
2637 case E_NDS_ARCH_STAR_V3_0:
2638 case E_NDS_ARCH_STAR_V3_M:
2639 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2640 break;
2641
2642 default:
2643 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2644 /* ARCH version determines how the e_flags are interpreted.
2645 If it is unknown, we cannot proceed. */
2646 return;
2647 }
2648
2649 /* Newer ABI; Now handle architecture specific flags. */
2650 if (arch == E_NDS_ARCH_STAR_V1_0)
2651 {
2652 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2653 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2654
2655 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2656 r += snprintf (buf + r, size -r, ", MAC");
2657
2658 if (config & E_NDS32_HAS_DIV_INST)
2659 r += snprintf (buf + r, size -r, ", DIV");
2660
2661 if (config & E_NDS32_HAS_16BIT_INST)
2662 r += snprintf (buf + r, size -r, ", 16b");
2663 }
2664 else
2665 {
2666 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2667 {
2668 if (version <= E_NDS32_ELF_VER_1_3)
2669 r += snprintf (buf + r, size -r, ", [B8]");
2670 else
2671 r += snprintf (buf + r, size -r, ", EX9");
2672 }
2673
2674 if (config & E_NDS32_HAS_MAC_DX_INST)
2675 r += snprintf (buf + r, size -r, ", MAC_DX");
2676
2677 if (config & E_NDS32_HAS_DIV_DX_INST)
2678 r += snprintf (buf + r, size -r, ", DIV_DX");
2679
2680 if (config & E_NDS32_HAS_16BIT_INST)
2681 {
2682 if (version <= E_NDS32_ELF_VER_1_3)
2683 r += snprintf (buf + r, size -r, ", 16b");
2684 else
2685 r += snprintf (buf + r, size -r, ", IFC");
2686 }
2687 }
2688
2689 if (config & E_NDS32_HAS_EXT_INST)
2690 r += snprintf (buf + r, size -r, ", PERF1");
2691
2692 if (config & E_NDS32_HAS_EXT2_INST)
2693 r += snprintf (buf + r, size -r, ", PERF2");
2694
2695 if (config & E_NDS32_HAS_FPU_INST)
2696 {
2697 has_fpu = 1;
2698 r += snprintf (buf + r, size -r, ", FPU_SP");
2699 }
2700
2701 if (config & E_NDS32_HAS_FPU_DP_INST)
2702 {
2703 has_fpu = 1;
2704 r += snprintf (buf + r, size -r, ", FPU_DP");
2705 }
2706
2707 if (config & E_NDS32_HAS_FPU_MAC_INST)
2708 {
2709 has_fpu = 1;
2710 r += snprintf (buf + r, size -r, ", FPU_MAC");
2711 }
2712
2713 if (has_fpu)
2714 {
2715 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2716 {
2717 case E_NDS32_FPU_REG_8SP_4DP:
2718 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2719 break;
2720 case E_NDS32_FPU_REG_16SP_8DP:
2721 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2722 break;
2723 case E_NDS32_FPU_REG_32SP_16DP:
2724 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2725 break;
2726 case E_NDS32_FPU_REG_32SP_32DP:
2727 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2728 break;
2729 }
2730 }
2731
2732 if (config & E_NDS32_HAS_AUDIO_INST)
2733 r += snprintf (buf + r, size -r, ", AUDIO");
2734
2735 if (config & E_NDS32_HAS_STRING_INST)
2736 r += snprintf (buf + r, size -r, ", STR");
2737
2738 if (config & E_NDS32_HAS_REDUCED_REGS)
2739 r += snprintf (buf + r, size -r, ", 16REG");
2740
2741 if (config & E_NDS32_HAS_VIDEO_INST)
2742 {
2743 if (version <= E_NDS32_ELF_VER_1_3)
2744 r += snprintf (buf + r, size -r, ", VIDEO");
2745 else
2746 r += snprintf (buf + r, size -r, ", SATURATION");
2747 }
2748
2749 if (config & E_NDS32_HAS_ENCRIPT_INST)
2750 r += snprintf (buf + r, size -r, ", ENCRP");
2751
2752 if (config & E_NDS32_HAS_L2C_INST)
2753 r += snprintf (buf + r, size -r, ", L2C");
2754}
2755
252b5132 2756static char *
d3ba0551 2757get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2758{
b34976b6 2759 static char buf[1024];
252b5132
RH		 2760
2761 buf[0] = '\0';
76da6bbe 2762
252b5132
RH		 2763 if (e_flags)
2764 {
2765 switch (e_machine)
2766 {
2767 default:
2768 break;
2769
f3485b74
NC		 2770 case EM_ARM:
2771 decode_ARM_machine_flags (e_flags, buf);
2772 break;
76da6bbe 2773
343433df
AB		 2774 case EM_AVR:
2775 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2776 break;
2777
781303ce
MF		 2778 case EM_BLACKFIN:
2779 if (e_flags & EF_BFIN_PIC)
2780 strcat (buf, ", PIC");
2781
2782 if (e_flags & EF_BFIN_FDPIC)
2783 strcat (buf, ", FDPIC");
2784
2785 if (e_flags & EF_BFIN_CODE_IN_L1)
2786 strcat (buf, ", code in L1");
2787
2788 if (e_flags & EF_BFIN_DATA_IN_L1)
2789 strcat (buf, ", data in L1");
2790
2791 break;
2792
ec2dfb42
AO		 2793 case EM_CYGNUS_FRV:
2794 switch (e_flags & EF_FRV_CPU_MASK)
2795 {
2796 case EF_FRV_CPU_GENERIC:
2797 break;
2798
2799 default:
2800 strcat (buf, ", fr???");
2801 break;
57346661 2802
ec2dfb42
AO		 2803 case EF_FRV_CPU_FR300:
2804 strcat (buf, ", fr300");
2805 break;
2806
2807 case EF_FRV_CPU_FR400:
2808 strcat (buf, ", fr400");
2809 break;
2810 case EF_FRV_CPU_FR405:
2811 strcat (buf, ", fr405");
2812 break;
2813
2814 case EF_FRV_CPU_FR450:
2815 strcat (buf, ", fr450");
2816 break;
2817
2818 case EF_FRV_CPU_FR500:
2819 strcat (buf, ", fr500");
2820 break;
2821 case EF_FRV_CPU_FR550:
2822 strcat (buf, ", fr550");
2823 break;
2824
2825 case EF_FRV_CPU_SIMPLE:
2826 strcat (buf, ", simple");
2827 break;
2828 case EF_FRV_CPU_TOMCAT:
2829 strcat (buf, ", tomcat");
2830 break;
2831 }
1c877e87 2832 break;
ec2dfb42 2833
53c7db4b 2834 case EM_68K:
425c6cb0 2835 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2836 strcat (buf, ", m68000");
425c6cb0 2837 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2838 strcat (buf, ", cpu32");
2839 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2840 strcat (buf, ", fido_a");
425c6cb0 2841 else
266abb8f 2842 {
2cf0635d
NC		 2843 char const * isa = _("unknown");
2844 char const * mac = _("unknown mac");
2845 char const * additional = NULL;
0112cd26 2846
c694fd50 2847 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2848 {
c694fd50 2849 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2850 isa = "A";
2851 additional = ", nodiv";
2852 break;
c694fd50 2853 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2854 isa = "A";
2855 break;
c694fd50 2856 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2857 isa = "A+";
2858 break;
c694fd50 2859 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2860 isa = "B";
2861 additional = ", nousp";
2862 break;
c694fd50 2863 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2864 isa = "B";
2865 break;
f608cd77
NS		 2866 case EF_M68K_CF_ISA_C:
2867 isa = "C";
2868 break;
2869 case EF_M68K_CF_ISA_C_NODIV:
2870 isa = "C";
2871 additional = ", nodiv";
2872 break;
266abb8f
NS		 2873 }
2874 strcat (buf, ", cf, isa ");
2875 strcat (buf, isa);
0b2e31dc
NS		 2876 if (additional)
2877 strcat (buf, additional);
c694fd50 2878 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2879 strcat (buf, ", float");
c694fd50 2880 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2881 {
2882 case 0:
2883 mac = NULL;
2884 break;
c694fd50 2885 case EF_M68K_CF_MAC:
266abb8f
NS		 2886 mac = "mac";
2887 break;
c694fd50 2888 case EF_M68K_CF_EMAC:
266abb8f
NS		 2889 mac = "emac";
2890 break;
f608cd77
NS		 2891 case EF_M68K_CF_EMAC_B:
2892 mac = "emac_b";
2893 break;
266abb8f
NS		 2894 }
2895 if (mac)
2896 {
2897 strcat (buf, ", ");
2898 strcat (buf, mac);
2899 }
266abb8f 2900 }
53c7db4b 2901 break;
33c63f9d 2902
252b5132
RH		 2903 case EM_PPC:
2904 if (e_flags & EF_PPC_EMB)
2905 strcat (buf, ", emb");
2906
2907 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2908 strcat (buf, _(", relocatable"));
252b5132
RH		 2909
2910 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 2911 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 2912 break;
2913
ee67d69a
AM		 2914 case EM_PPC64:
2915 if (e_flags & EF_PPC64_ABI)
2916 {
2917 char abi[] = ", abiv0";
2918
2919 abi[6] += e_flags & EF_PPC64_ABI;
2920 strcat (buf, abi);
2921 }
2922 break;
2923
708e2187
NC		 2924 case EM_V800:
2925 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2926 strcat (buf, ", RH850 ABI");
0b4362b0 2927
708e2187
NC		 2928 if (e_flags & EF_V800_850E3)
2929 strcat (buf, ", V3 architecture");
2930
2931 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2932 strcat (buf, ", FPU not used");
2933
2934 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2935 strcat (buf, ", regmode: COMMON");
2936
2937 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2938 strcat (buf, ", r4 not used");
2939
2940 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2941 strcat (buf, ", r30 not used");
2942
2943 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2944 strcat (buf, ", r5 not used");
2945
2946 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2947 strcat (buf, ", r2 not used");
2948
2949 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2950 {
2951 switch (e_flags & - e_flags)
2952 {
2953 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2954 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
708e2187
NC		 2955 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2956 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
708e2187
NC		 2957 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2958 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2959 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2960 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2961 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2962 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2963 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2964 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2965 default: break;
2966 }
2967 }
2968 break;
2969
2b0337b0 2970 case EM_V850:
252b5132
RH		 2971 case EM_CYGNUS_V850:
2972 switch (e_flags & EF_V850_ARCH)
2973 {
78c8d46c
NC		 2974 case E_V850E3V5_ARCH:
2975 strcat (buf, ", v850e3v5");
2976 break;
1cd986c5
NC		 2977 case E_V850E2V3_ARCH:
2978 strcat (buf, ", v850e2v3");
2979 break;
2980 case E_V850E2_ARCH:
2981 strcat (buf, ", v850e2");
2982 break;
2983 case E_V850E1_ARCH:
2984 strcat (buf, ", v850e1");
8ad30312 2985 break;
252b5132
RH		 2986 case E_V850E_ARCH:
2987 strcat (buf, ", v850e");
2988 break;
252b5132
RH		 2989 case E_V850_ARCH:
2990 strcat (buf, ", v850");
2991 break;
2992 default:
2b692964 2993 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 2994 break;
2995 }
2996 break;
2997
2b0337b0 2998 case EM_M32R:
252b5132
RH		 2999 case EM_CYGNUS_M32R:
3000 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3001 strcat (buf, ", m32r");
252b5132
RH		 3002 break;
3003
3004 case EM_MIPS:
4fe85591 3005 case EM_MIPS_RS3_LE:
252b5132
RH		 3006 if (e_flags & EF_MIPS_NOREORDER)
3007 strcat (buf, ", noreorder");
3008
3009 if (e_flags & EF_MIPS_PIC)
3010 strcat (buf, ", pic");
3011
3012 if (e_flags & EF_MIPS_CPIC)
3013 strcat (buf, ", cpic");
3014
d1bdd336
TS		 3015 if (e_flags & EF_MIPS_UCODE)
3016 strcat (buf, ", ugen_reserved");
3017
252b5132
RH		 3018 if (e_flags & EF_MIPS_ABI2)
3019 strcat (buf, ", abi2");
3020
43521d43
TS		 3021 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3022 strcat (buf, ", odk first");
3023
a5d22d2a
TS		 3024 if (e_flags & EF_MIPS_32BITMODE)
3025 strcat (buf, ", 32bitmode");
3026
ba92f887
MR		 3027 if (e_flags & EF_MIPS_NAN2008)
3028 strcat (buf, ", nan2008");
3029
fef1b0b3
SE		 3030 if (e_flags & EF_MIPS_FP64)
3031 strcat (buf, ", fp64");
3032
156c2f8b
NC		 3033 switch ((e_flags & EF_MIPS_MACH))
3034 {
3035 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3036 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3037 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 3038 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 3039 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3040 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3041 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3042 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 3043 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 3044 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 3045 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3046 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 3047 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 3048 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 3049 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
d32e5c54 3050 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
52b6b6b9 3051 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 3052 case 0:
3053 /* We simply ignore the field in this case to avoid confusion:
3054 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3055 extension. */
3056 break;
2b692964 3057 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 3058 }
43521d43
TS		 3059
3060 switch ((e_flags & EF_MIPS_ABI))
3061 {
3062 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3063 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3064 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3065 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3066 case 0:
3067 /* We simply ignore the field in this case to avoid confusion:
3068 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3069 This means it is likely to be an o32 file, but not for
3070 sure. */
3071 break;
2b692964 3072 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 3073 }
3074
3075 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3076 strcat (buf, ", mdmx");
3077
3078 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3079 strcat (buf, ", mips16");
3080
df58fc94
RS		 3081 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3082 strcat (buf, ", micromips");
3083
43521d43
TS		 3084 switch ((e_flags & EF_MIPS_ARCH))
3085 {
3086 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3087 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3088 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3089 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3090 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3091 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 3092 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
7361da2c 3093 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
43521d43 3094 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 3095 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
7361da2c 3096 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
2b692964 3097 default: strcat (buf, _(", unknown ISA")); break;
43521d43 3098 }
252b5132 3099 break;
351b4b40 3100
35c08157
KLC		 3101 case EM_NDS32:
3102 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3103 break;
3104
ccde1100
AO		 3105 case EM_SH:
3106 switch ((e_flags & EF_SH_MACH_MASK))
3107 {
3108 case EF_SH1: strcat (buf, ", sh1"); break;
3109 case EF_SH2: strcat (buf, ", sh2"); break;
3110 case EF_SH3: strcat (buf, ", sh3"); break;
3111 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3112 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3113 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3114 case EF_SH3E: strcat (buf, ", sh3e"); break;
3115 case EF_SH4: strcat (buf, ", sh4"); break;
3116 case EF_SH5: strcat (buf, ", sh5"); break;
3117 case EF_SH2E: strcat (buf, ", sh2e"); break;
3118 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 3119 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 3120 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3121 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 3122 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 3123 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3124 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3125 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3126 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3127 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3128 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 3129 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 3130 }
3131
cec6a5b8
MR		 3132 if (e_flags & EF_SH_PIC)
3133 strcat (buf, ", pic");
3134
3135 if (e_flags & EF_SH_FDPIC)
3136 strcat (buf, ", fdpic");
ccde1100 3137 break;
948f632f 3138
73589c9d
CS		 3139 case EM_OR1K:
3140 if (e_flags & EF_OR1K_NODELAY)
3141 strcat (buf, ", no delay");
3142 break;
57346661 3143
351b4b40
RH		 3144 case EM_SPARCV9:
3145 if (e_flags & EF_SPARC_32PLUS)
3146 strcat (buf, ", v8+");
3147
3148 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 3149 strcat (buf, ", ultrasparcI");
3150
3151 if (e_flags & EF_SPARC_SUN_US3)
3152 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 3153
3154 if (e_flags & EF_SPARC_HAL_R1)
3155 strcat (buf, ", halr1");
3156
3157 if (e_flags & EF_SPARC_LEDATA)
3158 strcat (buf, ", ledata");
3159
3160 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3161 strcat (buf, ", tso");
3162
3163 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3164 strcat (buf, ", pso");
3165
3166 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3167 strcat (buf, ", rmo");
3168 break;
7d466069 3169
103f02d3
UD		 3170 case EM_PARISC:
3171 switch (e_flags & EF_PARISC_ARCH)
3172 {
3173 case EFA_PARISC_1_0:
3174 strcpy (buf, ", PA-RISC 1.0");
3175 break;
3176 case EFA_PARISC_1_1:
3177 strcpy (buf, ", PA-RISC 1.1");
3178 break;
3179 case EFA_PARISC_2_0:
3180 strcpy (buf, ", PA-RISC 2.0");
3181 break;
3182 default:
3183 break;
3184 }
3185 if (e_flags & EF_PARISC_TRAPNIL)
3186 strcat (buf, ", trapnil");
3187 if (e_flags & EF_PARISC_EXT)
3188 strcat (buf, ", ext");
3189 if (e_flags & EF_PARISC_LSB)
3190 strcat (buf, ", lsb");
3191 if (e_flags & EF_PARISC_WIDE)
3192 strcat (buf, ", wide");
3193 if (e_flags & EF_PARISC_NO_KABP)
3194 strcat (buf, ", no kabp");
3195 if (e_flags & EF_PARISC_LAZYSWAP)
3196 strcat (buf, ", lazyswap");
30800947 3197 break;
76da6bbe 3198
7d466069 3199 case EM_PJ:
2b0337b0 3200 case EM_PJ_OLD:
7d466069
ILT		 3201 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3202 strcat (buf, ", new calling convention");
3203
3204 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3205 strcat (buf, ", gnu calling convention");
3206 break;
4d6ed7c8
NC		 3207
3208 case EM_IA_64:
3209 if ((e_flags & EF_IA_64_ABI64))
3210 strcat (buf, ", 64-bit");
3211 else
3212 strcat (buf, ", 32-bit");
3213 if ((e_flags & EF_IA_64_REDUCEDFP))
3214 strcat (buf, ", reduced fp model");
3215 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3216 strcat (buf, ", no function descriptors, constant gp");
3217 else if ((e_flags & EF_IA_64_CONS_GP))
3218 strcat (buf, ", constant gp");
3219 if ((e_flags & EF_IA_64_ABSOLUTE))
3220 strcat (buf, ", absolute");
28f997cf
TG		 3221 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3222 {
3223 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3224 strcat (buf, ", vms_linkages");
3225 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3226 {
3227 case EF_IA_64_VMS_COMCOD_SUCCESS:
3228 break;
3229 case EF_IA_64_VMS_COMCOD_WARNING:
3230 strcat (buf, ", warning");
3231 break;
3232 case EF_IA_64_VMS_COMCOD_ERROR:
3233 strcat (buf, ", error");
3234 break;
3235 case EF_IA_64_VMS_COMCOD_ABORT:
3236 strcat (buf, ", abort");
3237 break;
3238 default:
bee0ee85
NC		 3239 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3240 e_flags & EF_IA_64_VMS_COMCOD);
3241 strcat (buf, ", <unknown>");
28f997cf
TG		 3242 }
3243 }
4d6ed7c8 3244 break;
179d3252
JT		 3245
3246 case EM_VAX:
3247 if ((e_flags & EF_VAX_NONPIC))
3248 strcat (buf, ", non-PIC");
3249 if ((e_flags & EF_VAX_DFLOAT))
3250 strcat (buf, ", D-Float");
3251 if ((e_flags & EF_VAX_GFLOAT))
3252 strcat (buf, ", G-Float");
3253 break;
c7927a3c 3254
619ed720
EB		 3255 case EM_VISIUM:
3256 if (e_flags & EF_VISIUM_ARCH_MCM)
3257 strcat (buf, ", mcm");
3258 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3259 strcat (buf, ", mcm24");
3260 if (e_flags & EF_VISIUM_ARCH_GR6)
3261 strcat (buf, ", gr6");
3262 break;
3263
4046d87a
NC		 3264 case EM_RL78:
3265 if (e_flags & E_FLAG_RL78_G10)
3266 strcat (buf, ", G10");
856ea05c
KP		 3267 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3268 strcat (buf, ", 64-bit doubles");
4046d87a 3269 break;
0b4362b0 3270
c7927a3c
NC		 3271 case EM_RX:
3272 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3273 strcat (buf, ", 64-bit doubles");
3274 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 3275 strcat (buf, ", dsp");
d4cb0ea0 3276 if (e_flags & E_FLAG_RX_PID)
0b4362b0 3277 strcat (buf, ", pid");
708e2187
NC		 3278 if (e_flags & E_FLAG_RX_ABI)
3279 strcat (buf, ", RX ABI");
d4cb0ea0 3280 break;
55786da2
AK		 3281
3282 case EM_S390:
3283 if (e_flags & EF_S390_HIGH_GPRS)
3284 strcat (buf, ", highgprs");
d4cb0ea0 3285 break;
40b36596
JM		 3286
3287 case EM_TI_C6000:
3288 if ((e_flags & EF_C6000_REL))
3289 strcat (buf, ", relocatable module");
d4cb0ea0 3290 break;
13761a11
NC		 3291
3292 case EM_MSP430:
3293 strcat (buf, _(": architecture variant: "));
3294 switch (e_flags & EF_MSP430_MACH)
3295 {
3296 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3297 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3298 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3299 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3300 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3301 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3302 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3303 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3304 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3305 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3306 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3307 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3308 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3309 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3310 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3311 default:
3312 strcat (buf, _(": unknown")); break;
3313 }
3314
3315 if (e_flags & ~ EF_MSP430_MACH)
3316 strcat (buf, _(": unknown extra flag bits also present"));
252b5132
RH		 3317 }
3318 }
3319
3320 return buf;
3321}
3322
252b5132 3323static const char *
d3ba0551
AM		 3324get_osabi_name (unsigned int osabi)
3325{
3326 static char buff[32];
3327
3328 switch (osabi)
3329 {
3330 case ELFOSABI_NONE: return "UNIX - System V";
3331 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3332 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 3333 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 3334 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3335 case ELFOSABI_AIX: return "UNIX - AIX";
3336 case ELFOSABI_IRIX: return "UNIX - IRIX";
3337 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3338 case ELFOSABI_TRU64: return "UNIX - TRU64";
3339 case ELFOSABI_MODESTO: return "Novell - Modesto";
3340 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3341 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3342 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 3343 case ELFOSABI_AROS: return "AROS";
11636f9e 3344 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 3345 default:
40b36596
JM		 3346 if (osabi >= 64)
3347 switch (elf_header.e_machine)
3348 {
3349 case EM_ARM:
3350 switch (osabi)
3351 {
3352 case ELFOSABI_ARM: return "ARM";
3353 default:
3354 break;
3355 }
3356 break;
3357
3358 case EM_MSP430:
3359 case EM_MSP430_OLD:
619ed720 3360 case EM_VISIUM:
40b36596
JM		 3361 switch (osabi)
3362 {
3363 case ELFOSABI_STANDALONE: return _("Standalone App");
3364 default:
3365 break;
3366 }
3367 break;
3368
3369 case EM_TI_C6000:
3370 switch (osabi)
3371 {
3372 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3373 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3374 default:
3375 break;
3376 }
3377 break;
3378
3379 default:
3380 break;
3381 }
e9e44622 3382 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 3383 return buff;
3384 }
3385}
3386
a06ea964
NC		 3387static const char *
3388get_aarch64_segment_type (unsigned long type)
3389{
3390 switch (type)
3391 {
3392 case PT_AARCH64_ARCHEXT:
3393 return "AARCH64_ARCHEXT";
3394 default:
3395 break;
3396 }
3397
3398 return NULL;
3399}
3400
b294bdf8
MM		 3401static const char *
3402get_arm_segment_type (unsigned long type)
3403{
3404 switch (type)
3405 {
3406 case PT_ARM_EXIDX:
3407 return "EXIDX";
3408 default:
3409 break;
3410 }
3411
3412 return NULL;
3413}
3414
d3ba0551
AM		 3415static const char *
3416get_mips_segment_type (unsigned long type)
252b5132
RH		 3417{
3418 switch (type)
3419 {
3420 case PT_MIPS_REGINFO:
3421 return "REGINFO";
3422 case PT_MIPS_RTPROC:
3423 return "RTPROC";
3424 case PT_MIPS_OPTIONS:
3425 return "OPTIONS";
351cdf24
MF		 3426 case PT_MIPS_ABIFLAGS:
3427 return "ABIFLAGS";
252b5132
RH		 3428 default:
3429 break;
3430 }
3431
3432 return NULL;
3433}
3434
103f02d3 3435static const char *
d3ba0551 3436get_parisc_segment_type (unsigned long type)
103f02d3
UD		 3437{
3438 switch (type)
3439 {
3440 case PT_HP_TLS: return "HP_TLS";
3441 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3442 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3443 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3444 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3445 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3446 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3447 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3448 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3449 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3450 case PT_HP_PARALLEL: return "HP_PARALLEL";
3451 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 3452 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3453 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3454 case PT_HP_STACK: return "HP_STACK";
3455 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 3456 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3457 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 3458 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 3459 default:
3460 break;
3461 }
3462
3463 return NULL;
3464}
3465
4d6ed7c8 3466static const char *
d3ba0551 3467get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 3468{
3469 switch (type)
3470 {
3471 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3472 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 3473 case PT_HP_TLS: return "HP_TLS";
3474 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3475 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3476 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 3477 default:
3478 break;
3479 }
3480
3481 return NULL;
3482}
3483
40b36596
JM		 3484static const char *
3485get_tic6x_segment_type (unsigned long type)
3486{
3487 switch (type)
3488 {
3489 case PT_C6000_PHATTR: return "C6000_PHATTR";
3490 default:
3491 break;
3492 }
3493
3494 return NULL;
3495}
3496
252b5132 3497static const char *
d3ba0551 3498get_segment_type (unsigned long p_type)
252b5132 3499{
b34976b6 3500 static char buff[32];
252b5132
RH		 3501
3502 switch (p_type)
3503 {
b34976b6
AM		 3504 case PT_NULL: return "NULL";
3505 case PT_LOAD: return "LOAD";
252b5132 3506 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 3507 case PT_INTERP: return "INTERP";
3508 case PT_NOTE: return "NOTE";
3509 case PT_SHLIB: return "SHLIB";
3510 case PT_PHDR: return "PHDR";
13ae64f3 3511 case PT_TLS: return "TLS";
252b5132 3512
65765700
JJ		 3513 case PT_GNU_EH_FRAME:
3514 return "GNU_EH_FRAME";
2b05f1b7 3515 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 3516 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 3517
252b5132
RH		 3518 default:
3519 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3520 {
2cf0635d 3521 const char * result;
103f02d3 3522
252b5132
RH		 3523 switch (elf_header.e_machine)
3524 {
a06ea964
NC		 3525 case EM_AARCH64:
3526 result = get_aarch64_segment_type (p_type);
3527 break;
b294bdf8
MM		 3528 case EM_ARM:
3529 result = get_arm_segment_type (p_type);
3530 break;
252b5132 3531 case EM_MIPS:
4fe85591 3532 case EM_MIPS_RS3_LE:
252b5132
RH		 3533 result = get_mips_segment_type (p_type);
3534 break;
103f02d3
UD		 3535 case EM_PARISC:
3536 result = get_parisc_segment_type (p_type);
3537 break;
4d6ed7c8
NC		 3538 case EM_IA_64:
3539 result = get_ia64_segment_type (p_type);
3540 break;
40b36596
JM		 3541 case EM_TI_C6000:
3542 result = get_tic6x_segment_type (p_type);
3543 break;
252b5132
RH		 3544 default:
3545 result = NULL;
3546 break;
3547 }
103f02d3 3548
252b5132
RH		 3549 if (result != NULL)
3550 return result;
103f02d3 3551
252b5132
RH		 3552 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3553 }
3554 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3555 {
2cf0635d 3556 const char * result;
103f02d3
UD		 3557
3558 switch (elf_header.e_machine)
3559 {
3560 case EM_PARISC:
3561 result = get_parisc_segment_type (p_type);
3562 break;
00428cca
AM		 3563 case EM_IA_64:
3564 result = get_ia64_segment_type (p_type);
3565 break;
103f02d3
UD		 3566 default:
3567 result = NULL;
3568 break;
3569 }
3570
3571 if (result != NULL)
3572 return result;
3573
3574 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3575 }
252b5132 3576 else
e9e44622 3577 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3578
3579 return buff;
3580 }
3581}
3582
3583static const char *
d3ba0551 3584get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3585{
3586 switch (sh_type)
3587 {
b34976b6
AM		 3588 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3589 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3590 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3591 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3592 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3593 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3594 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3595 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3596 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3597 case SHT_MIPS_RELD: return "MIPS_RELD";
3598 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3599 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3600 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3601 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3602 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3603 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3604 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3605 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3606 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3607 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3608 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3609 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3610 case SHT_MIPS_LINE: return "MIPS_LINE";
3611 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3612 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3613 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3614 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3615 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3616 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3617 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3618 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3619 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3620 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3621 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3622 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3623 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3624 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3625 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132 3626 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
351cdf24 3627 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
252b5132
RH		 3628 default:
3629 break;
3630 }
3631 return NULL;
3632}
3633
103f02d3 3634static const char *
d3ba0551 3635get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3636{
3637 switch (sh_type)
3638 {
3639 case SHT_PARISC_EXT: return "PARISC_EXT";
3640 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3641 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3642 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3643 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3644 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3645 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3646 default:
3647 break;
3648 }
3649 return NULL;
3650}
3651
4d6ed7c8 3652static const char *
d3ba0551 3653get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3654{
18bd398b 3655 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3656 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3657 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3658
4d6ed7c8
NC		 3659 switch (sh_type)
3660 {
148b93f2
NC		 3661 case SHT_IA_64_EXT: return "IA_64_EXT";
3662 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3663 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3664 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3665 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3666 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3667 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3668 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3669 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3670 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3671 default:
3672 break;
3673 }
3674 return NULL;
3675}
3676
d2b2c203
DJ		 3677static const char *
3678get_x86_64_section_type_name (unsigned int sh_type)
3679{
3680 switch (sh_type)
3681 {
3682 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3683 default:
3684 break;
3685 }
3686 return NULL;
3687}
3688
a06ea964
NC		 3689static const char *
3690get_aarch64_section_type_name (unsigned int sh_type)
3691{
3692 switch (sh_type)
3693 {
3694 case SHT_AARCH64_ATTRIBUTES:
3695 return "AARCH64_ATTRIBUTES";
3696 default:
3697 break;
3698 }
3699 return NULL;
3700}
3701
40a18ebd
NC		 3702static const char *
3703get_arm_section_type_name (unsigned int sh_type)
3704{
3705 switch (sh_type)
3706 {
7f6fed87
NC		 3707 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3708 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3709 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3710 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3711 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3712 default:
3713 break;
3714 }
3715 return NULL;
3716}
3717
40b36596
JM		 3718static const char *
3719get_tic6x_section_type_name (unsigned int sh_type)
3720{
3721 switch (sh_type)
3722 {
3723 case SHT_C6000_UNWIND:
3724 return "C6000_UNWIND";
3725 case SHT_C6000_PREEMPTMAP:
3726 return "C6000_PREEMPTMAP";
3727 case SHT_C6000_ATTRIBUTES:
3728 return "C6000_ATTRIBUTES";
3729 case SHT_TI_ICODE:
3730 return "TI_ICODE";
3731 case SHT_TI_XREF:
3732 return "TI_XREF";
3733 case SHT_TI_HANDLER:
3734 return "TI_HANDLER";
3735 case SHT_TI_INITINFO:
3736 return "TI_INITINFO";
3737 case SHT_TI_PHATTRS:
3738 return "TI_PHATTRS";
3739 default:
3740 break;
3741 }
3742 return NULL;
3743}
3744
13761a11
NC		 3745static const char *
3746get_msp430x_section_type_name (unsigned int sh_type)
3747{
3748 switch (sh_type)
3749 {
3750 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3751 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3752 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3753 default: return NULL;
3754 }
3755}
3756
685080f2
NC		 3757static const char *
3758get_v850_section_type_name (unsigned int sh_type)
3759{
3760 switch (sh_type)
3761 {
3762 case SHT_V850_SCOMMON: return "V850 Small Common";
3763 case SHT_V850_TCOMMON: return "V850 Tiny Common";
3764 case SHT_V850_ZCOMMON: return "V850 Zero Common";
3765 case SHT_RENESAS_IOP: return "RENESAS IOP";
3766 case SHT_RENESAS_INFO: return "RENESAS INFO";
3767 default: return NULL;
3768 }
3769}
3770
252b5132 3771static const char *
d3ba0551 3772get_section_type_name (unsigned int sh_type)
252b5132 3773{
b34976b6 3774 static char buff[32];
252b5132
RH		 3775
3776 switch (sh_type)
3777 {
3778 case SHT_NULL: return "NULL";
3779 case SHT_PROGBITS: return "PROGBITS";
3780 case SHT_SYMTAB: return "SYMTAB";
3781 case SHT_STRTAB: return "STRTAB";
3782 case SHT_RELA: return "RELA";
3783 case SHT_HASH: return "HASH";
3784 case SHT_DYNAMIC: return "DYNAMIC";
3785 case SHT_NOTE: return "NOTE";
3786 case SHT_NOBITS: return "NOBITS";
3787 case SHT_REL: return "REL";
3788 case SHT_SHLIB: return "SHLIB";
3789 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3790 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3791 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3792 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3793 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3794 case SHT_GROUP: return "GROUP";
3795 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3796 case SHT_GNU_verdef: return "VERDEF";
3797 case SHT_GNU_verneed: return "VERNEED";
3798 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3799 case 0x6ffffff0: return "VERSYM";
3800 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3801 case 0x7ffffffd: return "AUXILIARY";
3802 case 0x7fffffff: return "FILTER";
047b2264 3803 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3804
3805 default:
3806 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3807 {
2cf0635d 3808 const char * result;
252b5132
RH		 3809
3810 switch (elf_header.e_machine)
3811 {
3812 case EM_MIPS:
4fe85591 3813 case EM_MIPS_RS3_LE:
252b5132
RH		 3814 result = get_mips_section_type_name (sh_type);
3815 break;
103f02d3
UD		 3816 case EM_PARISC:
3817 result = get_parisc_section_type_name (sh_type);
3818 break;
4d6ed7c8
NC		 3819 case EM_IA_64:
3820 result = get_ia64_section_type_name (sh_type);
3821 break;
d2b2c203 3822 case EM_X86_64:
8a9036a4 3823 case EM_L1OM:
7a9068fe 3824 case EM_K1OM:
d2b2c203
DJ		 3825 result = get_x86_64_section_type_name (sh_type);
3826 break;
a06ea964
NC		 3827 case EM_AARCH64:
3828 result = get_aarch64_section_type_name (sh_type);
3829 break;
40a18ebd
NC		 3830 case EM_ARM:
3831 result = get_arm_section_type_name (sh_type);
3832 break;
40b36596
JM		 3833 case EM_TI_C6000:
3834 result = get_tic6x_section_type_name (sh_type);
3835 break;
13761a11
NC		 3836 case EM_MSP430:
3837 result = get_msp430x_section_type_name (sh_type);
3838 break;
685080f2
NC		 3839 case EM_V800:
3840 case EM_V850:
3841 case EM_CYGNUS_V850:
3842 result = get_v850_section_type_name (sh_type);
3843 break;
252b5132
RH		 3844 default:
3845 result = NULL;
3846 break;
3847 }
3848
3849 if (result != NULL)
3850 return result;
3851
c91d0dfb 3852 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3853 }
3854 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3855 {
2cf0635d 3856 const char * result;
148b93f2
NC		 3857
3858 switch (elf_header.e_machine)
3859 {
3860 case EM_IA_64:
3861 result = get_ia64_section_type_name (sh_type);
3862 break;
3863 default:
3864 result = NULL;
3865 break;
3866 }
3867
3868 if (result != NULL)
3869 return result;
3870
3871 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3872 }
252b5132 3873 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
685080f2
NC		 3874 {
3875 switch (elf_header.e_machine)
3876 {
3877 case EM_V800:
3878 case EM_V850:
3879 case EM_CYGNUS_V850:
3880 return get_v850_section_type_name (sh_type);
3881 default:
3882 break;
3883 }
3884
3885 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3886 }
252b5132 3887 else
a7dbfd1c
NC		 3888 /* This message is probably going to be displayed in a 15
3889 character wide field, so put the hex value first. */
3890 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3891
252b5132
RH		 3892 return buff;
3893 }
3894}
3895
2979dc34 3896#define OPTION_DEBUG_DUMP 512
2c610e4b 3897#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3898#define OPTION_DWARF_DEPTH 514
3899#define OPTION_DWARF_START 515
4723351a 3900#define OPTION_DWARF_CHECK 516
2979dc34 3901
85b1c36d 3902static struct option options[] =
252b5132 3903{
b34976b6 3904 {"all", no_argument, 0, 'a'},
252b5132
RH		 3905 {"file-header", no_argument, 0, 'h'},
3906 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3907 {"headers", no_argument, 0, 'e'},
3908 {"histogram", no_argument, 0, 'I'},
3909 {"segments", no_argument, 0, 'l'},
3910 {"sections", no_argument, 0, 'S'},
252b5132 3911 {"section-headers", no_argument, 0, 'S'},
f5842774 3912 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3913 {"section-details", no_argument, 0, 't'},
595cf52e 3914 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3915 {"symbols", no_argument, 0, 's'},
3916 {"syms", no_argument, 0, 's'},
2c610e4b 3917 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3918 {"relocs", no_argument, 0, 'r'},
3919 {"notes", no_argument, 0, 'n'},
3920 {"dynamic", no_argument, 0, 'd'},
a952a375 3921 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3922 {"version-info", no_argument, 0, 'V'},
3923 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3924 {"unwind", no_argument, 0, 'u'},
4145f1d5 3925 {"archive-index", no_argument, 0, 'c'},
b34976b6 3926 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3927 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3928 {"string-dump", required_argument, 0, 'p'},
252b5132
RH		 3929#ifdef SUPPORT_DISASSEMBLY
3930 {"instruction-dump", required_argument, 0, 'i'},
3931#endif
cf13d699 3932 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3933
fd2f0033
TT		 3934 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3935 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 3936 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 3937
b34976b6
AM		 3938 {"version", no_argument, 0, 'v'},
3939 {"wide", no_argument, 0, 'W'},
3940 {"help", no_argument, 0, 'H'},
3941 {0, no_argument, 0, 0}
252b5132
RH		 3942};
3943
3944static void
2cf0635d 3945usage (FILE * stream)
252b5132 3946{
92f01d61
JM		 3947 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3948 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3949 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3950 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3951 -h --file-header Display the ELF file header\n\
3952 -l --program-headers Display the program headers\n\
3953 --segments An alias for --program-headers\n\
3954 -S --section-headers Display the sections' header\n\
3955 --sections An alias for --section-headers\n\
f5842774 3956 -g --section-groups Display the section groups\n\
5477e8a0 3957 -t --section-details Display the section details\n\
8b53311e
NC		 3958 -e --headers Equivalent to: -h -l -S\n\
3959 -s --syms Display the symbol table\n\
3f08eb35 3960 --symbols An alias for --syms\n\
2c610e4b 3961 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3962 -n --notes Display the core notes (if present)\n\
3963 -r --relocs Display the relocations (if present)\n\
3964 -u --unwind Display the unwind info (if present)\n\
b2d38a17 3965 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 3966 -V --version-info Display the version sections (if present)\n\
1b31d05e 3967 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 3968 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 3969 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 3970 -x --hex-dump=<number|name>\n\
3971 Dump the contents of section <number|name> as bytes\n\
3972 -p --string-dump=<number|name>\n\
3973 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 3974 -R --relocated-dump=<number|name>\n\
3975 Dump the contents of section <number|name> as relocated bytes\n\
f9f0e732 3976 -w[lLiaprmfFsoRt] or\n\
1ed06042 3977 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 3978 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 3979 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3980 =addr,=cu_index]\n\
8b53311e 3981 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 3982 fprintf (stream, _("\
3983 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3984 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3985 or deeper\n"));
252b5132 3986#ifdef SUPPORT_DISASSEMBLY
92f01d61 3987 fprintf (stream, _("\
09c11c86
NC		 3988 -i --instruction-dump=<number|name>\n\
3989 Disassemble the contents of section <number|name>\n"));
252b5132 3990#endif
92f01d61 3991 fprintf (stream, _("\
8b53311e
NC		 3992 -I --histogram Display histogram of bucket list lengths\n\
3993 -W --wide Allow output width to exceed 80 characters\n\
07012eee 3994 @<file> Read options from <file>\n\
8b53311e
NC		 3995 -H --help Display this information\n\
3996 -v --version Display the version number of readelf\n"));
1118d252 3997
92f01d61
JM		 3998 if (REPORT_BUGS_TO[0] && stream == stdout)
3999 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 4000
92f01d61 4001 exit (stream == stdout ? 0 : 1);
252b5132
RH		 4002}
4003
18bd398b
NC		 4004/* Record the fact that the user wants the contents of section number
4005 SECTION to be displayed using the method(s) encoded as flags bits
4006 in TYPE. Note, TYPE can be zero if we are creating the array for
4007 the first time. */
4008
252b5132 4009static void
09c11c86 4010request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 4011{
4012 if (section >= num_dump_sects)
4013 {
2cf0635d 4014 dump_type * new_dump_sects;
252b5132 4015
3f5e193b
NC		 4016 new_dump_sects = (dump_type *) calloc (section + 1,
4017 sizeof (* dump_sects));
252b5132
RH		 4018
4019 if (new_dump_sects == NULL)
591a748a 4020 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 4021 else
4022 {
4023 /* Copy current flag settings. */
09c11c86 4024 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 4025
4026 free (dump_sects);
4027
4028 dump_sects = new_dump_sects;
4029 num_dump_sects = section + 1;
4030 }
4031 }
4032
4033 if (dump_sects)
b34976b6 4034 dump_sects[section] |= type;
252b5132
RH		 4035
4036 return;
4037}
4038
aef1f6d0
DJ		 4039/* Request a dump by section name. */
4040
4041static void
2cf0635d 4042request_dump_byname (const char * section, dump_type type)
aef1f6d0 4043{
2cf0635d 4044 struct dump_list_entry * new_request;
aef1f6d0 4045
3f5e193b
NC		 4046 new_request = (struct dump_list_entry *)
4047 malloc (sizeof (struct dump_list_entry));
aef1f6d0 4048 if (!new_request)
591a748a 4049 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4050
4051 new_request->name = strdup (section);
4052 if (!new_request->name)
591a748a 4053 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4054
4055 new_request->type = type;
4056
4057 new_request->next = dump_sects_byname;
4058 dump_sects_byname = new_request;
4059}
4060
cf13d699
NC		 4061static inline void
4062request_dump (dump_type type)
4063{
4064 int section;
4065 char * cp;
4066
4067 do_dump++;
4068 section = strtoul (optarg, & cp, 0);
4069
4070 if (! *cp && section >= 0)
4071 request_dump_bynumber (section, type);
4072 else
4073 request_dump_byname (optarg, type);
4074}
4075
4076
252b5132 4077static void
2cf0635d 4078parse_args (int argc, char ** argv)
252b5132
RH		 4079{
4080 int c;
4081
4082 if (argc < 2)
92f01d61 4083 usage (stderr);
252b5132
RH		 4084
4085 while ((c = getopt_long
cf13d699 4086 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
252b5132 4087 {
252b5132
RH		 4088 switch (c)
4089 {
4090 case 0:
4091 /* Long options. */
4092 break;
4093 case 'H':
92f01d61 4094 usage (stdout);
252b5132
RH		 4095 break;
4096
4097 case 'a':
b34976b6
AM		 4098 do_syms++;
4099 do_reloc++;
4100 do_unwind++;
4101 do_dynamic++;
4102 do_header++;
4103 do_sections++;
f5842774 4104 do_section_groups++;
b34976b6
AM		 4105 do_segments++;
4106 do_version++;
4107 do_histogram++;
4108 do_arch++;
4109 do_notes++;
252b5132 4110 break;
f5842774
L		 4111 case 'g':
4112 do_section_groups++;
4113 break;
5477e8a0 4114 case 't':
595cf52e 4115 case 'N':
5477e8a0
L		 4116 do_sections++;
4117 do_section_details++;
595cf52e 4118 break;
252b5132 4119 case 'e':
b34976b6
AM		 4120 do_header++;
4121 do_sections++;
4122 do_segments++;
252b5132 4123 break;
a952a375 4124 case 'A':
b34976b6 4125 do_arch++;
a952a375 4126 break;
252b5132 4127 case 'D':
b34976b6 4128 do_using_dynamic++;
252b5132
RH		 4129 break;
4130 case 'r':
b34976b6 4131 do_reloc++;
252b5132 4132 break;
4d6ed7c8 4133 case 'u':
b34976b6 4134 do_unwind++;
4d6ed7c8 4135 break;
252b5132 4136 case 'h':
b34976b6 4137 do_header++;
252b5132
RH		 4138 break;
4139 case 'l':
b34976b6 4140 do_segments++;
252b5132
RH		 4141 break;
4142 case 's':
b34976b6 4143 do_syms++;
252b5132
RH		 4144 break;
4145 case 'S':
b34976b6 4146 do_sections++;
252b5132
RH		 4147 break;
4148 case 'd':
b34976b6 4149 do_dynamic++;
252b5132 4150 break;
a952a375 4151 case 'I':
b34976b6 4152 do_histogram++;
a952a375 4153 break;
779fe533 4154 case 'n':
b34976b6 4155 do_notes++;
779fe533 4156 break;
4145f1d5
NC		 4157 case 'c':
4158 do_archive_index++;
4159 break;
252b5132 4160 case 'x':
cf13d699 4161 request_dump (HEX_DUMP);
aef1f6d0 4162 break;
09c11c86 4163 case 'p':
cf13d699
NC		 4164 request_dump (STRING_DUMP);
4165 break;
4166 case 'R':
4167 request_dump (RELOC_DUMP);
09c11c86 4168 break;
252b5132 4169 case 'w':
b34976b6 4170 do_dump++;
252b5132 4171 if (optarg == 0)
613ff48b
CC		 4172 {
4173 do_debugging = 1;
4174 dwarf_select_sections_all ();
4175 }
252b5132
RH		 4176 else
4177 {
4178 do_debugging = 0;
4cb93e3b 4179 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 4180 }
4181 break;
2979dc34 4182 case OPTION_DEBUG_DUMP:
b34976b6 4183 do_dump++;
2979dc34
JJ		 4184 if (optarg == 0)
4185 do_debugging = 1;
4186 else
4187 {
2979dc34 4188 do_debugging = 0;
4cb93e3b 4189 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 4190 }
4191 break;
fd2f0033
TT		 4192 case OPTION_DWARF_DEPTH:
4193 {
4194 char *cp;
4195
4196 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4197 }
4198 break;
4199 case OPTION_DWARF_START:
4200 {
4201 char *cp;
4202
4203 dwarf_start_die = strtoul (optarg, & cp, 0);
4204 }
4205 break;
4723351a
CC		 4206 case OPTION_DWARF_CHECK:
4207 dwarf_check = 1;
4208 break;
2c610e4b
L		 4209 case OPTION_DYN_SYMS:
4210 do_dyn_syms++;
4211 break;
252b5132
RH		 4212#ifdef SUPPORT_DISASSEMBLY
4213 case 'i':
cf13d699
NC		 4214 request_dump (DISASS_DUMP);
4215 break;
252b5132
RH		 4216#endif
4217 case 'v':
4218 print_version (program_name);
4219 break;
4220 case 'V':
b34976b6 4221 do_version++;
252b5132 4222 break;
d974e256 4223 case 'W':
b34976b6 4224 do_wide++;
d974e256 4225 break;
252b5132 4226 default:
252b5132
RH		 4227 /* xgettext:c-format */
4228 error (_("Invalid option '-%c'\n"), c);
4229 /* Drop through. */
4230 case '?':
92f01d61 4231 usage (stderr);
252b5132
RH		 4232 }
4233 }
4234
4d6ed7c8 4235 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 4236 && !do_segments && !do_header && !do_dump && !do_version
f5842774 4237 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 4238 && !do_section_groups && !do_archive_index
4239 && !do_dyn_syms)
92f01d61 4240 usage (stderr);
252b5132
RH		 4241 else if (argc < 3)
4242 {
4243 warn (_("Nothing to do.\n"));
92f01d61 4244 usage (stderr);
252b5132
RH		 4245 }
4246}
4247
4248static const char *
d3ba0551 4249get_elf_class (unsigned int elf_class)
252b5132 4250{
b34976b6 4251 static char buff[32];
103f02d3 4252
252b5132
RH		 4253 switch (elf_class)
4254 {
4255 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 4256 case ELFCLASS32: return "ELF32";
4257 case ELFCLASS64: return "ELF64";
ab5e7794 4258 default:
e9e44622 4259 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 4260 return buff;
252b5132
RH		 4261 }
4262}
4263
4264static const char *
d3ba0551 4265get_data_encoding (unsigned int encoding)
252b5132 4266{
b34976b6 4267 static char buff[32];
103f02d3 4268
252b5132
RH		 4269 switch (encoding)
4270 {
4271 case ELFDATANONE: return _("none");
33c63f9d
CM		 4272 case ELFDATA2LSB: return _("2's complement, little endian");
4273 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 4274 default:
e9e44622 4275 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 4276 return buff;
252b5132
RH		 4277 }
4278}
4279
252b5132 4280/* Decode the data held in 'elf_header'. */
ee42cf8c 4281
252b5132 4282static int
d3ba0551 4283process_file_header (void)
252b5132 4284{
b34976b6
AM		 4285 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4286 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4287 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4288 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 4289 {
4290 error
4291 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4292 return 0;
4293 }
4294
2dc4cec1
L		 4295 init_dwarf_regnames (elf_header.e_machine);
4296
252b5132
RH		 4297 if (do_header)
4298 {
4299 int i;
4300
4301 printf (_("ELF Header:\n"));
4302 printf (_(" Magic: "));
b34976b6
AM		 4303 for (i = 0; i < EI_NIDENT; i++)
4304 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 4305 printf ("\n");
4306 printf (_(" Class: %s\n"),
b34976b6 4307 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 4308 printf (_(" Data: %s\n"),
b34976b6 4309 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 4310 printf (_(" Version: %d %s\n"),
b34976b6
AM		 4311 elf_header.e_ident[EI_VERSION],
4312 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 4313 ? "(current)"
b34976b6 4314 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 4315 ? _("<unknown: %lx>")
789be9f7 4316 : "")));
252b5132 4317 printf (_(" OS/ABI: %s\n"),
b34976b6 4318 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 4319 printf (_(" ABI Version: %d\n"),
b34976b6 4320 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 4321 printf (_(" Type: %s\n"),
4322 get_file_type (elf_header.e_type));
4323 printf (_(" Machine: %s\n"),
4324 get_machine_name (elf_header.e_machine));
4325 printf (_(" Version: 0x%lx\n"),
4326 (unsigned long) elf_header.e_version);
76da6bbe 4327
f7a99963
NC		 4328 printf (_(" Entry point address: "));
4329 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4330 printf (_("\n Start of program headers: "));
4331 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4332 printf (_(" (bytes into file)\n Start of section headers: "));
4333 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4334 printf (_(" (bytes into file)\n"));
76da6bbe 4335
252b5132
RH		 4336 printf (_(" Flags: 0x%lx%s\n"),
4337 (unsigned long) elf_header.e_flags,
4338 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4339 printf (_(" Size of this header: %ld (bytes)\n"),
4340 (long) elf_header.e_ehsize);
4341 printf (_(" Size of program headers: %ld (bytes)\n"),
4342 (long) elf_header.e_phentsize);
2046a35d 4343 printf (_(" Number of program headers: %ld"),
252b5132 4344 (long) elf_header.e_phnum);
2046a35d
AM		 4345 if (section_headers != NULL
4346 && elf_header.e_phnum == PN_XNUM
4347 && section_headers[0].sh_info != 0)
cc5914eb 4348 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 4349 putc ('\n', stdout);
252b5132
RH		 4350 printf (_(" Size of section headers: %ld (bytes)\n"),
4351 (long) elf_header.e_shentsize);
560f3c1c 4352 printf (_(" Number of section headers: %ld"),
252b5132 4353 (long) elf_header.e_shnum);
4fbb74a6 4354 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 4355 printf (" (%ld)", (long) section_headers[0].sh_size);
4356 putc ('\n', stdout);
4357 printf (_(" Section header string table index: %ld"),
252b5132 4358 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 4359 if (section_headers != NULL
4360 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 4361 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 4362 else if (elf_header.e_shstrndx != SHN_UNDEF
4363 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 4364 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 4365 putc ('\n', stdout);
4366 }
4367
4368 if (section_headers != NULL)
4369 {
2046a35d
AM		 4370 if (elf_header.e_phnum == PN_XNUM
4371 && section_headers[0].sh_info != 0)
4372 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 4373 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 4374 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 4375 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 4376 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 4377 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 4378 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 4379 free (section_headers);
4380 section_headers = NULL;
252b5132 4381 }
103f02d3 4382
9ea033b2
NC		 4383 return 1;
4384}
4385
e0a31db1 4386static bfd_boolean
91d6fa6a 4387get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4388{
2cf0635d
NC		 4389 Elf32_External_Phdr * phdrs;
4390 Elf32_External_Phdr * external;
4391 Elf_Internal_Phdr * internal;
b34976b6 4392 unsigned int i;
e0a31db1
NC		 4393 unsigned int size = elf_header.e_phentsize;
4394 unsigned int num = elf_header.e_phnum;
4395
4396 /* PR binutils/17531: Cope with unexpected section header sizes. */
4397 if (size == 0 || num == 0)
4398 return FALSE;
4399 if (size < sizeof * phdrs)
4400 {
4401 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4402 return FALSE;
4403 }
4404 if (size > sizeof * phdrs)
4405 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4406
3f5e193b 4407 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1
NC		 4408 size, num, _("program headers"));
4409 if (phdrs == NULL)
4410 return FALSE;
9ea033b2 4411
91d6fa6a 4412 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4413 i < elf_header.e_phnum;
b34976b6 4414 i++, internal++, external++)
252b5132 4415 {
9ea033b2
NC		 4416 internal->p_type = BYTE_GET (external->p_type);
4417 internal->p_offset = BYTE_GET (external->p_offset);
4418 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4419 internal->p_paddr = BYTE_GET (external->p_paddr);
4420 internal->p_filesz = BYTE_GET (external->p_filesz);
4421 internal->p_memsz = BYTE_GET (external->p_memsz);
4422 internal->p_flags = BYTE_GET (external->p_flags);
4423 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 4424 }
4425
9ea033b2 4426 free (phdrs);
e0a31db1 4427 return TRUE;
252b5132
RH		 4428}
4429
e0a31db1 4430static bfd_boolean
91d6fa6a 4431get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4432{
2cf0635d
NC		 4433 Elf64_External_Phdr * phdrs;
4434 Elf64_External_Phdr * external;
4435 Elf_Internal_Phdr * internal;
b34976b6 4436 unsigned int i;
e0a31db1
NC		 4437 unsigned int size = elf_header.e_phentsize;
4438 unsigned int num = elf_header.e_phnum;
4439
4440 /* PR binutils/17531: Cope with unexpected section header sizes. */
4441 if (size == 0 || num == 0)
4442 return FALSE;
4443 if (size < sizeof * phdrs)
4444 {
4445 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4446 return FALSE;
4447 }
4448 if (size > sizeof * phdrs)
4449 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4450
3f5e193b 4451 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1 4452 size, num, _("program headers"));
a6e9f9df 4453 if (!phdrs)
e0a31db1 4454 return FALSE;
9ea033b2 4455
91d6fa6a 4456 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4457 i < elf_header.e_phnum;
b34976b6 4458 i++, internal++, external++)
9ea033b2
NC		 4459 {
4460 internal->p_type = BYTE_GET (external->p_type);
4461 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 4462 internal->p_offset = BYTE_GET (external->p_offset);
4463 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4464 internal->p_paddr = BYTE_GET (external->p_paddr);
4465 internal->p_filesz = BYTE_GET (external->p_filesz);
4466 internal->p_memsz = BYTE_GET (external->p_memsz);
4467 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 4468 }
4469
4470 free (phdrs);
e0a31db1 4471 return TRUE;
9ea033b2 4472}
252b5132 4473
d93f0186
NC		 4474/* Returns 1 if the program headers were read into `program_headers'. */
4475
4476static int
2cf0635d 4477get_program_headers (FILE * file)
d93f0186 4478{
2cf0635d 4479 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 4480
4481 /* Check cache of prior read. */
4482 if (program_headers != NULL)
4483 return 1;
4484
3f5e193b
NC		 4485 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4486 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 4487
4488 if (phdrs == NULL)
4489 {
8b73c356
NC		 4490 error (_("Out of memory reading %u program headers\n"),
4491 elf_header.e_phnum);
d93f0186
NC		 4492 return 0;
4493 }
4494
4495 if (is_32bit_elf
4496 ? get_32bit_program_headers (file, phdrs)
4497 : get_64bit_program_headers (file, phdrs))
4498 {
4499 program_headers = phdrs;
4500 return 1;
4501 }
4502
4503 free (phdrs);
4504 return 0;
4505}
4506
2f62977e
NC		 4507/* Returns 1 if the program headers were loaded. */
4508
252b5132 4509static int
2cf0635d 4510process_program_headers (FILE * file)
252b5132 4511{
2cf0635d 4512 Elf_Internal_Phdr * segment;
b34976b6 4513 unsigned int i;
252b5132
RH		 4514
4515 if (elf_header.e_phnum == 0)
4516 {
82f2dbf7
NC		 4517 /* PR binutils/12467. */
4518 if (elf_header.e_phoff != 0)
4519 warn (_("possibly corrupt ELF header - it has a non-zero program"
9035ed51 4520 " header offset, but no program headers\n"));
82f2dbf7 4521 else if (do_segments)
252b5132 4522 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 4523 return 0;
252b5132
RH		 4524 }
4525
4526 if (do_segments && !do_header)
4527 {
f7a99963
NC		 4528 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4529 printf (_("Entry point "));
4530 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4531 printf (_("\nThere are %d program headers, starting at offset "),
4532 elf_header.e_phnum);
4533 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4534 printf ("\n");
252b5132
RH		 4535 }
4536
d93f0186 4537 if (! get_program_headers (file))
252b5132 4538 return 0;
103f02d3 4539
252b5132
RH		 4540 if (do_segments)
4541 {
3a1a2036
NC		 4542 if (elf_header.e_phnum > 1)
4543 printf (_("\nProgram Headers:\n"));
4544 else
4545 printf (_("\nProgram Headers:\n"));
76da6bbe 4546
f7a99963
NC		 4547 if (is_32bit_elf)
4548 printf
4549 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 4550 else if (do_wide)
4551 printf
4552 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 4553 else
4554 {
4555 printf
4556 (_(" Type Offset VirtAddr PhysAddr\n"));
4557 printf
4558 (_(" FileSiz MemSiz Flags Align\n"));
4559 }
252b5132
RH		 4560 }
4561
252b5132 4562 dynamic_addr = 0;
1b228002 4563 dynamic_size = 0;
252b5132
RH		 4564
4565 for (i = 0, segment = program_headers;
4566 i < elf_header.e_phnum;
b34976b6 4567 i++, segment++)
252b5132
RH		 4568 {
4569 if (do_segments)
4570 {
103f02d3 4571 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 4572
4573 if (is_32bit_elf)
4574 {
4575 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4576 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4577 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4578 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4579 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4580 printf ("%c%c%c ",
4581 (segment->p_flags & PF_R ? 'R' : ' '),
4582 (segment->p_flags & PF_W ? 'W' : ' '),
4583 (segment->p_flags & PF_X ? 'E' : ' '));
4584 printf ("%#lx", (unsigned long) segment->p_align);
4585 }
d974e256
JJ		 4586 else if (do_wide)
4587 {
4588 if ((unsigned long) segment->p_offset == segment->p_offset)
4589 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4590 else
4591 {
4592 print_vma (segment->p_offset, FULL_HEX);
4593 putchar (' ');
4594 }
4595
4596 print_vma (segment->p_vaddr, FULL_HEX);
4597 putchar (' ');
4598 print_vma (segment->p_paddr, FULL_HEX);
4599 putchar (' ');
4600
4601 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4602 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4603 else
4604 {
4605 print_vma (segment->p_filesz, FULL_HEX);
4606 putchar (' ');
4607 }
4608
4609 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4610 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4611 else
4612 {
f48e6c45 4613 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 4614 }
4615
4616 printf (" %c%c%c ",
4617 (segment->p_flags & PF_R ? 'R' : ' '),
4618 (segment->p_flags & PF_W ? 'W' : ' '),
4619 (segment->p_flags & PF_X ? 'E' : ' '));
4620
4621 if ((unsigned long) segment->p_align == segment->p_align)
4622 printf ("%#lx", (unsigned long) segment->p_align);
4623 else
4624 {
4625 print_vma (segment->p_align, PREFIX_HEX);
4626 }
4627 }
f7a99963
NC		 4628 else
4629 {
4630 print_vma (segment->p_offset, FULL_HEX);
4631 putchar (' ');
4632 print_vma (segment->p_vaddr, FULL_HEX);
4633 putchar (' ');
4634 print_vma (segment->p_paddr, FULL_HEX);
4635 printf ("\n ");
4636 print_vma (segment->p_filesz, FULL_HEX);
4637 putchar (' ');
4638 print_vma (segment->p_memsz, FULL_HEX);
4639 printf (" %c%c%c ",
4640 (segment->p_flags & PF_R ? 'R' : ' '),
4641 (segment->p_flags & PF_W ? 'W' : ' '),
4642 (segment->p_flags & PF_X ? 'E' : ' '));
4643 print_vma (segment->p_align, HEX);
4644 }
252b5132
RH		 4645 }
4646
f54498b4
NC		 4647 if (do_segments)
4648 putc ('\n', stdout);
4649
252b5132
RH		 4650 switch (segment->p_type)
4651 {
252b5132
RH		 4652 case PT_DYNAMIC:
4653 if (dynamic_addr)
4654 error (_("more than one dynamic segment\n"));
4655
20737c13
AM		 4656 /* By default, assume that the .dynamic section is the first
4657 section in the DYNAMIC segment. */
4658 dynamic_addr = segment->p_offset;
4659 dynamic_size = segment->p_filesz;
f54498b4
NC		 4660 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4661 if (dynamic_addr + dynamic_size >= current_file_size)
4662 {
4663 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4664 dynamic_addr = dynamic_size = 0;
4665 }
20737c13 4666
b2d38a17
NC		 4667 /* Try to locate the .dynamic section. If there is
4668 a section header table, we can easily locate it. */
4669 if (section_headers != NULL)
4670 {
2cf0635d 4671 Elf_Internal_Shdr * sec;
b2d38a17 4672
89fac5e3
RS		 4673 sec = find_section (".dynamic");
4674 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4675 {
28f997cf
TG		 4676 /* A corresponding .dynamic section is expected, but on
4677 IA-64/OpenVMS it is OK for it to be missing. */
4678 if (!is_ia64_vms ())
4679 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 4680 break;
4681 }
4682
42bb2e33 4683 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 4684 {
4685 dynamic_size = 0;
4686 break;
4687 }
42bb2e33 4688
b2d38a17
NC		 4689 dynamic_addr = sec->sh_offset;
4690 dynamic_size = sec->sh_size;
4691
4692 if (dynamic_addr < segment->p_offset
4693 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 4694 warn (_("the .dynamic section is not contained"
4695 " within the dynamic segment\n"));
b2d38a17 4696 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 4697 warn (_("the .dynamic section is not the first section"
4698 " in the dynamic segment.\n"));
b2d38a17 4699 }
252b5132
RH		 4700 break;
4701
4702 case PT_INTERP:
fb52b2f4
NC		 4703 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4704 SEEK_SET))
252b5132
RH		 4705 error (_("Unable to find program interpreter name\n"));
4706 else
4707 {
f8eae8b2 4708 char fmt [32];
9495b2e6 4709 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
f8eae8b2
L		 4710
4711 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4712 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4713
252b5132 4714 program_interpreter[0] = 0;
7bd7b3ef
AM		 4715 if (fscanf (file, fmt, program_interpreter) <= 0)
4716 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 4717
4718 if (do_segments)
f54498b4 4719 printf (_(" [Requesting program interpreter: %s]\n"),
252b5132
RH		 4720 program_interpreter);
4721 }
4722 break;
4723 }
252b5132
RH		 4724 }
4725
c256ffe7 4726 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 4727 {
4728 printf (_("\n Section to Segment mapping:\n"));
4729 printf (_(" Segment Sections...\n"));
4730
252b5132
RH		 4731 for (i = 0; i < elf_header.e_phnum; i++)
4732 {
9ad5cbcf 4733 unsigned int j;
2cf0635d 4734 Elf_Internal_Shdr * section;
252b5132
RH		 4735
4736 segment = program_headers + i;
b391a3e3 4737 section = section_headers + 1;
252b5132
RH		 4738
4739 printf (" %2.2d ", i);
4740
b34976b6 4741 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4742 {
f4638467
AM		 4743 if (!ELF_TBSS_SPECIAL (section, segment)
4744 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
74e1a04b 4745 printf ("%s ", printable_section_name (section));
252b5132
RH		 4746 }
4747
4748 putc ('\n',stdout);
4749 }
4750 }
4751
252b5132
RH		 4752 return 1;
4753}
4754
4755
d93f0186
NC		 4756/* Find the file offset corresponding to VMA by using the program headers. */
4757
4758static long
2cf0635d 4759offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4760{
2cf0635d 4761 Elf_Internal_Phdr * seg;
d93f0186
NC		 4762
4763 if (! get_program_headers (file))
4764 {
4765 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4766 return (long) vma;
4767 }
4768
4769 for (seg = program_headers;
4770 seg < program_headers + elf_header.e_phnum;
4771 ++seg)
4772 {
4773 if (seg->p_type != PT_LOAD)
4774 continue;
4775
4776 if (vma >= (seg->p_vaddr & -seg->p_align)
4777 && vma + size <= seg->p_vaddr + seg->p_filesz)
4778 return vma - seg->p_vaddr + seg->p_offset;
4779 }
4780
4781 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4782 (unsigned long) vma);
d93f0186
NC		 4783 return (long) vma;
4784}
4785
4786
049b0c3a
NC		 4787/* Allocate memory and load the sections headers into the global pointer
4788 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4789 generate any error messages if the load fails. */
4790
4791static bfd_boolean
4792get_32bit_section_headers (FILE * file, bfd_boolean probe)
252b5132 4793{
2cf0635d
NC		 4794 Elf32_External_Shdr * shdrs;
4795 Elf_Internal_Shdr * internal;
b34976b6 4796 unsigned int i;
049b0c3a
NC		 4797 unsigned int size = elf_header.e_shentsize;
4798 unsigned int num = probe ? 1 : elf_header.e_shnum;
4799
4800 /* PR binutils/17531: Cope with unexpected section header sizes. */
4801 if (size == 0 || num == 0)
4802 return FALSE;
4803 if (size < sizeof * shdrs)
4804 {
4805 if (! probe)
4806 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4807 return FALSE;
4808 }
4809 if (!probe && size > sizeof * shdrs)
4810 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
252b5132 4811
3f5e193b 4812 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4813 size, num,
4814 probe ? NULL : _("section headers"));
4815 if (shdrs == NULL)
4816 return FALSE;
252b5132 4817
049b0c3a
NC		 4818 if (section_headers != NULL)
4819 free (section_headers);
3f5e193b
NC		 4820 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4821 sizeof (Elf_Internal_Shdr));
252b5132
RH		 4822 if (section_headers == NULL)
4823 {
049b0c3a 4824 if (!probe)
8b73c356 4825 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4826 return FALSE;
252b5132
RH		 4827 }
4828
4829 for (i = 0, internal = section_headers;
560f3c1c 4830 i < num;
b34976b6 4831 i++, internal++)
252b5132
RH		 4832 {
4833 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4834 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4835 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4836 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4837 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4838 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4839 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4840 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4841 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4842 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4843 }
4844
4845 free (shdrs);
049b0c3a 4846 return TRUE;
252b5132
RH		 4847}
4848
049b0c3a
NC		 4849static bfd_boolean
4850get_64bit_section_headers (FILE * file, bfd_boolean probe)
9ea033b2 4851{
2cf0635d
NC		 4852 Elf64_External_Shdr * shdrs;
4853 Elf_Internal_Shdr * internal;
b34976b6 4854 unsigned int i;
049b0c3a
NC		 4855 unsigned int size = elf_header.e_shentsize;
4856 unsigned int num = probe ? 1 : elf_header.e_shnum;
4857
4858 /* PR binutils/17531: Cope with unexpected section header sizes. */
4859 if (size == 0 || num == 0)
4860 return FALSE;
4861 if (size < sizeof * shdrs)
4862 {
4863 if (! probe)
4864 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4865 return FALSE;
4866 }
4867 if (! probe && size > sizeof * shdrs)
4868 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
9ea033b2 4869
3f5e193b 4870 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4871 size, num,
4872 probe ? NULL : _("section headers"));
4873 if (shdrs == NULL)
4874 return FALSE;
9ea033b2 4875
049b0c3a
NC		 4876 if (section_headers != NULL)
4877 free (section_headers);
3f5e193b
NC		 4878 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4879 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4880 if (section_headers == NULL)
4881 {
049b0c3a 4882 if (! probe)
8b73c356 4883 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4884 return FALSE;
9ea033b2
NC		 4885 }
4886
4887 for (i = 0, internal = section_headers;
560f3c1c 4888 i < num;
b34976b6 4889 i++, internal++)
9ea033b2
NC		 4890 {
4891 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4892 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4893 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4894 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4895 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4896 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4897 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4898 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4899 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4900 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4901 }
4902
4903 free (shdrs);
049b0c3a 4904 return TRUE;
9ea033b2
NC		 4905}
4906
252b5132 4907static Elf_Internal_Sym *
ba5cdace
NC		 4908get_32bit_elf_symbols (FILE * file,
4909 Elf_Internal_Shdr * section,
4910 unsigned long * num_syms_return)
252b5132 4911{
ba5cdace 4912 unsigned long number = 0;
dd24e3da 4913 Elf32_External_Sym * esyms = NULL;
ba5cdace 4914 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 4915 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4916 Elf_Internal_Sym * psym;
b34976b6 4917 unsigned int j;
252b5132 4918
c9c1d674
EG		 4919 if (section->sh_size == 0)
4920 {
4921 if (num_syms_return != NULL)
4922 * num_syms_return = 0;
4923 return NULL;
4924 }
4925
dd24e3da 4926 /* Run some sanity checks first. */
c9c1d674 4927 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 4928 {
c9c1d674
EG		 4929 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4930 printable_section_name (section), (unsigned long) section->sh_entsize);
ba5cdace 4931 goto exit_point;
dd24e3da
NC		 4932 }
4933
f54498b4
NC		 4934 if (section->sh_size > current_file_size)
4935 {
4936 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
74e1a04b 4937 printable_section_name (section), (unsigned long) section->sh_size);
f54498b4
NC		 4938 goto exit_point;
4939 }
4940
dd24e3da
NC		 4941 number = section->sh_size / section->sh_entsize;
4942
4943 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4944 {
c9c1d674 4945 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 4946 (unsigned long) section->sh_size,
4947 printable_section_name (section),
4948 (unsigned long) section->sh_entsize);
ba5cdace 4949 goto exit_point;
dd24e3da
NC		 4950 }
4951
3f5e193b
NC		 4952 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4953 section->sh_size, _("symbols"));
dd24e3da 4954 if (esyms == NULL)
ba5cdace 4955 goto exit_point;
252b5132 4956
9ad5cbcf
AM		 4957 shndx = NULL;
4958 if (symtab_shndx_hdr != NULL
4959 && (symtab_shndx_hdr->sh_link
4fbb74a6 4960 == (unsigned long) (section - section_headers)))
9ad5cbcf 4961 {
3f5e193b
NC		 4962 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4963 symtab_shndx_hdr->sh_offset,
4964 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4965 _("symbol table section indicies"));
dd24e3da
NC		 4966 if (shndx == NULL)
4967 goto exit_point;
c9c1d674
EG		 4968 /* PR17531: file: heap-buffer-overflow */
4969 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
4970 {
4971 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
4972 printable_section_name (symtab_shndx_hdr),
4973 (unsigned long) symtab_shndx_hdr->sh_size,
4974 (unsigned long) section->sh_size);
4975 goto exit_point;
4976 }
9ad5cbcf
AM		 4977 }
4978
3f5e193b 4979 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 4980
4981 if (isyms == NULL)
4982 {
8b73c356
NC		 4983 error (_("Out of memory reading %lu symbols\n"),
4984 (unsigned long) number);
dd24e3da 4985 goto exit_point;
252b5132
RH		 4986 }
4987
dd24e3da 4988 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 4989 {
4990 psym->st_name = BYTE_GET (esyms[j].st_name);
4991 psym->st_value = BYTE_GET (esyms[j].st_value);
4992 psym->st_size = BYTE_GET (esyms[j].st_size);
4993 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4994 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4995 psym->st_shndx
4996 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4997 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4998 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 4999 psym->st_info = BYTE_GET (esyms[j].st_info);
5000 psym->st_other = BYTE_GET (esyms[j].st_other);
5001 }
5002
dd24e3da 5003 exit_point:
ba5cdace 5004 if (shndx != NULL)
9ad5cbcf 5005 free (shndx);
ba5cdace 5006 if (esyms != NULL)
dd24e3da 5007 free (esyms);
252b5132 5008
ba5cdace
NC		 5009 if (num_syms_return != NULL)
5010 * num_syms_return = isyms == NULL ? 0 : number;
5011
252b5132
RH		 5012 return isyms;
5013}
5014
9ea033b2 5015static Elf_Internal_Sym *
ba5cdace
NC		 5016get_64bit_elf_symbols (FILE * file,
5017 Elf_Internal_Shdr * section,
5018 unsigned long * num_syms_return)
9ea033b2 5019{
ba5cdace
NC		 5020 unsigned long number = 0;
5021 Elf64_External_Sym * esyms = NULL;
5022 Elf_External_Sym_Shndx * shndx = NULL;
5023 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5024 Elf_Internal_Sym * psym;
b34976b6 5025 unsigned int j;
9ea033b2 5026
c9c1d674
EG		 5027 if (section->sh_size == 0)
5028 {
5029 if (num_syms_return != NULL)
5030 * num_syms_return = 0;
5031 return NULL;
5032 }
5033
dd24e3da 5034 /* Run some sanity checks first. */
c9c1d674 5035 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5036 {
c9c1d674 5037 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
8066deb1
AM		 5038 printable_section_name (section),
5039 (unsigned long) section->sh_entsize);
ba5cdace 5040 goto exit_point;
dd24e3da
NC		 5041 }
5042
f54498b4
NC		 5043 if (section->sh_size > current_file_size)
5044 {
5045 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
8066deb1
AM		 5046 printable_section_name (section),
5047 (unsigned long) section->sh_size);
f54498b4
NC		 5048 goto exit_point;
5049 }
5050
dd24e3da
NC		 5051 number = section->sh_size / section->sh_entsize;
5052
5053 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5054 {
c9c1d674 5055 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5056 (unsigned long) section->sh_size,
5057 printable_section_name (section),
5058 (unsigned long) section->sh_entsize);
ba5cdace 5059 goto exit_point;
dd24e3da
NC		 5060 }
5061
3f5e193b
NC		 5062 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5063 section->sh_size, _("symbols"));
a6e9f9df 5064 if (!esyms)
ba5cdace 5065 goto exit_point;
9ea033b2 5066
9ad5cbcf
AM		 5067 if (symtab_shndx_hdr != NULL
5068 && (symtab_shndx_hdr->sh_link
4fbb74a6 5069 == (unsigned long) (section - section_headers)))
9ad5cbcf 5070 {
3f5e193b
NC		 5071 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5072 symtab_shndx_hdr->sh_offset,
5073 1, symtab_shndx_hdr->sh_size,
9cf03b7e 5074 _("symbol table section indicies"));
ba5cdace
NC		 5075 if (shndx == NULL)
5076 goto exit_point;
c9c1d674
EG		 5077 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5078 {
5079 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5080 printable_section_name (symtab_shndx_hdr),
5081 (unsigned long) symtab_shndx_hdr->sh_size,
5082 (unsigned long) section->sh_size);
5083 goto exit_point;
5084 }
9ad5cbcf
AM		 5085 }
5086
3f5e193b 5087 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 5088
5089 if (isyms == NULL)
5090 {
8b73c356
NC		 5091 error (_("Out of memory reading %lu symbols\n"),
5092 (unsigned long) number);
ba5cdace 5093 goto exit_point;
9ea033b2
NC		 5094 }
5095
ba5cdace 5096 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 5097 {
5098 psym->st_name = BYTE_GET (esyms[j].st_name);
5099 psym->st_info = BYTE_GET (esyms[j].st_info);
5100 psym->st_other = BYTE_GET (esyms[j].st_other);
5101 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 5102
4fbb74a6 5103 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5104 psym->st_shndx
5105 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5106 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5107 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 5108
66543521
AM		 5109 psym->st_value = BYTE_GET (esyms[j].st_value);
5110 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 5111 }
5112
ba5cdace
NC		 5113 exit_point:
5114 if (shndx != NULL)
9ad5cbcf 5115 free (shndx);
ba5cdace
NC		 5116 if (esyms != NULL)
5117 free (esyms);
5118
5119 if (num_syms_return != NULL)
5120 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 5121
5122 return isyms;
5123}
5124
d1133906 5125static const char *
d3ba0551 5126get_elf_section_flags (bfd_vma sh_flags)
d1133906 5127{
5477e8a0 5128 static char buff[1024];
2cf0635d 5129 char * p = buff;
8d5ff12c 5130 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 5131 int sindex;
5132 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 5133 bfd_vma os_flags = 0;
5134 bfd_vma proc_flags = 0;
5135 bfd_vma unknown_flags = 0;
148b93f2 5136 static const struct
5477e8a0 5137 {
2cf0635d 5138 const char * str;
5477e8a0
L		 5139 int len;
5140 }
5141 flags [] =
5142 {
cfcac11d
NC		 5143 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5144 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5145 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5146 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5147 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5148 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5149 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5150 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5151 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5152 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5153 /* IA-64 specific. */
5154 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5155 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5156 /* IA-64 OpenVMS specific. */
5157 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5158 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5159 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5160 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5161 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5162 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 5163 /* Generic. */
cfcac11d 5164 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 5165 /* SPARC specific. */
cfcac11d 5166 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5477e8a0
L		 5167 };
5168
5169 if (do_section_details)
5170 {
8d5ff12c
L		 5171 sprintf (buff, "[%*.*lx]: ",
5172 field_size, field_size, (unsigned long) sh_flags);
5173 p += field_size + 4;
5477e8a0 5174 }
76da6bbe 5175
d1133906
NC		 5176 while (sh_flags)
5177 {
5178 bfd_vma flag;
5179
5180 flag = sh_flags & - sh_flags;
5181 sh_flags &= ~ flag;
76da6bbe 5182
5477e8a0 5183 if (do_section_details)
d1133906 5184 {
5477e8a0
L		 5185 switch (flag)
5186 {
91d6fa6a
NC		 5187 case SHF_WRITE: sindex = 0; break;
5188 case SHF_ALLOC: sindex = 1; break;
5189 case SHF_EXECINSTR: sindex = 2; break;
5190 case SHF_MERGE: sindex = 3; break;
5191 case SHF_STRINGS: sindex = 4; break;
5192 case SHF_INFO_LINK: sindex = 5; break;
5193 case SHF_LINK_ORDER: sindex = 6; break;
5194 case SHF_OS_NONCONFORMING: sindex = 7; break;
5195 case SHF_GROUP: sindex = 8; break;
5196 case SHF_TLS: sindex = 9; break;
18ae9cc1 5197 case SHF_EXCLUDE: sindex = 18; break;
76da6bbe 5198
5477e8a0 5199 default:
91d6fa6a 5200 sindex = -1;
cfcac11d 5201 switch (elf_header.e_machine)
148b93f2 5202 {
cfcac11d 5203 case EM_IA_64:
148b93f2 5204 if (flag == SHF_IA_64_SHORT)
91d6fa6a 5205 sindex = 10;
148b93f2 5206 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 5207 sindex = 11;
148b93f2
NC		 5208#ifdef BFD64
5209 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5210 switch (flag)
5211 {
91d6fa6a
NC		 5212 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5213 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5214 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5215 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5216 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5217 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 5218 default: break;
5219 }
5220#endif
cfcac11d
NC		 5221 break;
5222
caa83f8b
NC		 5223 case EM_386:
5224 case EM_486:
5225 case EM_X86_64:
7f502d6c 5226 case EM_L1OM:
7a9068fe 5227 case EM_K1OM:
cfcac11d
NC		 5228 case EM_OLD_SPARCV9:
5229 case EM_SPARC32PLUS:
5230 case EM_SPARCV9:
5231 case EM_SPARC:
18ae9cc1 5232 if (flag == SHF_ORDERED)
91d6fa6a 5233 sindex = 19;
cfcac11d
NC		 5234 break;
5235 default:
5236 break;
148b93f2 5237 }
5477e8a0
L		 5238 }
5239
91d6fa6a 5240 if (sindex != -1)
5477e8a0 5241 {
8d5ff12c
L		 5242 if (p != buff + field_size + 4)
5243 {
5244 if (size < (10 + 2))
bee0ee85
NC		 5245 {
5246 warn (_("Internal error: not enough buffer room for section flag info"));
5247 return _("<unknown>");
5248 }
8d5ff12c
L		 5249 size -= 2;
5250 *p++ = ',';
5251 *p++ = ' ';
5252 }
5253
91d6fa6a
NC		 5254 size -= flags [sindex].len;
5255 p = stpcpy (p, flags [sindex].str);
5477e8a0 5256 }
3b22753a 5257 else if (flag & SHF_MASKOS)
8d5ff12c 5258 os_flags |= flag;
d1133906 5259 else if (flag & SHF_MASKPROC)
8d5ff12c 5260 proc_flags |= flag;
d1133906 5261 else
8d5ff12c 5262 unknown_flags |= flag;
5477e8a0
L		 5263 }
5264 else
5265 {
5266 switch (flag)
5267 {
5268 case SHF_WRITE: *p = 'W'; break;
5269 case SHF_ALLOC: *p = 'A'; break;
5270 case SHF_EXECINSTR: *p = 'X'; break;
5271 case SHF_MERGE: *p = 'M'; break;
5272 case SHF_STRINGS: *p = 'S'; break;
5273 case SHF_INFO_LINK: *p = 'I'; break;
5274 case SHF_LINK_ORDER: *p = 'L'; break;
5275 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5276 case SHF_GROUP: *p = 'G'; break;
5277 case SHF_TLS: *p = 'T'; break;
18ae9cc1 5278 case SHF_EXCLUDE: *p = 'E'; break;
5477e8a0
L		 5279
5280 default:
8a9036a4 5281 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 5282 || elf_header.e_machine == EM_L1OM
5283 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 5284 && flag == SHF_X86_64_LARGE)
5285 *p = 'l';
5286 else if (flag & SHF_MASKOS)
5287 {
5288 *p = 'o';
5289 sh_flags &= ~ SHF_MASKOS;
5290 }
5291 else if (flag & SHF_MASKPROC)
5292 {
5293 *p = 'p';
5294 sh_flags &= ~ SHF_MASKPROC;
5295 }
5296 else
5297 *p = 'x';
5298 break;
5299 }
5300 p++;
d1133906
NC		 5301 }
5302 }
76da6bbe 5303
8d5ff12c
L		 5304 if (do_section_details)
5305 {
5306 if (os_flags)
5307 {
5308 size -= 5 + field_size;
5309 if (p != buff + field_size + 4)
5310 {
5311 if (size < (2 + 1))
bee0ee85
NC		 5312 {
5313 warn (_("Internal error: not enough buffer room for section flag info"));
5314 return _("<unknown>");
5315 }
8d5ff12c
L		 5316 size -= 2;
5317 *p++ = ',';
5318 *p++ = ' ';
5319 }
5320 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5321 (unsigned long) os_flags);
5322 p += 5 + field_size;
5323 }
5324 if (proc_flags)
5325 {
5326 size -= 7 + field_size;
5327 if (p != buff + field_size + 4)
5328 {
5329 if (size < (2 + 1))
bee0ee85
NC		 5330 {
5331 warn (_("Internal error: not enough buffer room for section flag info"));
5332 return _("<unknown>");
5333 }
8d5ff12c
L		 5334 size -= 2;
5335 *p++ = ',';
5336 *p++ = ' ';
5337 }
5338 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5339 (unsigned long) proc_flags);
5340 p += 7 + field_size;
5341 }
5342 if (unknown_flags)
5343 {
5344 size -= 10 + field_size;
5345 if (p != buff + field_size + 4)
5346 {
5347 if (size < (2 + 1))
bee0ee85
NC		 5348 {
5349 warn (_("Internal error: not enough buffer room for section flag info"));
5350 return _("<unknown>");
5351 }
8d5ff12c
L		 5352 size -= 2;
5353 *p++ = ',';
5354 *p++ = ' ';
5355 }
2b692964 5356 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 5357 (unsigned long) unknown_flags);
5358 p += 10 + field_size;
5359 }
5360 }
5361
e9e44622 5362 *p = '\0';
d1133906
NC		 5363 return buff;
5364}
5365
252b5132 5366static int
2cf0635d 5367process_section_headers (FILE * file)
252b5132 5368{
2cf0635d 5369 Elf_Internal_Shdr * section;
b34976b6 5370 unsigned int i;
252b5132
RH		 5371
5372 section_headers = NULL;
5373
5374 if (elf_header.e_shnum == 0)
5375 {
82f2dbf7
NC		 5376 /* PR binutils/12467. */
5377 if (elf_header.e_shoff != 0)
5378 warn (_("possibly corrupt ELF file header - it has a non-zero"
5379 " section header offset, but no section headers\n"));
5380 else if (do_sections)
252b5132
RH		 5381 printf (_("\nThere are no sections in this file.\n"));
5382
5383 return 1;
5384 }
5385
5386 if (do_sections && !do_header)
9ea033b2 5387 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 5388 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5389
9ea033b2
NC		 5390 if (is_32bit_elf)
5391 {
049b0c3a 5392 if (! get_32bit_section_headers (file, FALSE))
9ea033b2
NC		 5393 return 0;
5394 }
049b0c3a 5395 else if (! get_64bit_section_headers (file, FALSE))
252b5132
RH		 5396 return 0;
5397
5398 /* Read in the string table, so that we have names to display. */
0b49d371 5399 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 5400 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 5401 {
4fbb74a6 5402 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 5403
c256ffe7
JJ		 5404 if (section->sh_size != 0)
5405 {
3f5e193b
NC		 5406 string_table = (char *) get_data (NULL, file, section->sh_offset,
5407 1, section->sh_size,
5408 _("string table"));
0de14b54 5409
c256ffe7
JJ		 5410 string_table_length = string_table != NULL ? section->sh_size : 0;
5411 }
252b5132
RH		 5412 }
5413
5414 /* Scan the sections for the dynamic symbol table
e3c8793a 5415 and dynamic string table and debug sections. */
252b5132
RH		 5416 dynamic_symbols = NULL;
5417 dynamic_strings = NULL;
5418 dynamic_syminfo = NULL;
f1ef08cb 5419 symtab_shndx_hdr = NULL;
103f02d3 5420
89fac5e3
RS		 5421 eh_addr_size = is_32bit_elf ? 4 : 8;
5422 switch (elf_header.e_machine)
5423 {
5424 case EM_MIPS:
5425 case EM_MIPS_RS3_LE:
5426 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5427 FDE addresses. However, the ABI also has a semi-official ILP32
5428 variant for which the normal FDE address size rules apply.
5429
5430 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5431 section, where XX is the size of longs in bits. Unfortunately,
5432 earlier compilers provided no way of distinguishing ILP32 objects
5433 from LP64 objects, so if there's any doubt, we should assume that
5434 the official LP64 form is being used. */
5435 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5436 && find_section (".gcc_compiled_long32") == NULL)
5437 eh_addr_size = 8;
5438 break;
0f56a26a
DD		 5439
5440 case EM_H8_300:
5441 case EM_H8_300H:
5442 switch (elf_header.e_flags & EF_H8_MACH)
5443 {
5444 case E_H8_MACH_H8300:
5445 case E_H8_MACH_H8300HN:
5446 case E_H8_MACH_H8300SN:
5447 case E_H8_MACH_H8300SXN:
5448 eh_addr_size = 2;
5449 break;
5450 case E_H8_MACH_H8300H:
5451 case E_H8_MACH_H8300S:
5452 case E_H8_MACH_H8300SX:
5453 eh_addr_size = 4;
5454 break;
5455 }
f4236fe4
DD		 5456 break;
5457
ff7eeb89 5458 case EM_M32C_OLD:
f4236fe4
DD		 5459 case EM_M32C:
5460 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5461 {
5462 case EF_M32C_CPU_M16C:
5463 eh_addr_size = 2;
5464 break;
5465 }
5466 break;
89fac5e3
RS		 5467 }
5468
76ca31c0
NC		 5469#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5470 do \
5471 { \
5472 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5473 if (section->sh_entsize != expected_entsize) \
9dd3a467 5474 { \
76ca31c0
NC		 5475 char buf[40]; \
5476 sprintf_vma (buf, section->sh_entsize); \
5477 /* Note: coded this way so that there is a single string for \
5478 translation. */ \
5479 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5480 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5481 (unsigned) expected_entsize); \
9dd3a467 5482 section->sh_entsize = expected_entsize; \
76ca31c0
NC		 5483 } \
5484 } \
08d8fa11 5485 while (0)
9dd3a467
NC		 5486
5487#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 5488 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5489 sizeof (Elf64_External_##type))
5490
252b5132
RH		 5491 for (i = 0, section = section_headers;
5492 i < elf_header.e_shnum;
b34976b6 5493 i++, section++)
252b5132 5494 {
2cf0635d 5495 char * name = SECTION_NAME (section);
252b5132
RH		 5496
5497 if (section->sh_type == SHT_DYNSYM)
5498 {
5499 if (dynamic_symbols != NULL)
5500 {
5501 error (_("File contains multiple dynamic symbol tables\n"));
5502 continue;
5503 }
5504
08d8fa11 5505 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 5506 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 5507 }
5508 else if (section->sh_type == SHT_STRTAB
18bd398b 5509 && streq (name, ".dynstr"))
252b5132
RH		 5510 {
5511 if (dynamic_strings != NULL)
5512 {
5513 error (_("File contains multiple dynamic string tables\n"));
5514 continue;
5515 }
5516
3f5e193b
NC		 5517 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5518 1, section->sh_size,
5519 _("dynamic strings"));
59245841 5520 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 5521 }
9ad5cbcf
AM		 5522 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5523 {
5524 if (symtab_shndx_hdr != NULL)
5525 {
5526 error (_("File contains multiple symtab shndx tables\n"));
5527 continue;
5528 }
5529 symtab_shndx_hdr = section;
5530 }
08d8fa11
JJ		 5531 else if (section->sh_type == SHT_SYMTAB)
5532 CHECK_ENTSIZE (section, i, Sym);
5533 else if (section->sh_type == SHT_GROUP)
5534 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5535 else if (section->sh_type == SHT_REL)
5536 CHECK_ENTSIZE (section, i, Rel);
5537 else if (section->sh_type == SHT_RELA)
5538 CHECK_ENTSIZE (section, i, Rela);
252b5132 5539 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 5540 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 5541 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 5542 || do_debug_str || do_debug_loc || do_debug_ranges
5543 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 5544 && (const_strneq (name, ".debug_")
5545 || const_strneq (name, ".zdebug_")))
252b5132 5546 {
1b315056
CS		 5547 if (name[1] == 'z')
5548 name += sizeof (".zdebug_") - 1;
5549 else
5550 name += sizeof (".debug_") - 1;
252b5132
RH		 5551
5552 if (do_debugging
4723351a
CC		 5553 || (do_debug_info && const_strneq (name, "info"))
5554 || (do_debug_info && const_strneq (name, "types"))
5555 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 5556 || (do_debug_lines && strcmp (name, "line") == 0)
5557 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 5558 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5559 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
459d52c8
DE		 5560 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5561 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4723351a
CC		 5562 || (do_debug_aranges && const_strneq (name, "aranges"))
5563 || (do_debug_ranges && const_strneq (name, "ranges"))
5564 || (do_debug_frames && const_strneq (name, "frame"))
5565 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5566 || (do_debug_macinfo && const_strneq (name, "macro"))
5567 || (do_debug_str && const_strneq (name, "str"))
5568 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 5569 || (do_debug_addr && const_strneq (name, "addr"))
5570 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5571 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 5572 )
09c11c86 5573 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 5574 }
a262ae96 5575 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 5576 else if ((do_debugging || do_debug_info)
0112cd26 5577 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 5578 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 5579 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 5580 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 5581 else if (do_gdb_index && streq (name, ".gdb_index"))
5582 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 5583 /* Trace sections for Itanium VMS. */
5584 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5585 || do_trace_aranges)
5586 && const_strneq (name, ".trace_"))
5587 {
5588 name += sizeof (".trace_") - 1;
5589
5590 if (do_debugging
5591 || (do_trace_info && streq (name, "info"))
5592 || (do_trace_abbrevs && streq (name, "abbrev"))
5593 || (do_trace_aranges && streq (name, "aranges"))
5594 )
5595 request_dump_bynumber (i, DEBUG_DUMP);
5596 }
252b5132
RH		 5597 }
5598
5599 if (! do_sections)
5600 return 1;
5601
3a1a2036
NC		 5602 if (elf_header.e_shnum > 1)
5603 printf (_("\nSection Headers:\n"));
5604 else
5605 printf (_("\nSection Header:\n"));
76da6bbe 5606
f7a99963 5607 if (is_32bit_elf)
595cf52e 5608 {
5477e8a0 5609 if (do_section_details)
595cf52e
L		 5610 {
5611 printf (_(" [Nr] Name\n"));
5477e8a0 5612 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 5613 }
5614 else
5615 printf
5616 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5617 }
d974e256 5618 else if (do_wide)
595cf52e 5619 {
5477e8a0 5620 if (do_section_details)
595cf52e
L		 5621 {
5622 printf (_(" [Nr] Name\n"));
5477e8a0 5623 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 5624 }
5625 else
5626 printf
5627 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5628 }
f7a99963
NC		 5629 else
5630 {
5477e8a0 5631 if (do_section_details)
595cf52e
L		 5632 {
5633 printf (_(" [Nr] Name\n"));
5477e8a0
L		 5634 printf (_(" Type Address Offset Link\n"));
5635 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 5636 }
5637 else
5638 {
5639 printf (_(" [Nr] Name Type Address Offset\n"));
5640 printf (_(" Size EntSize Flags Link Info Align\n"));
5641 }
f7a99963 5642 }
252b5132 5643
5477e8a0
L		 5644 if (do_section_details)
5645 printf (_(" Flags\n"));
5646
252b5132
RH		 5647 for (i = 0, section = section_headers;
5648 i < elf_header.e_shnum;
b34976b6 5649 i++, section++)
252b5132 5650 {
7bfd842d 5651 printf (" [%2u] ", i);
5477e8a0 5652 if (do_section_details)
74e1a04b 5653 printf ("%s\n ", printable_section_name (section));
595cf52e 5654 else
74e1a04b 5655 print_symbol (-17, SECTION_NAME (section));
0b4362b0 5656
ea52a088
NC		 5657 printf (do_wide ? " %-15s " : " %-15.15s ",
5658 get_section_type_name (section->sh_type));
0b4362b0 5659
f7a99963
NC		 5660 if (is_32bit_elf)
5661 {
cfcac11d
NC		 5662 const char * link_too_big = NULL;
5663
f7a99963 5664 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 5665
f7a99963
NC		 5666 printf ( " %6.6lx %6.6lx %2.2lx",
5667 (unsigned long) section->sh_offset,
5668 (unsigned long) section->sh_size,
5669 (unsigned long) section->sh_entsize);
d1133906 5670
5477e8a0
L		 5671 if (do_section_details)
5672 fputs (" ", stdout);
5673 else
5674 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5675
cfcac11d
NC		 5676 if (section->sh_link >= elf_header.e_shnum)
5677 {
5678 link_too_big = "";
5679 /* The sh_link value is out of range. Normally this indicates
caa83f8b 5680 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 5681 switch (elf_header.e_machine)
5682 {
caa83f8b
NC		 5683 case EM_386:
5684 case EM_486:
5685 case EM_X86_64:
7f502d6c 5686 case EM_L1OM:
7a9068fe 5687 case EM_K1OM:
cfcac11d
NC		 5688 case EM_OLD_SPARCV9:
5689 case EM_SPARC32PLUS:
5690 case EM_SPARCV9:
5691 case EM_SPARC:
5692 if (section->sh_link == (SHN_BEFORE & 0xffff))
5693 link_too_big = "BEFORE";
5694 else if (section->sh_link == (SHN_AFTER & 0xffff))
5695 link_too_big = "AFTER";
5696 break;
5697 default:
5698 break;
5699 }
5700 }
5701
5702 if (do_section_details)
5703 {
5704 if (link_too_big != NULL && * link_too_big)
5705 printf ("<%s> ", link_too_big);
5706 else
5707 printf ("%2u ", section->sh_link);
5708 printf ("%3u %2lu\n", section->sh_info,
5709 (unsigned long) section->sh_addralign);
5710 }
5711 else
5712 printf ("%2u %3u %2lu\n",
5713 section->sh_link,
5714 section->sh_info,
5715 (unsigned long) section->sh_addralign);
5716
5717 if (link_too_big && ! * link_too_big)
5718 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5719 i, section->sh_link);
f7a99963 5720 }
d974e256
JJ		 5721 else if (do_wide)
5722 {
5723 print_vma (section->sh_addr, LONG_HEX);
5724
5725 if ((long) section->sh_offset == section->sh_offset)
5726 printf (" %6.6lx", (unsigned long) section->sh_offset);
5727 else
5728 {
5729 putchar (' ');
5730 print_vma (section->sh_offset, LONG_HEX);
5731 }
5732
5733 if ((unsigned long) section->sh_size == section->sh_size)
5734 printf (" %6.6lx", (unsigned long) section->sh_size);
5735 else
5736 {
5737 putchar (' ');
5738 print_vma (section->sh_size, LONG_HEX);
5739 }
5740
5741 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5742 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5743 else
5744 {
5745 putchar (' ');
5746 print_vma (section->sh_entsize, LONG_HEX);
5747 }
5748
5477e8a0
L		 5749 if (do_section_details)
5750 fputs (" ", stdout);
5751 else
5752 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 5753
72de5009 5754 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 5755
5756 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 5757 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 5758 else
5759 {
5760 print_vma (section->sh_addralign, DEC);
5761 putchar ('\n');
5762 }
5763 }
5477e8a0 5764 else if (do_section_details)
595cf52e 5765 {
5477e8a0 5766 printf (" %-15.15s ",
595cf52e 5767 get_section_type_name (section->sh_type));
595cf52e
L		 5768 print_vma (section->sh_addr, LONG_HEX);
5769 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 5770 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 5771 else
5772 {
5773 printf (" ");
5774 print_vma (section->sh_offset, LONG_HEX);
5775 }
72de5009 5776 printf (" %u\n ", section->sh_link);
595cf52e 5777 print_vma (section->sh_size, LONG_HEX);
5477e8a0 5778 putchar (' ');
595cf52e
L		 5779 print_vma (section->sh_entsize, LONG_HEX);
5780
72de5009
AM		 5781 printf (" %-16u %lu\n",
5782 section->sh_info,
595cf52e
L		 5783 (unsigned long) section->sh_addralign);
5784 }
f7a99963
NC		 5785 else
5786 {
5787 putchar (' ');
5788 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 5789 if ((long) section->sh_offset == section->sh_offset)
5790 printf (" %8.8lx", (unsigned long) section->sh_offset);
5791 else
5792 {
5793 printf (" ");
5794 print_vma (section->sh_offset, LONG_HEX);
5795 }
f7a99963
NC		 5796 printf ("\n ");
5797 print_vma (section->sh_size, LONG_HEX);
5798 printf (" ");
5799 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 5800
d1133906 5801 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5802
72de5009
AM		 5803 printf (" %2u %3u %lu\n",
5804 section->sh_link,
5805 section->sh_info,
f7a99963
NC		 5806 (unsigned long) section->sh_addralign);
5807 }
5477e8a0
L		 5808
5809 if (do_section_details)
5810 printf (" %s\n", get_elf_section_flags (section->sh_flags));
252b5132
RH		 5811 }
5812
5477e8a0 5813 if (!do_section_details)
3dbcc61d
NC		 5814 {
5815 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 5816 || elf_header.e_machine == EM_L1OM
5817 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 5818 printf (_("Key to Flags:\n\
5819 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5820 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5821 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5822 else
5823 printf (_("Key to Flags:\n\
e3c8793a 5824 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 5825 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 5826 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
0b4362b0 5827 }
d1133906 5828
252b5132
RH		 5829 return 1;
5830}
5831
f5842774
L		 5832static const char *
5833get_group_flags (unsigned int flags)
5834{
5835 static char buff[32];
5836 switch (flags)
5837 {
220453ec
AM		 5838 case 0:
5839 return "";
5840
f5842774 5841 case GRP_COMDAT:
220453ec 5842 return "COMDAT ";
f5842774
L		 5843
5844 default:
220453ec 5845 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 5846 break;
5847 }
5848 return buff;
5849}
5850
5851static int
2cf0635d 5852process_section_groups (FILE * file)
f5842774 5853{
2cf0635d 5854 Elf_Internal_Shdr * section;
f5842774 5855 unsigned int i;
2cf0635d
NC		 5856 struct group * group;
5857 Elf_Internal_Shdr * symtab_sec;
5858 Elf_Internal_Shdr * strtab_sec;
5859 Elf_Internal_Sym * symtab;
ba5cdace 5860 unsigned long num_syms;
2cf0635d 5861 char * strtab;
c256ffe7 5862 size_t strtab_size;
d1f5c6e3
L		 5863
5864 /* Don't process section groups unless needed. */
5865 if (!do_unwind && !do_section_groups)
5866 return 1;
f5842774
L		 5867
5868 if (elf_header.e_shnum == 0)
5869 {
5870 if (do_section_groups)
82f2dbf7 5871 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 5872
5873 return 1;
5874 }
5875
5876 if (section_headers == NULL)
5877 {
5878 error (_("Section headers are not available!\n"));
fa1908fd
NC		 5879 /* PR 13622: This can happen with a corrupt ELF header. */
5880 return 0;
f5842774
L		 5881 }
5882
3f5e193b
NC		 5883 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5884 sizeof (struct group *));
e4b17d5c
L		 5885
5886 if (section_headers_groups == NULL)
5887 {
8b73c356
NC		 5888 error (_("Out of memory reading %u section group headers\n"),
5889 elf_header.e_shnum);
e4b17d5c
L		 5890 return 0;
5891 }
5892
f5842774 5893 /* Scan the sections for the group section. */
d1f5c6e3 5894 group_count = 0;
f5842774
L		 5895 for (i = 0, section = section_headers;
5896 i < elf_header.e_shnum;
5897 i++, section++)
e4b17d5c
L		 5898 if (section->sh_type == SHT_GROUP)
5899 group_count++;
5900
d1f5c6e3
L		 5901 if (group_count == 0)
5902 {
5903 if (do_section_groups)
5904 printf (_("\nThere are no section groups in this file.\n"));
5905
5906 return 1;
5907 }
5908
3f5e193b 5909 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 5910
5911 if (section_groups == NULL)
5912 {
8b73c356
NC		 5913 error (_("Out of memory reading %lu groups\n"),
5914 (unsigned long) group_count);
e4b17d5c
L		 5915 return 0;
5916 }
5917
d1f5c6e3
L		 5918 symtab_sec = NULL;
5919 strtab_sec = NULL;
5920 symtab = NULL;
ba5cdace 5921 num_syms = 0;
d1f5c6e3 5922 strtab = NULL;
c256ffe7 5923 strtab_size = 0;
e4b17d5c
L		 5924 for (i = 0, section = section_headers, group = section_groups;
5925 i < elf_header.e_shnum;
5926 i++, section++)
f5842774
L		 5927 {
5928 if (section->sh_type == SHT_GROUP)
5929 {
74e1a04b
NC		 5930 const char * name = printable_section_name (section);
5931 const char * group_name;
2cf0635d
NC		 5932 unsigned char * start;
5933 unsigned char * indices;
f5842774 5934 unsigned int entry, j, size;
2cf0635d
NC		 5935 Elf_Internal_Shdr * sec;
5936 Elf_Internal_Sym * sym;
f5842774
L		 5937
5938 /* Get the symbol table. */
4fbb74a6
AM		 5939 if (section->sh_link >= elf_header.e_shnum
5940 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 5941 != SHT_SYMTAB))
f5842774
L		 5942 {
5943 error (_("Bad sh_link in group section `%s'\n"), name);
5944 continue;
5945 }
d1f5c6e3
L		 5946
5947 if (symtab_sec != sec)
5948 {
5949 symtab_sec = sec;
5950 if (symtab)
5951 free (symtab);
ba5cdace 5952 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 5953 }
f5842774 5954
dd24e3da
NC		 5955 if (symtab == NULL)
5956 {
5957 error (_("Corrupt header in group section `%s'\n"), name);
5958 continue;
5959 }
5960
ba5cdace
NC		 5961 if (section->sh_info >= num_syms)
5962 {
5963 error (_("Bad sh_info in group section `%s'\n"), name);
5964 continue;
5965 }
5966
f5842774
L		 5967 sym = symtab + section->sh_info;
5968
5969 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5970 {
4fbb74a6
AM		 5971 if (sym->st_shndx == 0
5972 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 5973 {
5974 error (_("Bad sh_info in group section `%s'\n"), name);
5975 continue;
5976 }
ba2685cc 5977
4fbb74a6 5978 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 5979 strtab_sec = NULL;
5980 if (strtab)
5981 free (strtab);
f5842774 5982 strtab = NULL;
c256ffe7 5983 strtab_size = 0;
f5842774
L		 5984 }
5985 else
5986 {
5987 /* Get the string table. */
4fbb74a6 5988 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 5989 {
5990 strtab_sec = NULL;
5991 if (strtab)
5992 free (strtab);
5993 strtab = NULL;
5994 strtab_size = 0;
5995 }
5996 else if (strtab_sec
4fbb74a6 5997 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 5998 {
5999 strtab_sec = sec;
6000 if (strtab)
6001 free (strtab);
071436c6 6002
3f5e193b 6003 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
071436c6
NC		 6004 1, strtab_sec->sh_size,
6005 _("string table"));
c256ffe7 6006 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 6007 }
c256ffe7 6008 group_name = sym->st_name < strtab_size
2b692964 6009 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 6010 }
6011
c9c1d674
EG		 6012 /* PR 17531: file: loop. */
6013 if (section->sh_entsize > section->sh_size)
6014 {
6015 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6016 printable_section_name (section),
8066deb1
AM		 6017 (unsigned long) section->sh_entsize,
6018 (unsigned long) section->sh_size);
c9c1d674
EG		 6019 break;
6020 }
6021
3f5e193b
NC		 6022 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6023 1, section->sh_size,
6024 _("section data"));
59245841
NC		 6025 if (start == NULL)
6026 continue;
f5842774
L		 6027
6028 indices = start;
6029 size = (section->sh_size / section->sh_entsize) - 1;
6030 entry = byte_get (indices, 4);
6031 indices += 4;
e4b17d5c
L		 6032
6033 if (do_section_groups)
6034 {
2b692964 6035 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 6036 get_group_flags (entry), i, name, group_name, size);
ba2685cc 6037
e4b17d5c
L		 6038 printf (_(" [Index] Name\n"));
6039 }
6040
6041 group->group_index = i;
6042
f5842774
L		 6043 for (j = 0; j < size; j++)
6044 {
2cf0635d 6045 struct group_list * g;
e4b17d5c 6046
f5842774
L		 6047 entry = byte_get (indices, 4);
6048 indices += 4;
6049
4fbb74a6 6050 if (entry >= elf_header.e_shnum)
391cb864 6051 {
57028622
NC		 6052 static unsigned num_group_errors = 0;
6053
6054 if (num_group_errors ++ < 10)
6055 {
6056 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6057 entry, i, elf_header.e_shnum - 1);
6058 if (num_group_errors == 10)
6059 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6060 }
391cb864
L		 6061 continue;
6062 }
391cb864 6063
4fbb74a6 6064 if (section_headers_groups [entry] != NULL)
e4b17d5c 6065 {
d1f5c6e3
L		 6066 if (entry)
6067 {
57028622
NC		 6068 static unsigned num_errs = 0;
6069
6070 if (num_errs ++ < 10)
6071 {
6072 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6073 entry, i,
6074 section_headers_groups [entry]->group_index);
6075 if (num_errs == 10)
6076 warn (_("Further error messages about already contained group sections suppressed\n"));
6077 }
d1f5c6e3
L		 6078 continue;
6079 }
6080 else
6081 {
6082 /* Intel C/C++ compiler may put section 0 in a
6083 section group. We just warn it the first time
6084 and ignore it afterwards. */
6085 static int warned = 0;
6086 if (!warned)
6087 {
6088 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 6089 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 6090 warned++;
6091 }
6092 }
e4b17d5c
L		 6093 }
6094
4fbb74a6 6095 section_headers_groups [entry] = group;
e4b17d5c
L		 6096
6097 if (do_section_groups)
6098 {
4fbb74a6 6099 sec = section_headers + entry;
74e1a04b 6100 printf (" [%5u] %s\n", entry, printable_section_name (sec));
ba2685cc
AM		 6101 }
6102
3f5e193b 6103 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 6104 g->section_index = entry;
6105 g->next = group->root;
6106 group->root = g;
f5842774
L		 6107 }
6108
f5842774
L		 6109 if (start)
6110 free (start);
e4b17d5c
L		 6111
6112 group++;
f5842774
L		 6113 }
6114 }
6115
d1f5c6e3
L		 6116 if (symtab)
6117 free (symtab);
6118 if (strtab)
6119 free (strtab);
f5842774
L		 6120 return 1;
6121}
6122
28f997cf
TG		 6123/* Data used to display dynamic fixups. */
6124
6125struct ia64_vms_dynfixup
6126{
6127 bfd_vma needed_ident; /* Library ident number. */
6128 bfd_vma needed; /* Index in the dstrtab of the library name. */
6129 bfd_vma fixup_needed; /* Index of the library. */
6130 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6131 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6132};
6133
6134/* Data used to display dynamic relocations. */
6135
6136struct ia64_vms_dynimgrela
6137{
6138 bfd_vma img_rela_cnt; /* Number of relocations. */
6139 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6140};
6141
6142/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6143 library). */
6144
6145static void
6146dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6147 const char *strtab, unsigned int strtab_sz)
6148{
6149 Elf64_External_VMS_IMAGE_FIXUP *imfs;
6150 long i;
6151 const char *lib_name;
6152
6153 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6154 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6155 _("dynamic section image fixups"));
6156 if (!imfs)
6157 return;
6158
6159 if (fixup->needed < strtab_sz)
6160 lib_name = strtab + fixup->needed;
6161 else
6162 {
6163 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 6164 (unsigned long) fixup->needed);
28f997cf
TG		 6165 lib_name = "???";
6166 }
6167 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6168 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6169 printf
6170 (_("Seg Offset Type SymVec DataType\n"));
6171
6172 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6173 {
6174 unsigned int type;
6175 const char *rtype;
6176
6177 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6178 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6179 type = BYTE_GET (imfs [i].type);
6180 rtype = elf_ia64_reloc_type (type);
6181 if (rtype == NULL)
6182 printf (" 0x%08x ", type);
6183 else
6184 printf (" %-32s ", rtype);
6185 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6186 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6187 }
6188
6189 free (imfs);
6190}
6191
6192/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6193
6194static void
6195dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6196{
6197 Elf64_External_VMS_IMAGE_RELA *imrs;
6198 long i;
6199
6200 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6201 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 6202 _("dynamic section image relocations"));
28f997cf
TG		 6203 if (!imrs)
6204 return;
6205
6206 printf (_("\nImage relocs\n"));
6207 printf
6208 (_("Seg Offset Type Addend Seg Sym Off\n"));
6209
6210 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6211 {
6212 unsigned int type;
6213 const char *rtype;
6214
6215 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6216 printf ("%08" BFD_VMA_FMT "x ",
6217 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6218 type = BYTE_GET (imrs [i].type);
6219 rtype = elf_ia64_reloc_type (type);
6220 if (rtype == NULL)
6221 printf ("0x%08x ", type);
6222 else
6223 printf ("%-31s ", rtype);
6224 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6225 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6226 printf ("%08" BFD_VMA_FMT "x\n",
6227 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6228 }
6229
6230 free (imrs);
6231}
6232
6233/* Display IA-64 OpenVMS dynamic relocations and fixups. */
6234
6235static int
6236process_ia64_vms_dynamic_relocs (FILE *file)
6237{
6238 struct ia64_vms_dynfixup fixup;
6239 struct ia64_vms_dynimgrela imgrela;
6240 Elf_Internal_Dyn *entry;
6241 int res = 0;
6242 bfd_vma strtab_off = 0;
6243 bfd_vma strtab_sz = 0;
6244 char *strtab = NULL;
6245
6246 memset (&fixup, 0, sizeof (fixup));
6247 memset (&imgrela, 0, sizeof (imgrela));
6248
6249 /* Note: the order of the entries is specified by the OpenVMS specs. */
6250 for (entry = dynamic_section;
6251 entry < dynamic_section + dynamic_nent;
6252 entry++)
6253 {
6254 switch (entry->d_tag)
6255 {
6256 case DT_IA_64_VMS_STRTAB_OFFSET:
6257 strtab_off = entry->d_un.d_val;
6258 break;
6259 case DT_STRSZ:
6260 strtab_sz = entry->d_un.d_val;
6261 if (strtab == NULL)
6262 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6263 1, strtab_sz, _("dynamic string section"));
6264 break;
6265
6266 case DT_IA_64_VMS_NEEDED_IDENT:
6267 fixup.needed_ident = entry->d_un.d_val;
6268 break;
6269 case DT_NEEDED:
6270 fixup.needed = entry->d_un.d_val;
6271 break;
6272 case DT_IA_64_VMS_FIXUP_NEEDED:
6273 fixup.fixup_needed = entry->d_un.d_val;
6274 break;
6275 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6276 fixup.fixup_rela_cnt = entry->d_un.d_val;
6277 break;
6278 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6279 fixup.fixup_rela_off = entry->d_un.d_val;
6280 res++;
6281 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6282 break;
6283
6284 case DT_IA_64_VMS_IMG_RELA_CNT:
6285 imgrela.img_rela_cnt = entry->d_un.d_val;
6286 break;
6287 case DT_IA_64_VMS_IMG_RELA_OFF:
6288 imgrela.img_rela_off = entry->d_un.d_val;
6289 res++;
6290 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6291 break;
6292
6293 default:
6294 break;
6295 }
6296 }
6297
6298 if (strtab != NULL)
6299 free (strtab);
6300
6301 return res;
6302}
6303
85b1c36d 6304static struct
566b0d53 6305{
2cf0635d 6306 const char * name;
566b0d53
L		 6307 int reloc;
6308 int size;
6309 int rela;
6310} dynamic_relocations [] =
6311{
6312 { "REL", DT_REL, DT_RELSZ, FALSE },
6313 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6314 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6315};
6316
252b5132 6317/* Process the reloc section. */
18bd398b 6318
252b5132 6319static int
2cf0635d 6320process_relocs (FILE * file)
252b5132 6321{
b34976b6
AM		 6322 unsigned long rel_size;
6323 unsigned long rel_offset;
252b5132
RH		 6324
6325
6326 if (!do_reloc)
6327 return 1;
6328
6329 if (do_using_dynamic)
6330 {
566b0d53 6331 int is_rela;
2cf0635d 6332 const char * name;
566b0d53
L		 6333 int has_dynamic_reloc;
6334 unsigned int i;
0de14b54 6335
566b0d53 6336 has_dynamic_reloc = 0;
252b5132 6337
566b0d53 6338 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 6339 {
566b0d53
L		 6340 is_rela = dynamic_relocations [i].rela;
6341 name = dynamic_relocations [i].name;
6342 rel_size = dynamic_info [dynamic_relocations [i].size];
6343 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 6344
566b0d53
L		 6345 has_dynamic_reloc |= rel_size;
6346
6347 if (is_rela == UNKNOWN)
aa903cfb 6348 {
566b0d53
L		 6349 if (dynamic_relocations [i].reloc == DT_JMPREL)
6350 switch (dynamic_info[DT_PLTREL])
6351 {
6352 case DT_REL:
6353 is_rela = FALSE;
6354 break;
6355 case DT_RELA:
6356 is_rela = TRUE;
6357 break;
6358 }
aa903cfb 6359 }
252b5132 6360
566b0d53
L		 6361 if (rel_size)
6362 {
6363 printf
6364 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6365 name, rel_offset, rel_size);
252b5132 6366
d93f0186
NC		 6367 dump_relocations (file,
6368 offset_from_vma (file, rel_offset, rel_size),
6369 rel_size,
566b0d53 6370 dynamic_symbols, num_dynamic_syms,
bb4d2ac2
L		 6371 dynamic_strings, dynamic_strings_length,
6372 is_rela, 1);
566b0d53 6373 }
252b5132 6374 }
566b0d53 6375
28f997cf
TG		 6376 if (is_ia64_vms ())
6377 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6378
566b0d53 6379 if (! has_dynamic_reloc)
252b5132
RH		 6380 printf (_("\nThere are no dynamic relocations in this file.\n"));
6381 }
6382 else
6383 {
2cf0635d 6384 Elf_Internal_Shdr * section;
b34976b6
AM		 6385 unsigned long i;
6386 int found = 0;
252b5132
RH		 6387
6388 for (i = 0, section = section_headers;
6389 i < elf_header.e_shnum;
b34976b6 6390 i++, section++)
252b5132
RH		 6391 {
6392 if ( section->sh_type != SHT_RELA
6393 && section->sh_type != SHT_REL)
6394 continue;
6395
6396 rel_offset = section->sh_offset;
6397 rel_size = section->sh_size;
6398
6399 if (rel_size)
6400 {
2cf0635d 6401 Elf_Internal_Shdr * strsec;
b34976b6 6402 int is_rela;
103f02d3 6403
252b5132
RH		 6404 printf (_("\nRelocation section "));
6405
6406 if (string_table == NULL)
19936277 6407 printf ("%d", section->sh_name);
252b5132 6408 else
74e1a04b 6409 printf ("'%s'", printable_section_name (section));
252b5132
RH		 6410
6411 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6412 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6413
d79b3d50
NC		 6414 is_rela = section->sh_type == SHT_RELA;
6415
4fbb74a6
AM		 6416 if (section->sh_link != 0
6417 && section->sh_link < elf_header.e_shnum)
af3fc3bc 6418 {
2cf0635d
NC		 6419 Elf_Internal_Shdr * symsec;
6420 Elf_Internal_Sym * symtab;
d79b3d50 6421 unsigned long nsyms;
c256ffe7 6422 unsigned long strtablen = 0;
2cf0635d 6423 char * strtab = NULL;
57346661 6424
4fbb74a6 6425 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 6426 if (symsec->sh_type != SHT_SYMTAB
6427 && symsec->sh_type != SHT_DYNSYM)
6428 continue;
6429
ba5cdace 6430 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 6431
af3fc3bc
AM		 6432 if (symtab == NULL)
6433 continue;
252b5132 6434
4fbb74a6
AM		 6435 if (symsec->sh_link != 0
6436 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 6437 {
4fbb74a6 6438 strsec = section_headers + symsec->sh_link;
103f02d3 6439
3f5e193b 6440 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
071436c6
NC		 6441 1, strsec->sh_size,
6442 _("string table"));
c256ffe7
JJ		 6443 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6444 }
252b5132 6445
d79b3d50 6446 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2
L		 6447 symtab, nsyms, strtab, strtablen,
6448 is_rela,
6449 symsec->sh_type == SHT_DYNSYM);
d79b3d50
NC		 6450 if (strtab)
6451 free (strtab);
6452 free (symtab);
6453 }
6454 else
6455 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2 6456 NULL, 0, NULL, 0, is_rela, 0);
252b5132
RH		 6457
6458 found = 1;
6459 }
6460 }
6461
6462 if (! found)
6463 printf (_("\nThere are no relocations in this file.\n"));
6464 }
6465
6466 return 1;
6467}
6468
4d6ed7c8
NC		 6469/* An absolute address consists of a section and an offset. If the
6470 section is NULL, the offset itself is the address, otherwise, the
6471 address equals to LOAD_ADDRESS(section) + offset. */
6472
6473struct absaddr
948f632f
DA		 6474{
6475 unsigned short section;
6476 bfd_vma offset;
6477};
4d6ed7c8 6478
1949de15
L		 6479#define ABSADDR(a) \
6480 ((a).section \
6481 ? section_headers [(a).section].sh_addr + (a).offset \
6482 : (a).offset)
6483
948f632f
DA		 6484/* Find the nearest symbol at or below ADDR. Returns the symbol
6485 name, if found, and the offset from the symbol to ADDR. */
4d6ed7c8 6486
4d6ed7c8 6487static void
2cf0635d 6488find_symbol_for_address (Elf_Internal_Sym * symtab,
948f632f
DA		 6489 unsigned long nsyms,
6490 const char * strtab,
6491 unsigned long strtab_size,
6492 struct absaddr addr,
6493 const char ** symname,
6494 bfd_vma * offset)
4d6ed7c8 6495{
d3ba0551 6496 bfd_vma dist = 0x100000;
2cf0635d 6497 Elf_Internal_Sym * sym;
948f632f
DA		 6498 Elf_Internal_Sym * beg;
6499 Elf_Internal_Sym * end;
2cf0635d 6500 Elf_Internal_Sym * best = NULL;
4d6ed7c8 6501
0b6ae522 6502 REMOVE_ARCH_BITS (addr.offset);
948f632f
DA		 6503 beg = symtab;
6504 end = symtab + nsyms;
0b6ae522 6505
948f632f 6506 while (beg < end)
4d6ed7c8 6507 {
948f632f
DA		 6508 bfd_vma value;
6509
6510 sym = beg + (end - beg) / 2;
0b6ae522 6511
948f632f 6512 value = sym->st_value;
0b6ae522
DJ		 6513 REMOVE_ARCH_BITS (value);
6514
948f632f 6515 if (sym->st_name != 0
4d6ed7c8 6516 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 6517 && addr.offset >= value
6518 && addr.offset - value < dist)
4d6ed7c8
NC		 6519 {
6520 best = sym;
0b6ae522 6521 dist = addr.offset - value;
4d6ed7c8
NC		 6522 if (!dist)
6523 break;
6524 }
948f632f
DA		 6525
6526 if (addr.offset < value)
6527 end = sym;
6528 else
6529 beg = sym + 1;
4d6ed7c8 6530 }
1b31d05e 6531
4d6ed7c8
NC		 6532 if (best)
6533 {
57346661 6534 *symname = (best->st_name >= strtab_size
2b692964 6535 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 6536 *offset = dist;
6537 return;
6538 }
1b31d05e 6539
4d6ed7c8
NC		 6540 *symname = NULL;
6541 *offset = addr.offset;
6542}
6543
948f632f
DA		 6544static int
6545symcmp (const void *p, const void *q)
6546{
6547 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
6548 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
6549
6550 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
6551}
6552
6553/* Process the unwind section. */
6554
6555#include "unwind-ia64.h"
6556
6557struct ia64_unw_table_entry
6558{
6559 struct absaddr start;
6560 struct absaddr end;
6561 struct absaddr info;
6562};
6563
6564struct ia64_unw_aux_info
6565{
6566 struct ia64_unw_table_entry *table; /* Unwind table. */
6567 unsigned long table_len; /* Length of unwind table. */
6568 unsigned char * info; /* Unwind info. */
6569 unsigned long info_size; /* Size of unwind info. */
6570 bfd_vma info_addr; /* Starting address of unwind info. */
6571 bfd_vma seg_base; /* Starting address of segment. */
6572 Elf_Internal_Sym * symtab; /* The symbol table. */
6573 unsigned long nsyms; /* Number of symbols. */
6574 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
6575 unsigned long nfuns; /* Number of entries in funtab. */
6576 char * strtab; /* The string table. */
6577 unsigned long strtab_size; /* Size of string table. */
6578};
6579
4d6ed7c8 6580static void
2cf0635d 6581dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 6582{
2cf0635d 6583 struct ia64_unw_table_entry * tp;
948f632f 6584 unsigned long j, nfuns;
4d6ed7c8 6585 int in_body;
7036c0e1 6586
948f632f
DA		 6587 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
6588 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
6589 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
6590 aux->funtab[nfuns++] = aux->symtab[j];
6591 aux->nfuns = nfuns;
6592 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
6593
4d6ed7c8
NC		 6594 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6595 {
6596 bfd_vma stamp;
6597 bfd_vma offset;
2cf0635d
NC		 6598 const unsigned char * dp;
6599 const unsigned char * head;
53774b7e 6600 const unsigned char * end;
2cf0635d 6601 const char * procname;
4d6ed7c8 6602
948f632f 6603 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661 6604 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 6605
6606 fputs ("\n<", stdout);
6607
6608 if (procname)
6609 {
6610 fputs (procname, stdout);
6611
6612 if (offset)
6613 printf ("+%lx", (unsigned long) offset);
6614 }
6615
6616 fputs (">: [", stdout);
6617 print_vma (tp->start.offset, PREFIX_HEX);
6618 fputc ('-', stdout);
6619 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 6620 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 6621 (unsigned long) (tp->info.offset - aux->seg_base));
6622
53774b7e
NC		 6623 /* PR 17531: file: 86232b32. */
6624 if (aux->info == NULL)
6625 continue;
6626
6627 /* PR 17531: file: 0997b4d1. */
6628 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6629 {
6630 warn (_("Invalid offset %lx in table entry %ld\n"),
6631 (long) tp->info.offset, (long) (tp - aux->table));
6632 continue;
6633 }
6634
1949de15 6635 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 6636 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 6637
86f55779 6638 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 6639 (unsigned) UNW_VER (stamp),
6640 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6641 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6642 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 6643 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 6644
6645 if (UNW_VER (stamp) != 1)
6646 {
2b692964 6647 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 6648 continue;
6649 }
6650
6651 in_body = 0;
53774b7e
NC		 6652 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6653 /* PR 17531: file: 16ceda89. */
6654 if (end > aux->info + aux->info_size)
6655 end = aux->info + aux->info_size;
6656 for (dp = head + 8; dp < end;)
4d6ed7c8
NC		 6657 dp = unw_decode (dp, in_body, & in_body);
6658 }
948f632f
DA		 6659
6660 free (aux->funtab);
4d6ed7c8
NC		 6661}
6662
53774b7e 6663static bfd_boolean
2cf0635d
NC		 6664slurp_ia64_unwind_table (FILE * file,
6665 struct ia64_unw_aux_info * aux,
6666 Elf_Internal_Shdr * sec)
4d6ed7c8 6667{
89fac5e3 6668 unsigned long size, nrelas, i;
2cf0635d
NC		 6669 Elf_Internal_Phdr * seg;
6670 struct ia64_unw_table_entry * tep;
6671 Elf_Internal_Shdr * relsec;
6672 Elf_Internal_Rela * rela;
6673 Elf_Internal_Rela * rp;
6674 unsigned char * table;
6675 unsigned char * tp;
6676 Elf_Internal_Sym * sym;
6677 const char * relname;
4d6ed7c8 6678
53774b7e
NC		 6679 aux->table_len = 0;
6680
4d6ed7c8
NC		 6681 /* First, find the starting address of the segment that includes
6682 this section: */
6683
6684 if (elf_header.e_phnum)
6685 {
d93f0186 6686 if (! get_program_headers (file))
53774b7e 6687 return FALSE;
4d6ed7c8 6688
d93f0186
NC		 6689 for (seg = program_headers;
6690 seg < program_headers + elf_header.e_phnum;
6691 ++seg)
4d6ed7c8
NC		 6692 {
6693 if (seg->p_type != PT_LOAD)
6694 continue;
6695
6696 if (sec->sh_addr >= seg->p_vaddr
6697 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6698 {
6699 aux->seg_base = seg->p_vaddr;
6700 break;
6701 }
6702 }
4d6ed7c8
NC		 6703 }
6704
6705 /* Second, build the unwind table from the contents of the unwind section: */
6706 size = sec->sh_size;
3f5e193b
NC		 6707 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6708 _("unwind table"));
a6e9f9df 6709 if (!table)
53774b7e 6710 return FALSE;
4d6ed7c8 6711
53774b7e 6712 aux->table_len = size / (3 * eh_addr_size);
3f5e193b 6713 aux->table = (struct ia64_unw_table_entry *)
53774b7e 6714 xcmalloc (aux->table_len, sizeof (aux->table[0]));
89fac5e3 6715 tep = aux->table;
53774b7e
NC		 6716
6717 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
4d6ed7c8
NC		 6718 {
6719 tep->start.section = SHN_UNDEF;
6720 tep->end.section = SHN_UNDEF;
6721 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 6722 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6723 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6724 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 6725 tep->start.offset += aux->seg_base;
6726 tep->end.offset += aux->seg_base;
6727 tep->info.offset += aux->seg_base;
6728 }
6729 free (table);
6730
41e92641 6731 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 6732 for (relsec = section_headers;
6733 relsec < section_headers + elf_header.e_shnum;
6734 ++relsec)
6735 {
6736 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6737 || relsec->sh_info >= elf_header.e_shnum
6738 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 6739 continue;
6740
6741 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6742 & rela, & nrelas))
53774b7e
NC		 6743 {
6744 free (aux->table);
6745 aux->table = NULL;
6746 aux->table_len = 0;
6747 return FALSE;
6748 }
4d6ed7c8
NC		 6749
6750 for (rp = rela; rp < rela + nrelas; ++rp)
6751 {
aca88567
NC		 6752 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6753 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 6754
82b1b41b
NC		 6755 /* PR 17531: file: 9fa67536. */
6756 if (relname == NULL)
6757 {
6758 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
6759 continue;
6760 }
948f632f 6761
0112cd26 6762 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 6763 {
82b1b41b 6764 warn (_("Skipping unexpected relocation type: %s\n"), relname);
4d6ed7c8
NC		 6765 continue;
6766 }
6767
89fac5e3 6768 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 6769
53774b7e
NC		 6770 /* PR 17531: file: 5bc8d9bf. */
6771 if (i >= aux->table_len)
6772 {
6773 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
6774 continue;
6775 }
6776
6777 switch (rp->r_offset / eh_addr_size % 3)
4d6ed7c8
NC		 6778 {
6779 case 0:
6780 aux->table[i].start.section = sym->st_shndx;
e466bc6e 6781 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6782 break;
6783 case 1:
6784 aux->table[i].end.section = sym->st_shndx;
e466bc6e 6785 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6786 break;
6787 case 2:
6788 aux->table[i].info.section = sym->st_shndx;
e466bc6e 6789 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6790 break;
6791 default:
6792 break;
6793 }
6794 }
6795
6796 free (rela);
6797 }
6798
53774b7e 6799 return TRUE;
4d6ed7c8
NC		 6800}
6801
1b31d05e 6802static void
2cf0635d 6803ia64_process_unwind (FILE * file)
4d6ed7c8 6804{
2cf0635d
NC		 6805 Elf_Internal_Shdr * sec;
6806 Elf_Internal_Shdr * unwsec = NULL;
6807 Elf_Internal_Shdr * strsec;
89fac5e3 6808 unsigned long i, unwcount = 0, unwstart = 0;
57346661 6809 struct ia64_unw_aux_info aux;
f1467e33 6810
4d6ed7c8
NC		 6811 memset (& aux, 0, sizeof (aux));
6812
4d6ed7c8
NC		 6813 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6814 {
c256ffe7 6815 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6816 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 6817 {
ba5cdace 6818 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 6819
4fbb74a6 6820 strsec = section_headers + sec->sh_link;
4082ef84
NC		 6821 if (aux.strtab != NULL)
6822 {
6823 error (_("Multiple auxillary string tables encountered\n"));
6824 free (aux.strtab);
6825 }
3f5e193b
NC		 6826 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6827 1, strsec->sh_size,
6828 _("string table"));
c256ffe7 6829 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 6830 }
6831 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 6832 unwcount++;
6833 }
6834
6835 if (!unwcount)
6836 printf (_("\nThere are no unwind sections in this file.\n"));
6837
6838 while (unwcount-- > 0)
6839 {
2cf0635d 6840 char * suffix;
579f31ac
JJ		 6841 size_t len, len2;
6842
4082ef84 6843 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
579f31ac
JJ		 6844 i < elf_header.e_shnum; ++i, ++sec)
6845 if (sec->sh_type == SHT_IA_64_UNWIND)
6846 {
6847 unwsec = sec;
6848 break;
6849 }
4082ef84
NC		 6850 /* We have already counted the number of SHT_IA64_UNWIND
6851 sections so the loop above should never fail. */
6852 assert (unwsec != NULL);
579f31ac
JJ		 6853
6854 unwstart = i + 1;
6855 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6856
e4b17d5c
L		 6857 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6858 {
6859 /* We need to find which section group it is in. */
4082ef84 6860 struct group_list * g;
e4b17d5c 6861
4082ef84
NC		 6862 if (section_headers_groups == NULL
6863 || section_headers_groups [i] == NULL)
6864 i = elf_header.e_shnum;
6865 else
e4b17d5c 6866 {
4082ef84 6867 g = section_headers_groups [i]->root;
18bd398b 6868
4082ef84
NC		 6869 for (; g != NULL; g = g->next)
6870 {
6871 sec = section_headers + g->section_index;
e4b17d5c 6872
4082ef84
NC		 6873 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6874 break;
6875 }
6876
6877 if (g == NULL)
6878 i = elf_header.e_shnum;
6879 }
e4b17d5c 6880 }
18bd398b 6881 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 6882 {
18bd398b 6883 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 6884 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6885 suffix = SECTION_NAME (unwsec) + len;
6886 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6887 ++i, ++sec)
18bd398b
NC		 6888 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6889 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6890 break;
6891 }
6892 else
6893 {
6894 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 6895 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 6896 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6897 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6898 suffix = "";
18bd398b 6899 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 6900 suffix = SECTION_NAME (unwsec) + len;
6901 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6902 ++i, ++sec)
18bd398b
NC		 6903 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6904 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6905 break;
6906 }
6907
6908 if (i == elf_header.e_shnum)
6909 {
6910 printf (_("\nCould not find unwind info section for "));
6911
6912 if (string_table == NULL)
6913 printf ("%d", unwsec->sh_name);
6914 else
74e1a04b 6915 printf ("'%s'", printable_section_name (unwsec));
579f31ac
JJ		 6916 }
6917 else
4d6ed7c8 6918 {
4d6ed7c8 6919 aux.info_addr = sec->sh_addr;
3f5e193b 6920 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
4082ef84
NC		 6921 sec->sh_size,
6922 _("unwind info"));
59245841 6923 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 6924
579f31ac 6925 printf (_("\nUnwind section "));
4d6ed7c8 6926
579f31ac
JJ		 6927 if (string_table == NULL)
6928 printf ("%d", unwsec->sh_name);
6929 else
74e1a04b 6930 printf ("'%s'", printable_section_name (unwsec));
4d6ed7c8 6931
579f31ac 6932 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 6933 (unsigned long) unwsec->sh_offset,
89fac5e3 6934 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 6935
53774b7e
NC		 6936 if (slurp_ia64_unwind_table (file, & aux, unwsec)
6937 && aux.table_len > 0)
579f31ac
JJ		 6938 dump_ia64_unwind (& aux);
6939
6940 if (aux.table)
6941 free ((char *) aux.table);
6942 if (aux.info)
6943 free ((char *) aux.info);
6944 aux.table = NULL;
6945 aux.info = NULL;
6946 }
4d6ed7c8 6947 }
4d6ed7c8 6948
4d6ed7c8
NC		 6949 if (aux.symtab)
6950 free (aux.symtab);
6951 if (aux.strtab)
6952 free ((char *) aux.strtab);
4d6ed7c8
NC		 6953}
6954
3f5e193b
NC		 6955struct hppa_unw_table_entry
6956 {
6957 struct absaddr start;
6958 struct absaddr end;
948f632f 6959 unsigned int Cannot_unwind:1; /* 0 */
3f5e193b
NC		 6960 unsigned int Millicode:1; /* 1 */
6961 unsigned int Millicode_save_sr0:1; /* 2 */
6962 unsigned int Region_description:2; /* 3..4 */
6963 unsigned int reserved1:1; /* 5 */
6964 unsigned int Entry_SR:1; /* 6 */
6965 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
6966 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
6967 unsigned int Args_stored:1; /* 16 */
948f632f
DA		 6968 unsigned int Variable_Frame:1; /* 17 */
6969 unsigned int Separate_Package_Body:1; /* 18 */
3f5e193b 6970 unsigned int Frame_Extension_Millicode:1; /* 19 */
948f632f
DA		 6971 unsigned int Stack_Overflow_Check:1; /* 20 */
6972 unsigned int Two_Instruction_SP_Increment:1;/* 21 */
3f5e193b
NC		 6973 unsigned int Ada_Region:1; /* 22 */
6974 unsigned int cxx_info:1; /* 23 */
948f632f
DA		 6975 unsigned int cxx_try_catch:1; /* 24 */
6976 unsigned int sched_entry_seq:1; /* 25 */
3f5e193b 6977 unsigned int reserved2:1; /* 26 */
948f632f
DA		 6978 unsigned int Save_SP:1; /* 27 */
6979 unsigned int Save_RP:1; /* 28 */
3f5e193b
NC		 6980 unsigned int Save_MRP_in_frame:1; /* 29 */
6981 unsigned int extn_ptr_defined:1; /* 30 */
948f632f 6982 unsigned int Cleanup_defined:1; /* 31 */
3f5e193b 6983
948f632f
DA		 6984 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
6985 unsigned int HP_UX_interrupt_marker:1; /* 1 */
3f5e193b 6986 unsigned int Large_frame:1; /* 2 */
948f632f 6987 unsigned int Pseudo_SP_Set:1; /* 3 */
3f5e193b
NC		 6988 unsigned int reserved4:1; /* 4 */
6989 unsigned int Total_frame_size:27; /* 5..31 */
6990 };
6991
57346661 6992struct hppa_unw_aux_info
948f632f
DA		 6993{
6994 struct hppa_unw_table_entry * table; /* Unwind table. */
6995 unsigned long table_len; /* Length of unwind table. */
6996 bfd_vma seg_base; /* Starting address of segment. */
6997 Elf_Internal_Sym * symtab; /* The symbol table. */
6998 unsigned long nsyms; /* Number of symbols. */
6999 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7000 unsigned long nfuns; /* Number of entries in funtab. */
7001 char * strtab; /* The string table. */
7002 unsigned long strtab_size; /* Size of string table. */
7003};
57346661
AM		 7004
7005static void
2cf0635d 7006dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 7007{
2cf0635d 7008 struct hppa_unw_table_entry * tp;
948f632f
DA		 7009 unsigned long j, nfuns;
7010
7011 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7012 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7013 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7014 aux->funtab[nfuns++] = aux->symtab[j];
7015 aux->nfuns = nfuns;
7016 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
57346661 7017
57346661
AM		 7018 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7019 {
7020 bfd_vma offset;
2cf0635d 7021 const char * procname;
57346661 7022
948f632f 7023 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661
AM		 7024 aux->strtab_size, tp->start, &procname,
7025 &offset);
7026
7027 fputs ("\n<", stdout);
7028
7029 if (procname)
7030 {
7031 fputs (procname, stdout);
7032
7033 if (offset)
7034 printf ("+%lx", (unsigned long) offset);
7035 }
7036
7037 fputs (">: [", stdout);
7038 print_vma (tp->start.offset, PREFIX_HEX);
7039 fputc ('-', stdout);
7040 print_vma (tp->end.offset, PREFIX_HEX);
7041 printf ("]\n\t");
7042
18bd398b
NC		 7043#define PF(_m) if (tp->_m) printf (#_m " ");
7044#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 7045 PF(Cannot_unwind);
7046 PF(Millicode);
7047 PF(Millicode_save_sr0);
18bd398b 7048 /* PV(Region_description); */
57346661
AM		 7049 PF(Entry_SR);
7050 PV(Entry_FR);
7051 PV(Entry_GR);
7052 PF(Args_stored);
7053 PF(Variable_Frame);
7054 PF(Separate_Package_Body);
7055 PF(Frame_Extension_Millicode);
7056 PF(Stack_Overflow_Check);
7057 PF(Two_Instruction_SP_Increment);
7058 PF(Ada_Region);
7059 PF(cxx_info);
7060 PF(cxx_try_catch);
7061 PF(sched_entry_seq);
7062 PF(Save_SP);
7063 PF(Save_RP);
7064 PF(Save_MRP_in_frame);
7065 PF(extn_ptr_defined);
7066 PF(Cleanup_defined);
7067 PF(MPE_XL_interrupt_marker);
7068 PF(HP_UX_interrupt_marker);
7069 PF(Large_frame);
7070 PF(Pseudo_SP_Set);
7071 PV(Total_frame_size);
7072#undef PF
7073#undef PV
7074 }
7075
18bd398b 7076 printf ("\n");
948f632f
DA		 7077
7078 free (aux->funtab);
57346661
AM		 7079}
7080
7081static int
2cf0635d
NC		 7082slurp_hppa_unwind_table (FILE * file,
7083 struct hppa_unw_aux_info * aux,
7084 Elf_Internal_Shdr * sec)
57346661 7085{
1c0751b2 7086 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 7087 Elf_Internal_Phdr * seg;
7088 struct hppa_unw_table_entry * tep;
7089 Elf_Internal_Shdr * relsec;
7090 Elf_Internal_Rela * rela;
7091 Elf_Internal_Rela * rp;
7092 unsigned char * table;
7093 unsigned char * tp;
7094 Elf_Internal_Sym * sym;
7095 const char * relname;
57346661 7096
57346661
AM		 7097 /* First, find the starting address of the segment that includes
7098 this section. */
7099
7100 if (elf_header.e_phnum)
7101 {
7102 if (! get_program_headers (file))
7103 return 0;
7104
7105 for (seg = program_headers;
7106 seg < program_headers + elf_header.e_phnum;
7107 ++seg)
7108 {
7109 if (seg->p_type != PT_LOAD)
7110 continue;
7111
7112 if (sec->sh_addr >= seg->p_vaddr
7113 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7114 {
7115 aux->seg_base = seg->p_vaddr;
7116 break;
7117 }
7118 }
7119 }
7120
7121 /* Second, build the unwind table from the contents of the unwind
7122 section. */
7123 size = sec->sh_size;
3f5e193b
NC		 7124 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7125 _("unwind table"));
57346661
AM		 7126 if (!table)
7127 return 0;
7128
1c0751b2
DA		 7129 unw_ent_size = 16;
7130 nentries = size / unw_ent_size;
7131 size = unw_ent_size * nentries;
57346661 7132
3f5e193b
NC		 7133 tep = aux->table = (struct hppa_unw_table_entry *)
7134 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 7135
1c0751b2 7136 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 7137 {
7138 unsigned int tmp1, tmp2;
7139
7140 tep->start.section = SHN_UNDEF;
7141 tep->end.section = SHN_UNDEF;
7142
1c0751b2
DA		 7143 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7144 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7145 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7146 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7147
7148 tep->start.offset += aux->seg_base;
7149 tep->end.offset += aux->seg_base;
57346661
AM		 7150
7151 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7152 tep->Millicode = (tmp1 >> 30) & 0x1;
7153 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7154 tep->Region_description = (tmp1 >> 27) & 0x3;
7155 tep->reserved1 = (tmp1 >> 26) & 0x1;
7156 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7157 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7158 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7159 tep->Args_stored = (tmp1 >> 15) & 0x1;
7160 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7161 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7162 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7163 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7164 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7165 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7166 tep->cxx_info = (tmp1 >> 8) & 0x1;
7167 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7168 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7169 tep->reserved2 = (tmp1 >> 5) & 0x1;
7170 tep->Save_SP = (tmp1 >> 4) & 0x1;
7171 tep->Save_RP = (tmp1 >> 3) & 0x1;
7172 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7173 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7174 tep->Cleanup_defined = tmp1 & 0x1;
7175
7176 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7177 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7178 tep->Large_frame = (tmp2 >> 29) & 0x1;
7179 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7180 tep->reserved4 = (tmp2 >> 27) & 0x1;
7181 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 7182 }
7183 free (table);
7184
7185 /* Third, apply any relocations to the unwind table. */
57346661
AM		 7186 for (relsec = section_headers;
7187 relsec < section_headers + elf_header.e_shnum;
7188 ++relsec)
7189 {
7190 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7191 || relsec->sh_info >= elf_header.e_shnum
7192 || section_headers + relsec->sh_info != sec)
57346661
AM		 7193 continue;
7194
7195 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7196 & rela, & nrelas))
7197 return 0;
7198
7199 for (rp = rela; rp < rela + nrelas; ++rp)
7200 {
aca88567
NC		 7201 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7202 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 7203
7204 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 7205 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 7206 {
7207 warn (_("Skipping unexpected relocation type %s\n"), relname);
7208 continue;
7209 }
7210
7211 i = rp->r_offset / unw_ent_size;
7212
89fac5e3 7213 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 7214 {
7215 case 0:
7216 aux->table[i].start.section = sym->st_shndx;
1e456d54 7217 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 7218 break;
7219 case 1:
7220 aux->table[i].end.section = sym->st_shndx;
1e456d54 7221 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 7222 break;
7223 default:
7224 break;
7225 }
7226 }
7227
7228 free (rela);
7229 }
7230
1c0751b2 7231 aux->table_len = nentries;
57346661
AM		 7232
7233 return 1;
7234}
7235
1b31d05e 7236static void
2cf0635d 7237hppa_process_unwind (FILE * file)
57346661 7238{
57346661 7239 struct hppa_unw_aux_info aux;
2cf0635d
NC		 7240 Elf_Internal_Shdr * unwsec = NULL;
7241 Elf_Internal_Shdr * strsec;
7242 Elf_Internal_Shdr * sec;
18bd398b 7243 unsigned long i;
57346661 7244
c256ffe7 7245 if (string_table == NULL)
1b31d05e
NC		 7246 return;
7247
7248 memset (& aux, 0, sizeof (aux));
57346661
AM		 7249
7250 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7251 {
c256ffe7 7252 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7253 && sec->sh_link < elf_header.e_shnum)
57346661 7254 {
ba5cdace 7255 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 7256
4fbb74a6 7257 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7258 if (aux.strtab != NULL)
7259 {
7260 error (_("Multiple auxillary string tables encountered\n"));
7261 free (aux.strtab);
7262 }
3f5e193b
NC		 7263 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7264 1, strsec->sh_size,
7265 _("string table"));
c256ffe7 7266 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 7267 }
18bd398b 7268 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 7269 unwsec = sec;
7270 }
7271
7272 if (!unwsec)
7273 printf (_("\nThere are no unwind sections in this file.\n"));
7274
7275 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7276 {
18bd398b 7277 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 7278 {
74e1a04b
NC		 7279 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7280 printable_section_name (sec),
57346661 7281 (unsigned long) sec->sh_offset,
89fac5e3 7282 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 7283
7284 slurp_hppa_unwind_table (file, &aux, sec);
7285 if (aux.table_len > 0)
7286 dump_hppa_unwind (&aux);
7287
7288 if (aux.table)
7289 free ((char *) aux.table);
7290 aux.table = NULL;
7291 }
7292 }
7293
7294 if (aux.symtab)
7295 free (aux.symtab);
7296 if (aux.strtab)
7297 free ((char *) aux.strtab);
57346661
AM		 7298}
7299
0b6ae522
DJ		 7300struct arm_section
7301{
a734115a
NC		 7302 unsigned char * data; /* The unwind data. */
7303 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7304 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7305 unsigned long nrelas; /* The number of relocations. */
7306 unsigned int rel_type; /* REL or RELA ? */
7307 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 7308};
7309
7310struct arm_unw_aux_info
7311{
a734115a
NC		 7312 FILE * file; /* The file containing the unwind sections. */
7313 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7314 unsigned long nsyms; /* Number of symbols. */
948f632f
DA		 7315 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7316 unsigned long nfuns; /* Number of these symbols. */
a734115a
NC		 7317 char * strtab; /* The file's string table. */
7318 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 7319};
7320
7321static const char *
7322arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7323 bfd_vma fn, struct absaddr addr)
7324{
7325 const char *procname;
7326 bfd_vma sym_offset;
7327
7328 if (addr.section == SHN_UNDEF)
7329 addr.offset = fn;
7330
948f632f 7331 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
0b6ae522
DJ		 7332 aux->strtab_size, addr, &procname,
7333 &sym_offset);
7334
7335 print_vma (fn, PREFIX_HEX);
7336
7337 if (procname)
7338 {
7339 fputs (" <", stdout);
7340 fputs (procname, stdout);
7341
7342 if (sym_offset)
7343 printf ("+0x%lx", (unsigned long) sym_offset);
7344 fputc ('>', stdout);
7345 }
7346
7347 return procname;
7348}
7349
7350static void
7351arm_free_section (struct arm_section *arm_sec)
7352{
7353 if (arm_sec->data != NULL)
7354 free (arm_sec->data);
7355
7356 if (arm_sec->rela != NULL)
7357 free (arm_sec->rela);
7358}
7359
a734115a
NC		 7360/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7361 cached section and install SEC instead.
7362 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7363 and return its valued in * WORDP, relocating if necessary.
1b31d05e 7364 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 7365 relocation's offset in ADDR.
1b31d05e
NC		 7366 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7367 into the string table of the symbol associated with the reloc. If no
7368 reloc was applied store -1 there.
7369 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 7370
7371static bfd_boolean
1b31d05e
NC		 7372get_unwind_section_word (struct arm_unw_aux_info * aux,
7373 struct arm_section * arm_sec,
7374 Elf_Internal_Shdr * sec,
7375 bfd_vma word_offset,
7376 unsigned int * wordp,
7377 struct absaddr * addr,
7378 bfd_vma * sym_name)
0b6ae522
DJ		 7379{
7380 Elf_Internal_Rela *rp;
7381 Elf_Internal_Sym *sym;
7382 const char * relname;
7383 unsigned int word;
7384 bfd_boolean wrapped;
7385
e0a31db1
NC		 7386 if (sec == NULL || arm_sec == NULL)
7387 return FALSE;
7388
0b6ae522
DJ		 7389 addr->section = SHN_UNDEF;
7390 addr->offset = 0;
7391
1b31d05e
NC		 7392 if (sym_name != NULL)
7393 *sym_name = (bfd_vma) -1;
7394
a734115a 7395 /* If necessary, update the section cache. */
0b6ae522
DJ		 7396 if (sec != arm_sec->sec)
7397 {
7398 Elf_Internal_Shdr *relsec;
7399
7400 arm_free_section (arm_sec);
7401
7402 arm_sec->sec = sec;
7403 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7404 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 7405 arm_sec->rela = NULL;
7406 arm_sec->nrelas = 0;
7407
7408 for (relsec = section_headers;
7409 relsec < section_headers + elf_header.e_shnum;
7410 ++relsec)
7411 {
7412 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 7413 || section_headers + relsec->sh_info != sec
7414 /* PR 15745: Check the section type as well. */
7415 || (relsec->sh_type != SHT_REL
7416 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 7417 continue;
7418
a734115a 7419 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 7420 if (relsec->sh_type == SHT_REL)
7421 {
7422 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7423 relsec->sh_size,
7424 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7425 return FALSE;
0b6ae522 7426 }
1ae40aa4 7427 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 7428 {
7429 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7430 relsec->sh_size,
7431 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7432 return FALSE;
0b6ae522 7433 }
1ae40aa4 7434 break;
0b6ae522
DJ		 7435 }
7436
7437 arm_sec->next_rela = arm_sec->rela;
7438 }
7439
a734115a 7440 /* If there is no unwind data we can do nothing. */
0b6ae522 7441 if (arm_sec->data == NULL)
a734115a 7442 return FALSE;
0b6ae522 7443
e0a31db1
NC		 7444 /* If the offset is invalid then fail. */
7445 if (word_offset > sec->sh_size - 4)
7446 return FALSE;
7447
a734115a 7448 /* Get the word at the required offset. */
0b6ae522
DJ		 7449 word = byte_get (arm_sec->data + word_offset, 4);
7450
0eff7165
NC		 7451 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7452 if (arm_sec->rela == NULL)
7453 {
7454 * wordp = word;
7455 return TRUE;
7456 }
7457
a734115a 7458 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 7459 wrapped = FALSE;
7460 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7461 {
7462 bfd_vma prelval, offset;
7463
7464 if (rp->r_offset > word_offset && !wrapped)
7465 {
7466 rp = arm_sec->rela;
7467 wrapped = TRUE;
7468 }
7469 if (rp->r_offset > word_offset)
7470 break;
7471
7472 if (rp->r_offset & 3)
7473 {
7474 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7475 (unsigned long) rp->r_offset);
7476 continue;
7477 }
7478
7479 if (rp->r_offset < word_offset)
7480 continue;
7481
74e1a04b
NC		 7482 /* PR 17531: file: 027-161405-0.004 */
7483 if (aux->symtab == NULL)
7484 continue;
7485
0b6ae522
DJ		 7486 if (arm_sec->rel_type == SHT_REL)
7487 {
7488 offset = word & 0x7fffffff;
7489 if (offset & 0x40000000)
7490 offset |= ~ (bfd_vma) 0x7fffffff;
7491 }
a734115a 7492 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 7493 offset = rp->r_addend;
a734115a 7494 else
74e1a04b
NC		 7495 {
7496 error (_("Unknown section relocation type %d encountered\n"),
7497 arm_sec->rel_type);
7498 break;
7499 }
0b6ae522 7500
071436c6
NC		 7501 /* PR 17531 file: 027-1241568-0.004. */
7502 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7503 {
7504 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7505 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7506 break;
7507 }
7508
7509 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
0b6ae522
DJ		 7510 offset += sym->st_value;
7511 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7512
a734115a
NC		 7513 /* Check that we are processing the expected reloc type. */
7514 if (elf_header.e_machine == EM_ARM)
7515 {
7516 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7517 if (relname == NULL)
7518 {
7519 warn (_("Skipping unknown ARM relocation type: %d\n"),
7520 (int) ELF32_R_TYPE (rp->r_info));
7521 continue;
7522 }
a734115a
NC		 7523
7524 if (streq (relname, "R_ARM_NONE"))
7525 continue;
0b4362b0 7526
a734115a
NC		 7527 if (! streq (relname, "R_ARM_PREL31"))
7528 {
071436c6 7529 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
a734115a
NC		 7530 continue;
7531 }
7532 }
7533 else if (elf_header.e_machine == EM_TI_C6000)
7534 {
7535 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7536 if (relname == NULL)
7537 {
7538 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7539 (int) ELF32_R_TYPE (rp->r_info));
7540 continue;
7541 }
0b4362b0 7542
a734115a
NC		 7543 if (streq (relname, "R_C6000_NONE"))
7544 continue;
7545
7546 if (! streq (relname, "R_C6000_PREL31"))
7547 {
071436c6 7548 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
a734115a
NC		 7549 continue;
7550 }
7551
7552 prelval >>= 1;
7553 }
7554 else
74e1a04b
NC		 7555 {
7556 /* This function currently only supports ARM and TI unwinders. */
7557 warn (_("Only TI and ARM unwinders are currently supported\n"));
7558 break;
7559 }
fa197c1c 7560
0b6ae522
DJ		 7561 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7562 addr->section = sym->st_shndx;
7563 addr->offset = offset;
74e1a04b 7564
1b31d05e
NC		 7565 if (sym_name)
7566 * sym_name = sym->st_name;
0b6ae522
DJ		 7567 break;
7568 }
7569
7570 *wordp = word;
7571 arm_sec->next_rela = rp;
7572
a734115a 7573 return TRUE;
0b6ae522
DJ		 7574}
7575
a734115a
NC		 7576static const char *tic6x_unwind_regnames[16] =
7577{
0b4362b0
RM		 7578 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7579 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 7580 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7581};
fa197c1c 7582
0b6ae522 7583static void
fa197c1c 7584decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 7585{
fa197c1c
PB		 7586 int i;
7587
7588 for (i = 12; mask; mask >>= 1, i--)
7589 {
7590 if (mask & 1)
7591 {
7592 fputs (tic6x_unwind_regnames[i], stdout);
7593 if (mask > 1)
7594 fputs (", ", stdout);
7595 }
7596 }
7597}
0b6ae522
DJ		 7598
7599#define ADVANCE \
7600 if (remaining == 0 && more_words) \
7601 { \
7602 data_offset += 4; \
1b31d05e
NC		 7603 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7604 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 7605 return; \
7606 remaining = 4; \
7607 more_words--; \
7608 } \
7609
7610#define GET_OP(OP) \
7611 ADVANCE; \
7612 if (remaining) \
7613 { \
7614 remaining--; \
7615 (OP) = word >> 24; \
7616 word <<= 8; \
7617 } \
7618 else \
7619 { \
2b692964 7620 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 7621 return; \
7622 } \
cc5914eb 7623 printf ("0x%02x ", OP)
0b6ae522 7624
fa197c1c 7625static void
948f632f
DA		 7626decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
7627 unsigned int word,
7628 unsigned int remaining,
7629 unsigned int more_words,
7630 bfd_vma data_offset,
7631 Elf_Internal_Shdr * data_sec,
7632 struct arm_section * data_arm_sec)
fa197c1c
PB		 7633{
7634 struct absaddr addr;
0b6ae522
DJ		 7635
7636 /* Decode the unwinding instructions. */
7637 while (1)
7638 {
7639 unsigned int op, op2;
7640
7641 ADVANCE;
7642 if (remaining == 0)
7643 break;
7644 remaining--;
7645 op = word >> 24;
7646 word <<= 8;
7647
cc5914eb 7648 printf (" 0x%02x ", op);
0b6ae522
DJ		 7649
7650 if ((op & 0xc0) == 0x00)
7651 {
7652 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7653
cc5914eb 7654 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 7655 }
7656 else if ((op & 0xc0) == 0x40)
7657 {
7658 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7659
cc5914eb 7660 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 7661 }
7662 else if ((op & 0xf0) == 0x80)
7663 {
7664 GET_OP (op2);
7665 if (op == 0x80 && op2 == 0)
7666 printf (_("Refuse to unwind"));
7667 else
7668 {
7669 unsigned int mask = ((op & 0x0f) << 8) | op2;
7670 int first = 1;
7671 int i;
2b692964 7672
0b6ae522
DJ		 7673 printf ("pop {");
7674 for (i = 0; i < 12; i++)
7675 if (mask & (1 << i))
7676 {
7677 if (first)
7678 first = 0;
7679 else
7680 printf (", ");
7681 printf ("r%d", 4 + i);
7682 }
7683 printf ("}");
7684 }
7685 }
7686 else if ((op & 0xf0) == 0x90)
7687 {
7688 if (op == 0x9d || op == 0x9f)
7689 printf (_(" [Reserved]"));
7690 else
cc5914eb 7691 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 7692 }
7693 else if ((op & 0xf0) == 0xa0)
7694 {
7695 int end = 4 + (op & 0x07);
7696 int first = 1;
7697 int i;
61865e30 7698
0b6ae522
DJ		 7699 printf (" pop {");
7700 for (i = 4; i <= end; i++)
7701 {
7702 if (first)
7703 first = 0;
7704 else
7705 printf (", ");
7706 printf ("r%d", i);
7707 }
7708 if (op & 0x08)
7709 {
1b31d05e 7710 if (!first)
0b6ae522
DJ		 7711 printf (", ");
7712 printf ("r14");
7713 }
7714 printf ("}");
7715 }
7716 else if (op == 0xb0)
7717 printf (_(" finish"));
7718 else if (op == 0xb1)
7719 {
7720 GET_OP (op2);
7721 if (op2 == 0 || (op2 & 0xf0) != 0)
7722 printf (_("[Spare]"));
7723 else
7724 {
7725 unsigned int mask = op2 & 0x0f;
7726 int first = 1;
7727 int i;
61865e30 7728
0b6ae522
DJ		 7729 printf ("pop {");
7730 for (i = 0; i < 12; i++)
7731 if (mask & (1 << i))
7732 {
7733 if (first)
7734 first = 0;
7735 else
7736 printf (", ");
7737 printf ("r%d", i);
7738 }
7739 printf ("}");
7740 }
7741 }
7742 else if (op == 0xb2)
7743 {
b115cf96 7744 unsigned char buf[9];
0b6ae522
DJ		 7745 unsigned int i, len;
7746 unsigned long offset;
61865e30 7747
b115cf96 7748 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 7749 {
7750 GET_OP (buf[i]);
7751 if ((buf[i] & 0x80) == 0)
7752 break;
7753 }
4082ef84
NC		 7754 if (i == sizeof (buf))
7755 printf (_("corrupt change to vsp"));
7756 else
7757 {
7758 offset = read_uleb128 (buf, &len, buf + i + 1);
7759 assert (len == i + 1);
7760 offset = offset * 4 + 0x204;
7761 printf ("vsp = vsp + %ld", offset);
7762 }
0b6ae522 7763 }
61865e30 7764 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 7765 {
61865e30
NC		 7766 unsigned int first, last;
7767
7768 GET_OP (op2);
7769 first = op2 >> 4;
7770 last = op2 & 0x0f;
7771 if (op == 0xc8)
7772 first = first + 16;
7773 printf ("pop {D%d", first);
7774 if (last)
7775 printf ("-D%d", first + last);
7776 printf ("}");
7777 }
7778 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7779 {
7780 unsigned int count = op & 0x07;
7781
7782 printf ("pop {D8");
7783 if (count)
7784 printf ("-D%d", 8 + count);
7785 printf ("}");
7786 }
7787 else if (op >= 0xc0 && op <= 0xc5)
7788 {
7789 unsigned int count = op & 0x07;
7790
7791 printf (" pop {wR10");
7792 if (count)
7793 printf ("-wR%d", 10 + count);
7794 printf ("}");
7795 }
7796 else if (op == 0xc6)
7797 {
7798 unsigned int first, last;
7799
7800 GET_OP (op2);
7801 first = op2 >> 4;
7802 last = op2 & 0x0f;
7803 printf ("pop {wR%d", first);
7804 if (last)
7805 printf ("-wR%d", first + last);
7806 printf ("}");
7807 }
7808 else if (op == 0xc7)
7809 {
7810 GET_OP (op2);
7811 if (op2 == 0 || (op2 & 0xf0) != 0)
7812 printf (_("[Spare]"));
0b6ae522
DJ		 7813 else
7814 {
61865e30
NC		 7815 unsigned int mask = op2 & 0x0f;
7816 int first = 1;
7817 int i;
7818
7819 printf ("pop {");
7820 for (i = 0; i < 4; i++)
7821 if (mask & (1 << i))
7822 {
7823 if (first)
7824 first = 0;
7825 else
7826 printf (", ");
7827 printf ("wCGR%d", i);
7828 }
7829 printf ("}");
0b6ae522
DJ		 7830 }
7831 }
61865e30
NC		 7832 else
7833 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 7834 printf ("\n");
7835 }
fa197c1c
PB		 7836}
7837
7838static void
948f632f
DA		 7839decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
7840 unsigned int word,
7841 unsigned int remaining,
7842 unsigned int more_words,
7843 bfd_vma data_offset,
7844 Elf_Internal_Shdr * data_sec,
7845 struct arm_section * data_arm_sec)
fa197c1c
PB		 7846{
7847 struct absaddr addr;
7848
7849 /* Decode the unwinding instructions. */
7850 while (1)
7851 {
7852 unsigned int op, op2;
7853
7854 ADVANCE;
7855 if (remaining == 0)
7856 break;
7857 remaining--;
7858 op = word >> 24;
7859 word <<= 8;
7860
9cf03b7e 7861 printf (" 0x%02x ", op);
fa197c1c
PB		 7862
7863 if ((op & 0xc0) == 0x00)
7864 {
7865 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 7866 printf (" sp = sp + %d", offset);
fa197c1c
PB		 7867 }
7868 else if ((op & 0xc0) == 0x80)
7869 {
7870 GET_OP (op2);
7871 if (op == 0x80 && op2 == 0)
7872 printf (_("Refuse to unwind"));
7873 else
7874 {
7875 unsigned int mask = ((op & 0x1f) << 8) | op2;
7876 if (op & 0x20)
7877 printf ("pop compact {");
7878 else
7879 printf ("pop {");
7880
7881 decode_tic6x_unwind_regmask (mask);
7882 printf("}");
7883 }
7884 }
7885 else if ((op & 0xf0) == 0xc0)
7886 {
7887 unsigned int reg;
7888 unsigned int nregs;
7889 unsigned int i;
7890 const char *name;
a734115a
NC		 7891 struct
7892 {
fa197c1c
PB		 7893 unsigned int offset;
7894 unsigned int reg;
7895 } regpos[16];
7896
7897 /* Scan entire instruction first so that GET_OP output is not
7898 interleaved with disassembly. */
7899 nregs = 0;
7900 for (i = 0; nregs < (op & 0xf); i++)
7901 {
7902 GET_OP (op2);
7903 reg = op2 >> 4;
7904 if (reg != 0xf)
7905 {
7906 regpos[nregs].offset = i * 2;
7907 regpos[nregs].reg = reg;
7908 nregs++;
7909 }
7910
7911 reg = op2 & 0xf;
7912 if (reg != 0xf)
7913 {
7914 regpos[nregs].offset = i * 2 + 1;
7915 regpos[nregs].reg = reg;
7916 nregs++;
7917 }
7918 }
7919
7920 printf (_("pop frame {"));
7921 reg = nregs - 1;
7922 for (i = i * 2; i > 0; i--)
7923 {
7924 if (regpos[reg].offset == i - 1)
7925 {
7926 name = tic6x_unwind_regnames[regpos[reg].reg];
7927 if (reg > 0)
7928 reg--;
7929 }
7930 else
7931 name = _("[pad]");
7932
7933 fputs (name, stdout);
7934 if (i > 1)
7935 printf (", ");
7936 }
7937
7938 printf ("}");
7939 }
7940 else if (op == 0xd0)
7941 printf (" MOV FP, SP");
7942 else if (op == 0xd1)
7943 printf (" __c6xabi_pop_rts");
7944 else if (op == 0xd2)
7945 {
7946 unsigned char buf[9];
7947 unsigned int i, len;
7948 unsigned long offset;
a734115a 7949
fa197c1c
PB		 7950 for (i = 0; i < sizeof (buf); i++)
7951 {
7952 GET_OP (buf[i]);
7953 if ((buf[i] & 0x80) == 0)
7954 break;
7955 }
0eff7165
NC		 7956 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
7957 if (i == sizeof (buf))
7958 {
7959 printf ("<corrupt sp adjust>\n");
7960 warn (_("Corrupt stack pointer adjustment detected\n"));
7961 return;
7962 }
948f632f 7963
f6f0e17b 7964 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 7965 assert (len == i + 1);
7966 offset = offset * 8 + 0x408;
7967 printf (_("sp = sp + %ld"), offset);
7968 }
7969 else if ((op & 0xf0) == 0xe0)
7970 {
7971 if ((op & 0x0f) == 7)
7972 printf (" RETURN");
7973 else
7974 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7975 }
7976 else
7977 {
7978 printf (_(" [unsupported opcode]"));
7979 }
7980 putchar ('\n');
7981 }
7982}
7983
7984static bfd_vma
a734115a 7985arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 7986{
7987 bfd_vma offset;
7988
7989 offset = word & 0x7fffffff;
7990 if (offset & 0x40000000)
7991 offset |= ~ (bfd_vma) 0x7fffffff;
7992
7993 if (elf_header.e_machine == EM_TI_C6000)
7994 offset <<= 1;
7995
7996 return offset + where;
7997}
7998
7999static void
1b31d05e
NC		 8000decode_arm_unwind (struct arm_unw_aux_info * aux,
8001 unsigned int word,
8002 unsigned int remaining,
8003 bfd_vma data_offset,
8004 Elf_Internal_Shdr * data_sec,
8005 struct arm_section * data_arm_sec)
fa197c1c
PB		 8006{
8007 int per_index;
8008 unsigned int more_words = 0;
37e14bc3 8009 struct absaddr addr;
1b31d05e 8010 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 8011
8012 if (remaining == 0)
8013 {
1b31d05e
NC		 8014 /* Fetch the first word.
8015 Note - when decoding an object file the address extracted
8016 here will always be 0. So we also pass in the sym_name
8017 parameter so that we can find the symbol associated with
8018 the personality routine. */
8019 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8020 & word, & addr, & sym_name))
fa197c1c 8021 return;
1b31d05e 8022
fa197c1c
PB		 8023 remaining = 4;
8024 }
8025
8026 if ((word & 0x80000000) == 0)
8027 {
8028 /* Expand prel31 for personality routine. */
8029 bfd_vma fn;
8030 const char *procname;
8031
a734115a 8032 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 8033 printf (_(" Personality routine: "));
1b31d05e
NC		 8034 if (fn == 0
8035 && addr.section == SHN_UNDEF && addr.offset == 0
8036 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8037 {
8038 procname = aux->strtab + sym_name;
8039 print_vma (fn, PREFIX_HEX);
8040 if (procname)
8041 {
8042 fputs (" <", stdout);
8043 fputs (procname, stdout);
8044 fputc ('>', stdout);
8045 }
8046 }
8047 else
8048 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 8049 fputc ('\n', stdout);
8050
8051 /* The GCC personality routines use the standard compact
8052 encoding, starting with one byte giving the number of
8053 words. */
8054 if (procname != NULL
8055 && (const_strneq (procname, "__gcc_personality_v0")
8056 || const_strneq (procname, "__gxx_personality_v0")
8057 || const_strneq (procname, "__gcj_personality_v0")
8058 || const_strneq (procname, "__gnu_objc_personality_v0")))
8059 {
8060 remaining = 0;
8061 more_words = 1;
8062 ADVANCE;
8063 if (!remaining)
8064 {
8065 printf (_(" [Truncated data]\n"));
8066 return;
8067 }
8068 more_words = word >> 24;
8069 word <<= 8;
8070 remaining--;
8071 per_index = -1;
8072 }
8073 else
8074 return;
8075 }
8076 else
8077 {
1b31d05e 8078 /* ARM EHABI Section 6.3:
0b4362b0 8079
1b31d05e 8080 An exception-handling table entry for the compact model looks like:
0b4362b0 8081
1b31d05e
NC		 8082 31 30-28 27-24 23-0
8083 -- ----- ----- ----
8084 1 0 index Data for personalityRoutine[index] */
8085
8086 if (elf_header.e_machine == EM_ARM
8087 && (word & 0x70000000))
83c257ca 8088 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 8089
fa197c1c 8090 per_index = (word >> 24) & 0x7f;
1b31d05e 8091 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 8092 if (per_index == 0)
8093 {
8094 more_words = 0;
8095 word <<= 8;
8096 remaining--;
8097 }
8098 else if (per_index < 3)
8099 {
8100 more_words = (word >> 16) & 0xff;
8101 word <<= 16;
8102 remaining -= 2;
8103 }
8104 }
8105
8106 switch (elf_header.e_machine)
8107 {
8108 case EM_ARM:
8109 if (per_index < 3)
8110 {
8111 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8112 data_offset, data_sec, data_arm_sec);
8113 }
8114 else
1b31d05e
NC		 8115 {
8116 warn (_("Unknown ARM compact model index encountered\n"));
8117 printf (_(" [reserved]\n"));
8118 }
fa197c1c
PB		 8119 break;
8120
8121 case EM_TI_C6000:
8122 if (per_index < 3)
8123 {
8124 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 8125 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 8126 }
8127 else if (per_index < 5)
8128 {
8129 if (((word >> 17) & 0x7f) == 0x7f)
8130 printf (_(" Restore stack from frame pointer\n"));
8131 else
8132 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8133 printf (_(" Registers restored: "));
8134 if (per_index == 4)
8135 printf (" (compact) ");
8136 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8137 putchar ('\n');
8138 printf (_(" Return register: %s\n"),
8139 tic6x_unwind_regnames[word & 0xf]);
8140 }
8141 else
1b31d05e 8142 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 8143 break;
8144
8145 default:
74e1a04b 8146 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
1b31d05e 8147 elf_header.e_machine);
fa197c1c 8148 }
0b6ae522
DJ		 8149
8150 /* Decode the descriptors. Not implemented. */
8151}
8152
8153static void
8154dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8155{
8156 struct arm_section exidx_arm_sec, extab_arm_sec;
8157 unsigned int i, exidx_len;
948f632f 8158 unsigned long j, nfuns;
0b6ae522
DJ		 8159
8160 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8161 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8162 exidx_len = exidx_sec->sh_size / 8;
8163
948f632f
DA		 8164 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8165 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8166 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8167 aux->funtab[nfuns++] = aux->symtab[j];
8168 aux->nfuns = nfuns;
8169 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8170
0b6ae522
DJ		 8171 for (i = 0; i < exidx_len; i++)
8172 {
8173 unsigned int exidx_fn, exidx_entry;
8174 struct absaddr fn_addr, entry_addr;
8175 bfd_vma fn;
8176
8177 fputc ('\n', stdout);
8178
1b31d05e
NC		 8179 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8180 8 * i, & exidx_fn, & fn_addr, NULL)
8181 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8182 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 8183 {
948f632f 8184 free (aux->funtab);
1b31d05e
NC		 8185 arm_free_section (& exidx_arm_sec);
8186 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 8187 return;
8188 }
8189
83c257ca
NC		 8190 /* ARM EHABI, Section 5:
8191 An index table entry consists of 2 words.
8192 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8193 if (exidx_fn & 0x80000000)
8194 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8195
a734115a 8196 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 8197
a734115a 8198 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 8199 fputs (": ", stdout);
8200
8201 if (exidx_entry == 1)
8202 {
8203 print_vma (exidx_entry, PREFIX_HEX);
8204 fputs (" [cantunwind]\n", stdout);
8205 }
8206 else if (exidx_entry & 0x80000000)
8207 {
8208 print_vma (exidx_entry, PREFIX_HEX);
8209 fputc ('\n', stdout);
8210 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8211 }
8212 else
8213 {
8f73510c 8214 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 8215 Elf_Internal_Shdr *table_sec;
8216
8217 fputs ("@", stdout);
a734115a 8218 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 8219 print_vma (table, PREFIX_HEX);
8220 printf ("\n");
8221
8222 /* Locate the matching .ARM.extab. */
8223 if (entry_addr.section != SHN_UNDEF
8224 && entry_addr.section < elf_header.e_shnum)
8225 {
8226 table_sec = section_headers + entry_addr.section;
8227 table_offset = entry_addr.offset;
8228 }
8229 else
8230 {
8231 table_sec = find_section_by_address (table);
8232 if (table_sec != NULL)
8233 table_offset = table - table_sec->sh_addr;
8234 }
8235 if (table_sec == NULL)
8236 {
8237 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8238 (unsigned long) table);
8239 continue;
8240 }
8241 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8242 &extab_arm_sec);
8243 }
8244 }
8245
8246 printf ("\n");
8247
948f632f 8248 free (aux->funtab);
0b6ae522
DJ		 8249 arm_free_section (&exidx_arm_sec);
8250 arm_free_section (&extab_arm_sec);
8251}
8252
fa197c1c 8253/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 8254
8255static void
0b6ae522
DJ		 8256arm_process_unwind (FILE *file)
8257{
8258 struct arm_unw_aux_info aux;
8259 Elf_Internal_Shdr *unwsec = NULL;
8260 Elf_Internal_Shdr *strsec;
8261 Elf_Internal_Shdr *sec;
8262 unsigned long i;
fa197c1c 8263 unsigned int sec_type;
0b6ae522 8264
fa197c1c
PB		 8265 switch (elf_header.e_machine)
8266 {
8267 case EM_ARM:
8268 sec_type = SHT_ARM_EXIDX;
8269 break;
8270
8271 case EM_TI_C6000:
8272 sec_type = SHT_C6000_UNWIND;
8273 break;
8274
0b4362b0 8275 default:
74e1a04b 8276 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
1b31d05e
NC		 8277 elf_header.e_machine);
8278 return;
fa197c1c
PB		 8279 }
8280
0b6ae522 8281 if (string_table == NULL)
1b31d05e
NC		 8282 return;
8283
8284 memset (& aux, 0, sizeof (aux));
8285 aux.file = file;
0b6ae522
DJ		 8286
8287 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8288 {
8289 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8290 {
ba5cdace 8291 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 8292
8293 strsec = section_headers + sec->sh_link;
74e1a04b
NC		 8294
8295 /* PR binutils/17531 file: 011-12666-0.004. */
8296 if (aux.strtab != NULL)
8297 {
4082ef84 8298 error (_("Multiple string tables found in file.\n"));
74e1a04b
NC		 8299 free (aux.strtab);
8300 }
0b6ae522
DJ		 8301 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8302 1, strsec->sh_size, _("string table"));
8303 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8304 }
fa197c1c 8305 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 8306 unwsec = sec;
8307 }
8308
1b31d05e 8309 if (unwsec == NULL)
0b6ae522 8310 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 8311 else
8312 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8313 {
8314 if (sec->sh_type == sec_type)
8315 {
8316 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
74e1a04b 8317 printable_section_name (sec),
1b31d05e
NC		 8318 (unsigned long) sec->sh_offset,
8319 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 8320
1b31d05e
NC		 8321 dump_arm_unwind (&aux, sec);
8322 }
8323 }
0b6ae522
DJ		 8324
8325 if (aux.symtab)
8326 free (aux.symtab);
8327 if (aux.strtab)
8328 free ((char *) aux.strtab);
0b6ae522
DJ		 8329}
8330
1b31d05e 8331static void
2cf0635d 8332process_unwind (FILE * file)
57346661 8333{
2cf0635d
NC		 8334 struct unwind_handler
8335 {
57346661 8336 int machtype;
1b31d05e 8337 void (* handler)(FILE *);
2cf0635d
NC		 8338 } handlers[] =
8339 {
0b6ae522 8340 { EM_ARM, arm_process_unwind },
57346661
AM		 8341 { EM_IA_64, ia64_process_unwind },
8342 { EM_PARISC, hppa_process_unwind },
fa197c1c 8343 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 8344 { 0, 0 }
8345 };
8346 int i;
8347
8348 if (!do_unwind)
1b31d05e 8349 return;
57346661
AM		 8350
8351 for (i = 0; handlers[i].handler != NULL; i++)
8352 if (elf_header.e_machine == handlers[i].machtype)
9f758fdc
NC		 8353 {
8354 handlers[i].handler (file);
8355 return;
8356 }
57346661 8357
1b31d05e
NC		 8358 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8359 get_machine_name (elf_header.e_machine));
57346661
AM		 8360}
8361
252b5132 8362static void
2cf0635d 8363dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 8364{
8365 switch (entry->d_tag)
8366 {
8367 case DT_MIPS_FLAGS:
8368 if (entry->d_un.d_val == 0)
4b68bca3 8369 printf (_("NONE"));
252b5132
RH		 8370 else
8371 {
8372 static const char * opts[] =
8373 {
8374 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8375 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8376 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8377 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8378 "RLD_ORDER_SAFE"
8379 };
8380 unsigned int cnt;
8381 int first = 1;
2b692964 8382
60bca95a 8383 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 8384 if (entry->d_un.d_val & (1 << cnt))
8385 {
8386 printf ("%s%s", first ? "" : " ", opts[cnt]);
8387 first = 0;
8388 }
252b5132
RH		 8389 }
8390 break;
103f02d3 8391
252b5132 8392 case DT_MIPS_IVERSION:
d79b3d50 8393 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 8394 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8395 else
76ca31c0
NC		 8396 {
8397 char buf[40];
8398 sprintf_vma (buf, entry->d_un.d_ptr);
8399 /* Note: coded this way so that there is a single string for translation. */
8400 printf (_("<corrupt: %s>"), buf);
8401 }
252b5132 8402 break;
103f02d3 8403
252b5132
RH		 8404 case DT_MIPS_TIME_STAMP:
8405 {
8406 char timebuf[20];
2cf0635d 8407 struct tm * tmp;
91d6fa6a 8408 time_t atime = entry->d_un.d_val;
82b1b41b 8409
91d6fa6a 8410 tmp = gmtime (&atime);
82b1b41b
NC		 8411 /* PR 17531: file: 6accc532. */
8412 if (tmp == NULL)
8413 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8414 else
8415 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8416 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8417 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 8418 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 8419 }
8420 break;
103f02d3 8421
252b5132
RH		 8422 case DT_MIPS_RLD_VERSION:
8423 case DT_MIPS_LOCAL_GOTNO:
8424 case DT_MIPS_CONFLICTNO:
8425 case DT_MIPS_LIBLISTNO:
8426 case DT_MIPS_SYMTABNO:
8427 case DT_MIPS_UNREFEXTNO:
8428 case DT_MIPS_HIPAGENO:
8429 case DT_MIPS_DELTA_CLASS_NO:
8430 case DT_MIPS_DELTA_INSTANCE_NO:
8431 case DT_MIPS_DELTA_RELOC_NO:
8432 case DT_MIPS_DELTA_SYM_NO:
8433 case DT_MIPS_DELTA_CLASSSYM_NO:
8434 case DT_MIPS_COMPACT_SIZE:
4b68bca3 8435 print_vma (entry->d_un.d_ptr, DEC);
252b5132 8436 break;
103f02d3
UD		 8437
8438 default:
4b68bca3 8439 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 8440 }
4b68bca3 8441 putchar ('\n');
103f02d3
UD		 8442}
8443
103f02d3 8444static void
2cf0635d 8445dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 8446{
8447 switch (entry->d_tag)
8448 {
8449 case DT_HP_DLD_FLAGS:
8450 {
8451 static struct
8452 {
8453 long int bit;
2cf0635d 8454 const char * str;
5e220199
NC		 8455 }
8456 flags[] =
8457 {
8458 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8459 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8460 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8461 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8462 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8463 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8464 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8465 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8466 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8467 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 8468 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8469 { DT_HP_GST, "HP_GST" },
8470 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8471 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8472 { DT_HP_NODELETE, "HP_NODELETE" },
8473 { DT_HP_GROUP, "HP_GROUP" },
8474 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 8475 };
103f02d3 8476 int first = 1;
5e220199 8477 size_t cnt;
f7a99963 8478 bfd_vma val = entry->d_un.d_val;
103f02d3 8479
60bca95a 8480 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 8481 if (val & flags[cnt].bit)
30800947
NC		 8482 {
8483 if (! first)
8484 putchar (' ');
8485 fputs (flags[cnt].str, stdout);
8486 first = 0;
8487 val ^= flags[cnt].bit;
8488 }
76da6bbe 8489
103f02d3 8490 if (val != 0 || first)
f7a99963
NC		 8491 {
8492 if (! first)
8493 putchar (' ');
8494 print_vma (val, HEX);
8495 }
103f02d3
UD		 8496 }
8497 break;
76da6bbe 8498
252b5132 8499 default:
f7a99963
NC		 8500 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8501 break;
252b5132 8502 }
35b1837e 8503 putchar ('\n');
252b5132
RH		 8504}
8505
28f997cf
TG		 8506#ifdef BFD64
8507
8508/* VMS vs Unix time offset and factor. */
8509
8510#define VMS_EPOCH_OFFSET 35067168000000000LL
8511#define VMS_GRANULARITY_FACTOR 10000000
8512
8513/* Display a VMS time in a human readable format. */
8514
8515static void
8516print_vms_time (bfd_int64_t vmstime)
8517{
8518 struct tm *tm;
8519 time_t unxtime;
8520
8521 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8522 tm = gmtime (&unxtime);
8523 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8524 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8525 tm->tm_hour, tm->tm_min, tm->tm_sec);
8526}
8527#endif /* BFD64 */
8528
ecc51f48 8529static void
2cf0635d 8530dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 8531{
8532 switch (entry->d_tag)
8533 {
0de14b54 8534 case DT_IA_64_PLT_RESERVE:
bdf4d63a 8535 /* First 3 slots reserved. */
ecc51f48
NC		 8536 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8537 printf (" -- ");
8538 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 8539 break;
8540
28f997cf
TG		 8541 case DT_IA_64_VMS_LINKTIME:
8542#ifdef BFD64
8543 print_vms_time (entry->d_un.d_val);
8544#endif
8545 break;
8546
8547 case DT_IA_64_VMS_LNKFLAGS:
8548 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8549 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8550 printf (" CALL_DEBUG");
8551 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8552 printf (" NOP0BUFS");
8553 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8554 printf (" P0IMAGE");
8555 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8556 printf (" MKTHREADS");
8557 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8558 printf (" UPCALLS");
8559 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8560 printf (" IMGSTA");
8561 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8562 printf (" INITIALIZE");
8563 if (entry->d_un.d_val & VMS_LF_MAIN)
8564 printf (" MAIN");
8565 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8566 printf (" EXE_INIT");
8567 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8568 printf (" TBK_IN_IMG");
8569 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8570 printf (" DBG_IN_IMG");
8571 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8572 printf (" TBK_IN_DSF");
8573 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8574 printf (" DBG_IN_DSF");
8575 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8576 printf (" SIGNATURES");
8577 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8578 printf (" REL_SEG_OFF");
8579 break;
8580
bdf4d63a
JJ		 8581 default:
8582 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8583 break;
ecc51f48 8584 }
bdf4d63a 8585 putchar ('\n');
ecc51f48
NC		 8586}
8587
252b5132 8588static int
2cf0635d 8589get_32bit_dynamic_section (FILE * file)
252b5132 8590{
2cf0635d
NC		 8591 Elf32_External_Dyn * edyn;
8592 Elf32_External_Dyn * ext;
8593 Elf_Internal_Dyn * entry;
103f02d3 8594
3f5e193b
NC		 8595 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8596 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8597 if (!edyn)
8598 return 0;
103f02d3 8599
071436c6
NC		 8600 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8601 might not have the luxury of section headers. Look for the DT_NULL
8602 terminator to determine the number of entries. */
ba2685cc 8603 for (ext = edyn, dynamic_nent = 0;
071436c6 8604 (char *) ext < (char *) edyn + dynamic_size - sizeof (* entry);
ba2685cc
AM		 8605 ext++)
8606 {
8607 dynamic_nent++;
8608 if (BYTE_GET (ext->d_tag) == DT_NULL)
8609 break;
8610 }
252b5132 8611
3f5e193b
NC		 8612 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8613 sizeof (* entry));
b2d38a17 8614 if (dynamic_section == NULL)
252b5132 8615 {
8b73c356
NC		 8616 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8617 (unsigned long) dynamic_nent);
9ea033b2
NC		 8618 free (edyn);
8619 return 0;
8620 }
252b5132 8621
fb514b26 8622 for (ext = edyn, entry = dynamic_section;
ba2685cc 8623 entry < dynamic_section + dynamic_nent;
fb514b26 8624 ext++, entry++)
9ea033b2 8625 {
fb514b26
AM		 8626 entry->d_tag = BYTE_GET (ext->d_tag);
8627 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8628 }
8629
9ea033b2
NC		 8630 free (edyn);
8631
8632 return 1;
8633}
8634
8635static int
2cf0635d 8636get_64bit_dynamic_section (FILE * file)
9ea033b2 8637{
2cf0635d
NC		 8638 Elf64_External_Dyn * edyn;
8639 Elf64_External_Dyn * ext;
8640 Elf_Internal_Dyn * entry;
103f02d3 8641
071436c6 8642 /* Read in the data. */
3f5e193b
NC		 8643 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8644 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8645 if (!edyn)
8646 return 0;
103f02d3 8647
071436c6
NC		 8648 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8649 might not have the luxury of section headers. Look for the DT_NULL
8650 terminator to determine the number of entries. */
ba2685cc 8651 for (ext = edyn, dynamic_nent = 0;
071436c6
NC		 8652 /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer. */
8653 (char *) ext < ((char *) edyn) + dynamic_size - sizeof (* ext);
ba2685cc
AM		 8654 ext++)
8655 {
8656 dynamic_nent++;
66543521 8657 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 8658 break;
8659 }
252b5132 8660
3f5e193b
NC		 8661 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8662 sizeof (* entry));
b2d38a17 8663 if (dynamic_section == NULL)
252b5132 8664 {
8b73c356
NC		 8665 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8666 (unsigned long) dynamic_nent);
252b5132
RH		 8667 free (edyn);
8668 return 0;
8669 }
8670
071436c6 8671 /* Convert from external to internal formats. */
fb514b26 8672 for (ext = edyn, entry = dynamic_section;
ba2685cc 8673 entry < dynamic_section + dynamic_nent;
fb514b26 8674 ext++, entry++)
252b5132 8675 {
66543521
AM		 8676 entry->d_tag = BYTE_GET (ext->d_tag);
8677 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8678 }
8679
8680 free (edyn);
8681
9ea033b2
NC		 8682 return 1;
8683}
8684
e9e44622
JJ		 8685static void
8686print_dynamic_flags (bfd_vma flags)
d1133906 8687{
e9e44622 8688 int first = 1;
13ae64f3 8689
d1133906
NC		 8690 while (flags)
8691 {
8692 bfd_vma flag;
8693
8694 flag = flags & - flags;
8695 flags &= ~ flag;
8696
e9e44622
JJ		 8697 if (first)
8698 first = 0;
8699 else
8700 putc (' ', stdout);
13ae64f3 8701
d1133906
NC		 8702 switch (flag)
8703 {
e9e44622
JJ		 8704 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
8705 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
8706 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
8707 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
8708 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 8709 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 8710 }
8711 }
e9e44622 8712 puts ("");
d1133906
NC		 8713}
8714
b2d38a17
NC		 8715/* Parse and display the contents of the dynamic section. */
8716
9ea033b2 8717static int
2cf0635d 8718process_dynamic_section (FILE * file)
9ea033b2 8719{
2cf0635d 8720 Elf_Internal_Dyn * entry;
9ea033b2
NC		 8721
8722 if (dynamic_size == 0)
8723 {
8724 if (do_dynamic)
b2d38a17 8725 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 8726
8727 return 1;
8728 }
8729
8730 if (is_32bit_elf)
8731 {
b2d38a17 8732 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 8733 return 0;
8734 }
b2d38a17 8735 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 8736 return 0;
8737
252b5132
RH		 8738 /* Find the appropriate symbol table. */
8739 if (dynamic_symbols == NULL)
8740 {
86dba8ee
AM		 8741 for (entry = dynamic_section;
8742 entry < dynamic_section + dynamic_nent;
8743 ++entry)
252b5132 8744 {
c8286bd1 8745 Elf_Internal_Shdr section;
252b5132
RH		 8746
8747 if (entry->d_tag != DT_SYMTAB)
8748 continue;
8749
8750 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8751
8752 /* Since we do not know how big the symbol table is,
8753 we default to reading in the entire file (!) and
8754 processing that. This is overkill, I know, but it
e3c8793a 8755 should work. */
d93f0186 8756 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 8757
fb52b2f4
NC		 8758 if (archive_file_offset != 0)
8759 section.sh_size = archive_file_size - section.sh_offset;
8760 else
8761 {
8762 if (fseek (file, 0, SEEK_END))
591a748a 8763 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 8764
8765 section.sh_size = ftell (file) - section.sh_offset;
8766 }
252b5132 8767
9ea033b2 8768 if (is_32bit_elf)
9ad5cbcf 8769 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 8770 else
9ad5cbcf 8771 section.sh_entsize = sizeof (Elf64_External_Sym);
071436c6 8772 section.sh_name = string_table_length;
252b5132 8773
ba5cdace 8774 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 8775 if (num_dynamic_syms < 1)
252b5132
RH		 8776 {
8777 error (_("Unable to determine the number of symbols to load\n"));
8778 continue;
8779 }
252b5132
RH		 8780 }
8781 }
8782
8783 /* Similarly find a string table. */
8784 if (dynamic_strings == NULL)
8785 {
86dba8ee
AM		 8786 for (entry = dynamic_section;
8787 entry < dynamic_section + dynamic_nent;
8788 ++entry)
252b5132
RH		 8789 {
8790 unsigned long offset;
b34976b6 8791 long str_tab_len;
252b5132
RH		 8792
8793 if (entry->d_tag != DT_STRTAB)
8794 continue;
8795
8796 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8797
8798 /* Since we do not know how big the string table is,
8799 we default to reading in the entire file (!) and
8800 processing that. This is overkill, I know, but it
e3c8793a 8801 should work. */
252b5132 8802
d93f0186 8803 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 8804
8805 if (archive_file_offset != 0)
8806 str_tab_len = archive_file_size - offset;
8807 else
8808 {
8809 if (fseek (file, 0, SEEK_END))
8810 error (_("Unable to seek to end of file\n"));
8811 str_tab_len = ftell (file) - offset;
8812 }
252b5132
RH		 8813
8814 if (str_tab_len < 1)
8815 {
8816 error
8817 (_("Unable to determine the length of the dynamic string table\n"));
8818 continue;
8819 }
8820
3f5e193b
NC		 8821 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8822 str_tab_len,
8823 _("dynamic string table"));
59245841 8824 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 8825 break;
8826 }
8827 }
8828
8829 /* And find the syminfo section if available. */
8830 if (dynamic_syminfo == NULL)
8831 {
3e8bba36 8832 unsigned long syminsz = 0;
252b5132 8833
86dba8ee
AM		 8834 for (entry = dynamic_section;
8835 entry < dynamic_section + dynamic_nent;
8836 ++entry)
252b5132
RH		 8837 {
8838 if (entry->d_tag == DT_SYMINENT)
8839 {
8840 /* Note: these braces are necessary to avoid a syntax
8841 error from the SunOS4 C compiler. */
049b0c3a
NC		 8842 /* PR binutils/17531: A corrupt file can trigger this test.
8843 So do not use an assert, instead generate an error message. */
8844 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
071436c6 8845 error (_("Bad value (%d) for SYMINENT entry\n"),
049b0c3a 8846 (int) entry->d_un.d_val);
252b5132
RH		 8847 }
8848 else if (entry->d_tag == DT_SYMINSZ)
8849 syminsz = entry->d_un.d_val;
8850 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 8851 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8852 syminsz);
252b5132
RH		 8853 }
8854
8855 if (dynamic_syminfo_offset != 0 && syminsz != 0)
8856 {
2cf0635d
NC		 8857 Elf_External_Syminfo * extsyminfo;
8858 Elf_External_Syminfo * extsym;
8859 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 8860
8861 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 8862 extsyminfo = (Elf_External_Syminfo *)
8863 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8864 _("symbol information"));
a6e9f9df
AM		 8865 if (!extsyminfo)
8866 return 0;
252b5132 8867
3f5e193b 8868 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 8869 if (dynamic_syminfo == NULL)
8870 {
8b73c356
NC		 8871 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8872 (unsigned long) syminsz);
252b5132
RH		 8873 return 0;
8874 }
8875
8876 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 8877 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8878 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8879 ++syminfo, ++extsym)
252b5132 8880 {
86dba8ee
AM		 8881 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8882 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 8883 }
8884
8885 free (extsyminfo);
8886 }
8887 }
8888
8889 if (do_dynamic && dynamic_addr)
8b73c356
NC		 8890 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8891 dynamic_addr, (unsigned long) dynamic_nent);
252b5132
RH		 8892 if (do_dynamic)
8893 printf (_(" Tag Type Name/Value\n"));
8894
86dba8ee
AM		 8895 for (entry = dynamic_section;
8896 entry < dynamic_section + dynamic_nent;
8897 entry++)
252b5132
RH		 8898 {
8899 if (do_dynamic)
f7a99963 8900 {
2cf0635d 8901 const char * dtype;
e699b9ff 8902
f7a99963
NC		 8903 putchar (' ');
8904 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 8905 dtype = get_dynamic_type (entry->d_tag);
8906 printf (" (%s)%*s", dtype,
8907 ((is_32bit_elf ? 27 : 19)
8908 - (int) strlen (dtype)),
f7a99963
NC		 8909 " ");
8910 }
252b5132
RH		 8911
8912 switch (entry->d_tag)
8913 {
d1133906
NC		 8914 case DT_FLAGS:
8915 if (do_dynamic)
e9e44622 8916 print_dynamic_flags (entry->d_un.d_val);
d1133906 8917 break;
76da6bbe 8918
252b5132
RH		 8919 case DT_AUXILIARY:
8920 case DT_FILTER:
019148e4
L		 8921 case DT_CONFIG:
8922 case DT_DEPAUDIT:
8923 case DT_AUDIT:
252b5132
RH		 8924 if (do_dynamic)
8925 {
019148e4 8926 switch (entry->d_tag)
b34976b6 8927 {
019148e4
L		 8928 case DT_AUXILIARY:
8929 printf (_("Auxiliary library"));
8930 break;
8931
8932 case DT_FILTER:
8933 printf (_("Filter library"));
8934 break;
8935
b34976b6 8936 case DT_CONFIG:
019148e4
L		 8937 printf (_("Configuration file"));
8938 break;
8939
8940 case DT_DEPAUDIT:
8941 printf (_("Dependency audit library"));
8942 break;
8943
8944 case DT_AUDIT:
8945 printf (_("Audit library"));
8946 break;
8947 }
252b5132 8948
d79b3d50
NC		 8949 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8950 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8951 else
f7a99963
NC		 8952 {
8953 printf (": ");
8954 print_vma (entry->d_un.d_val, PREFIX_HEX);
8955 putchar ('\n');
8956 }
252b5132
RH		 8957 }
8958 break;
8959
dcefbbbd 8960 case DT_FEATURE:
252b5132
RH		 8961 if (do_dynamic)
8962 {
8963 printf (_("Flags:"));
86f55779 8964
252b5132
RH		 8965 if (entry->d_un.d_val == 0)
8966 printf (_(" None\n"));
8967 else
8968 {
8969 unsigned long int val = entry->d_un.d_val;
86f55779 8970
252b5132
RH		 8971 if (val & DTF_1_PARINIT)
8972 {
8973 printf (" PARINIT");
8974 val ^= DTF_1_PARINIT;
8975 }
dcefbbbd
L		 8976 if (val & DTF_1_CONFEXP)
8977 {
8978 printf (" CONFEXP");
8979 val ^= DTF_1_CONFEXP;
8980 }
252b5132
RH		 8981 if (val != 0)
8982 printf (" %lx", val);
8983 puts ("");
8984 }
8985 }
8986 break;
8987
8988 case DT_POSFLAG_1:
8989 if (do_dynamic)
8990 {
8991 printf (_("Flags:"));
86f55779 8992
252b5132
RH		 8993 if (entry->d_un.d_val == 0)
8994 printf (_(" None\n"));
8995 else
8996 {
8997 unsigned long int val = entry->d_un.d_val;
86f55779 8998
252b5132
RH		 8999 if (val & DF_P1_LAZYLOAD)
9000 {
9001 printf (" LAZYLOAD");
9002 val ^= DF_P1_LAZYLOAD;
9003 }
9004 if (val & DF_P1_GROUPPERM)
9005 {
9006 printf (" GROUPPERM");
9007 val ^= DF_P1_GROUPPERM;
9008 }
9009 if (val != 0)
9010 printf (" %lx", val);
9011 puts ("");
9012 }
9013 }
9014 break;
9015
9016 case DT_FLAGS_1:
9017 if (do_dynamic)
9018 {
9019 printf (_("Flags:"));
9020 if (entry->d_un.d_val == 0)
9021 printf (_(" None\n"));
9022 else
9023 {
9024 unsigned long int val = entry->d_un.d_val;
86f55779 9025
252b5132
RH		 9026 if (val & DF_1_NOW)
9027 {
9028 printf (" NOW");
9029 val ^= DF_1_NOW;
9030 }
9031 if (val & DF_1_GLOBAL)
9032 {
9033 printf (" GLOBAL");
9034 val ^= DF_1_GLOBAL;
9035 }
9036 if (val & DF_1_GROUP)
9037 {
9038 printf (" GROUP");
9039 val ^= DF_1_GROUP;
9040 }
9041 if (val & DF_1_NODELETE)
9042 {
9043 printf (" NODELETE");
9044 val ^= DF_1_NODELETE;
9045 }
9046 if (val & DF_1_LOADFLTR)
9047 {
9048 printf (" LOADFLTR");
9049 val ^= DF_1_LOADFLTR;
9050 }
9051 if (val & DF_1_INITFIRST)
9052 {
9053 printf (" INITFIRST");
9054 val ^= DF_1_INITFIRST;
9055 }
9056 if (val & DF_1_NOOPEN)
9057 {
9058 printf (" NOOPEN");
9059 val ^= DF_1_NOOPEN;
9060 }
9061 if (val & DF_1_ORIGIN)
9062 {
9063 printf (" ORIGIN");
9064 val ^= DF_1_ORIGIN;
9065 }
9066 if (val & DF_1_DIRECT)
9067 {
9068 printf (" DIRECT");
9069 val ^= DF_1_DIRECT;
9070 }
9071 if (val & DF_1_TRANS)
9072 {
9073 printf (" TRANS");
9074 val ^= DF_1_TRANS;
9075 }
9076 if (val & DF_1_INTERPOSE)
9077 {
9078 printf (" INTERPOSE");
9079 val ^= DF_1_INTERPOSE;
9080 }
f7db6139 9081 if (val & DF_1_NODEFLIB)
dcefbbbd 9082 {
f7db6139
L		 9083 printf (" NODEFLIB");
9084 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 9085 }
9086 if (val & DF_1_NODUMP)
9087 {
9088 printf (" NODUMP");
9089 val ^= DF_1_NODUMP;
9090 }
34b60028 9091 if (val & DF_1_CONFALT)
dcefbbbd 9092 {
34b60028
L		 9093 printf (" CONFALT");
9094 val ^= DF_1_CONFALT;
9095 }
9096 if (val & DF_1_ENDFILTEE)
9097 {
9098 printf (" ENDFILTEE");
9099 val ^= DF_1_ENDFILTEE;
9100 }
9101 if (val & DF_1_DISPRELDNE)
9102 {
9103 printf (" DISPRELDNE");
9104 val ^= DF_1_DISPRELDNE;
9105 }
9106 if (val & DF_1_DISPRELPND)
9107 {
9108 printf (" DISPRELPND");
9109 val ^= DF_1_DISPRELPND;
9110 }
9111 if (val & DF_1_NODIRECT)
9112 {
9113 printf (" NODIRECT");
9114 val ^= DF_1_NODIRECT;
9115 }
9116 if (val & DF_1_IGNMULDEF)
9117 {
9118 printf (" IGNMULDEF");
9119 val ^= DF_1_IGNMULDEF;
9120 }
9121 if (val & DF_1_NOKSYMS)
9122 {
9123 printf (" NOKSYMS");
9124 val ^= DF_1_NOKSYMS;
9125 }
9126 if (val & DF_1_NOHDR)
9127 {
9128 printf (" NOHDR");
9129 val ^= DF_1_NOHDR;
9130 }
9131 if (val & DF_1_EDITED)
9132 {
9133 printf (" EDITED");
9134 val ^= DF_1_EDITED;
9135 }
9136 if (val & DF_1_NORELOC)
9137 {
9138 printf (" NORELOC");
9139 val ^= DF_1_NORELOC;
9140 }
9141 if (val & DF_1_SYMINTPOSE)
9142 {
9143 printf (" SYMINTPOSE");
9144 val ^= DF_1_SYMINTPOSE;
9145 }
9146 if (val & DF_1_GLOBAUDIT)
9147 {
9148 printf (" GLOBAUDIT");
9149 val ^= DF_1_GLOBAUDIT;
9150 }
9151 if (val & DF_1_SINGLETON)
9152 {
9153 printf (" SINGLETON");
9154 val ^= DF_1_SINGLETON;
dcefbbbd 9155 }
252b5132
RH		 9156 if (val != 0)
9157 printf (" %lx", val);
9158 puts ("");
9159 }
9160 }
9161 break;
9162
9163 case DT_PLTREL:
566b0d53 9164 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9165 if (do_dynamic)
9166 puts (get_dynamic_type (entry->d_un.d_val));
9167 break;
9168
9169 case DT_NULL :
9170 case DT_NEEDED :
9171 case DT_PLTGOT :
9172 case DT_HASH :
9173 case DT_STRTAB :
9174 case DT_SYMTAB :
9175 case DT_RELA :
9176 case DT_INIT :
9177 case DT_FINI :
9178 case DT_SONAME :
9179 case DT_RPATH :
9180 case DT_SYMBOLIC:
9181 case DT_REL :
9182 case DT_DEBUG :
9183 case DT_TEXTREL :
9184 case DT_JMPREL :
019148e4 9185 case DT_RUNPATH :
252b5132
RH		 9186 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9187
9188 if (do_dynamic)
9189 {
2cf0635d 9190 char * name;
252b5132 9191
d79b3d50
NC		 9192 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9193 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9194 else
d79b3d50 9195 name = NULL;
252b5132
RH		 9196
9197 if (name)
9198 {
9199 switch (entry->d_tag)
9200 {
9201 case DT_NEEDED:
9202 printf (_("Shared library: [%s]"), name);
9203
18bd398b 9204 if (streq (name, program_interpreter))
f7a99963 9205 printf (_(" program interpreter"));
252b5132
RH		 9206 break;
9207
9208 case DT_SONAME:
f7a99963 9209 printf (_("Library soname: [%s]"), name);
252b5132
RH		 9210 break;
9211
9212 case DT_RPATH:
f7a99963 9213 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 9214 break;
9215
019148e4
L		 9216 case DT_RUNPATH:
9217 printf (_("Library runpath: [%s]"), name);
9218 break;
9219
252b5132 9220 default:
f7a99963
NC		 9221 print_vma (entry->d_un.d_val, PREFIX_HEX);
9222 break;
252b5132
RH		 9223 }
9224 }
9225 else
f7a99963
NC		 9226 print_vma (entry->d_un.d_val, PREFIX_HEX);
9227
9228 putchar ('\n');
252b5132
RH		 9229 }
9230 break;
9231
9232 case DT_PLTRELSZ:
9233 case DT_RELASZ :
9234 case DT_STRSZ :
9235 case DT_RELSZ :
9236 case DT_RELAENT :
9237 case DT_SYMENT :
9238 case DT_RELENT :
566b0d53 9239 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9240 case DT_PLTPADSZ:
9241 case DT_MOVEENT :
9242 case DT_MOVESZ :
9243 case DT_INIT_ARRAYSZ:
9244 case DT_FINI_ARRAYSZ:
047b2264
JJ		 9245 case DT_GNU_CONFLICTSZ:
9246 case DT_GNU_LIBLISTSZ:
252b5132 9247 if (do_dynamic)
f7a99963
NC		 9248 {
9249 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 9250 printf (_(" (bytes)\n"));
f7a99963 9251 }
252b5132
RH		 9252 break;
9253
9254 case DT_VERDEFNUM:
9255 case DT_VERNEEDNUM:
9256 case DT_RELACOUNT:
9257 case DT_RELCOUNT:
9258 if (do_dynamic)
f7a99963
NC		 9259 {
9260 print_vma (entry->d_un.d_val, UNSIGNED);
9261 putchar ('\n');
9262 }
252b5132
RH		 9263 break;
9264
9265 case DT_SYMINSZ:
9266 case DT_SYMINENT:
9267 case DT_SYMINFO:
9268 case DT_USED:
9269 case DT_INIT_ARRAY:
9270 case DT_FINI_ARRAY:
9271 if (do_dynamic)
9272 {
d79b3d50
NC		 9273 if (entry->d_tag == DT_USED
9274 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 9275 {
2cf0635d 9276 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9277
b34976b6 9278 if (*name)
252b5132
RH		 9279 {
9280 printf (_("Not needed object: [%s]\n"), name);
9281 break;
9282 }
9283 }
103f02d3 9284
f7a99963
NC		 9285 print_vma (entry->d_un.d_val, PREFIX_HEX);
9286 putchar ('\n');
252b5132
RH		 9287 }
9288 break;
9289
9290 case DT_BIND_NOW:
9291 /* The value of this entry is ignored. */
35b1837e
AM		 9292 if (do_dynamic)
9293 putchar ('\n');
252b5132 9294 break;
103f02d3 9295
047b2264
JJ		 9296 case DT_GNU_PRELINKED:
9297 if (do_dynamic)
9298 {
2cf0635d 9299 struct tm * tmp;
91d6fa6a 9300 time_t atime = entry->d_un.d_val;
047b2264 9301
91d6fa6a 9302 tmp = gmtime (&atime);
071436c6
NC		 9303 /* PR 17533 file: 041-1244816-0.004. */
9304 if (tmp == NULL)
5a2cbcf4
L		 9305 printf (_("<corrupt time val: %lx"),
9306 (unsigned long) atime);
071436c6
NC		 9307 else
9308 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9309 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9310 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 9311
9312 }
9313 break;
9314
fdc90cb4
JJ		 9315 case DT_GNU_HASH:
9316 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9317 if (do_dynamic)
9318 {
9319 print_vma (entry->d_un.d_val, PREFIX_HEX);
9320 putchar ('\n');
9321 }
9322 break;
9323
252b5132
RH		 9324 default:
9325 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 9326 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 9327 entry->d_un.d_val;
9328
9329 if (do_dynamic)
9330 {
9331 switch (elf_header.e_machine)
9332 {
9333 case EM_MIPS:
4fe85591 9334 case EM_MIPS_RS3_LE:
b2d38a17 9335 dynamic_section_mips_val (entry);
252b5132 9336 break;
103f02d3 9337 case EM_PARISC:
b2d38a17 9338 dynamic_section_parisc_val (entry);
103f02d3 9339 break;
ecc51f48 9340 case EM_IA_64:
b2d38a17 9341 dynamic_section_ia64_val (entry);
ecc51f48 9342 break;
252b5132 9343 default:
f7a99963
NC		 9344 print_vma (entry->d_un.d_val, PREFIX_HEX);
9345 putchar ('\n');
252b5132
RH		 9346 }
9347 }
9348 break;
9349 }
9350 }
9351
9352 return 1;
9353}
9354
9355static char *
d3ba0551 9356get_ver_flags (unsigned int flags)
252b5132 9357{
b34976b6 9358 static char buff[32];
252b5132
RH		 9359
9360 buff[0] = 0;
9361
9362 if (flags == 0)
9363 return _("none");
9364
9365 if (flags & VER_FLG_BASE)
9366 strcat (buff, "BASE ");
9367
9368 if (flags & VER_FLG_WEAK)
9369 {
9370 if (flags & VER_FLG_BASE)
9371 strcat (buff, "| ");
9372
9373 strcat (buff, "WEAK ");
9374 }
9375
44ec90b9
RO		 9376 if (flags & VER_FLG_INFO)
9377 {
9378 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9379 strcat (buff, "| ");
9380
9381 strcat (buff, "INFO ");
9382 }
9383
9384 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 9385 strcat (buff, _("| <unknown>"));
252b5132
RH		 9386
9387 return buff;
9388}
9389
9390/* Display the contents of the version sections. */
98fb390a 9391
252b5132 9392static int
2cf0635d 9393process_version_sections (FILE * file)
252b5132 9394{
2cf0635d 9395 Elf_Internal_Shdr * section;
b34976b6
AM		 9396 unsigned i;
9397 int found = 0;
252b5132
RH		 9398
9399 if (! do_version)
9400 return 1;
9401
9402 for (i = 0, section = section_headers;
9403 i < elf_header.e_shnum;
b34976b6 9404 i++, section++)
252b5132
RH		 9405 {
9406 switch (section->sh_type)
9407 {
9408 case SHT_GNU_verdef:
9409 {
2cf0635d 9410 Elf_External_Verdef * edefs;
b34976b6
AM		 9411 unsigned int idx;
9412 unsigned int cnt;
2cf0635d 9413 char * endbuf;
252b5132
RH		 9414
9415 found = 1;
9416
74e1a04b
NC		 9417 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9418 printable_section_name (section),
9419 section->sh_info);
252b5132
RH		 9420
9421 printf (_(" Addr: 0x"));
9422 printf_vma (section->sh_addr);
74e1a04b 9423 printf (_(" Offset: %#08lx Link: %u (%s)"),
1b228002 9424 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9425 printable_section_name_from_index (section->sh_link));
252b5132 9426
3f5e193b
NC		 9427 edefs = (Elf_External_Verdef *)
9428 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9429 _("version definition section"));
a6e9f9df
AM		 9430 if (!edefs)
9431 break;
59245841 9432 endbuf = (char *) edefs + section->sh_size;
252b5132 9433
b34976b6 9434 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 9435 {
2cf0635d
NC		 9436 char * vstart;
9437 Elf_External_Verdef * edef;
b34976b6 9438 Elf_Internal_Verdef ent;
2cf0635d 9439 Elf_External_Verdaux * eaux;
b34976b6
AM		 9440 Elf_Internal_Verdaux aux;
9441 int j;
9442 int isum;
103f02d3 9443
7e26601c
NC		 9444 /* Check for very large indicies. */
9445 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 9446 break;
9447
252b5132 9448 vstart = ((char *) edefs) + idx;
54806181
AM		 9449 if (vstart + sizeof (*edef) > endbuf)
9450 break;
252b5132
RH		 9451
9452 edef = (Elf_External_Verdef *) vstart;
9453
9454 ent.vd_version = BYTE_GET (edef->vd_version);
9455 ent.vd_flags = BYTE_GET (edef->vd_flags);
9456 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9457 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9458 ent.vd_hash = BYTE_GET (edef->vd_hash);
9459 ent.vd_aux = BYTE_GET (edef->vd_aux);
9460 ent.vd_next = BYTE_GET (edef->vd_next);
9461
9462 printf (_(" %#06x: Rev: %d Flags: %s"),
9463 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9464
9465 printf (_(" Index: %d Cnt: %d "),
9466 ent.vd_ndx, ent.vd_cnt);
9467
dd24e3da 9468 /* Check for overflow. */
7e26601c 9469 if (ent.vd_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 9470 break;
9471
252b5132
RH		 9472 vstart += ent.vd_aux;
9473
9474 eaux = (Elf_External_Verdaux *) vstart;
9475
9476 aux.vda_name = BYTE_GET (eaux->vda_name);
9477 aux.vda_next = BYTE_GET (eaux->vda_next);
9478
d79b3d50
NC		 9479 if (VALID_DYNAMIC_NAME (aux.vda_name))
9480 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9481 else
9482 printf (_("Name index: %ld\n"), aux.vda_name);
9483
9484 isum = idx + ent.vd_aux;
9485
b34976b6 9486 for (j = 1; j < ent.vd_cnt; j++)
252b5132 9487 {
dd24e3da 9488 /* Check for overflow. */
7e26601c 9489 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 9490 break;
9491
252b5132
RH		 9492 isum += aux.vda_next;
9493 vstart += aux.vda_next;
9494
9495 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 9496 if (vstart + sizeof (*eaux) > endbuf)
9497 break;
252b5132
RH		 9498
9499 aux.vda_name = BYTE_GET (eaux->vda_name);
9500 aux.vda_next = BYTE_GET (eaux->vda_next);
9501
d79b3d50 9502 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 9503 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 9504 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9505 else
9506 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9507 isum, j, aux.vda_name);
9508 }
dd24e3da 9509
54806181
AM		 9510 if (j < ent.vd_cnt)
9511 printf (_(" Version def aux past end of section\n"));
252b5132 9512
5d921cbd
NC		 9513 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9514 if (idx + ent.vd_next <= idx)
9515 break;
9516
252b5132
RH		 9517 idx += ent.vd_next;
9518 }
dd24e3da 9519
54806181
AM		 9520 if (cnt < section->sh_info)
9521 printf (_(" Version definition past end of section\n"));
252b5132
RH		 9522
9523 free (edefs);
9524 }
9525 break;
103f02d3 9526
252b5132
RH		 9527 case SHT_GNU_verneed:
9528 {
2cf0635d 9529 Elf_External_Verneed * eneed;
b34976b6
AM		 9530 unsigned int idx;
9531 unsigned int cnt;
2cf0635d 9532 char * endbuf;
252b5132
RH		 9533
9534 found = 1;
9535
72de5009 9536 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
74e1a04b 9537 printable_section_name (section), section->sh_info);
252b5132
RH		 9538
9539 printf (_(" Addr: 0x"));
9540 printf_vma (section->sh_addr);
72de5009 9541 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9542 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9543 printable_section_name_from_index (section->sh_link));
252b5132 9544
3f5e193b
NC		 9545 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9546 section->sh_offset, 1,
9547 section->sh_size,
9cf03b7e 9548 _("Version Needs section"));
a6e9f9df
AM		 9549 if (!eneed)
9550 break;
59245841 9551 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 9552
9553 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9554 {
2cf0635d 9555 Elf_External_Verneed * entry;
b34976b6
AM		 9556 Elf_Internal_Verneed ent;
9557 int j;
9558 int isum;
2cf0635d 9559 char * vstart;
252b5132 9560
7e26601c 9561 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 9562 break;
9563
252b5132 9564 vstart = ((char *) eneed) + idx;
54806181
AM		 9565 if (vstart + sizeof (*entry) > endbuf)
9566 break;
252b5132
RH		 9567
9568 entry = (Elf_External_Verneed *) vstart;
9569
9570 ent.vn_version = BYTE_GET (entry->vn_version);
9571 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
9572 ent.vn_file = BYTE_GET (entry->vn_file);
9573 ent.vn_aux = BYTE_GET (entry->vn_aux);
9574 ent.vn_next = BYTE_GET (entry->vn_next);
9575
9576 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
9577
d79b3d50
NC		 9578 if (VALID_DYNAMIC_NAME (ent.vn_file))
9579 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 9580 else
9581 printf (_(" File: %lx"), ent.vn_file);
9582
9583 printf (_(" Cnt: %d\n"), ent.vn_cnt);
9584
dd24e3da 9585 /* Check for overflow. */
7e26601c 9586 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da 9587 break;
252b5132
RH		 9588 vstart += ent.vn_aux;
9589
9590 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9591 {
2cf0635d 9592 Elf_External_Vernaux * eaux;
b34976b6 9593 Elf_Internal_Vernaux aux;
252b5132 9594
54806181
AM		 9595 if (vstart + sizeof (*eaux) > endbuf)
9596 break;
252b5132
RH		 9597 eaux = (Elf_External_Vernaux *) vstart;
9598
9599 aux.vna_hash = BYTE_GET (eaux->vna_hash);
9600 aux.vna_flags = BYTE_GET (eaux->vna_flags);
9601 aux.vna_other = BYTE_GET (eaux->vna_other);
9602 aux.vna_name = BYTE_GET (eaux->vna_name);
9603 aux.vna_next = BYTE_GET (eaux->vna_next);
9604
d79b3d50 9605 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 9606 printf (_(" %#06x: Name: %s"),
d79b3d50 9607 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 9608 else
ecc2063b 9609 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 9610 isum, aux.vna_name);
9611
9612 printf (_(" Flags: %s Version: %d\n"),
9613 get_ver_flags (aux.vna_flags), aux.vna_other);
9614
dd24e3da 9615 /* Check for overflow. */
53774b7e
NC		 9616 if (aux.vna_next > (size_t) (endbuf - vstart)
9617 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9618 {
9619 warn (_("Invalid vna_next field of %lx\n"),
9620 aux.vna_next);
9621 j = ent.vn_cnt;
9622 break;
9623 }
252b5132
RH		 9624 isum += aux.vna_next;
9625 vstart += aux.vna_next;
9626 }
9cf03b7e 9627
54806181 9628 if (j < ent.vn_cnt)
9cf03b7e 9629 warn (_("Missing Version Needs auxillary information\n"));
252b5132 9630
bcf83b2a 9631 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
c24cf8b6
NC		 9632 {
9633 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9634 cnt = section->sh_info;
9635 break;
9636 }
252b5132
RH		 9637 idx += ent.vn_next;
9638 }
9cf03b7e 9639
54806181 9640 if (cnt < section->sh_info)
9cf03b7e 9641 warn (_("Missing Version Needs information\n"));
103f02d3 9642
252b5132
RH		 9643 free (eneed);
9644 }
9645 break;
9646
9647 case SHT_GNU_versym:
9648 {
2cf0635d 9649 Elf_Internal_Shdr * link_section;
8b73c356
NC		 9650 size_t total;
9651 unsigned int cnt;
2cf0635d
NC		 9652 unsigned char * edata;
9653 unsigned short * data;
9654 char * strtab;
9655 Elf_Internal_Sym * symbols;
9656 Elf_Internal_Shdr * string_sec;
ba5cdace 9657 unsigned long num_syms;
d3ba0551 9658 long off;
252b5132 9659
4fbb74a6 9660 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9661 break;
9662
4fbb74a6 9663 link_section = section_headers + section->sh_link;
08d8fa11 9664 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 9665
4fbb74a6 9666 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9667 break;
9668
252b5132
RH		 9669 found = 1;
9670
ba5cdace 9671 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 9672 if (symbols == NULL)
9673 break;
252b5132 9674
4fbb74a6 9675 string_sec = section_headers + link_section->sh_link;
252b5132 9676
3f5e193b
NC		 9677 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9678 string_sec->sh_size,
9679 _("version string table"));
a6e9f9df 9680 if (!strtab)
0429c154
MS		 9681 {
9682 free (symbols);
9683 break;
9684 }
252b5132 9685
8b73c356
NC		 9686 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9687 printable_section_name (section), (unsigned long) total);
252b5132
RH		 9688
9689 printf (_(" Addr: "));
9690 printf_vma (section->sh_addr);
72de5009 9691 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9692 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9693 printable_section_name (link_section));
252b5132 9694
d3ba0551
AM		 9695 off = offset_from_vma (file,
9696 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9697 total * sizeof (short));
3f5e193b
NC		 9698 edata = (unsigned char *) get_data (NULL, file, off, total,
9699 sizeof (short),
9700 _("version symbol data"));
a6e9f9df
AM		 9701 if (!edata)
9702 {
9703 free (strtab);
0429c154 9704 free (symbols);
a6e9f9df
AM		 9705 break;
9706 }
252b5132 9707
3f5e193b 9708 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 9709
9710 for (cnt = total; cnt --;)
b34976b6
AM		 9711 data[cnt] = byte_get (edata + cnt * sizeof (short),
9712 sizeof (short));
252b5132
RH		 9713
9714 free (edata);
9715
9716 for (cnt = 0; cnt < total; cnt += 4)
9717 {
9718 int j, nn;
00d93f34 9719 int check_def, check_need;
2cf0635d 9720 char * name;
252b5132
RH		 9721
9722 printf (" %03x:", cnt);
9723
9724 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 9725 switch (data[cnt + j])
252b5132
RH		 9726 {
9727 case 0:
9728 fputs (_(" 0 (*local*) "), stdout);
9729 break;
9730
9731 case 1:
9732 fputs (_(" 1 (*global*) "), stdout);
9733 break;
9734
9735 default:
c244d050
NC		 9736 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9737 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 9738
dd24e3da 9739 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 9740 array, break to avoid an out-of-bounds read. */
9741 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 9742 {
9743 warn (_("invalid index into symbol array\n"));
9744 break;
9745 }
9746
00d93f34
JJ		 9747 check_def = 1;
9748 check_need = 1;
4fbb74a6
AM		 9749 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9750 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 9751 != SHT_NOBITS)
252b5132 9752 {
b34976b6 9753 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 9754 check_def = 0;
9755 else
9756 check_need = 0;
252b5132 9757 }
00d93f34
JJ		 9758
9759 if (check_need
b34976b6 9760 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 9761 {
b34976b6
AM		 9762 Elf_Internal_Verneed ivn;
9763 unsigned long offset;
252b5132 9764
d93f0186
NC		 9765 offset = offset_from_vma
9766 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9767 sizeof (Elf_External_Verneed));
252b5132 9768
b34976b6 9769 do
252b5132 9770 {
b34976b6
AM		 9771 Elf_Internal_Vernaux ivna;
9772 Elf_External_Verneed evn;
9773 Elf_External_Vernaux evna;
9774 unsigned long a_off;
252b5132 9775
59245841
NC		 9776 if (get_data (&evn, file, offset, sizeof (evn), 1,
9777 _("version need")) == NULL)
9778 break;
0b4362b0 9779
252b5132
RH		 9780 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9781 ivn.vn_next = BYTE_GET (evn.vn_next);
9782
9783 a_off = offset + ivn.vn_aux;
9784
9785 do
9786 {
59245841
NC		 9787 if (get_data (&evna, file, a_off, sizeof (evna),
9788 1, _("version need aux (2)")) == NULL)
9789 {
9790 ivna.vna_next = 0;
9791 ivna.vna_other = 0;
9792 }
9793 else
9794 {
9795 ivna.vna_next = BYTE_GET (evna.vna_next);
9796 ivna.vna_other = BYTE_GET (evna.vna_other);
9797 }
252b5132
RH		 9798
9799 a_off += ivna.vna_next;
9800 }
b34976b6 9801 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 9802 && ivna.vna_next != 0);
9803
b34976b6 9804 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 9805 {
9806 ivna.vna_name = BYTE_GET (evna.vna_name);
9807
54806181
AM		 9808 if (ivna.vna_name >= string_sec->sh_size)
9809 name = _("*invalid*");
9810 else
9811 name = strtab + ivna.vna_name;
252b5132 9812 nn += printf ("(%s%-*s",
16062207
ILT		 9813 name,
9814 12 - (int) strlen (name),
252b5132 9815 ")");
00d93f34 9816 check_def = 0;
252b5132
RH		 9817 break;
9818 }
9819
9820 offset += ivn.vn_next;
9821 }
9822 while (ivn.vn_next);
9823 }
00d93f34 9824
b34976b6
AM		 9825 if (check_def && data[cnt + j] != 0x8001
9826 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9827 {
b34976b6
AM		 9828 Elf_Internal_Verdef ivd;
9829 Elf_External_Verdef evd;
9830 unsigned long offset;
252b5132 9831
d93f0186
NC		 9832 offset = offset_from_vma
9833 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9834 sizeof evd);
252b5132
RH		 9835
9836 do
9837 {
59245841
NC		 9838 if (get_data (&evd, file, offset, sizeof (evd), 1,
9839 _("version def")) == NULL)
9840 {
9841 ivd.vd_next = 0;
948f632f 9842 /* PR 17531: file: 046-1082287-0.004. */
3102e897
NC		 9843 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
9844 break;
59245841
NC		 9845 }
9846 else
9847 {
9848 ivd.vd_next = BYTE_GET (evd.vd_next);
9849 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9850 }
252b5132
RH		 9851
9852 offset += ivd.vd_next;
9853 }
c244d050 9854 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 9855 && ivd.vd_next != 0);
9856
c244d050 9857 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 9858 {
b34976b6
AM		 9859 Elf_External_Verdaux evda;
9860 Elf_Internal_Verdaux ivda;
252b5132
RH		 9861
9862 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9863
59245841
NC		 9864 if (get_data (&evda, file,
9865 offset - ivd.vd_next + ivd.vd_aux,
9866 sizeof (evda), 1,
9867 _("version def aux")) == NULL)
9868 break;
252b5132
RH		 9869
9870 ivda.vda_name = BYTE_GET (evda.vda_name);
9871
54806181
AM		 9872 if (ivda.vda_name >= string_sec->sh_size)
9873 name = _("*invalid*");
9874 else
9875 name = strtab + ivda.vda_name;
252b5132 9876 nn += printf ("(%s%-*s",
16062207
ILT		 9877 name,
9878 12 - (int) strlen (name),
252b5132
RH		 9879 ")");
9880 }
9881 }
9882
9883 if (nn < 18)
9884 printf ("%*c", 18 - nn, ' ');
9885 }
9886
9887 putchar ('\n');
9888 }
9889
9890 free (data);
9891 free (strtab);
9892 free (symbols);
9893 }
9894 break;
103f02d3 9895
252b5132
RH		 9896 default:
9897 break;
9898 }
9899 }
9900
9901 if (! found)
9902 printf (_("\nNo version information found in this file.\n"));
9903
9904 return 1;
9905}
9906
d1133906 9907static const char *
d3ba0551 9908get_symbol_binding (unsigned int binding)
252b5132 9909{
b34976b6 9910 static char buff[32];
252b5132
RH		 9911
9912 switch (binding)
9913 {
b34976b6
AM		 9914 case STB_LOCAL: return "LOCAL";
9915 case STB_GLOBAL: return "GLOBAL";
9916 case STB_WEAK: return "WEAK";
252b5132
RH		 9917 default:
9918 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 9919 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9920 binding);
252b5132 9921 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 9922 {
9923 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 9924 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9925 /* GNU is still using the default value 0. */
3e7a7d11
NC		 9926 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9927 return "UNIQUE";
9928 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9929 }
252b5132 9930 else
e9e44622 9931 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 9932 return buff;
9933 }
9934}
9935
d1133906 9936static const char *
d3ba0551 9937get_symbol_type (unsigned int type)
252b5132 9938{
b34976b6 9939 static char buff[32];
252b5132
RH		 9940
9941 switch (type)
9942 {
b34976b6
AM		 9943 case STT_NOTYPE: return "NOTYPE";
9944 case STT_OBJECT: return "OBJECT";
9945 case STT_FUNC: return "FUNC";
9946 case STT_SECTION: return "SECTION";
9947 case STT_FILE: return "FILE";
9948 case STT_COMMON: return "COMMON";
9949 case STT_TLS: return "TLS";
15ab5209
DB		 9950 case STT_RELC: return "RELC";
9951 case STT_SRELC: return "SRELC";
252b5132
RH		 9952 default:
9953 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 9954 {
3510a7b8
NC		 9955 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
9956 return "THUMB_FUNC";
103f02d3 9957
351b4b40 9958 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 9959 return "REGISTER";
9960
9961 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
9962 return "PARISC_MILLI";
9963
e9e44622 9964 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 9965 }
252b5132 9966 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 9967 {
9968 if (elf_header.e_machine == EM_PARISC)
9969 {
9970 if (type == STT_HP_OPAQUE)
9971 return "HP_OPAQUE";
9972 if (type == STT_HP_STUB)
9973 return "HP_STUB";
9974 }
9975
d8045f23 9976 if (type == STT_GNU_IFUNC
9c55345c 9977 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 9978 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 9979 /* GNU is still using the default value 0. */
d8045f23
NC		 9980 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9981 return "IFUNC";
9982
e9e44622 9983 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 9984 }
252b5132 9985 else
e9e44622 9986 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 9987 return buff;
9988 }
9989}
9990
d1133906 9991static const char *
d3ba0551 9992get_symbol_visibility (unsigned int visibility)
d1133906
NC		 9993{
9994 switch (visibility)
9995 {
b34976b6
AM		 9996 case STV_DEFAULT: return "DEFAULT";
9997 case STV_INTERNAL: return "INTERNAL";
9998 case STV_HIDDEN: return "HIDDEN";
d1133906 9999 case STV_PROTECTED: return "PROTECTED";
bee0ee85
NC		 10000 default:
10001 error (_("Unrecognized visibility value: %u"), visibility);
10002 return _("<unknown>");
d1133906
NC		 10003 }
10004}
10005
5e2b0d47
NC		 10006static const char *
10007get_mips_symbol_other (unsigned int other)
10008{
10009 switch (other)
10010 {
df58fc94
RS		 10011 case STO_OPTIONAL:
10012 return "OPTIONAL";
10013 case STO_MIPS_PLT:
10014 return "MIPS PLT";
10015 case STO_MIPS_PIC:
10016 return "MIPS PIC";
10017 case STO_MICROMIPS:
10018 return "MICROMIPS";
10019 case STO_MICROMIPS | STO_MIPS_PIC:
10020 return "MICROMIPS, MIPS PIC";
10021 case STO_MIPS16:
10022 return "MIPS16";
10023 default:
10024 return NULL;
5e2b0d47
NC		 10025 }
10026}
10027
28f997cf
TG		 10028static const char *
10029get_ia64_symbol_other (unsigned int other)
10030{
10031 if (is_ia64_vms ())
10032 {
10033 static char res[32];
10034
10035 res[0] = 0;
10036
10037 /* Function types is for images and .STB files only. */
10038 switch (elf_header.e_type)
10039 {
10040 case ET_DYN:
10041 case ET_EXEC:
10042 switch (VMS_ST_FUNC_TYPE (other))
10043 {
10044 case VMS_SFT_CODE_ADDR:
10045 strcat (res, " CA");
10046 break;
10047 case VMS_SFT_SYMV_IDX:
10048 strcat (res, " VEC");
10049 break;
10050 case VMS_SFT_FD:
10051 strcat (res, " FD");
10052 break;
10053 case VMS_SFT_RESERVE:
10054 strcat (res, " RSV");
10055 break;
10056 default:
bee0ee85
NC		 10057 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10058 VMS_ST_FUNC_TYPE (other));
10059 strcat (res, " <unknown>");
10060 break;
28f997cf
TG		 10061 }
10062 break;
10063 default:
10064 break;
10065 }
10066 switch (VMS_ST_LINKAGE (other))
10067 {
10068 case VMS_STL_IGNORE:
10069 strcat (res, " IGN");
10070 break;
10071 case VMS_STL_RESERVE:
10072 strcat (res, " RSV");
10073 break;
10074 case VMS_STL_STD:
10075 strcat (res, " STD");
10076 break;
10077 case VMS_STL_LNK:
10078 strcat (res, " LNK");
10079 break;
10080 default:
bee0ee85
NC		 10081 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10082 VMS_ST_LINKAGE (other));
10083 strcat (res, " <unknown>");
10084 break;
28f997cf
TG		 10085 }
10086
10087 if (res[0] != 0)
10088 return res + 1;
10089 else
10090 return res;
10091 }
10092 return NULL;
10093}
10094
6911b7dc
AM		 10095static const char *
10096get_ppc64_symbol_other (unsigned int other)
10097{
10098 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10099 {
10100 static char buf[32];
10101 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10102 PPC64_LOCAL_ENTRY_OFFSET (other));
10103 return buf;
10104 }
10105 return NULL;
10106}
10107
5e2b0d47
NC		 10108static const char *
10109get_symbol_other (unsigned int other)
10110{
10111 const char * result = NULL;
10112 static char buff [32];
10113
10114 if (other == 0)
10115 return "";
10116
10117 switch (elf_header.e_machine)
10118 {
10119 case EM_MIPS:
10120 result = get_mips_symbol_other (other);
28f997cf
TG		 10121 break;
10122 case EM_IA_64:
10123 result = get_ia64_symbol_other (other);
10124 break;
6911b7dc
AM		 10125 case EM_PPC64:
10126 result = get_ppc64_symbol_other (other);
10127 break;
5e2b0d47
NC		 10128 default:
10129 break;
10130 }
10131
10132 if (result)
10133 return result;
10134
10135 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10136 return buff;
10137}
10138
d1133906 10139static const char *
d3ba0551 10140get_symbol_index_type (unsigned int type)
252b5132 10141{
b34976b6 10142 static char buff[32];
5cf1065c 10143
252b5132
RH		 10144 switch (type)
10145 {
b34976b6
AM		 10146 case SHN_UNDEF: return "UND";
10147 case SHN_ABS: return "ABS";
10148 case SHN_COMMON: return "COM";
252b5132 10149 default:
9ce701e2
L		 10150 if (type == SHN_IA_64_ANSI_COMMON
10151 && elf_header.e_machine == EM_IA_64
10152 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10153 return "ANSI_COM";
8a9036a4 10154 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 10155 || elf_header.e_machine == EM_L1OM
10156 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 10157 && type == SHN_X86_64_LCOMMON)
10158 return "LARGE_COM";
ac145307
BS		 10159 else if ((type == SHN_MIPS_SCOMMON
10160 && elf_header.e_machine == EM_MIPS)
10161 || (type == SHN_TIC6X_SCOMMON
10162 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 10163 return "SCOM";
10164 else if (type == SHN_MIPS_SUNDEFINED
10165 && elf_header.e_machine == EM_MIPS)
10166 return "SUND";
9ce701e2 10167 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 10168 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 10169 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 10170 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10171 else if (type >= SHN_LORESERVE)
10172 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4 10173 else if (type >= elf_header.e_shnum)
e0a31db1 10174 sprintf (buff, _("bad section index[%3d]"), type);
252b5132 10175 else
232e7cb8 10176 sprintf (buff, "%3d", type);
5cf1065c 10177 break;
252b5132 10178 }
5cf1065c
NC		 10179
10180 return buff;
252b5132
RH		 10181}
10182
66543521 10183static bfd_vma *
57028622 10184get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
252b5132 10185{
2cf0635d
NC		 10186 unsigned char * e_data;
10187 bfd_vma * i_data;
252b5132 10188
57028622
NC		 10189 /* If the size_t type is smaller than the bfd_size_type, eg because
10190 you are building a 32-bit tool on a 64-bit host, then make sure
10191 that when (number) is cast to (size_t) no information is lost. */
10192 if (sizeof (size_t) < sizeof (bfd_size_type)
10193 && (bfd_size_type) ((size_t) number) != number)
10194 {
10195 error (_("Size truncation prevents reading %llu elements of size %u\n"),
10196 (unsigned long long) number, ent_size);
10197 return NULL;
10198 }
948f632f 10199
3102e897
NC		 10200 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10201 attempting to allocate memory when the read is bound to fail. */
10202 if (ent_size * number > current_file_size)
10203 {
57028622
NC		 10204 error (_("Invalid number of dynamic entries: %llu\n"),
10205 (unsigned long long) number);
3102e897
NC		 10206 return NULL;
10207 }
10208
57028622 10209 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
252b5132
RH		 10210 if (e_data == NULL)
10211 {
57028622
NC		 10212 error (_("Out of memory reading %llu dynamic entries\n"),
10213 (unsigned long long) number);
252b5132
RH		 10214 return NULL;
10215 }
10216
57028622 10217 if (fread (e_data, ent_size, (size_t) number, file) != number)
252b5132 10218 {
57028622
NC		 10219 error (_("Unable to read in %llu bytes of dynamic data\n"),
10220 (unsigned long long) (number * ent_size));
3102e897 10221 free (e_data);
252b5132
RH		 10222 return NULL;
10223 }
10224
57028622 10225 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
252b5132
RH		 10226 if (i_data == NULL)
10227 {
57028622
NC		 10228 error (_("Out of memory allocating space for %llu dynamic entries\n"),
10229 (unsigned long long) number);
252b5132
RH		 10230 free (e_data);
10231 return NULL;
10232 }
10233
10234 while (number--)
66543521 10235 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 10236
10237 free (e_data);
10238
10239 return i_data;
10240}
10241
6bd1a22c
L		 10242static void
10243print_dynamic_symbol (bfd_vma si, unsigned long hn)
10244{
2cf0635d 10245 Elf_Internal_Sym * psym;
6bd1a22c
L		 10246 int n;
10247
6bd1a22c
L		 10248 n = print_vma (si, DEC_5);
10249 if (n < 5)
0b4362b0 10250 fputs (&" "[n], stdout);
6bd1a22c 10251 printf (" %3lu: ", hn);
e0a31db1
NC		 10252
10253 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10254 {
3102e897
NC		 10255 printf (_("<No info available for dynamic symbol number %lu>\n"),
10256 (unsigned long) si);
e0a31db1
NC		 10257 return;
10258 }
10259
10260 psym = dynamic_symbols + si;
6bd1a22c
L		 10261 print_vma (psym->st_value, LONG_HEX);
10262 putchar (' ');
10263 print_vma (psym->st_size, DEC_5);
10264
f4be36b3
AM		 10265 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10266 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10267 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 10268 /* Check to see if any other bits in the st_other field are set.
10269 Note - displaying this information disrupts the layout of the
10270 table being generated, but for the moment this case is very
10271 rare. */
10272 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10273 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10274 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10275 if (VALID_DYNAMIC_NAME (psym->st_name))
10276 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10277 else
2b692964 10278 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 10279 putchar ('\n');
10280}
10281
bb4d2ac2
L		 10282static const char *
10283get_symbol_version_string (FILE *file, int is_dynsym,
10284 const char *strtab,
10285 unsigned long int strtab_size,
10286 unsigned int si, Elf_Internal_Sym *psym,
10287 enum versioned_symbol_info *sym_info,
10288 unsigned short *vna_other)
10289{
10290 const char *version_string = NULL;
10291
10292 if (is_dynsym
10293 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
10294 {
10295 unsigned char data[2];
10296 unsigned short vers_data;
10297 unsigned long offset;
10298 int is_nobits;
10299 int check_def;
10300
10301 offset = offset_from_vma
10302 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10303 sizeof data + si * sizeof (vers_data));
10304
10305 if (get_data (&data, file, offset + si * sizeof (vers_data),
10306 sizeof (data), 1, _("version data")) == NULL)
10307 return NULL;
10308
10309 vers_data = byte_get (data, 2);
10310
53774b7e
NC		 10311 is_nobits = (section_headers != NULL
10312 && psym->st_shndx < elf_header.e_shnum
bb4d2ac2
L		 10313 && section_headers[psym->st_shndx].sh_type
10314 == SHT_NOBITS);
10315
10316 check_def = (psym->st_shndx != SHN_UNDEF);
10317
10318 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
10319 {
10320 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
10321 && (is_nobits || ! check_def))
10322 {
10323 Elf_External_Verneed evn;
10324 Elf_Internal_Verneed ivn;
10325 Elf_Internal_Vernaux ivna;
10326
10327 /* We must test both. */
10328 offset = offset_from_vma
10329 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10330 sizeof evn);
10331
10332 do
10333 {
10334 unsigned long vna_off;
10335
10336 if (get_data (&evn, file, offset, sizeof (evn), 1,
10337 _("version need")) == NULL)
10338 {
10339 ivna.vna_next = 0;
10340 ivna.vna_other = 0;
10341 ivna.vna_name = 0;
10342 break;
10343 }
10344
10345 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10346 ivn.vn_next = BYTE_GET (evn.vn_next);
10347
10348 vna_off = offset + ivn.vn_aux;
10349
10350 do
10351 {
10352 Elf_External_Vernaux evna;
10353
10354 if (get_data (&evna, file, vna_off,
10355 sizeof (evna), 1,
10356 _("version need aux (3)")) == NULL)
10357 {
10358 ivna.vna_next = 0;
10359 ivna.vna_other = 0;
10360 ivna.vna_name = 0;
10361 }
10362 else
10363 {
10364 ivna.vna_other = BYTE_GET (evna.vna_other);
10365 ivna.vna_next = BYTE_GET (evna.vna_next);
10366 ivna.vna_name = BYTE_GET (evna.vna_name);
10367 }
10368
10369 vna_off += ivna.vna_next;
10370 }
10371 while (ivna.vna_other != vers_data
10372 && ivna.vna_next != 0);
10373
10374 if (ivna.vna_other == vers_data)
10375 break;
10376
10377 offset += ivn.vn_next;
10378 }
10379 while (ivn.vn_next != 0);
10380
10381 if (ivna.vna_other == vers_data)
10382 {
10383 *sym_info = symbol_undefined;
10384 *vna_other = ivna.vna_other;
10385 version_string = (ivna.vna_name < strtab_size
10386 ? strtab + ivna.vna_name
10387 : _("<corrupt>"));
10388 check_def = 0;
10389 }
10390 else if (! is_nobits)
10391 error (_("bad dynamic symbol\n"));
10392 else
10393 check_def = 1;
10394 }
10395
10396 if (check_def)
10397 {
10398 if (vers_data != 0x8001
10399 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10400 {
10401 Elf_Internal_Verdef ivd;
10402 Elf_Internal_Verdaux ivda;
10403 Elf_External_Verdaux evda;
10404 unsigned long off;
10405
10406 off = offset_from_vma
10407 (file,
10408 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10409 sizeof (Elf_External_Verdef));
10410
10411 do
10412 {
10413 Elf_External_Verdef evd;
10414
10415 if (get_data (&evd, file, off, sizeof (evd),
10416 1, _("version def")) == NULL)
10417 {
10418 ivd.vd_ndx = 0;
10419 ivd.vd_aux = 0;
10420 ivd.vd_next = 0;
10421 }
10422 else
10423 {
10424 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10425 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10426 ivd.vd_next = BYTE_GET (evd.vd_next);
10427 }
10428
10429 off += ivd.vd_next;
10430 }
10431 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10432 && ivd.vd_next != 0);
10433
10434 off -= ivd.vd_next;
10435 off += ivd.vd_aux;
10436
10437 if (get_data (&evda, file, off, sizeof (evda),
10438 1, _("version def aux")) == NULL)
10439 return version_string;
10440
10441 ivda.vda_name = BYTE_GET (evda.vda_name);
10442
10443 if (psym->st_name != ivda.vda_name)
10444 {
10445 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10446 ? symbol_hidden : symbol_public);
10447 version_string = (ivda.vda_name < strtab_size
10448 ? strtab + ivda.vda_name
10449 : _("<corrupt>"));
10450 }
10451 }
10452 }
10453 }
10454 }
10455 return version_string;
10456}
10457
e3c8793a 10458/* Dump the symbol table. */
252b5132 10459static int
2cf0635d 10460process_symbol_table (FILE * file)
252b5132 10461{
2cf0635d 10462 Elf_Internal_Shdr * section;
8b73c356
NC		 10463 bfd_size_type nbuckets = 0;
10464 bfd_size_type nchains = 0;
2cf0635d
NC		 10465 bfd_vma * buckets = NULL;
10466 bfd_vma * chains = NULL;
fdc90cb4 10467 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 10468 bfd_vma * gnubuckets = NULL;
10469 bfd_vma * gnuchains = NULL;
6bd1a22c 10470 bfd_vma gnusymidx = 0;
071436c6 10471 bfd_size_type ngnuchains = 0;
252b5132 10472
2c610e4b 10473 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 10474 return 1;
10475
6bd1a22c
L		 10476 if (dynamic_info[DT_HASH]
10477 && (do_histogram
2c610e4b
L		 10478 || (do_using_dynamic
10479 && !do_dyn_syms
10480 && dynamic_strings != NULL)))
252b5132 10481 {
66543521
AM		 10482 unsigned char nb[8];
10483 unsigned char nc[8];
8b73c356 10484 unsigned int hash_ent_size = 4;
66543521
AM		 10485
10486 if ((elf_header.e_machine == EM_ALPHA
10487 || elf_header.e_machine == EM_S390
10488 || elf_header.e_machine == EM_S390_OLD)
10489 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10490 hash_ent_size = 8;
10491
fb52b2f4
NC		 10492 if (fseek (file,
10493 (archive_file_offset
10494 + offset_from_vma (file, dynamic_info[DT_HASH],
10495 sizeof nb + sizeof nc)),
d93f0186 10496 SEEK_SET))
252b5132 10497 {
591a748a 10498 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10499 goto no_hash;
252b5132
RH		 10500 }
10501
66543521 10502 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 10503 {
10504 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10505 goto no_hash;
252b5132
RH		 10506 }
10507
66543521 10508 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 10509 {
10510 error (_("Failed to read in number of chains\n"));
d3a44ec6 10511 goto no_hash;
252b5132
RH		 10512 }
10513
66543521
AM		 10514 nbuckets = byte_get (nb, hash_ent_size);
10515 nchains = byte_get (nc, hash_ent_size);
252b5132 10516
66543521
AM		 10517 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10518 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 10519
d3a44ec6 10520 no_hash:
252b5132 10521 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 10522 {
10523 if (do_using_dynamic)
10524 return 0;
10525 free (buckets);
10526 free (chains);
10527 buckets = NULL;
10528 chains = NULL;
10529 nbuckets = 0;
10530 nchains = 0;
10531 }
252b5132
RH		 10532 }
10533
6bd1a22c
L		 10534 if (dynamic_info_DT_GNU_HASH
10535 && (do_histogram
2c610e4b
L		 10536 || (do_using_dynamic
10537 && !do_dyn_syms
10538 && dynamic_strings != NULL)))
252b5132 10539 {
6bd1a22c
L		 10540 unsigned char nb[16];
10541 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10542 bfd_vma buckets_vma;
10543
10544 if (fseek (file,
10545 (archive_file_offset
10546 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10547 sizeof nb)),
10548 SEEK_SET))
10549 {
10550 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10551 goto no_gnu_hash;
6bd1a22c 10552 }
252b5132 10553
6bd1a22c
L		 10554 if (fread (nb, 16, 1, file) != 1)
10555 {
10556 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10557 goto no_gnu_hash;
6bd1a22c
L		 10558 }
10559
10560 ngnubuckets = byte_get (nb, 4);
10561 gnusymidx = byte_get (nb + 4, 4);
10562 bitmaskwords = byte_get (nb + 8, 4);
10563 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 10564 if (is_32bit_elf)
6bd1a22c 10565 buckets_vma += bitmaskwords * 4;
f7a99963 10566 else
6bd1a22c 10567 buckets_vma += bitmaskwords * 8;
252b5132 10568
6bd1a22c
L		 10569 if (fseek (file,
10570 (archive_file_offset
10571 + offset_from_vma (file, buckets_vma, 4)),
10572 SEEK_SET))
252b5132 10573 {
6bd1a22c 10574 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10575 goto no_gnu_hash;
6bd1a22c
L		 10576 }
10577
10578 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 10579
6bd1a22c 10580 if (gnubuckets == NULL)
d3a44ec6 10581 goto no_gnu_hash;
6bd1a22c
L		 10582
10583 for (i = 0; i < ngnubuckets; i++)
10584 if (gnubuckets[i] != 0)
10585 {
10586 if (gnubuckets[i] < gnusymidx)
10587 return 0;
10588
10589 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10590 maxchain = gnubuckets[i];
10591 }
10592
10593 if (maxchain == 0xffffffff)
d3a44ec6 10594 goto no_gnu_hash;
6bd1a22c
L		 10595
10596 maxchain -= gnusymidx;
10597
10598 if (fseek (file,
10599 (archive_file_offset
10600 + offset_from_vma (file, buckets_vma
10601 + 4 * (ngnubuckets + maxchain), 4)),
10602 SEEK_SET))
10603 {
10604 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10605 goto no_gnu_hash;
6bd1a22c
L		 10606 }
10607
10608 do
10609 {
10610 if (fread (nb, 4, 1, file) != 1)
252b5132 10611 {
6bd1a22c 10612 error (_("Failed to determine last chain length\n"));
d3a44ec6 10613 goto no_gnu_hash;
6bd1a22c 10614 }
252b5132 10615
6bd1a22c 10616 if (maxchain + 1 == 0)
d3a44ec6 10617 goto no_gnu_hash;
252b5132 10618
6bd1a22c
L		 10619 ++maxchain;
10620 }
10621 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 10622
6bd1a22c
L		 10623 if (fseek (file,
10624 (archive_file_offset
10625 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10626 SEEK_SET))
10627 {
10628 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10629 goto no_gnu_hash;
6bd1a22c
L		 10630 }
10631
10632 gnuchains = get_dynamic_data (file, maxchain, 4);
071436c6 10633 ngnuchains = maxchain;
6bd1a22c 10634
d3a44ec6 10635 no_gnu_hash:
6bd1a22c 10636 if (gnuchains == NULL)
d3a44ec6
JJ		 10637 {
10638 free (gnubuckets);
d3a44ec6
JJ		 10639 gnubuckets = NULL;
10640 ngnubuckets = 0;
f64fddf1
NC		 10641 if (do_using_dynamic)
10642 return 0;
d3a44ec6 10643 }
6bd1a22c
L		 10644 }
10645
10646 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10647 && do_syms
10648 && do_using_dynamic
3102e897
NC		 10649 && dynamic_strings != NULL
10650 && dynamic_symbols != NULL)
6bd1a22c
L		 10651 {
10652 unsigned long hn;
10653
10654 if (dynamic_info[DT_HASH])
10655 {
10656 bfd_vma si;
10657
10658 printf (_("\nSymbol table for image:\n"));
10659 if (is_32bit_elf)
10660 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10661 else
10662 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10663
10664 for (hn = 0; hn < nbuckets; hn++)
10665 {
10666 if (! buckets[hn])
10667 continue;
10668
10669 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10670 print_dynamic_symbol (si, hn);
252b5132
RH		 10671 }
10672 }
6bd1a22c
L		 10673
10674 if (dynamic_info_DT_GNU_HASH)
10675 {
10676 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10677 if (is_32bit_elf)
10678 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10679 else
10680 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10681
10682 for (hn = 0; hn < ngnubuckets; ++hn)
10683 if (gnubuckets[hn] != 0)
10684 {
10685 bfd_vma si = gnubuckets[hn];
10686 bfd_vma off = si - gnusymidx;
10687
10688 do
10689 {
10690 print_dynamic_symbol (si, hn);
10691 si++;
10692 }
071436c6 10693 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
6bd1a22c
L		 10694 }
10695 }
252b5132 10696 }
8b73c356
NC		 10697 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10698 && section_headers != NULL)
252b5132 10699 {
b34976b6 10700 unsigned int i;
252b5132
RH		 10701
10702 for (i = 0, section = section_headers;
10703 i < elf_header.e_shnum;
10704 i++, section++)
10705 {
b34976b6 10706 unsigned int si;
2cf0635d 10707 char * strtab = NULL;
c256ffe7 10708 unsigned long int strtab_size = 0;
2cf0635d
NC		 10709 Elf_Internal_Sym * symtab;
10710 Elf_Internal_Sym * psym;
ba5cdace 10711 unsigned long num_syms;
252b5132 10712
2c610e4b
L		 10713 if ((section->sh_type != SHT_SYMTAB
10714 && section->sh_type != SHT_DYNSYM)
10715 || (!do_syms
10716 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 10717 continue;
10718
dd24e3da
NC		 10719 if (section->sh_entsize == 0)
10720 {
10721 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
74e1a04b 10722 printable_section_name (section));
dd24e3da
NC		 10723 continue;
10724 }
10725
252b5132 10726 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
74e1a04b 10727 printable_section_name (section),
252b5132 10728 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 10729
f7a99963 10730 if (is_32bit_elf)
ca47b30c 10731 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 10732 else
ca47b30c 10733 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 10734
ba5cdace 10735 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 10736 if (symtab == NULL)
10737 continue;
10738
10739 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 10740 {
10741 strtab = string_table;
10742 strtab_size = string_table_length;
10743 }
4fbb74a6 10744 else if (section->sh_link < elf_header.e_shnum)
252b5132 10745 {
2cf0635d 10746 Elf_Internal_Shdr * string_sec;
252b5132 10747
4fbb74a6 10748 string_sec = section_headers + section->sh_link;
252b5132 10749
3f5e193b
NC		 10750 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10751 1, string_sec->sh_size,
10752 _("string table"));
c256ffe7 10753 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 10754 }
10755
ba5cdace 10756 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 10757 {
bb4d2ac2
L		 10758 const char *version_string;
10759 enum versioned_symbol_info sym_info;
10760 unsigned short vna_other;
10761
5e220199 10762 printf ("%6d: ", si);
f7a99963
NC		 10763 print_vma (psym->st_value, LONG_HEX);
10764 putchar (' ');
10765 print_vma (psym->st_size, DEC_5);
d1133906
NC		 10766 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10767 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 10768 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 10769 /* Check to see if any other bits in the st_other field are set.
10770 Note - displaying this information disrupts the layout of the
10771 table being generated, but for the moment this case is very rare. */
10772 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10773 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 10774 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 10775 print_symbol (25, psym->st_name < strtab_size
2b692964 10776 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 10777
bb4d2ac2
L		 10778 version_string
10779 = get_symbol_version_string (file,
10780 section->sh_type == SHT_DYNSYM,
10781 strtab, strtab_size, si,
10782 psym, &sym_info, &vna_other);
10783 if (version_string)
252b5132 10784 {
bb4d2ac2
L		 10785 if (sym_info == symbol_undefined)
10786 printf ("@%s (%d)", version_string, vna_other);
10787 else
10788 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10789 version_string);
252b5132
RH		 10790 }
10791
10792 putchar ('\n');
10793 }
10794
10795 free (symtab);
10796 if (strtab != string_table)
10797 free (strtab);
10798 }
10799 }
10800 else if (do_syms)
10801 printf
10802 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10803
10804 if (do_histogram && buckets != NULL)
10805 {
2cf0635d
NC		 10806 unsigned long * lengths;
10807 unsigned long * counts;
66543521
AM		 10808 unsigned long hn;
10809 bfd_vma si;
10810 unsigned long maxlength = 0;
10811 unsigned long nzero_counts = 0;
10812 unsigned long nsyms = 0;
94d15024 10813 unsigned long chained;
252b5132 10814
66543521
AM		 10815 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10816 (unsigned long) nbuckets);
252b5132 10817
3f5e193b 10818 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 10819 if (lengths == NULL)
10820 {
8b73c356 10821 error (_("Out of memory allocating space for histogram buckets\n"));
252b5132
RH		 10822 return 0;
10823 }
8b73c356
NC		 10824
10825 printf (_(" Length Number %% of total Coverage\n"));
252b5132
RH		 10826 for (hn = 0; hn < nbuckets; ++hn)
10827 {
94d15024
MF		 10828 for (si = buckets[hn], chained = 0;
10829 si > 0 && si < nchains && si < nbuckets && chained <= nchains;
10830 si = chains[si], ++chained)
252b5132 10831 {
b34976b6 10832 ++nsyms;
252b5132 10833 if (maxlength < ++lengths[hn])
b34976b6 10834 ++maxlength;
252b5132 10835 }
94d15024
MF		 10836
10837 /* PR binutils/17531: A corrupt binary could contain broken
10838 histogram data. Do not go into an infinite loop trying
10839 to process it. */
10840 if (chained > nchains)
10841 {
10842 error (_("histogram chain is corrupt\n"));
10843 break;
10844 }
252b5132
RH		 10845 }
10846
3f5e193b 10847 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 10848 if (counts == NULL)
10849 {
b2e951ec 10850 free (lengths);
8b73c356 10851 error (_("Out of memory allocating space for histogram counts\n"));
252b5132
RH		 10852 return 0;
10853 }
10854
10855 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 10856 ++counts[lengths[hn]];
252b5132 10857
103f02d3 10858 if (nbuckets > 0)
252b5132 10859 {
66543521
AM		 10860 unsigned long i;
10861 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 10862 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 10863 for (i = 1; i <= maxlength; ++i)
103f02d3 10864 {
66543521
AM		 10865 nzero_counts += counts[i] * i;
10866 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10867 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 10868 (nzero_counts * 100.0) / nsyms);
10869 }
252b5132
RH		 10870 }
10871
10872 free (counts);
10873 free (lengths);
10874 }
10875
10876 if (buckets != NULL)
10877 {
10878 free (buckets);
10879 free (chains);
10880 }
10881
d3a44ec6 10882 if (do_histogram && gnubuckets != NULL)
fdc90cb4 10883 {
2cf0635d
NC		 10884 unsigned long * lengths;
10885 unsigned long * counts;
fdc90cb4
JJ		 10886 unsigned long hn;
10887 unsigned long maxlength = 0;
10888 unsigned long nzero_counts = 0;
10889 unsigned long nsyms = 0;
fdc90cb4 10890
8b73c356
NC		 10891 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10892 (unsigned long) ngnubuckets);
10893
3f5e193b 10894 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 10895 if (lengths == NULL)
10896 {
8b73c356 10897 error (_("Out of memory allocating space for gnu histogram buckets\n"));
fdc90cb4
JJ		 10898 return 0;
10899 }
10900
fdc90cb4
JJ		 10901 printf (_(" Length Number %% of total Coverage\n"));
10902
10903 for (hn = 0; hn < ngnubuckets; ++hn)
10904 if (gnubuckets[hn] != 0)
10905 {
10906 bfd_vma off, length = 1;
10907
6bd1a22c 10908 for (off = gnubuckets[hn] - gnusymidx;
071436c6
NC		 10909 /* PR 17531 file: 010-77222-0.004. */
10910 off < ngnuchains && (gnuchains[off] & 1) == 0;
10911 ++off)
fdc90cb4
JJ		 10912 ++length;
10913 lengths[hn] = length;
10914 if (length > maxlength)
10915 maxlength = length;
10916 nsyms += length;
10917 }
10918
3f5e193b 10919 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 10920 if (counts == NULL)
10921 {
b2e951ec 10922 free (lengths);
8b73c356 10923 error (_("Out of memory allocating space for gnu histogram counts\n"));
fdc90cb4
JJ		 10924 return 0;
10925 }
10926
10927 for (hn = 0; hn < ngnubuckets; ++hn)
10928 ++counts[lengths[hn]];
10929
10930 if (ngnubuckets > 0)
10931 {
10932 unsigned long j;
10933 printf (" 0 %-10lu (%5.1f%%)\n",
10934 counts[0], (counts[0] * 100.0) / ngnubuckets);
10935 for (j = 1; j <= maxlength; ++j)
10936 {
10937 nzero_counts += counts[j] * j;
10938 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10939 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
10940 (nzero_counts * 100.0) / nsyms);
10941 }
10942 }
10943
10944 free (counts);
10945 free (lengths);
10946 free (gnubuckets);
10947 free (gnuchains);
10948 }
10949
252b5132
RH		 10950 return 1;
10951}
10952
10953static int
2cf0635d 10954process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 10955{
b4c96d0d 10956 unsigned int i;
252b5132
RH		 10957
10958 if (dynamic_syminfo == NULL
10959 || !do_dynamic)
10960 /* No syminfo, this is ok. */
10961 return 1;
10962
10963 /* There better should be a dynamic symbol section. */
10964 if (dynamic_symbols == NULL || dynamic_strings == NULL)
10965 return 0;
10966
10967 if (dynamic_addr)
10968 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10969 dynamic_syminfo_offset, dynamic_syminfo_nent);
10970
10971 printf (_(" Num: Name BoundTo Flags\n"));
10972 for (i = 0; i < dynamic_syminfo_nent; ++i)
10973 {
10974 unsigned short int flags = dynamic_syminfo[i].si_flags;
10975
31104126 10976 printf ("%4d: ", i);
4082ef84
NC		 10977 if (i >= num_dynamic_syms)
10978 printf (_("<corrupt index>"));
10979 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
d79b3d50
NC		 10980 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
10981 else
2b692964 10982 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 10983 putchar (' ');
252b5132
RH		 10984
10985 switch (dynamic_syminfo[i].si_boundto)
10986 {
10987 case SYMINFO_BT_SELF:
10988 fputs ("SELF ", stdout);
10989 break;
10990 case SYMINFO_BT_PARENT:
10991 fputs ("PARENT ", stdout);
10992 break;
10993 default:
10994 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 10995 && dynamic_syminfo[i].si_boundto < dynamic_nent
10996 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 10997 {
d79b3d50 10998 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 10999 putchar (' ' );
11000 }
252b5132
RH		 11001 else
11002 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11003 break;
11004 }
11005
11006 if (flags & SYMINFO_FLG_DIRECT)
11007 printf (" DIRECT");
11008 if (flags & SYMINFO_FLG_PASSTHRU)
11009 printf (" PASSTHRU");
11010 if (flags & SYMINFO_FLG_COPY)
11011 printf (" COPY");
11012 if (flags & SYMINFO_FLG_LAZYLOAD)
11013 printf (" LAZYLOAD");
11014
11015 puts ("");
11016 }
11017
11018 return 1;
11019}
11020
cf13d699
NC		 11021/* Check to see if the given reloc needs to be handled in a target specific
11022 manner. If so then process the reloc and return TRUE otherwise return
11023 FALSE. */
09c11c86 11024
cf13d699
NC		 11025static bfd_boolean
11026target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11027 unsigned char * start,
11028 Elf_Internal_Sym * symtab)
252b5132 11029{
cf13d699 11030 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 11031
cf13d699 11032 switch (elf_header.e_machine)
252b5132 11033 {
13761a11
NC		 11034 case EM_MSP430:
11035 case EM_MSP430_OLD:
11036 {
11037 static Elf_Internal_Sym * saved_sym = NULL;
11038
11039 switch (reloc_type)
11040 {
11041 case 10: /* R_MSP430_SYM_DIFF */
11042 if (uses_msp430x_relocs ())
11043 break;
11044 case 21: /* R_MSP430X_SYM_DIFF */
11045 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11046 return TRUE;
11047
11048 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11049 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11050 goto handle_sym_diff;
0b4362b0 11051
13761a11
NC		 11052 case 5: /* R_MSP430_16_BYTE */
11053 case 9: /* R_MSP430_8 */
11054 if (uses_msp430x_relocs ())
11055 break;
11056 goto handle_sym_diff;
11057
11058 case 2: /* R_MSP430_ABS16 */
11059 case 15: /* R_MSP430X_ABS16 */
11060 if (! uses_msp430x_relocs ())
11061 break;
11062 goto handle_sym_diff;
0b4362b0 11063
13761a11
NC		 11064 handle_sym_diff:
11065 if (saved_sym != NULL)
11066 {
11067 bfd_vma value;
11068
11069 value = reloc->r_addend
11070 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11071 - saved_sym->st_value);
11072
11073 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11074
11075 saved_sym = NULL;
11076 return TRUE;
11077 }
11078 break;
11079
11080 default:
11081 if (saved_sym != NULL)
071436c6 11082 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13761a11
NC		 11083 break;
11084 }
11085 break;
11086 }
11087
cf13d699
NC		 11088 case EM_MN10300:
11089 case EM_CYGNUS_MN10300:
11090 {
11091 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 11092
cf13d699
NC		 11093 switch (reloc_type)
11094 {
11095 case 34: /* R_MN10300_ALIGN */
11096 return TRUE;
11097 case 33: /* R_MN10300_SYM_DIFF */
11098 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11099 return TRUE;
11100 case 1: /* R_MN10300_32 */
11101 case 2: /* R_MN10300_16 */
11102 if (saved_sym != NULL)
11103 {
11104 bfd_vma value;
252b5132 11105
cf13d699
NC		 11106 value = reloc->r_addend
11107 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11108 - saved_sym->st_value);
252b5132 11109
cf13d699 11110 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 11111
cf13d699
NC		 11112 saved_sym = NULL;
11113 return TRUE;
11114 }
11115 break;
11116 default:
11117 if (saved_sym != NULL)
071436c6 11118 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
cf13d699
NC		 11119 break;
11120 }
11121 break;
11122 }
252b5132
RH		 11123 }
11124
cf13d699 11125 return FALSE;
252b5132
RH		 11126}
11127
aca88567
NC		 11128/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11129 DWARF debug sections. This is a target specific test. Note - we do not
11130 go through the whole including-target-headers-multiple-times route, (as
11131 we have already done with <elf/h8.h>) because this would become very
11132 messy and even then this function would have to contain target specific
11133 information (the names of the relocs instead of their numeric values).
11134 FIXME: This is not the correct way to solve this problem. The proper way
11135 is to have target specific reloc sizing and typing functions created by
11136 the reloc-macros.h header, in the same way that it already creates the
11137 reloc naming functions. */
11138
11139static bfd_boolean
11140is_32bit_abs_reloc (unsigned int reloc_type)
11141{
11142 switch (elf_header.e_machine)
11143 {
41e92641
NC		 11144 case EM_386:
11145 case EM_486:
11146 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 11147 case EM_68K:
11148 return reloc_type == 1; /* R_68K_32. */
11149 case EM_860:
11150 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 11151 case EM_960:
11152 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 11153 case EM_AARCH64:
11154 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 11155 case EM_ALPHA:
137b6b5f 11156 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 11157 case EM_ARC:
11158 return reloc_type == 1; /* R_ARC_32. */
11159 case EM_ARM:
11160 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 11161 case EM_AVR_OLD:
aca88567
NC		 11162 case EM_AVR:
11163 return reloc_type == 1;
cfb8c092
NC		 11164 case EM_ADAPTEVA_EPIPHANY:
11165 return reloc_type == 3;
aca88567
NC		 11166 case EM_BLACKFIN:
11167 return reloc_type == 0x12; /* R_byte4_data. */
11168 case EM_CRIS:
11169 return reloc_type == 3; /* R_CRIS_32. */
11170 case EM_CR16:
11171 return reloc_type == 3; /* R_CR16_NUM32. */
11172 case EM_CRX:
11173 return reloc_type == 15; /* R_CRX_NUM32. */
11174 case EM_CYGNUS_FRV:
11175 return reloc_type == 1;
41e92641
NC		 11176 case EM_CYGNUS_D10V:
11177 case EM_D10V:
11178 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 11179 case EM_CYGNUS_D30V:
11180 case EM_D30V:
11181 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 11182 case EM_DLX:
11183 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 11184 case EM_CYGNUS_FR30:
11185 case EM_FR30:
11186 return reloc_type == 3; /* R_FR30_32. */
3f8107ab
AM		 11187 case EM_FT32:
11188 return reloc_type == 1; /* R_FT32_32. */
aca88567
NC		 11189 case EM_H8S:
11190 case EM_H8_300:
11191 case EM_H8_300H:
11192 return reloc_type == 1; /* R_H8_DIR32. */
3730236a
NC		 11193 case EM_IA_64:
11194 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
aca88567
NC		 11195 case EM_IP2K_OLD:
11196 case EM_IP2K:
11197 return reloc_type == 2; /* R_IP2K_32. */
11198 case EM_IQ2000:
11199 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 11200 case EM_LATTICEMICO32:
11201 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 11202 case EM_M32C_OLD:
aca88567
NC		 11203 case EM_M32C:
11204 return reloc_type == 3; /* R_M32C_32. */
11205 case EM_M32R:
11206 return reloc_type == 34; /* R_M32R_32_RELA. */
11207 case EM_MCORE:
11208 return reloc_type == 1; /* R_MCORE_ADDR32. */
11209 case EM_CYGNUS_MEP:
11210 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 11211 case EM_METAG:
11212 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 11213 case EM_MICROBLAZE:
11214 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 11215 case EM_MIPS:
11216 return reloc_type == 2; /* R_MIPS_32. */
11217 case EM_MMIX:
11218 return reloc_type == 4; /* R_MMIX_32. */
11219 case EM_CYGNUS_MN10200:
11220 case EM_MN10200:
11221 return reloc_type == 1; /* R_MN10200_32. */
11222 case EM_CYGNUS_MN10300:
11223 case EM_MN10300:
11224 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 11225 case EM_MOXIE:
11226 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 11227 case EM_MSP430_OLD:
11228 case EM_MSP430:
13761a11 11229 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 11230 case EM_MT:
11231 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 11232 case EM_NDS32:
11233 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 11234 case EM_ALTERA_NIOS2:
36591ba1 11235 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 11236 case EM_NIOS32:
11237 return reloc_type == 1; /* R_NIOS_32. */
73589c9d
CS		 11238 case EM_OR1K:
11239 return reloc_type == 1; /* R_OR1K_32. */
aca88567 11240 case EM_PARISC:
5fda8eca
NC		 11241 return (reloc_type == 1 /* R_PARISC_DIR32. */
11242 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 11243 case EM_PJ:
11244 case EM_PJ_OLD:
11245 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
11246 case EM_PPC64:
11247 return reloc_type == 1; /* R_PPC64_ADDR32. */
11248 case EM_PPC:
11249 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 11250 case EM_RL78:
11251 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 11252 case EM_RX:
11253 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 11254 case EM_S370:
11255 return reloc_type == 1; /* R_I370_ADDR31. */
11256 case EM_S390_OLD:
11257 case EM_S390:
11258 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 11259 case EM_SCORE:
11260 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 11261 case EM_SH:
11262 return reloc_type == 1; /* R_SH_DIR32. */
11263 case EM_SPARC32PLUS:
11264 case EM_SPARCV9:
11265 case EM_SPARC:
11266 return reloc_type == 3 /* R_SPARC_32. */
11267 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 11268 case EM_SPU:
11269 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 11270 case EM_TI_C6000:
11271 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 11272 case EM_TILEGX:
11273 return reloc_type == 2; /* R_TILEGX_32. */
11274 case EM_TILEPRO:
11275 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 11276 case EM_CYGNUS_V850:
11277 case EM_V850:
11278 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 11279 case EM_V800:
11280 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 11281 case EM_VAX:
11282 return reloc_type == 1; /* R_VAX_32. */
619ed720
EB		 11283 case EM_VISIUM:
11284 return reloc_type == 3; /* R_VISIUM_32. */
aca88567 11285 case EM_X86_64:
8a9036a4 11286 case EM_L1OM:
7a9068fe 11287 case EM_K1OM:
aca88567 11288 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 11289 case EM_XC16X:
11290 case EM_C166:
11291 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 11292 case EM_XGATE:
11293 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 11294 case EM_XSTORMY16:
11295 return reloc_type == 1; /* R_XSTROMY16_32. */
11296 case EM_XTENSA_OLD:
11297 case EM_XTENSA:
11298 return reloc_type == 1; /* R_XTENSA_32. */
aca88567 11299 default:
bee0ee85
NC		 11300 {
11301 static unsigned int prev_warn = 0;
11302
11303 /* Avoid repeating the same warning multiple times. */
11304 if (prev_warn != elf_header.e_machine)
11305 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11306 elf_header.e_machine);
11307 prev_warn = elf_header.e_machine;
11308 return FALSE;
11309 }
aca88567
NC		 11310 }
11311}
11312
11313/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11314 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11315
11316static bfd_boolean
11317is_32bit_pcrel_reloc (unsigned int reloc_type)
11318{
11319 switch (elf_header.e_machine)
11320 {
41e92641
NC		 11321 case EM_386:
11322 case EM_486:
3e0873ac 11323 return reloc_type == 2; /* R_386_PC32. */
aca88567 11324 case EM_68K:
3e0873ac 11325 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 11326 case EM_AARCH64:
11327 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 11328 case EM_ADAPTEVA_EPIPHANY:
11329 return reloc_type == 6;
aca88567
NC		 11330 case EM_ALPHA:
11331 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 11332 case EM_ARM:
3e0873ac 11333 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 11334 case EM_MICROBLAZE:
11335 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
73589c9d
CS		 11336 case EM_OR1K:
11337 return reloc_type == 9; /* R_OR1K_32_PCREL. */
aca88567 11338 case EM_PARISC:
85acf597 11339 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 11340 case EM_PPC:
11341 return reloc_type == 26; /* R_PPC_REL32. */
11342 case EM_PPC64:
3e0873ac 11343 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 11344 case EM_S390_OLD:
11345 case EM_S390:
3e0873ac 11346 return reloc_type == 5; /* R_390_PC32. */
aca88567 11347 case EM_SH:
3e0873ac 11348 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 11349 case EM_SPARC32PLUS:
11350 case EM_SPARCV9:
11351 case EM_SPARC:
3e0873ac 11352 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 11353 case EM_SPU:
11354 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 11355 case EM_TILEGX:
11356 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
11357 case EM_TILEPRO:
11358 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
619ed720
EB		 11359 case EM_VISIUM:
11360 return reloc_type == 6; /* R_VISIUM_32_PCREL */
aca88567 11361 case EM_X86_64:
8a9036a4 11362 case EM_L1OM:
7a9068fe 11363 case EM_K1OM:
3e0873ac 11364 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 11365 case EM_XTENSA_OLD:
11366 case EM_XTENSA:
11367 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 11368 default:
11369 /* Do not abort or issue an error message here. Not all targets use
11370 pc-relative 32-bit relocs in their DWARF debug information and we
11371 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 11372 more helpful warning message will be generated by apply_relocations
11373 anyway, so just return. */
aca88567
NC		 11374 return FALSE;
11375 }
11376}
11377
11378/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11379 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11380
11381static bfd_boolean
11382is_64bit_abs_reloc (unsigned int reloc_type)
11383{
11384 switch (elf_header.e_machine)
11385 {
a06ea964
NC		 11386 case EM_AARCH64:
11387 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 11388 case EM_ALPHA:
11389 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 11390 case EM_IA_64:
11391 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 11392 case EM_PARISC:
11393 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 11394 case EM_PPC64:
11395 return reloc_type == 38; /* R_PPC64_ADDR64. */
11396 case EM_SPARC32PLUS:
11397 case EM_SPARCV9:
11398 case EM_SPARC:
11399 return reloc_type == 54; /* R_SPARC_UA64. */
11400 case EM_X86_64:
8a9036a4 11401 case EM_L1OM:
7a9068fe 11402 case EM_K1OM:
aca88567 11403 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 11404 case EM_S390_OLD:
11405 case EM_S390:
aa137e4d
NC		 11406 return reloc_type == 22; /* R_S390_64. */
11407 case EM_TILEGX:
11408 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 11409 case EM_MIPS:
aa137e4d 11410 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 11411 default:
11412 return FALSE;
11413 }
11414}
11415
85acf597
RH		 11416/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11417 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11418
11419static bfd_boolean
11420is_64bit_pcrel_reloc (unsigned int reloc_type)
11421{
11422 switch (elf_header.e_machine)
11423 {
a06ea964
NC		 11424 case EM_AARCH64:
11425 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 11426 case EM_ALPHA:
aa137e4d 11427 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 11428 case EM_IA_64:
aa137e4d 11429 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 11430 case EM_PARISC:
aa137e4d 11431 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 11432 case EM_PPC64:
aa137e4d 11433 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 11434 case EM_SPARC32PLUS:
11435 case EM_SPARCV9:
11436 case EM_SPARC:
aa137e4d 11437 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 11438 case EM_X86_64:
8a9036a4 11439 case EM_L1OM:
7a9068fe 11440 case EM_K1OM:
aa137e4d 11441 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 11442 case EM_S390_OLD:
11443 case EM_S390:
aa137e4d
NC		 11444 return reloc_type == 23; /* R_S390_PC64. */
11445 case EM_TILEGX:
11446 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 11447 default:
11448 return FALSE;
11449 }
11450}
11451
4dc3c23d
AM		 11452/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11453 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11454
11455static bfd_boolean
11456is_24bit_abs_reloc (unsigned int reloc_type)
11457{
11458 switch (elf_header.e_machine)
11459 {
11460 case EM_CYGNUS_MN10200:
11461 case EM_MN10200:
11462 return reloc_type == 4; /* R_MN10200_24. */
11463 default:
11464 return FALSE;
11465 }
11466}
11467
aca88567
NC		 11468/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11469 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11470
11471static bfd_boolean
11472is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 11473{
11474 switch (elf_header.e_machine)
11475 {
aca88567
NC		 11476 case EM_AVR_OLD:
11477 case EM_AVR:
11478 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 11479 case EM_ADAPTEVA_EPIPHANY:
11480 return reloc_type == 5;
41e92641
NC		 11481 case EM_CYGNUS_D10V:
11482 case EM_D10V:
11483 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 11484 case EM_H8S:
11485 case EM_H8_300:
11486 case EM_H8_300H:
aca88567
NC		 11487 return reloc_type == R_H8_DIR16;
11488 case EM_IP2K_OLD:
11489 case EM_IP2K:
11490 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 11491 case EM_M32C_OLD:
f4236fe4
DD		 11492 case EM_M32C:
11493 return reloc_type == 1; /* R_M32C_16 */
aca88567 11494 case EM_MSP430:
13761a11
NC		 11495 if (uses_msp430x_relocs ())
11496 return reloc_type == 2; /* R_MSP430_ABS16. */
78c8d46c 11497 case EM_MSP430_OLD:
aca88567 11498 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 11499 case EM_NDS32:
11500 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 11501 case EM_ALTERA_NIOS2:
36591ba1 11502 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 11503 case EM_NIOS32:
11504 return reloc_type == 9; /* R_NIOS_16. */
73589c9d
CS		 11505 case EM_OR1K:
11506 return reloc_type == 2; /* R_OR1K_16. */
40b36596
JM		 11507 case EM_TI_C6000:
11508 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 11509 case EM_XC16X:
11510 case EM_C166:
11511 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 11512 case EM_CYGNUS_MN10200:
11513 case EM_MN10200:
11514 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 11515 case EM_CYGNUS_MN10300:
11516 case EM_MN10300:
11517 return reloc_type == 2; /* R_MN10300_16. */
619ed720
EB		 11518 case EM_VISIUM:
11519 return reloc_type == 2; /* R_VISIUM_16. */
f6c1a2d5
NC		 11520 case EM_XGATE:
11521 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 11522 default:
aca88567 11523 return FALSE;
4b78141a
NC		 11524 }
11525}
11526
2a7b2e88
JK		 11527/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11528 relocation entries (possibly formerly used for SHT_GROUP sections). */
11529
11530static bfd_boolean
11531is_none_reloc (unsigned int reloc_type)
11532{
11533 switch (elf_header.e_machine)
11534 {
cb8f3167
NC		 11535 case EM_68K: /* R_68K_NONE. */
11536 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 11537 case EM_SPARC32PLUS:
11538 case EM_SPARCV9:
cb8f3167
NC		 11539 case EM_SPARC: /* R_SPARC_NONE. */
11540 case EM_MIPS: /* R_MIPS_NONE. */
11541 case EM_PARISC: /* R_PARISC_NONE. */
11542 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 11543 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 11544 case EM_PPC: /* R_PPC_NONE. */
11545 case EM_PPC64: /* R_PPC64_NONE. */
11546 case EM_ARM: /* R_ARM_NONE. */
11547 case EM_IA_64: /* R_IA64_NONE. */
11548 case EM_SH: /* R_SH_NONE. */
2a7b2e88 11549 case EM_S390_OLD:
cb8f3167
NC		 11550 case EM_S390: /* R_390_NONE. */
11551 case EM_CRIS: /* R_CRIS_NONE. */
11552 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 11553 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 11554 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 11555 case EM_MN10300: /* R_MN10300_NONE. */
3f8107ab 11556 case EM_FT32: /* R_FT32_NONE. */
5506d11a 11557 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 11558 case EM_M32R: /* R_M32R_NONE. */
40b36596 11559 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 11560 case EM_TILEGX: /* R_TILEGX_NONE. */
11561 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 11562 case EM_XC16X:
11563 case EM_C166: /* R_XC16X_NONE. */
36591ba1
SL		 11564 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
11565 case EM_NIOS32: /* R_NIOS_NONE. */
73589c9d 11566 case EM_OR1K: /* R_OR1K_NONE. */
cb8f3167 11567 return reloc_type == 0;
a06ea964
NC		 11568 case EM_AARCH64:
11569 return reloc_type == 0 || reloc_type == 256;
35c08157
KLC		 11570 case EM_NDS32:
11571 return (reloc_type == 0 /* R_XTENSA_NONE. */
11572 || reloc_type == 204 /* R_NDS32_DIFF8. */
11573 || reloc_type == 205 /* R_NDS32_DIFF16. */
11574 || reloc_type == 206 /* R_NDS32_DIFF32. */
11575 || reloc_type == 207 /* R_NDS32_ULEB128. */);
58332dda
JK		 11576 case EM_XTENSA_OLD:
11577 case EM_XTENSA:
4dc3c23d
AM		 11578 return (reloc_type == 0 /* R_XTENSA_NONE. */
11579 || reloc_type == 17 /* R_XTENSA_DIFF8. */
11580 || reloc_type == 18 /* R_XTENSA_DIFF16. */
11581 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
a3c62988
NC		 11582 case EM_METAG:
11583 return reloc_type == 3; /* R_METAG_NONE. */
2a7b2e88
JK		 11584 }
11585 return FALSE;
11586}
11587
cf13d699
NC		 11588/* Apply relocations to a section.
11589 Note: So far support has been added only for those relocations
11590 which can be found in debug sections.
11591 FIXME: Add support for more relocations ? */
1b315056 11592
cf13d699
NC		 11593static void
11594apply_relocations (void * file,
11595 Elf_Internal_Shdr * section,
11596 unsigned char * start)
1b315056 11597{
cf13d699
NC		 11598 Elf_Internal_Shdr * relsec;
11599 unsigned char * end = start + section->sh_size;
cb8f3167 11600
cf13d699
NC		 11601 if (elf_header.e_type != ET_REL)
11602 return;
1b315056 11603
cf13d699 11604 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 11605 for (relsec = section_headers;
11606 relsec < section_headers + elf_header.e_shnum;
11607 ++relsec)
252b5132 11608 {
41e92641
NC		 11609 bfd_boolean is_rela;
11610 unsigned long num_relocs;
2cf0635d
NC		 11611 Elf_Internal_Rela * relocs;
11612 Elf_Internal_Rela * rp;
11613 Elf_Internal_Shdr * symsec;
11614 Elf_Internal_Sym * symtab;
ba5cdace 11615 unsigned long num_syms;
2cf0635d 11616 Elf_Internal_Sym * sym;
252b5132 11617
41e92641 11618 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 11619 || relsec->sh_info >= elf_header.e_shnum
11620 || section_headers + relsec->sh_info != section
c256ffe7 11621 || relsec->sh_size == 0
4fbb74a6 11622 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 11623 continue;
428409d5 11624
41e92641
NC		 11625 is_rela = relsec->sh_type == SHT_RELA;
11626
11627 if (is_rela)
11628 {
3f5e193b
NC		 11629 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11630 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11631 return;
11632 }
11633 else
11634 {
3f5e193b
NC		 11635 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11636 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11637 return;
11638 }
11639
11640 /* SH uses RELA but uses in place value instead of the addend field. */
11641 if (elf_header.e_machine == EM_SH)
11642 is_rela = FALSE;
428409d5 11643
4fbb74a6 11644 symsec = section_headers + relsec->sh_link;
ba5cdace 11645 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 11646
41e92641 11647 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 11648 {
41e92641
NC		 11649 bfd_vma addend;
11650 unsigned int reloc_type;
11651 unsigned int reloc_size;
91d6fa6a 11652 unsigned char * rloc;
ba5cdace 11653 unsigned long sym_index;
4b78141a 11654
aca88567 11655 reloc_type = get_reloc_type (rp->r_info);
41e92641 11656
98fb390a 11657 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 11658 continue;
98fb390a
NC		 11659 else if (is_none_reloc (reloc_type))
11660 continue;
11661 else if (is_32bit_abs_reloc (reloc_type)
11662 || is_32bit_pcrel_reloc (reloc_type))
aca88567 11663 reloc_size = 4;
85acf597
RH		 11664 else if (is_64bit_abs_reloc (reloc_type)
11665 || is_64bit_pcrel_reloc (reloc_type))
aca88567 11666 reloc_size = 8;
4dc3c23d
AM		 11667 else if (is_24bit_abs_reloc (reloc_type))
11668 reloc_size = 3;
aca88567
NC		 11669 else if (is_16bit_abs_reloc (reloc_type))
11670 reloc_size = 2;
11671 else
4b78141a 11672 {
bee0ee85
NC		 11673 static unsigned int prev_reloc = 0;
11674 if (reloc_type != prev_reloc)
11675 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11676 reloc_type, printable_section_name (section));
11677 prev_reloc = reloc_type;
4b78141a
NC		 11678 continue;
11679 }
103f02d3 11680
91d6fa6a 11681 rloc = start + rp->r_offset;
c8da6823 11682 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 11683 {
11684 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11685 (unsigned long) rp->r_offset,
74e1a04b 11686 printable_section_name (section));
700dd8b7
L		 11687 continue;
11688 }
103f02d3 11689
ba5cdace
NC		 11690 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11691 if (sym_index >= num_syms)
11692 {
11693 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
74e1a04b 11694 sym_index, printable_section_name (section));
ba5cdace
NC		 11695 continue;
11696 }
11697 sym = symtab + sym_index;
41e92641
NC		 11698
11699 /* If the reloc has a symbol associated with it,
55f25fc3
L		 11700 make sure that it is of an appropriate type.
11701
11702 Relocations against symbols without type can happen.
11703 Gcc -feliminate-dwarf2-dups may generate symbols
11704 without type for debug info.
11705
11706 Icc generates relocations against function symbols
11707 instead of local labels.
11708
11709 Relocations against object symbols can happen, eg when
11710 referencing a global array. For an example of this see
11711 the _clz.o binary in libgcc.a. */
aca88567 11712 if (sym != symtab
55f25fc3 11713 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 11714 {
41e92641 11715 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 11716 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 11717 (long int)(rp - relocs),
74e1a04b 11718 printable_section_name (relsec));
aca88567 11719 continue;
5b18a4bc 11720 }
252b5132 11721
4dc3c23d
AM		 11722 addend = 0;
11723 if (is_rela)
11724 addend += rp->r_addend;
c47320c3
AM		 11725 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11726 partial_inplace. */
4dc3c23d
AM		 11727 if (!is_rela
11728 || (elf_header.e_machine == EM_XTENSA
11729 && reloc_type == 1)
11730 || ((elf_header.e_machine == EM_PJ
11731 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 11732 && reloc_type == 1)
11733 || ((elf_header.e_machine == EM_D30V
11734 || elf_header.e_machine == EM_CYGNUS_D30V)
11735 && reloc_type == 12))
91d6fa6a 11736 addend += byte_get (rloc, reloc_size);
cb8f3167 11737
85acf597
RH		 11738 if (is_32bit_pcrel_reloc (reloc_type)
11739 || is_64bit_pcrel_reloc (reloc_type))
11740 {
11741 /* On HPPA, all pc-relative relocations are biased by 8. */
11742 if (elf_header.e_machine == EM_PARISC)
11743 addend -= 8;
91d6fa6a 11744 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 11745 reloc_size);
11746 }
41e92641 11747 else
91d6fa6a 11748 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 11749 }
252b5132 11750
5b18a4bc 11751 free (symtab);
41e92641 11752 free (relocs);
5b18a4bc
NC		 11753 break;
11754 }
5b18a4bc 11755}
103f02d3 11756
cf13d699
NC		 11757#ifdef SUPPORT_DISASSEMBLY
11758static int
11759disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11760{
74e1a04b 11761 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
cf13d699 11762
74e1a04b 11763 /* FIXME: XXX -- to be done --- XXX */
cf13d699
NC		 11764
11765 return 1;
11766}
11767#endif
11768
11769/* Reads in the contents of SECTION from FILE, returning a pointer
11770 to a malloc'ed buffer or NULL if something went wrong. */
11771
11772static char *
11773get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11774{
11775 bfd_size_type num_bytes;
11776
11777 num_bytes = section->sh_size;
11778
11779 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11780 {
11781 printf (_("\nSection '%s' has no data to dump.\n"),
74e1a04b 11782 printable_section_name (section));
cf13d699
NC		 11783 return NULL;
11784 }
11785
3f5e193b
NC		 11786 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11787 _("section contents"));
cf13d699
NC		 11788}
11789
dd24e3da 11790
cf13d699
NC		 11791static void
11792dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
11793{
11794 Elf_Internal_Shdr * relsec;
11795 bfd_size_type num_bytes;
cf13d699
NC		 11796 char * data;
11797 char * end;
11798 char * start;
cf13d699
NC		 11799 bfd_boolean some_strings_shown;
11800
11801 start = get_section_contents (section, file);
11802 if (start == NULL)
11803 return;
11804
74e1a04b 11805 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
cf13d699
NC		 11806
11807 /* If the section being dumped has relocations against it the user might
11808 be expecting these relocations to have been applied. Check for this
11809 case and issue a warning message in order to avoid confusion.
11810 FIXME: Maybe we ought to have an option that dumps a section with
11811 relocs applied ? */
11812 for (relsec = section_headers;
11813 relsec < section_headers + elf_header.e_shnum;
11814 ++relsec)
11815 {
11816 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11817 || relsec->sh_info >= elf_header.e_shnum
11818 || section_headers + relsec->sh_info != section
11819 || relsec->sh_size == 0
11820 || relsec->sh_link >= elf_header.e_shnum)
11821 continue;
11822
11823 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11824 break;
11825 }
11826
11827 num_bytes = section->sh_size;
cf13d699
NC		 11828 data = start;
11829 end = start + num_bytes;
11830 some_strings_shown = FALSE;
11831
11832 while (data < end)
11833 {
11834 while (!ISPRINT (* data))
11835 if (++ data >= end)
11836 break;
11837
11838 if (data < end)
11839 {
071436c6
NC		 11840 size_t maxlen = end - data;
11841
cf13d699 11842#ifndef __MSVCRT__
c975cc98
NC		 11843 /* PR 11128: Use two separate invocations in order to work
11844 around bugs in the Solaris 8 implementation of printf. */
11845 printf (" [%6tx] ", data - start);
cf13d699 11846#else
071436c6 11847 printf (" [%6Ix] ", (size_t) (data - start));
cf13d699 11848#endif
4082ef84
NC		 11849 if (maxlen > 0)
11850 {
11851 print_symbol ((int) maxlen, data);
11852 putchar ('\n');
11853 data += strnlen (data, maxlen);
11854 }
11855 else
11856 {
11857 printf (_("<corrupt>\n"));
11858 data = end;
11859 }
cf13d699
NC		 11860 some_strings_shown = TRUE;
11861 }
11862 }
11863
11864 if (! some_strings_shown)
11865 printf (_(" No strings found in this section."));
11866
11867 free (start);
11868
11869 putchar ('\n');
11870}
11871
11872static void
11873dump_section_as_bytes (Elf_Internal_Shdr * section,
11874 FILE * file,
11875 bfd_boolean relocate)
11876{
11877 Elf_Internal_Shdr * relsec;
11878 bfd_size_type bytes;
11879 bfd_vma addr;
11880 unsigned char * data;
11881 unsigned char * start;
11882
11883 start = (unsigned char *) get_section_contents (section, file);
11884 if (start == NULL)
11885 return;
11886
74e1a04b 11887 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
cf13d699
NC		 11888
11889 if (relocate)
11890 {
11891 apply_relocations (file, section, start);
11892 }
11893 else
11894 {
11895 /* If the section being dumped has relocations against it the user might
11896 be expecting these relocations to have been applied. Check for this
11897 case and issue a warning message in order to avoid confusion.
11898 FIXME: Maybe we ought to have an option that dumps a section with
11899 relocs applied ? */
11900 for (relsec = section_headers;
11901 relsec < section_headers + elf_header.e_shnum;
11902 ++relsec)
11903 {
11904 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11905 || relsec->sh_info >= elf_header.e_shnum
11906 || section_headers + relsec->sh_info != section
11907 || relsec->sh_size == 0
11908 || relsec->sh_link >= elf_header.e_shnum)
11909 continue;
11910
11911 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11912 break;
11913 }
11914 }
11915
11916 addr = section->sh_addr;
11917 bytes = section->sh_size;
11918 data = start;
11919
11920 while (bytes)
11921 {
11922 int j;
11923 int k;
11924 int lbytes;
11925
11926 lbytes = (bytes > 16 ? 16 : bytes);
11927
11928 printf (" 0x%8.8lx ", (unsigned long) addr);
11929
11930 for (j = 0; j < 16; j++)
11931 {
11932 if (j < lbytes)
11933 printf ("%2.2x", data[j]);
11934 else
11935 printf (" ");
11936
11937 if ((j & 3) == 3)
11938 printf (" ");
11939 }
11940
11941 for (j = 0; j < lbytes; j++)
11942 {
11943 k = data[j];
11944 if (k >= ' ' && k < 0x7f)
11945 printf ("%c", k);
11946 else
11947 printf (".");
11948 }
11949
11950 putchar ('\n');
11951
11952 data += lbytes;
11953 addr += lbytes;
11954 bytes -= lbytes;
11955 }
11956
11957 free (start);
11958
11959 putchar ('\n');
11960}
11961
4a114e3e 11962/* Uncompresses a section that was compressed using zlib, in place. */
cf13d699
NC		 11963
11964static int
d3dbc530
AM		 11965uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
11966 dwarf_size_type *size ATTRIBUTE_UNUSED)
cf13d699
NC		 11967{
11968#ifndef HAVE_ZLIB_H
cf13d699
NC		 11969 return FALSE;
11970#else
11971 dwarf_size_type compressed_size = *size;
11972 unsigned char * compressed_buffer = *buffer;
11973 dwarf_size_type uncompressed_size;
11974 unsigned char * uncompressed_buffer;
11975 z_stream strm;
11976 int rc;
11977 dwarf_size_type header_size = 12;
11978
11979 /* Read the zlib header. In this case, it should be "ZLIB" followed
11980 by the uncompressed section size, 8 bytes in big-endian order. */
11981 if (compressed_size < header_size
11982 || ! streq ((char *) compressed_buffer, "ZLIB"))
11983 return 0;
11984
11985 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
11986 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
11987 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
11988 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
11989 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
11990 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
11991 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
11992 uncompressed_size += compressed_buffer[11];
11993
11994 /* It is possible the section consists of several compressed
11995 buffers concatenated together, so we uncompress in a loop. */
11996 strm.zalloc = NULL;
11997 strm.zfree = NULL;
11998 strm.opaque = NULL;
11999 strm.avail_in = compressed_size - header_size;
12000 strm.next_in = (Bytef *) compressed_buffer + header_size;
12001 strm.avail_out = uncompressed_size;
3f5e193b 12002 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
cf13d699
NC		 12003
12004 rc = inflateInit (& strm);
12005 while (strm.avail_in > 0)
12006 {
12007 if (rc != Z_OK)
12008 goto fail;
12009 strm.next_out = ((Bytef *) uncompressed_buffer
12010 + (uncompressed_size - strm.avail_out));
12011 rc = inflate (&strm, Z_FINISH);
12012 if (rc != Z_STREAM_END)
12013 goto fail;
12014 rc = inflateReset (& strm);
12015 }
12016 rc = inflateEnd (& strm);
12017 if (rc != Z_OK
12018 || strm.avail_out != 0)
12019 goto fail;
12020
12021 free (compressed_buffer);
12022 *buffer = uncompressed_buffer;
12023 *size = uncompressed_size;
12024 return 1;
12025
12026 fail:
12027 free (uncompressed_buffer);
4a114e3e
L		 12028 /* Indicate decompression failure. */
12029 *buffer = NULL;
cf13d699
NC		 12030 return 0;
12031#endif /* HAVE_ZLIB_H */
12032}
12033
d966045b
DJ		 12034static int
12035load_specific_debug_section (enum dwarf_section_display_enum debug,
2cf0635d 12036 Elf_Internal_Shdr * sec, void * file)
1007acb3 12037{
2cf0635d 12038 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 12039 char buf [64];
1007acb3 12040
19e6b90e
L		 12041 /* If it is already loaded, do nothing. */
12042 if (section->start != NULL)
12043 return 1;
1007acb3 12044
19e6b90e
L		 12045 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12046 section->address = sec->sh_addr;
06614111 12047 section->user_data = NULL;
3f5e193b
NC		 12048 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12049 sec->sh_offset, 1,
12050 sec->sh_size, buf);
59245841
NC		 12051 if (section->start == NULL)
12052 section->size = 0;
12053 else
12054 {
12055 section->size = sec->sh_size;
12056 if (uncompress_section_contents (&section->start, &section->size))
12057 sec->sh_size = section->size;
12058 }
4a114e3e 12059
1b315056
CS		 12060 if (section->start == NULL)
12061 return 0;
12062
19e6b90e 12063 if (debug_displays [debug].relocate)
3f5e193b 12064 apply_relocations ((FILE *) file, sec, section->start);
1007acb3 12065
1b315056 12066 return 1;
1007acb3
L		 12067}
12068
657d0d47
CC		 12069/* If this is not NULL, load_debug_section will only look for sections
12070 within the list of sections given here. */
12071unsigned int *section_subset = NULL;
12072
d966045b 12073int
2cf0635d 12074load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 12075{
2cf0635d
NC		 12076 struct dwarf_section * section = &debug_displays [debug].section;
12077 Elf_Internal_Shdr * sec;
d966045b
DJ		 12078
12079 /* Locate the debug section. */
657d0d47 12080 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 12081 if (sec != NULL)
12082 section->name = section->uncompressed_name;
12083 else
12084 {
657d0d47 12085 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 12086 if (sec != NULL)
12087 section->name = section->compressed_name;
12088 }
12089 if (sec == NULL)
12090 return 0;
12091
657d0d47
CC		 12092 /* If we're loading from a subset of sections, and we've loaded
12093 a section matching this name before, it's likely that it's a
12094 different one. */
12095 if (section_subset != NULL)
12096 free_debug_section (debug);
12097
3f5e193b 12098 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 12099}
12100
19e6b90e
L		 12101void
12102free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 12103{
2cf0635d 12104 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 12105
19e6b90e
L		 12106 if (section->start == NULL)
12107 return;
1007acb3 12108
19e6b90e
L		 12109 free ((char *) section->start);
12110 section->start = NULL;
12111 section->address = 0;
12112 section->size = 0;
1007acb3
L		 12113}
12114
1007acb3 12115static int
657d0d47 12116display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 12117{
2cf0635d 12118 char * name = SECTION_NAME (section);
74e1a04b 12119 const char * print_name = printable_section_name (section);
19e6b90e
L		 12120 bfd_size_type length;
12121 int result = 1;
3f5e193b 12122 int i;
1007acb3 12123
19e6b90e
L		 12124 length = section->sh_size;
12125 if (length == 0)
1007acb3 12126 {
74e1a04b 12127 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
19e6b90e 12128 return 0;
1007acb3 12129 }
5dff79d8
NC		 12130 if (section->sh_type == SHT_NOBITS)
12131 {
12132 /* There is no point in dumping the contents of a debugging section
12133 which has the NOBITS type - the bits in the file will be random.
12134 This can happen when a file containing a .eh_frame section is
12135 stripped with the --only-keep-debug command line option. */
74e1a04b
NC		 12136 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12137 print_name);
5dff79d8
NC		 12138 return 0;
12139 }
1007acb3 12140
0112cd26 12141 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 12142 name = ".debug_info";
1007acb3 12143
19e6b90e
L		 12144 /* See if we know how to display the contents of this section. */
12145 for (i = 0; i < max; i++)
1b315056 12146 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 12147 || (i == line && const_strneq (name, ".debug_line."))
1b315056 12148 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 12149 {
2cf0635d 12150 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 12151 int secondary = (section != find_section (name));
12152
12153 if (secondary)
3f5e193b 12154 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 12155
b40bf0a2
NC		 12156 if (i == line && const_strneq (name, ".debug_line."))
12157 sec->name = name;
12158 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 12159 sec->name = sec->uncompressed_name;
12160 else
12161 sec->name = sec->compressed_name;
3f5e193b
NC		 12162 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12163 section, file))
19e6b90e 12164 {
657d0d47
CC		 12165 /* If this debug section is part of a CU/TU set in a .dwp file,
12166 restrict load_debug_section to the sections in that set. */
12167 section_subset = find_cu_tu_set (file, shndx);
12168
19e6b90e 12169 result &= debug_displays[i].display (sec, file);
1007acb3 12170
657d0d47
CC		 12171 section_subset = NULL;
12172
d966045b 12173 if (secondary || (i != info && i != abbrev))
3f5e193b 12174 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 12175 }
1007acb3 12176
19e6b90e
L		 12177 break;
12178 }
1007acb3 12179
19e6b90e 12180 if (i == max)
1007acb3 12181 {
74e1a04b 12182 printf (_("Unrecognized debug section: %s\n"), print_name);
19e6b90e 12183 result = 0;
1007acb3
L		 12184 }
12185
19e6b90e 12186 return result;
5b18a4bc 12187}
103f02d3 12188
aef1f6d0
DJ		 12189/* Set DUMP_SECTS for all sections where dumps were requested
12190 based on section name. */
12191
12192static void
12193initialise_dumps_byname (void)
12194{
2cf0635d 12195 struct dump_list_entry * cur;
aef1f6d0
DJ		 12196
12197 for (cur = dump_sects_byname; cur; cur = cur->next)
12198 {
12199 unsigned int i;
12200 int any;
12201
12202 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12203 if (streq (SECTION_NAME (section_headers + i), cur->name))
12204 {
09c11c86 12205 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 12206 any = 1;
12207 }
12208
12209 if (!any)
12210 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12211 cur->name);
12212 }
12213}
12214
5b18a4bc 12215static void
2cf0635d 12216process_section_contents (FILE * file)
5b18a4bc 12217{
2cf0635d 12218 Elf_Internal_Shdr * section;
19e6b90e 12219 unsigned int i;
103f02d3 12220
19e6b90e
L		 12221 if (! do_dump)
12222 return;
103f02d3 12223
aef1f6d0
DJ		 12224 initialise_dumps_byname ();
12225
19e6b90e
L		 12226 for (i = 0, section = section_headers;
12227 i < elf_header.e_shnum && i < num_dump_sects;
12228 i++, section++)
12229 {
12230#ifdef SUPPORT_DISASSEMBLY
12231 if (dump_sects[i] & DISASS_DUMP)
12232 disassemble_section (section, file);
12233#endif
12234 if (dump_sects[i] & HEX_DUMP)
cf13d699 12235 dump_section_as_bytes (section, file, FALSE);
103f02d3 12236
cf13d699
NC		 12237 if (dump_sects[i] & RELOC_DUMP)
12238 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 12239
12240 if (dump_sects[i] & STRING_DUMP)
12241 dump_section_as_strings (section, file);
cf13d699
NC		 12242
12243 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 12244 display_debug_section (i, section, file);
5b18a4bc 12245 }
103f02d3 12246
19e6b90e
L		 12247 /* Check to see if the user requested a
12248 dump of a section that does not exist. */
12249 while (i++ < num_dump_sects)
12250 if (dump_sects[i])
12251 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 12252}
103f02d3 12253
5b18a4bc 12254static void
19e6b90e 12255process_mips_fpe_exception (int mask)
5b18a4bc 12256{
19e6b90e
L		 12257 if (mask)
12258 {
12259 int first = 1;
12260 if (mask & OEX_FPU_INEX)
12261 fputs ("INEX", stdout), first = 0;
12262 if (mask & OEX_FPU_UFLO)
12263 printf ("%sUFLO", first ? "" : "|"), first = 0;
12264 if (mask & OEX_FPU_OFLO)
12265 printf ("%sOFLO", first ? "" : "|"), first = 0;
12266 if (mask & OEX_FPU_DIV0)
12267 printf ("%sDIV0", first ? "" : "|"), first = 0;
12268 if (mask & OEX_FPU_INVAL)
12269 printf ("%sINVAL", first ? "" : "|");
12270 }
5b18a4bc 12271 else
19e6b90e 12272 fputs ("0", stdout);
5b18a4bc 12273}
103f02d3 12274
f6f0e17b
NC		 12275/* Display's the value of TAG at location P. If TAG is
12276 greater than 0 it is assumed to be an unknown tag, and
12277 a message is printed to this effect. Otherwise it is
12278 assumed that a message has already been printed.
12279
12280 If the bottom bit of TAG is set it assumed to have a
12281 string value, otherwise it is assumed to have an integer
12282 value.
12283
12284 Returns an updated P pointing to the first unread byte
12285 beyond the end of TAG's value.
12286
12287 Reads at or beyond END will not be made. */
12288
12289static unsigned char *
12290display_tag_value (int tag,
12291 unsigned char * p,
12292 const unsigned char * const end)
12293{
12294 unsigned long val;
12295
12296 if (tag > 0)
12297 printf (" Tag_unknown_%d: ", tag);
12298
12299 if (p >= end)
12300 {
4082ef84 12301 warn (_("<corrupt tag>\n"));
f6f0e17b
NC		 12302 }
12303 else if (tag & 1)
12304 {
071436c6
NC		 12305 /* PR 17531 file: 027-19978-0.004. */
12306 size_t maxlen = (end - p) - 1;
12307
12308 putchar ('"');
4082ef84
NC		 12309 if (maxlen > 0)
12310 {
12311 print_symbol ((int) maxlen, (const char *) p);
12312 p += strnlen ((char *) p, maxlen) + 1;
12313 }
12314 else
12315 {
12316 printf (_("<corrupt string tag>"));
12317 p = (unsigned char *) end;
12318 }
071436c6 12319 printf ("\"\n");
f6f0e17b
NC		 12320 }
12321 else
12322 {
12323 unsigned int len;
12324
12325 val = read_uleb128 (p, &len, end);
12326 p += len;
12327 printf ("%ld (0x%lx)\n", val, val);
12328 }
12329
4082ef84 12330 assert (p <= end);
f6f0e17b
NC		 12331 return p;
12332}
12333
11c1ff18
PB		 12334/* ARM EABI attributes section. */
12335typedef struct
12336{
70e99720 12337 unsigned int tag;
2cf0635d 12338 const char * name;
11c1ff18 12339 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 12340 unsigned int type;
2cf0635d 12341 const char ** table;
11c1ff18
PB		 12342} arm_attr_public_tag;
12343
2cf0635d 12344static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 12345 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 12346 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 12347static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12348static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 12349 {"No", "Thumb-1", "Thumb-2"};
75375b3e 12350static const char * arm_attr_tag_FP_arch[] =
bca38921 12351 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
a715796b 12352 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
2cf0635d 12353static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 12354static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 12355 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 12356static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 12357 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12358 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 12359static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 12360 {"V6", "SB", "TLS", "Unused"};
2cf0635d 12361static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 12362 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 12363static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 12364 {"Absolute", "PC-relative", "None"};
2cf0635d 12365static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 12366 {"None", "direct", "GOT-indirect"};
2cf0635d 12367static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 12368 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 12369static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12370static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 12371 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 12372static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12373static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12374static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 12375 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 12376static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 12377 {"Unused", "small", "int", "forced to int"};
2cf0635d 12378static const char * arm_attr_tag_ABI_HardFP_use[] =
99654aaf 12379 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
2cf0635d 12380static const char * arm_attr_tag_ABI_VFP_args[] =
5c294fee 12381 {"AAPCS", "VFP registers", "custom", "compatible"};
2cf0635d 12382static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 12383 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 12384static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 12385 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12386 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 12387static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 12388 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12389 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 12390static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 12391static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 12392 {"Not Allowed", "Allowed"};
2cf0635d 12393static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 12394 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 12395static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 12396 {"Not Allowed", "Allowed"};
12397static const char * arm_attr_tag_DIV_use[] =
dd24e3da 12398 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 12399 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 12400static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12401static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 12402 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 12403 "TrustZone and Virtualization Extensions"};
dd24e3da 12404static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 12405 {"Not Allowed", "Allowed"};
11c1ff18
PB		 12406
12407#define LOOKUP(id, name) \
12408 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 12409static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 12410{
12411 {4, "CPU_raw_name", 1, NULL},
12412 {5, "CPU_name", 1, NULL},
12413 LOOKUP(6, CPU_arch),
12414 {7, "CPU_arch_profile", 0, NULL},
12415 LOOKUP(8, ARM_ISA_use),
12416 LOOKUP(9, THUMB_ISA_use),
75375b3e 12417 LOOKUP(10, FP_arch),
11c1ff18 12418 LOOKUP(11, WMMX_arch),
f5f53991
AS		 12419 LOOKUP(12, Advanced_SIMD_arch),
12420 LOOKUP(13, PCS_config),
11c1ff18
PB		 12421 LOOKUP(14, ABI_PCS_R9_use),
12422 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 12423 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 12424 LOOKUP(17, ABI_PCS_GOT_use),
12425 LOOKUP(18, ABI_PCS_wchar_t),
12426 LOOKUP(19, ABI_FP_rounding),
12427 LOOKUP(20, ABI_FP_denormal),
12428 LOOKUP(21, ABI_FP_exceptions),
12429 LOOKUP(22, ABI_FP_user_exceptions),
12430 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 12431 {24, "ABI_align_needed", 0, NULL},
12432 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 12433 LOOKUP(26, ABI_enum_size),
12434 LOOKUP(27, ABI_HardFP_use),
12435 LOOKUP(28, ABI_VFP_args),
12436 LOOKUP(29, ABI_WMMX_args),
12437 LOOKUP(30, ABI_optimization_goals),
12438 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 12439 {32, "compatibility", 0, NULL},
f5f53991 12440 LOOKUP(34, CPU_unaligned_access),
75375b3e 12441 LOOKUP(36, FP_HP_extension),
8e79c3df 12442 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 12443 LOOKUP(42, MPextension_use),
12444 LOOKUP(44, DIV_use),
f5f53991
AS		 12445 {64, "nodefaults", 0, NULL},
12446 {65, "also_compatible_with", 0, NULL},
12447 LOOKUP(66, T2EE_use),
12448 {67, "conformance", 1, NULL},
12449 LOOKUP(68, Virtualization_use),
cd21e546 12450 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 12451};
12452#undef LOOKUP
12453
11c1ff18 12454static unsigned char *
f6f0e17b
NC		 12455display_arm_attribute (unsigned char * p,
12456 const unsigned char * const end)
11c1ff18 12457{
70e99720 12458 unsigned int tag;
11c1ff18 12459 unsigned int len;
70e99720 12460 unsigned int val;
2cf0635d 12461 arm_attr_public_tag * attr;
11c1ff18 12462 unsigned i;
70e99720 12463 unsigned int type;
11c1ff18 12464
f6f0e17b 12465 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 12466 p += len;
12467 attr = NULL;
2cf0635d 12468 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 12469 {
12470 if (arm_attr_public_tags[i].tag == tag)
12471 {
12472 attr = &arm_attr_public_tags[i];
12473 break;
12474 }
12475 }
12476
12477 if (attr)
12478 {
12479 printf (" Tag_%s: ", attr->name);
12480 switch (attr->type)
12481 {
12482 case 0:
12483 switch (tag)
12484 {
12485 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 12486 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12487 p += len;
12488 switch (val)
12489 {
2b692964
NC		 12490 case 0: printf (_("None\n")); break;
12491 case 'A': printf (_("Application\n")); break;
12492 case 'R': printf (_("Realtime\n")); break;
12493 case 'M': printf (_("Microcontroller\n")); break;
12494 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 12495 default: printf ("??? (%d)\n", val); break;
12496 }
12497 break;
12498
75375b3e 12499 case 24: /* Tag_align_needed. */
f6f0e17b 12500 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12501 p += len;
12502 switch (val)
12503 {
2b692964
NC		 12504 case 0: printf (_("None\n")); break;
12505 case 1: printf (_("8-byte\n")); break;
12506 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 12507 case 3: printf ("??? 3\n"); break;
12508 default:
12509 if (val <= 12)
dd24e3da 12510 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12511 1 << val);
12512 else
12513 printf ("??? (%d)\n", val);
12514 break;
12515 }
12516 break;
12517
12518 case 25: /* Tag_align_preserved. */
f6f0e17b 12519 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12520 p += len;
12521 switch (val)
12522 {
2b692964
NC		 12523 case 0: printf (_("None\n")); break;
12524 case 1: printf (_("8-byte, except leaf SP\n")); break;
12525 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 12526 case 3: printf ("??? 3\n"); break;
12527 default:
12528 if (val <= 12)
dd24e3da 12529 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12530 1 << val);
12531 else
12532 printf ("??? (%d)\n", val);
12533 break;
12534 }
12535 break;
12536
11c1ff18 12537 case 32: /* Tag_compatibility. */
071436c6 12538 {
071436c6
NC		 12539 val = read_uleb128 (p, &len, end);
12540 p += len;
071436c6 12541 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 12542 if (p < end - 1)
12543 {
12544 size_t maxlen = (end - p) - 1;
12545
12546 print_symbol ((int) maxlen, (const char *) p);
12547 p += strnlen ((char *) p, maxlen) + 1;
12548 }
12549 else
12550 {
12551 printf (_("<corrupt>"));
12552 p = (unsigned char *) end;
12553 }
071436c6 12554 putchar ('\n');
071436c6 12555 }
11c1ff18
PB		 12556 break;
12557
f5f53991 12558 case 64: /* Tag_nodefaults. */
541a3cbd
NC		 12559 /* PR 17531: file: 001-505008-0.01. */
12560 if (p < end)
12561 p++;
2b692964 12562 printf (_("True\n"));
f5f53991
AS		 12563 break;
12564
12565 case 65: /* Tag_also_compatible_with. */
f6f0e17b 12566 val = read_uleb128 (p, &len, end);
f5f53991
AS		 12567 p += len;
12568 if (val == 6 /* Tag_CPU_arch. */)
12569 {
f6f0e17b 12570 val = read_uleb128 (p, &len, end);
f5f53991 12571 p += len;
071436c6 12572 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 12573 printf ("??? (%d)\n", val);
12574 else
12575 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12576 }
12577 else
12578 printf ("???\n");
071436c6
NC		 12579 while (p < end && *(p++) != '\0' /* NUL terminator. */)
12580 ;
f5f53991
AS		 12581 break;
12582
11c1ff18 12583 default:
bee0ee85
NC		 12584 printf (_("<unknown: %d>\n"), tag);
12585 break;
11c1ff18
PB		 12586 }
12587 return p;
12588
12589 case 1:
f6f0e17b 12590 return display_tag_value (-1, p, end);
11c1ff18 12591 case 2:
f6f0e17b 12592 return display_tag_value (0, p, end);
11c1ff18
PB		 12593
12594 default:
12595 assert (attr->type & 0x80);
f6f0e17b 12596 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12597 p += len;
12598 type = attr->type & 0x7f;
12599 if (val >= type)
12600 printf ("??? (%d)\n", val);
12601 else
12602 printf ("%s\n", attr->table[val]);
12603 return p;
12604 }
12605 }
11c1ff18 12606
f6f0e17b 12607 return display_tag_value (tag, p, end);
11c1ff18
PB		 12608}
12609
104d59d1 12610static unsigned char *
60bca95a 12611display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 12612 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12613 const unsigned char * const end)
104d59d1
JM		 12614{
12615 int tag;
12616 unsigned int len;
12617 int val;
104d59d1 12618
f6f0e17b 12619 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 12620 p += len;
12621
12622 /* Tag_compatibility is the only generic GNU attribute defined at
12623 present. */
12624 if (tag == 32)
12625 {
f6f0e17b 12626 val = read_uleb128 (p, &len, end);
104d59d1 12627 p += len;
071436c6
NC		 12628
12629 printf (_("flag = %d, vendor = "), val);
f6f0e17b
NC		 12630 if (p == end)
12631 {
071436c6 12632 printf (_("<corrupt>\n"));
f6f0e17b
NC		 12633 warn (_("corrupt vendor attribute\n"));
12634 }
12635 else
12636 {
4082ef84
NC		 12637 if (p < end - 1)
12638 {
12639 size_t maxlen = (end - p) - 1;
071436c6 12640
4082ef84
NC		 12641 print_symbol ((int) maxlen, (const char *) p);
12642 p += strnlen ((char *) p, maxlen) + 1;
12643 }
12644 else
12645 {
12646 printf (_("<corrupt>"));
12647 p = (unsigned char *) end;
12648 }
071436c6 12649 putchar ('\n');
f6f0e17b 12650 }
104d59d1
JM		 12651 return p;
12652 }
12653
12654 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 12655 return display_proc_gnu_attribute (p, tag, end);
104d59d1 12656
f6f0e17b 12657 return display_tag_value (tag, p, end);
104d59d1
JM		 12658}
12659
34c8bcba 12660static unsigned char *
f6f0e17b
NC		 12661display_power_gnu_attribute (unsigned char * p,
12662 int tag,
12663 const unsigned char * const end)
34c8bcba 12664{
34c8bcba
JM		 12665 unsigned int len;
12666 int val;
12667
12668 if (tag == Tag_GNU_Power_ABI_FP)
12669 {
f6f0e17b 12670 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 12671 p += len;
12672 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 12673
34c8bcba
JM		 12674 switch (val)
12675 {
12676 case 0:
2b692964 12677 printf (_("Hard or soft float\n"));
34c8bcba
JM		 12678 break;
12679 case 1:
2b692964 12680 printf (_("Hard float\n"));
34c8bcba
JM		 12681 break;
12682 case 2:
2b692964 12683 printf (_("Soft float\n"));
34c8bcba 12684 break;
3c7b9897 12685 case 3:
2b692964 12686 printf (_("Single-precision hard float\n"));
3c7b9897 12687 break;
34c8bcba
JM		 12688 default:
12689 printf ("??? (%d)\n", val);
12690 break;
12691 }
12692 return p;
12693 }
12694
c6e65352
DJ		 12695 if (tag == Tag_GNU_Power_ABI_Vector)
12696 {
f6f0e17b 12697 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 12698 p += len;
12699 printf (" Tag_GNU_Power_ABI_Vector: ");
12700 switch (val)
12701 {
12702 case 0:
2b692964 12703 printf (_("Any\n"));
c6e65352
DJ		 12704 break;
12705 case 1:
2b692964 12706 printf (_("Generic\n"));
c6e65352
DJ		 12707 break;
12708 case 2:
12709 printf ("AltiVec\n");
12710 break;
12711 case 3:
12712 printf ("SPE\n");
12713 break;
12714 default:
12715 printf ("??? (%d)\n", val);
12716 break;
12717 }
12718 return p;
12719 }
12720
f82e0623
NF		 12721 if (tag == Tag_GNU_Power_ABI_Struct_Return)
12722 {
f6f0e17b
NC		 12723 if (p == end)
12724 {
071436c6 12725 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
f6f0e17b
NC		 12726 return p;
12727 }
0b4362b0 12728
f6f0e17b 12729 val = read_uleb128 (p, &len, end);
f82e0623
NF		 12730 p += len;
12731 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
12732 switch (val)
12733 {
12734 case 0:
2b692964 12735 printf (_("Any\n"));
f82e0623
NF		 12736 break;
12737 case 1:
12738 printf ("r3/r4\n");
12739 break;
12740 case 2:
2b692964 12741 printf (_("Memory\n"));
f82e0623
NF		 12742 break;
12743 default:
12744 printf ("??? (%d)\n", val);
12745 break;
12746 }
12747 return p;
12748 }
12749
f6f0e17b 12750 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 12751}
12752
9e8c70f9
DM		 12753static void
12754display_sparc_hwcaps (int mask)
12755{
12756 if (mask)
12757 {
12758 int first = 1;
071436c6 12759
9e8c70f9
DM		 12760 if (mask & ELF_SPARC_HWCAP_MUL32)
12761 fputs ("mul32", stdout), first = 0;
12762 if (mask & ELF_SPARC_HWCAP_DIV32)
12763 printf ("%sdiv32", first ? "" : "|"), first = 0;
12764 if (mask & ELF_SPARC_HWCAP_FSMULD)
12765 printf ("%sfsmuld", first ? "" : "|"), first = 0;
12766 if (mask & ELF_SPARC_HWCAP_V8PLUS)
12767 printf ("%sv8plus", first ? "" : "|"), first = 0;
12768 if (mask & ELF_SPARC_HWCAP_POPC)
12769 printf ("%spopc", first ? "" : "|"), first = 0;
12770 if (mask & ELF_SPARC_HWCAP_VIS)
12771 printf ("%svis", first ? "" : "|"), first = 0;
12772 if (mask & ELF_SPARC_HWCAP_VIS2)
12773 printf ("%svis2", first ? "" : "|"), first = 0;
12774 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
12775 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
12776 if (mask & ELF_SPARC_HWCAP_FMAF)
12777 printf ("%sfmaf", first ? "" : "|"), first = 0;
12778 if (mask & ELF_SPARC_HWCAP_VIS3)
12779 printf ("%svis3", first ? "" : "|"), first = 0;
12780 if (mask & ELF_SPARC_HWCAP_HPC)
12781 printf ("%shpc", first ? "" : "|"), first = 0;
12782 if (mask & ELF_SPARC_HWCAP_RANDOM)
12783 printf ("%srandom", first ? "" : "|"), first = 0;
12784 if (mask & ELF_SPARC_HWCAP_TRANS)
12785 printf ("%strans", first ? "" : "|"), first = 0;
12786 if (mask & ELF_SPARC_HWCAP_FJFMAU)
12787 printf ("%sfjfmau", first ? "" : "|"), first = 0;
12788 if (mask & ELF_SPARC_HWCAP_IMA)
12789 printf ("%sima", first ? "" : "|"), first = 0;
12790 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
12791 printf ("%scspare", first ? "" : "|"), first = 0;
12792 }
12793 else
071436c6
NC		 12794 fputc ('0', stdout);
12795 fputc ('\n', stdout);
9e8c70f9
DM		 12796}
12797
3d68f91c
JM		 12798static void
12799display_sparc_hwcaps2 (int mask)
12800{
12801 if (mask)
12802 {
12803 int first = 1;
071436c6 12804
3d68f91c
JM		 12805 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
12806 fputs ("fjathplus", stdout), first = 0;
12807 if (mask & ELF_SPARC_HWCAP2_VIS3B)
12808 printf ("%svis3b", first ? "" : "|"), first = 0;
12809 if (mask & ELF_SPARC_HWCAP2_ADP)
12810 printf ("%sadp", first ? "" : "|"), first = 0;
12811 if (mask & ELF_SPARC_HWCAP2_SPARC5)
12812 printf ("%ssparc5", first ? "" : "|"), first = 0;
12813 if (mask & ELF_SPARC_HWCAP2_MWAIT)
12814 printf ("%smwait", first ? "" : "|"), first = 0;
12815 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
12816 printf ("%sxmpmul", first ? "" : "|"), first = 0;
12817 if (mask & ELF_SPARC_HWCAP2_XMONT)
12818 printf ("%sxmont2", first ? "" : "|"), first = 0;
12819 if (mask & ELF_SPARC_HWCAP2_NSEC)
12820 printf ("%snsec", first ? "" : "|"), first = 0;
12821 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
12822 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
12823 if (mask & ELF_SPARC_HWCAP2_FJDES)
12824 printf ("%sfjdes", first ? "" : "|"), first = 0;
12825 if (mask & ELF_SPARC_HWCAP2_FJAES)
12826 printf ("%sfjaes", first ? "" : "|"), first = 0;
12827 }
12828 else
071436c6
NC		 12829 fputc ('0', stdout);
12830 fputc ('\n', stdout);
3d68f91c
JM		 12831}
12832
9e8c70f9 12833static unsigned char *
f6f0e17b
NC		 12834display_sparc_gnu_attribute (unsigned char * p,
12835 int tag,
12836 const unsigned char * const end)
9e8c70f9 12837{
3d68f91c
JM		 12838 unsigned int len;
12839 int val;
12840
9e8c70f9
DM		 12841 if (tag == Tag_GNU_Sparc_HWCAPS)
12842 {
f6f0e17b 12843 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 12844 p += len;
12845 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 12846 display_sparc_hwcaps (val);
12847 return p;
3d68f91c
JM		 12848 }
12849 if (tag == Tag_GNU_Sparc_HWCAPS2)
12850 {
12851 val = read_uleb128 (p, &len, end);
12852 p += len;
12853 printf (" Tag_GNU_Sparc_HWCAPS2: ");
12854 display_sparc_hwcaps2 (val);
12855 return p;
12856 }
9e8c70f9 12857
f6f0e17b 12858 return display_tag_value (tag, p, end);
9e8c70f9
DM		 12859}
12860
351cdf24
MF		 12861static void
12862print_mips_fp_abi_value (int val)
12863{
12864 switch (val)
12865 {
12866 case Val_GNU_MIPS_ABI_FP_ANY:
12867 printf (_("Hard or soft float\n"));
12868 break;
12869 case Val_GNU_MIPS_ABI_FP_DOUBLE:
12870 printf (_("Hard float (double precision)\n"));
12871 break;
12872 case Val_GNU_MIPS_ABI_FP_SINGLE:
12873 printf (_("Hard float (single precision)\n"));
12874 break;
12875 case Val_GNU_MIPS_ABI_FP_SOFT:
12876 printf (_("Soft float\n"));
12877 break;
12878 case Val_GNU_MIPS_ABI_FP_OLD_64:
12879 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12880 break;
12881 case Val_GNU_MIPS_ABI_FP_XX:
12882 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12883 break;
12884 case Val_GNU_MIPS_ABI_FP_64:
12885 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12886 break;
12887 case Val_GNU_MIPS_ABI_FP_64A:
12888 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12889 break;
12890 default:
12891 printf ("??? (%d)\n", val);
12892 break;
12893 }
12894}
12895
2cf19d5c 12896static unsigned char *
f6f0e17b
NC		 12897display_mips_gnu_attribute (unsigned char * p,
12898 int tag,
12899 const unsigned char * const end)
2cf19d5c 12900{
2cf19d5c
JM		 12901 if (tag == Tag_GNU_MIPS_ABI_FP)
12902 {
f6f0e17b
NC		 12903 unsigned int len;
12904 int val;
12905
12906 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 12907 p += len;
12908 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 12909
351cdf24
MF		 12910 print_mips_fp_abi_value (val);
12911
2cf19d5c
JM		 12912 return p;
12913 }
12914
a9f58168
CF		 12915 if (tag == Tag_GNU_MIPS_ABI_MSA)
12916 {
12917 unsigned int len;
12918 int val;
12919
12920 val = read_uleb128 (p, &len, end);
12921 p += len;
12922 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12923
12924 switch (val)
12925 {
12926 case Val_GNU_MIPS_ABI_MSA_ANY:
12927 printf (_("Any MSA or not\n"));
12928 break;
12929 case Val_GNU_MIPS_ABI_MSA_128:
12930 printf (_("128-bit MSA\n"));
12931 break;
12932 default:
12933 printf ("??? (%d)\n", val);
12934 break;
12935 }
12936 return p;
12937 }
12938
f6f0e17b 12939 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 12940}
12941
59e6276b 12942static unsigned char *
f6f0e17b
NC		 12943display_tic6x_attribute (unsigned char * p,
12944 const unsigned char * const end)
59e6276b
JM		 12945{
12946 int tag;
12947 unsigned int len;
12948 int val;
12949
f6f0e17b 12950 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 12951 p += len;
12952
12953 switch (tag)
12954 {
75fa6dc1 12955 case Tag_ISA:
f6f0e17b 12956 val = read_uleb128 (p, &len, end);
59e6276b 12957 p += len;
75fa6dc1 12958 printf (" Tag_ISA: ");
59e6276b
JM		 12959
12960 switch (val)
12961 {
75fa6dc1 12962 case C6XABI_Tag_ISA_none:
59e6276b
JM		 12963 printf (_("None\n"));
12964 break;
75fa6dc1 12965 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 12966 printf ("C62x\n");
12967 break;
75fa6dc1 12968 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 12969 printf ("C67x\n");
12970 break;
75fa6dc1 12971 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 12972 printf ("C67x+\n");
12973 break;
75fa6dc1 12974 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 12975 printf ("C64x\n");
12976 break;
75fa6dc1 12977 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 12978 printf ("C64x+\n");
12979 break;
75fa6dc1 12980 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 12981 printf ("C674x\n");
12982 break;
12983 default:
12984 printf ("??? (%d)\n", val);
12985 break;
12986 }
12987 return p;
12988
87779176 12989 case Tag_ABI_wchar_t:
f6f0e17b 12990 val = read_uleb128 (p, &len, end);
87779176
JM		 12991 p += len;
12992 printf (" Tag_ABI_wchar_t: ");
12993 switch (val)
12994 {
12995 case 0:
12996 printf (_("Not used\n"));
12997 break;
12998 case 1:
12999 printf (_("2 bytes\n"));
13000 break;
13001 case 2:
13002 printf (_("4 bytes\n"));
13003 break;
13004 default:
13005 printf ("??? (%d)\n", val);
13006 break;
13007 }
13008 return p;
13009
13010 case Tag_ABI_stack_align_needed:
f6f0e17b 13011 val = read_uleb128 (p, &len, end);
87779176
JM		 13012 p += len;
13013 printf (" Tag_ABI_stack_align_needed: ");
13014 switch (val)
13015 {
13016 case 0:
13017 printf (_("8-byte\n"));
13018 break;
13019 case 1:
13020 printf (_("16-byte\n"));
13021 break;
13022 default:
13023 printf ("??? (%d)\n", val);
13024 break;
13025 }
13026 return p;
13027
13028 case Tag_ABI_stack_align_preserved:
f6f0e17b 13029 val = read_uleb128 (p, &len, end);
87779176
JM		 13030 p += len;
13031 printf (" Tag_ABI_stack_align_preserved: ");
13032 switch (val)
13033 {
13034 case 0:
13035 printf (_("8-byte\n"));
13036 break;
13037 case 1:
13038 printf (_("16-byte\n"));
13039 break;
13040 default:
13041 printf ("??? (%d)\n", val);
13042 break;
13043 }
13044 return p;
13045
b5593623 13046 case Tag_ABI_DSBT:
f6f0e17b 13047 val = read_uleb128 (p, &len, end);
b5593623
JM		 13048 p += len;
13049 printf (" Tag_ABI_DSBT: ");
13050 switch (val)
13051 {
13052 case 0:
13053 printf (_("DSBT addressing not used\n"));
13054 break;
13055 case 1:
13056 printf (_("DSBT addressing used\n"));
13057 break;
13058 default:
13059 printf ("??? (%d)\n", val);
13060 break;
13061 }
13062 return p;
13063
87779176 13064 case Tag_ABI_PID:
f6f0e17b 13065 val = read_uleb128 (p, &len, end);
87779176
JM		 13066 p += len;
13067 printf (" Tag_ABI_PID: ");
13068 switch (val)
13069 {
13070 case 0:
13071 printf (_("Data addressing position-dependent\n"));
13072 break;
13073 case 1:
13074 printf (_("Data addressing position-independent, GOT near DP\n"));
13075 break;
13076 case 2:
13077 printf (_("Data addressing position-independent, GOT far from DP\n"));
13078 break;
13079 default:
13080 printf ("??? (%d)\n", val);
13081 break;
13082 }
13083 return p;
13084
13085 case Tag_ABI_PIC:
f6f0e17b 13086 val = read_uleb128 (p, &len, end);
87779176
JM		 13087 p += len;
13088 printf (" Tag_ABI_PIC: ");
13089 switch (val)
13090 {
13091 case 0:
13092 printf (_("Code addressing position-dependent\n"));
13093 break;
13094 case 1:
13095 printf (_("Code addressing position-independent\n"));
13096 break;
13097 default:
13098 printf ("??? (%d)\n", val);
13099 break;
13100 }
13101 return p;
13102
13103 case Tag_ABI_array_object_alignment:
f6f0e17b 13104 val = read_uleb128 (p, &len, end);
87779176
JM		 13105 p += len;
13106 printf (" Tag_ABI_array_object_alignment: ");
13107 switch (val)
13108 {
13109 case 0:
13110 printf (_("8-byte\n"));
13111 break;
13112 case 1:
13113 printf (_("4-byte\n"));
13114 break;
13115 case 2:
13116 printf (_("16-byte\n"));
13117 break;
13118 default:
13119 printf ("??? (%d)\n", val);
13120 break;
13121 }
13122 return p;
13123
13124 case Tag_ABI_array_object_align_expected:
f6f0e17b 13125 val = read_uleb128 (p, &len, end);
87779176
JM		 13126 p += len;
13127 printf (" Tag_ABI_array_object_align_expected: ");
13128 switch (val)
13129 {
13130 case 0:
13131 printf (_("8-byte\n"));
13132 break;
13133 case 1:
13134 printf (_("4-byte\n"));
13135 break;
13136 case 2:
13137 printf (_("16-byte\n"));
13138 break;
13139 default:
13140 printf ("??? (%d)\n", val);
13141 break;
13142 }
13143 return p;
13144
3cbd1c06 13145 case Tag_ABI_compatibility:
071436c6 13146 {
071436c6
NC		 13147 val = read_uleb128 (p, &len, end);
13148 p += len;
13149 printf (" Tag_ABI_compatibility: ");
071436c6 13150 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13151 if (p < end - 1)
13152 {
13153 size_t maxlen = (end - p) - 1;
13154
13155 print_symbol ((int) maxlen, (const char *) p);
13156 p += strnlen ((char *) p, maxlen) + 1;
13157 }
13158 else
13159 {
13160 printf (_("<corrupt>"));
13161 p = (unsigned char *) end;
13162 }
071436c6 13163 putchar ('\n');
071436c6
NC		 13164 return p;
13165 }
87779176
JM		 13166
13167 case Tag_ABI_conformance:
071436c6 13168 {
4082ef84
NC		 13169 printf (" Tag_ABI_conformance: \"");
13170 if (p < end - 1)
13171 {
13172 size_t maxlen = (end - p) - 1;
071436c6 13173
4082ef84
NC		 13174 print_symbol ((int) maxlen, (const char *) p);
13175 p += strnlen ((char *) p, maxlen) + 1;
13176 }
13177 else
13178 {
13179 printf (_("<corrupt>"));
13180 p = (unsigned char *) end;
13181 }
071436c6 13182 printf ("\"\n");
071436c6
NC		 13183 return p;
13184 }
59e6276b
JM		 13185 }
13186
f6f0e17b
NC		 13187 return display_tag_value (tag, p, end);
13188}
59e6276b 13189
f6f0e17b
NC		 13190static void
13191display_raw_attribute (unsigned char * p, unsigned char * end)
13192{
13193 unsigned long addr = 0;
13194 size_t bytes = end - p;
13195
e0a31db1 13196 assert (end > p);
f6f0e17b 13197 while (bytes)
87779176 13198 {
f6f0e17b
NC		 13199 int j;
13200 int k;
13201 int lbytes = (bytes > 16 ? 16 : bytes);
13202
13203 printf (" 0x%8.8lx ", addr);
13204
13205 for (j = 0; j < 16; j++)
13206 {
13207 if (j < lbytes)
13208 printf ("%2.2x", p[j]);
13209 else
13210 printf (" ");
13211
13212 if ((j & 3) == 3)
13213 printf (" ");
13214 }
13215
13216 for (j = 0; j < lbytes; j++)
13217 {
13218 k = p[j];
13219 if (k >= ' ' && k < 0x7f)
13220 printf ("%c", k);
13221 else
13222 printf (".");
13223 }
13224
13225 putchar ('\n');
13226
13227 p += lbytes;
13228 bytes -= lbytes;
13229 addr += lbytes;
87779176 13230 }
59e6276b 13231
f6f0e17b 13232 putchar ('\n');
59e6276b
JM		 13233}
13234
13761a11
NC		 13235static unsigned char *
13236display_msp430x_attribute (unsigned char * p,
13237 const unsigned char * const end)
13238{
13239 unsigned int len;
13240 int val;
13241 int tag;
13242
13243 tag = read_uleb128 (p, & len, end);
13244 p += len;
0b4362b0 13245
13761a11
NC		 13246 switch (tag)
13247 {
13248 case OFBA_MSPABI_Tag_ISA:
13249 val = read_uleb128 (p, &len, end);
13250 p += len;
13251 printf (" Tag_ISA: ");
13252 switch (val)
13253 {
13254 case 0: printf (_("None\n")); break;
13255 case 1: printf (_("MSP430\n")); break;
13256 case 2: printf (_("MSP430X\n")); break;
13257 default: printf ("??? (%d)\n", val); break;
13258 }
13259 break;
13260
13261 case OFBA_MSPABI_Tag_Code_Model:
13262 val = read_uleb128 (p, &len, end);
13263 p += len;
13264 printf (" Tag_Code_Model: ");
13265 switch (val)
13266 {
13267 case 0: printf (_("None\n")); break;
13268 case 1: printf (_("Small\n")); break;
13269 case 2: printf (_("Large\n")); break;
13270 default: printf ("??? (%d)\n", val); break;
13271 }
13272 break;
13273
13274 case OFBA_MSPABI_Tag_Data_Model:
13275 val = read_uleb128 (p, &len, end);
13276 p += len;
13277 printf (" Tag_Data_Model: ");
13278 switch (val)
13279 {
13280 case 0: printf (_("None\n")); break;
13281 case 1: printf (_("Small\n")); break;
13282 case 2: printf (_("Large\n")); break;
13283 case 3: printf (_("Restricted Large\n")); break;
13284 default: printf ("??? (%d)\n", val); break;
13285 }
13286 break;
13287
13288 default:
13289 printf (_(" <unknown tag %d>: "), tag);
13290
13291 if (tag & 1)
13292 {
071436c6 13293 putchar ('"');
4082ef84
NC		 13294 if (p < end - 1)
13295 {
13296 size_t maxlen = (end - p) - 1;
13297
13298 print_symbol ((int) maxlen, (const char *) p);
13299 p += strnlen ((char *) p, maxlen) + 1;
13300 }
13301 else
13302 {
13303 printf (_("<corrupt>"));
13304 p = (unsigned char *) end;
13305 }
071436c6 13306 printf ("\"\n");
13761a11
NC		 13307 }
13308 else
13309 {
13310 val = read_uleb128 (p, &len, end);
13311 p += len;
13312 printf ("%d (0x%x)\n", val, val);
13313 }
13314 break;
13315 }
13316
4082ef84 13317 assert (p <= end);
13761a11
NC		 13318 return p;
13319}
13320
11c1ff18 13321static int
60bca95a
NC		 13322process_attributes (FILE * file,
13323 const char * public_name,
104d59d1 13324 unsigned int proc_type,
f6f0e17b
NC		 13325 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13326 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 13327{
2cf0635d 13328 Elf_Internal_Shdr * sect;
11c1ff18
PB		 13329 unsigned i;
13330
13331 /* Find the section header so that we get the size. */
13332 for (i = 0, sect = section_headers;
13333 i < elf_header.e_shnum;
13334 i++, sect++)
13335 {
071436c6
NC		 13336 unsigned char * contents;
13337 unsigned char * p;
13338
104d59d1 13339 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 13340 continue;
13341
3f5e193b
NC		 13342 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13343 sect->sh_size, _("attributes"));
60bca95a 13344 if (contents == NULL)
11c1ff18 13345 continue;
60bca95a 13346
11c1ff18
PB		 13347 p = contents;
13348 if (*p == 'A')
13349 {
071436c6
NC		 13350 bfd_vma section_len;
13351
13352 section_len = sect->sh_size - 1;
11c1ff18 13353 p++;
60bca95a 13354
071436c6 13355 while (section_len > 0)
11c1ff18 13356 {
071436c6 13357 bfd_vma attr_len;
e9847026 13358 unsigned int namelen;
11c1ff18 13359 bfd_boolean public_section;
104d59d1 13360 bfd_boolean gnu_section;
11c1ff18 13361
071436c6 13362 if (section_len <= 4)
e0a31db1
NC		 13363 {
13364 error (_("Tag section ends prematurely\n"));
13365 break;
13366 }
071436c6 13367 attr_len = byte_get (p, 4);
11c1ff18 13368 p += 4;
60bca95a 13369
071436c6 13370 if (attr_len > section_len)
11c1ff18 13371 {
071436c6
NC		 13372 error (_("Bad attribute length (%u > %u)\n"),
13373 (unsigned) attr_len, (unsigned) section_len);
13374 attr_len = section_len;
11c1ff18 13375 }
74e1a04b 13376 /* PR 17531: file: 001-101425-0.004 */
071436c6 13377 else if (attr_len < 5)
74e1a04b 13378 {
071436c6 13379 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
74e1a04b
NC		 13380 break;
13381 }
e9847026 13382
071436c6
NC		 13383 section_len -= attr_len;
13384 attr_len -= 4;
13385
13386 namelen = strnlen ((char *) p, attr_len) + 1;
13387 if (namelen == 0 || namelen >= attr_len)
e9847026
NC		 13388 {
13389 error (_("Corrupt attribute section name\n"));
13390 break;
13391 }
13392
071436c6
NC		 13393 printf (_("Attribute Section: "));
13394 print_symbol (INT_MAX, (const char *) p);
13395 putchar ('\n');
60bca95a
NC		 13396
13397 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 13398 public_section = TRUE;
13399 else
13400 public_section = FALSE;
60bca95a
NC		 13401
13402 if (streq ((char *) p, "gnu"))
104d59d1
JM		 13403 gnu_section = TRUE;
13404 else
13405 gnu_section = FALSE;
60bca95a 13406
11c1ff18 13407 p += namelen;
071436c6 13408 attr_len -= namelen;
e0a31db1 13409
071436c6 13410 while (attr_len > 0 && p < contents + sect->sh_size)
11c1ff18 13411 {
e0a31db1 13412 int tag;
11c1ff18
PB		 13413 int val;
13414 bfd_vma size;
071436c6 13415 unsigned char * end;
60bca95a 13416
e0a31db1 13417 /* PR binutils/17531: Safe handling of corrupt files. */
071436c6 13418 if (attr_len < 6)
e0a31db1
NC		 13419 {
13420 error (_("Unused bytes at end of section\n"));
13421 section_len = 0;
13422 break;
13423 }
13424
13425 tag = *(p++);
11c1ff18 13426 size = byte_get (p, 4);
071436c6 13427 if (size > attr_len)
11c1ff18 13428 {
e9847026 13429 error (_("Bad subsection length (%u > %u)\n"),
071436c6
NC		 13430 (unsigned) size, (unsigned) attr_len);
13431 size = attr_len;
11c1ff18 13432 }
e0a31db1
NC		 13433 /* PR binutils/17531: Safe handling of corrupt files. */
13434 if (size < 6)
13435 {
13436 error (_("Bad subsection length (%u < 6)\n"),
13437 (unsigned) size);
13438 section_len = 0;
13439 break;
13440 }
60bca95a 13441
071436c6 13442 attr_len -= size;
11c1ff18 13443 end = p + size - 1;
071436c6 13444 assert (end <= contents + sect->sh_size);
11c1ff18 13445 p += 4;
60bca95a 13446
11c1ff18
PB		 13447 switch (tag)
13448 {
13449 case 1:
2b692964 13450 printf (_("File Attributes\n"));
11c1ff18
PB		 13451 break;
13452 case 2:
2b692964 13453 printf (_("Section Attributes:"));
11c1ff18
PB		 13454 goto do_numlist;
13455 case 3:
2b692964 13456 printf (_("Symbol Attributes:"));
11c1ff18
PB		 13457 do_numlist:
13458 for (;;)
13459 {
91d6fa6a 13460 unsigned int j;
60bca95a 13461
f6f0e17b 13462 val = read_uleb128 (p, &j, end);
91d6fa6a 13463 p += j;
11c1ff18
PB		 13464 if (val == 0)
13465 break;
13466 printf (" %d", val);
13467 }
13468 printf ("\n");
13469 break;
13470 default:
2b692964 13471 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 13472 public_section = FALSE;
13473 break;
13474 }
60bca95a 13475
071436c6 13476 if (public_section && display_pub_attribute != NULL)
11c1ff18
PB		 13477 {
13478 while (p < end)
f6f0e17b 13479 p = display_pub_attribute (p, end);
071436c6 13480 assert (p <= end);
104d59d1 13481 }
071436c6 13482 else if (gnu_section && display_proc_gnu_attribute != NULL)
104d59d1
JM		 13483 {
13484 while (p < end)
13485 p = display_gnu_attribute (p,
f6f0e17b
NC		 13486 display_proc_gnu_attribute,
13487 end);
071436c6 13488 assert (p <= end);
11c1ff18 13489 }
071436c6 13490 else if (p < end)
11c1ff18 13491 {
071436c6 13492 printf (_(" Unknown attribute:\n"));
f6f0e17b 13493 display_raw_attribute (p, end);
11c1ff18
PB		 13494 p = end;
13495 }
071436c6
NC		 13496 else
13497 attr_len = 0;
11c1ff18
PB		 13498 }
13499 }
13500 }
13501 else
e9847026 13502 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
d70c5fc7 13503
60bca95a 13504 free (contents);
11c1ff18
PB		 13505 }
13506 return 1;
13507}
13508
104d59d1 13509static int
2cf0635d 13510process_arm_specific (FILE * file)
104d59d1
JM		 13511{
13512 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13513 display_arm_attribute, NULL);
13514}
13515
34c8bcba 13516static int
2cf0635d 13517process_power_specific (FILE * file)
34c8bcba
JM		 13518{
13519 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13520 display_power_gnu_attribute);
13521}
13522
9e8c70f9
DM		 13523static int
13524process_sparc_specific (FILE * file)
13525{
13526 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13527 display_sparc_gnu_attribute);
13528}
13529
59e6276b
JM		 13530static int
13531process_tic6x_specific (FILE * file)
13532{
13533 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13534 display_tic6x_attribute, NULL);
13535}
13536
13761a11
NC		 13537static int
13538process_msp430x_specific (FILE * file)
13539{
13540 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13541 display_msp430x_attribute, NULL);
13542}
13543
ccb4c951
RS		 13544/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13545 Print the Address, Access and Initial fields of an entry at VMA ADDR
82b1b41b
NC		 13546 and return the VMA of the next entry, or -1 if there was a problem.
13547 Does not read from DATA_END or beyond. */
ccb4c951
RS		 13548
13549static bfd_vma
82b1b41b
NC		 13550print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
13551 unsigned char * data_end)
ccb4c951
RS		 13552{
13553 printf (" ");
13554 print_vma (addr, LONG_HEX);
13555 printf (" ");
13556 if (addr < pltgot + 0xfff0)
13557 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13558 else
13559 printf ("%10s", "");
13560 printf (" ");
13561 if (data == NULL)
2b692964 13562 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 13563 else
13564 {
13565 bfd_vma entry;
82b1b41b 13566 unsigned char * from = data + addr - pltgot;
ccb4c951 13567
82b1b41b
NC		 13568 if (from + (is_32bit_elf ? 4 : 8) > data_end)
13569 {
13570 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13571 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
13572 return (bfd_vma) -1;
13573 }
13574 else
13575 {
13576 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13577 print_vma (entry, LONG_HEX);
13578 }
ccb4c951
RS		 13579 }
13580 return addr + (is_32bit_elf ? 4 : 8);
13581}
13582
861fb55a
DJ		 13583/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13584 PLTGOT. Print the Address and Initial fields of an entry at VMA
13585 ADDR and return the VMA of the next entry. */
13586
13587static bfd_vma
2cf0635d 13588print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 13589{
13590 printf (" ");
13591 print_vma (addr, LONG_HEX);
13592 printf (" ");
13593 if (data == NULL)
2b692964 13594 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 13595 else
13596 {
13597 bfd_vma entry;
13598
13599 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13600 print_vma (entry, LONG_HEX);
13601 }
13602 return addr + (is_32bit_elf ? 4 : 8);
13603}
13604
351cdf24
MF		 13605static void
13606print_mips_ases (unsigned int mask)
13607{
13608 if (mask & AFL_ASE_DSP)
13609 fputs ("\n\tDSP ASE", stdout);
13610 if (mask & AFL_ASE_DSPR2)
13611 fputs ("\n\tDSP R2 ASE", stdout);
13612 if (mask & AFL_ASE_EVA)
13613 fputs ("\n\tEnhanced VA Scheme", stdout);
13614 if (mask & AFL_ASE_MCU)
13615 fputs ("\n\tMCU (MicroController) ASE", stdout);
13616 if (mask & AFL_ASE_MDMX)
13617 fputs ("\n\tMDMX ASE", stdout);
13618 if (mask & AFL_ASE_MIPS3D)
13619 fputs ("\n\tMIPS-3D ASE", stdout);
13620 if (mask & AFL_ASE_MT)
13621 fputs ("\n\tMT ASE", stdout);
13622 if (mask & AFL_ASE_SMARTMIPS)
13623 fputs ("\n\tSmartMIPS ASE", stdout);
13624 if (mask & AFL_ASE_VIRT)
13625 fputs ("\n\tVZ ASE", stdout);
13626 if (mask & AFL_ASE_MSA)
13627 fputs ("\n\tMSA ASE", stdout);
13628 if (mask & AFL_ASE_MIPS16)
13629 fputs ("\n\tMIPS16 ASE", stdout);
13630 if (mask & AFL_ASE_MICROMIPS)
13631 fputs ("\n\tMICROMIPS ASE", stdout);
13632 if (mask & AFL_ASE_XPA)
13633 fputs ("\n\tXPA ASE", stdout);
13634 if (mask == 0)
13635 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 13636 else if ((mask & ~AFL_ASE_MASK) != 0)
13637 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 13638}
13639
13640static void
13641print_mips_isa_ext (unsigned int isa_ext)
13642{
13643 switch (isa_ext)
13644 {
13645 case 0:
13646 fputs (_("None"), stdout);
13647 break;
13648 case AFL_EXT_XLR:
13649 fputs ("RMI XLR", stdout);
13650 break;
2c629856
N		 13651 case AFL_EXT_OCTEON3:
13652 fputs ("Cavium Networks Octeon3", stdout);
13653 break;
351cdf24
MF		 13654 case AFL_EXT_OCTEON2:
13655 fputs ("Cavium Networks Octeon2", stdout);
13656 break;
13657 case AFL_EXT_OCTEONP:
13658 fputs ("Cavium Networks OcteonP", stdout);
13659 break;
13660 case AFL_EXT_LOONGSON_3A:
13661 fputs ("Loongson 3A", stdout);
13662 break;
13663 case AFL_EXT_OCTEON:
13664 fputs ("Cavium Networks Octeon", stdout);
13665 break;
13666 case AFL_EXT_5900:
13667 fputs ("Toshiba R5900", stdout);
13668 break;
13669 case AFL_EXT_4650:
13670 fputs ("MIPS R4650", stdout);
13671 break;
13672 case AFL_EXT_4010:
13673 fputs ("LSI R4010", stdout);
13674 break;
13675 case AFL_EXT_4100:
13676 fputs ("NEC VR4100", stdout);
13677 break;
13678 case AFL_EXT_3900:
13679 fputs ("Toshiba R3900", stdout);
13680 break;
13681 case AFL_EXT_10000:
13682 fputs ("MIPS R10000", stdout);
13683 break;
13684 case AFL_EXT_SB1:
13685 fputs ("Broadcom SB-1", stdout);
13686 break;
13687 case AFL_EXT_4111:
13688 fputs ("NEC VR4111/VR4181", stdout);
13689 break;
13690 case AFL_EXT_4120:
13691 fputs ("NEC VR4120", stdout);
13692 break;
13693 case AFL_EXT_5400:
13694 fputs ("NEC VR5400", stdout);
13695 break;
13696 case AFL_EXT_5500:
13697 fputs ("NEC VR5500", stdout);
13698 break;
13699 case AFL_EXT_LOONGSON_2E:
13700 fputs ("ST Microelectronics Loongson 2E", stdout);
13701 break;
13702 case AFL_EXT_LOONGSON_2F:
13703 fputs ("ST Microelectronics Loongson 2F", stdout);
13704 break;
13705 default:
00ac7aa0 13706 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 13707 }
13708}
13709
13710static int
13711get_mips_reg_size (int reg_size)
13712{
13713 return (reg_size == AFL_REG_NONE) ? 0
13714 : (reg_size == AFL_REG_32) ? 32
13715 : (reg_size == AFL_REG_64) ? 64
13716 : (reg_size == AFL_REG_128) ? 128
13717 : -1;
13718}
13719
19e6b90e 13720static int
2cf0635d 13721process_mips_specific (FILE * file)
5b18a4bc 13722{
2cf0635d 13723 Elf_Internal_Dyn * entry;
351cdf24 13724 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 13725 size_t liblist_offset = 0;
13726 size_t liblistno = 0;
13727 size_t conflictsno = 0;
13728 size_t options_offset = 0;
13729 size_t conflicts_offset = 0;
861fb55a
DJ		 13730 size_t pltrelsz = 0;
13731 size_t pltrel = 0;
ccb4c951 13732 bfd_vma pltgot = 0;
861fb55a
DJ		 13733 bfd_vma mips_pltgot = 0;
13734 bfd_vma jmprel = 0;
ccb4c951
RS		 13735 bfd_vma local_gotno = 0;
13736 bfd_vma gotsym = 0;
13737 bfd_vma symtabno = 0;
103f02d3 13738
2cf19d5c
JM		 13739 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13740 display_mips_gnu_attribute);
13741
351cdf24
MF		 13742 sect = find_section (".MIPS.abiflags");
13743
13744 if (sect != NULL)
13745 {
13746 Elf_External_ABIFlags_v0 *abiflags_ext;
13747 Elf_Internal_ABIFlags_v0 abiflags_in;
13748
13749 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
13750 fputs ("\nCorrupt ABI Flags section.\n", stdout);
13751 else
13752 {
13753 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
13754 sect->sh_size, _("MIPS ABI Flags section"));
13755 if (abiflags_ext)
13756 {
13757 abiflags_in.version = BYTE_GET (abiflags_ext->version);
13758 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
13759 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
13760 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
13761 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
13762 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
13763 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
13764 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
13765 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
13766 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
13767 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
13768
13769 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
13770 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
13771 if (abiflags_in.isa_rev > 1)
13772 printf ("r%d", abiflags_in.isa_rev);
13773 printf ("\nGPR size: %d",
13774 get_mips_reg_size (abiflags_in.gpr_size));
13775 printf ("\nCPR1 size: %d",
13776 get_mips_reg_size (abiflags_in.cpr1_size));
13777 printf ("\nCPR2 size: %d",
13778 get_mips_reg_size (abiflags_in.cpr2_size));
13779 fputs ("\nFP ABI: ", stdout);
13780 print_mips_fp_abi_value (abiflags_in.fp_abi);
13781 fputs ("ISA Extension: ", stdout);
13782 print_mips_isa_ext (abiflags_in.isa_ext);
13783 fputs ("\nASEs:", stdout);
13784 print_mips_ases (abiflags_in.ases);
13785 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
13786 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
13787 fputc ('\n', stdout);
13788 free (abiflags_ext);
13789 }
13790 }
13791 }
13792
19e6b90e
L		 13793 /* We have a lot of special sections. Thanks SGI! */
13794 if (dynamic_section == NULL)
13795 /* No information available. */
13796 return 0;
252b5132 13797
071436c6
NC		 13798 for (entry = dynamic_section;
13799 /* PR 17531 file: 012-50589-0.004. */
13800 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
13801 ++entry)
252b5132
RH		 13802 switch (entry->d_tag)
13803 {
13804 case DT_MIPS_LIBLIST:
d93f0186
NC		 13805 liblist_offset
13806 = offset_from_vma (file, entry->d_un.d_val,
13807 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 13808 break;
13809 case DT_MIPS_LIBLISTNO:
13810 liblistno = entry->d_un.d_val;
13811 break;
13812 case DT_MIPS_OPTIONS:
d93f0186 13813 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 13814 break;
13815 case DT_MIPS_CONFLICT:
d93f0186
NC		 13816 conflicts_offset
13817 = offset_from_vma (file, entry->d_un.d_val,
13818 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 13819 break;
13820 case DT_MIPS_CONFLICTNO:
13821 conflictsno = entry->d_un.d_val;
13822 break;
ccb4c951 13823 case DT_PLTGOT:
861fb55a
DJ		 13824 pltgot = entry->d_un.d_ptr;
13825 break;
ccb4c951
RS		 13826 case DT_MIPS_LOCAL_GOTNO:
13827 local_gotno = entry->d_un.d_val;
13828 break;
13829 case DT_MIPS_GOTSYM:
13830 gotsym = entry->d_un.d_val;
13831 break;
13832 case DT_MIPS_SYMTABNO:
13833 symtabno = entry->d_un.d_val;
13834 break;
861fb55a
DJ		 13835 case DT_MIPS_PLTGOT:
13836 mips_pltgot = entry->d_un.d_ptr;
13837 break;
13838 case DT_PLTREL:
13839 pltrel = entry->d_un.d_val;
13840 break;
13841 case DT_PLTRELSZ:
13842 pltrelsz = entry->d_un.d_val;
13843 break;
13844 case DT_JMPREL:
13845 jmprel = entry->d_un.d_ptr;
13846 break;
252b5132
RH		 13847 default:
13848 break;
13849 }
13850
13851 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
13852 {
2cf0635d 13853 Elf32_External_Lib * elib;
252b5132
RH		 13854 size_t cnt;
13855
3f5e193b
NC		 13856 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
13857 liblistno,
13858 sizeof (Elf32_External_Lib),
9cf03b7e 13859 _("liblist section data"));
a6e9f9df 13860 if (elib)
252b5132 13861 {
2b692964 13862 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 13863 (unsigned long) liblistno);
2b692964 13864 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 13865 stdout);
13866
13867 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 13868 {
a6e9f9df 13869 Elf32_Lib liblist;
91d6fa6a 13870 time_t atime;
a6e9f9df 13871 char timebuf[20];
2cf0635d 13872 struct tm * tmp;
a6e9f9df
AM		 13873
13874 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 13875 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 13876 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13877 liblist.l_version = BYTE_GET (elib[cnt].l_version);
13878 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13879
91d6fa6a 13880 tmp = gmtime (&atime);
e9e44622
JJ		 13881 snprintf (timebuf, sizeof (timebuf),
13882 "%04u-%02u-%02uT%02u:%02u:%02u",
13883 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13884 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 13885
31104126 13886 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 13887 if (VALID_DYNAMIC_NAME (liblist.l_name))
13888 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
13889 else
2b692964 13890 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 13891 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
13892 liblist.l_version);
a6e9f9df
AM		 13893
13894 if (liblist.l_flags == 0)
2b692964 13895 puts (_(" NONE"));
a6e9f9df
AM		 13896 else
13897 {
13898 static const struct
252b5132 13899 {
2cf0635d 13900 const char * name;
a6e9f9df 13901 int bit;
252b5132 13902 }
a6e9f9df
AM		 13903 l_flags_vals[] =
13904 {
13905 { " EXACT_MATCH", LL_EXACT_MATCH },
13906 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
13907 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
13908 { " EXPORTS", LL_EXPORTS },
13909 { " DELAY_LOAD", LL_DELAY_LOAD },
13910 { " DELTA", LL_DELTA }
13911 };
13912 int flags = liblist.l_flags;
13913 size_t fcnt;
13914
60bca95a 13915 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 13916 if ((flags & l_flags_vals[fcnt].bit) != 0)
13917 {
13918 fputs (l_flags_vals[fcnt].name, stdout);
13919 flags ^= l_flags_vals[fcnt].bit;
13920 }
13921 if (flags != 0)
13922 printf (" %#x", (unsigned int) flags);
252b5132 13923
a6e9f9df
AM		 13924 puts ("");
13925 }
252b5132 13926 }
252b5132 13927
a6e9f9df
AM		 13928 free (elib);
13929 }
252b5132
RH		 13930 }
13931
13932 if (options_offset != 0)
13933 {
2cf0635d 13934 Elf_External_Options * eopt;
2cf0635d
NC		 13935 Elf_Internal_Options * iopt;
13936 Elf_Internal_Options * option;
252b5132
RH		 13937 size_t offset;
13938 int cnt;
351cdf24 13939 sect = section_headers;
252b5132
RH		 13940
13941 /* Find the section header so that we get the size. */
071436c6 13942 sect = find_section_by_type (SHT_MIPS_OPTIONS);
948f632f 13943 /* PR 17533 file: 012-277276-0.004. */
071436c6
NC		 13944 if (sect == NULL)
13945 {
13946 error (_("No MIPS_OPTIONS header found\n"));
13947 return 0;
13948 }
252b5132 13949
3f5e193b
NC		 13950 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
13951 sect->sh_size, _("options"));
a6e9f9df 13952 if (eopt)
252b5132 13953 {
3f5e193b
NC		 13954 iopt = (Elf_Internal_Options *)
13955 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 13956 if (iopt == NULL)
13957 {
8b73c356 13958 error (_("Out of memory allocatinf space for MIPS options\n"));
a6e9f9df
AM		 13959 return 0;
13960 }
76da6bbe 13961
a6e9f9df
AM		 13962 offset = cnt = 0;
13963 option = iopt;
252b5132 13964
82b1b41b 13965 while (offset <= sect->sh_size - sizeof (* eopt))
a6e9f9df 13966 {
2cf0635d 13967 Elf_External_Options * eoption;
252b5132 13968
a6e9f9df 13969 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 13970
a6e9f9df
AM		 13971 option->kind = BYTE_GET (eoption->kind);
13972 option->size = BYTE_GET (eoption->size);
13973 option->section = BYTE_GET (eoption->section);
13974 option->info = BYTE_GET (eoption->info);
76da6bbe 13975
82b1b41b
NC		 13976 /* PR 17531: file: ffa0fa3b. */
13977 if (option->size < sizeof (* eopt)
13978 || offset + option->size > sect->sh_size)
13979 {
55325047
NC		 13980 error (_("Invalid size (%u) for MIPS option\n"), option->size);
13981 return 0;
82b1b41b 13982 }
a6e9f9df 13983 offset += option->size;
82b1b41b 13984
a6e9f9df
AM		 13985 ++option;
13986 ++cnt;
13987 }
252b5132 13988
a6e9f9df 13989 printf (_("\nSection '%s' contains %d entries:\n"),
74e1a04b 13990 printable_section_name (sect), cnt);
76da6bbe 13991
a6e9f9df 13992 option = iopt;
82b1b41b 13993 offset = 0;
252b5132 13994
a6e9f9df 13995 while (cnt-- > 0)
252b5132 13996 {
a6e9f9df
AM		 13997 size_t len;
13998
13999 switch (option->kind)
252b5132 14000 {
a6e9f9df
AM		 14001 case ODK_NULL:
14002 /* This shouldn't happen. */
14003 printf (" NULL %d %lx", option->section, option->info);
14004 break;
14005 case ODK_REGINFO:
14006 printf (" REGINFO ");
14007 if (elf_header.e_machine == EM_MIPS)
14008 {
14009 /* 32bit form. */
2cf0635d 14010 Elf32_External_RegInfo * ereg;
b34976b6 14011 Elf32_RegInfo reginfo;
a6e9f9df
AM		 14012
14013 ereg = (Elf32_External_RegInfo *) (option + 1);
14014 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14015 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14016 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14017 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14018 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14019 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14020
14021 printf ("GPR %08lx GP 0x%lx\n",
14022 reginfo.ri_gprmask,
14023 (unsigned long) reginfo.ri_gp_value);
14024 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14025 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14026 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14027 }
14028 else
14029 {
14030 /* 64 bit form. */
2cf0635d 14031 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 14032 Elf64_Internal_RegInfo reginfo;
14033
14034 ereg = (Elf64_External_RegInfo *) (option + 1);
14035 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14036 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14037 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14038 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14039 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 14040 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 14041
14042 printf ("GPR %08lx GP 0x",
14043 reginfo.ri_gprmask);
14044 printf_vma (reginfo.ri_gp_value);
14045 printf ("\n");
14046
14047 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14048 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14049 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14050 }
14051 ++option;
14052 continue;
14053 case ODK_EXCEPTIONS:
14054 fputs (" EXCEPTIONS fpe_min(", stdout);
14055 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14056 fputs (") fpe_max(", stdout);
14057 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14058 fputs (")", stdout);
14059
14060 if (option->info & OEX_PAGE0)
14061 fputs (" PAGE0", stdout);
14062 if (option->info & OEX_SMM)
14063 fputs (" SMM", stdout);
14064 if (option->info & OEX_FPDBUG)
14065 fputs (" FPDBUG", stdout);
14066 if (option->info & OEX_DISMISS)
14067 fputs (" DISMISS", stdout);
14068 break;
14069 case ODK_PAD:
14070 fputs (" PAD ", stdout);
14071 if (option->info & OPAD_PREFIX)
14072 fputs (" PREFIX", stdout);
14073 if (option->info & OPAD_POSTFIX)
14074 fputs (" POSTFIX", stdout);
14075 if (option->info & OPAD_SYMBOL)
14076 fputs (" SYMBOL", stdout);
14077 break;
14078 case ODK_HWPATCH:
14079 fputs (" HWPATCH ", stdout);
14080 if (option->info & OHW_R4KEOP)
14081 fputs (" R4KEOP", stdout);
14082 if (option->info & OHW_R8KPFETCH)
14083 fputs (" R8KPFETCH", stdout);
14084 if (option->info & OHW_R5KEOP)
14085 fputs (" R5KEOP", stdout);
14086 if (option->info & OHW_R5KCVTL)
14087 fputs (" R5KCVTL", stdout);
14088 break;
14089 case ODK_FILL:
14090 fputs (" FILL ", stdout);
14091 /* XXX Print content of info word? */
14092 break;
14093 case ODK_TAGS:
14094 fputs (" TAGS ", stdout);
14095 /* XXX Print content of info word? */
14096 break;
14097 case ODK_HWAND:
14098 fputs (" HWAND ", stdout);
14099 if (option->info & OHWA0_R4KEOP_CHECKED)
14100 fputs (" R4KEOP_CHECKED", stdout);
14101 if (option->info & OHWA0_R4KEOP_CLEAN)
14102 fputs (" R4KEOP_CLEAN", stdout);
14103 break;
14104 case ODK_HWOR:
14105 fputs (" HWOR ", stdout);
14106 if (option->info & OHWA0_R4KEOP_CHECKED)
14107 fputs (" R4KEOP_CHECKED", stdout);
14108 if (option->info & OHWA0_R4KEOP_CLEAN)
14109 fputs (" R4KEOP_CLEAN", stdout);
14110 break;
14111 case ODK_GP_GROUP:
14112 printf (" GP_GROUP %#06lx self-contained %#06lx",
14113 option->info & OGP_GROUP,
14114 (option->info & OGP_SELF) >> 16);
14115 break;
14116 case ODK_IDENT:
14117 printf (" IDENT %#06lx self-contained %#06lx",
14118 option->info & OGP_GROUP,
14119 (option->info & OGP_SELF) >> 16);
14120 break;
14121 default:
14122 /* This shouldn't happen. */
14123 printf (" %3d ??? %d %lx",
14124 option->kind, option->section, option->info);
14125 break;
252b5132 14126 }
a6e9f9df 14127
2cf0635d 14128 len = sizeof (* eopt);
a6e9f9df 14129 while (len < option->size)
82b1b41b
NC		 14130 {
14131 char datum = * ((char *) eopt + offset + len);
a6e9f9df 14132
82b1b41b
NC		 14133 if (ISPRINT (datum))
14134 printf ("%c", datum);
14135 else
14136 printf ("\\%03o", datum);
14137 len ++;
14138 }
a6e9f9df 14139 fputs ("\n", stdout);
82b1b41b
NC		 14140
14141 offset += option->size;
252b5132 14142 ++option;
252b5132
RH		 14143 }
14144
a6e9f9df 14145 free (eopt);
252b5132 14146 }
252b5132
RH		 14147 }
14148
14149 if (conflicts_offset != 0 && conflictsno != 0)
14150 {
2cf0635d 14151 Elf32_Conflict * iconf;
252b5132
RH		 14152 size_t cnt;
14153
14154 if (dynamic_symbols == NULL)
14155 {
591a748a 14156 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 14157 return 0;
14158 }
14159
3f5e193b 14160 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 14161 if (iconf == NULL)
14162 {
8b73c356 14163 error (_("Out of memory allocating space for dynamic conflicts\n"));
252b5132
RH		 14164 return 0;
14165 }
14166
9ea033b2 14167 if (is_32bit_elf)
252b5132 14168 {
2cf0635d 14169 Elf32_External_Conflict * econf32;
a6e9f9df 14170
3f5e193b
NC		 14171 econf32 = (Elf32_External_Conflict *)
14172 get_data (NULL, file, conflicts_offset, conflictsno,
14173 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 14174 if (!econf32)
14175 return 0;
252b5132
RH		 14176
14177 for (cnt = 0; cnt < conflictsno; ++cnt)
14178 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 14179
14180 free (econf32);
252b5132
RH		 14181 }
14182 else
14183 {
2cf0635d 14184 Elf64_External_Conflict * econf64;
a6e9f9df 14185
3f5e193b
NC		 14186 econf64 = (Elf64_External_Conflict *)
14187 get_data (NULL, file, conflicts_offset, conflictsno,
14188 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 14189 if (!econf64)
14190 return 0;
252b5132
RH		 14191
14192 for (cnt = 0; cnt < conflictsno; ++cnt)
14193 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 14194
14195 free (econf64);
252b5132
RH		 14196 }
14197
c7e7ca54
NC		 14198 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14199 (unsigned long) conflictsno);
252b5132
RH		 14200 puts (_(" Num: Index Value Name"));
14201
14202 for (cnt = 0; cnt < conflictsno; ++cnt)
14203 {
b34976b6 14204 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 14205
14206 if (iconf[cnt] >= num_dynamic_syms)
14207 printf (_("<corrupt symbol index>"));
d79b3d50 14208 else
e0a31db1
NC		 14209 {
14210 Elf_Internal_Sym * psym;
14211
14212 psym = & dynamic_symbols[iconf[cnt]];
14213 print_vma (psym->st_value, FULL_HEX);
14214 putchar (' ');
14215 if (VALID_DYNAMIC_NAME (psym->st_name))
14216 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14217 else
14218 printf (_("<corrupt: %14ld>"), psym->st_name);
14219 }
31104126 14220 putchar ('\n');
252b5132
RH		 14221 }
14222
252b5132
RH		 14223 free (iconf);
14224 }
14225
ccb4c951
RS		 14226 if (pltgot != 0 && local_gotno != 0)
14227 {
91d6fa6a 14228 bfd_vma ent, local_end, global_end;
bbeee7ea 14229 size_t i, offset;
2cf0635d 14230 unsigned char * data;
82b1b41b 14231 unsigned char * data_end;
bbeee7ea 14232 int addr_size;
ccb4c951 14233
91d6fa6a 14234 ent = pltgot;
ccb4c951
RS		 14235 addr_size = (is_32bit_elf ? 4 : 8);
14236 local_end = pltgot + local_gotno * addr_size;
ccb4c951 14237
74e1a04b
NC		 14238 /* PR binutils/17533 file: 012-111227-0.004 */
14239 if (symtabno < gotsym)
14240 {
14241 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
82b1b41b 14242 (unsigned long) gotsym, (unsigned long) symtabno);
74e1a04b
NC		 14243 return 0;
14244 }
82b1b41b 14245
74e1a04b 14246 global_end = local_end + (symtabno - gotsym) * addr_size;
82b1b41b
NC		 14247 /* PR 17531: file: 54c91a34. */
14248 if (global_end < local_end)
14249 {
14250 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14251 return 0;
14252 }
948f632f 14253
ccb4c951 14254 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 14255 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 14256 global_end - pltgot, 1,
14257 _("Global Offset Table data"));
59245841
NC		 14258 if (data == NULL)
14259 return 0;
82b1b41b 14260 data_end = data + (global_end - pltgot);
59245841 14261
ccb4c951
RS		 14262 printf (_("\nPrimary GOT:\n"));
14263 printf (_(" Canonical gp value: "));
14264 print_vma (pltgot + 0x7ff0, LONG_HEX);
14265 printf ("\n\n");
14266
14267 printf (_(" Reserved entries:\n"));
14268 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 14269 addr_size * 2, _("Address"), _("Access"),
14270 addr_size * 2, _("Initial"));
82b1b41b 14271 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14272 printf (_(" Lazy resolver\n"));
82b1b41b
NC		 14273 if (ent == (bfd_vma) -1)
14274 goto got_print_fail;
ccb4c951 14275 if (data
91d6fa6a 14276 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 14277 >> (addr_size * 8 - 1)) != 0)
14278 {
82b1b41b 14279 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14280 printf (_(" Module pointer (GNU extension)\n"));
82b1b41b
NC		 14281 if (ent == (bfd_vma) -1)
14282 goto got_print_fail;
ccb4c951
RS		 14283 }
14284 printf ("\n");
14285
91d6fa6a 14286 if (ent < local_end)
ccb4c951
RS		 14287 {
14288 printf (_(" Local entries:\n"));
cc5914eb 14289 printf (" %*s %10s %*s\n",
2b692964
NC		 14290 addr_size * 2, _("Address"), _("Access"),
14291 addr_size * 2, _("Initial"));
91d6fa6a 14292 while (ent < local_end)
ccb4c951 14293 {
82b1b41b 14294 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14295 printf ("\n");
82b1b41b
NC		 14296 if (ent == (bfd_vma) -1)
14297 goto got_print_fail;
ccb4c951
RS		 14298 }
14299 printf ("\n");
14300 }
14301
14302 if (gotsym < symtabno)
14303 {
14304 int sym_width;
14305
14306 printf (_(" Global entries:\n"));
cc5914eb 14307 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 14308 addr_size * 2, _("Address"),
14309 _("Access"),
2b692964 14310 addr_size * 2, _("Initial"),
9cf03b7e
NC		 14311 addr_size * 2, _("Sym.Val."),
14312 _("Type"),
14313 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14314 _("Ndx"), _("Name"));
0b4362b0 14315
ccb4c951 14316 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 14317
ccb4c951
RS		 14318 for (i = gotsym; i < symtabno; i++)
14319 {
82b1b41b 14320 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14321 printf (" ");
e0a31db1
NC		 14322
14323 if (dynamic_symbols == NULL)
14324 printf (_("<no dynamic symbols>"));
14325 else if (i < num_dynamic_syms)
14326 {
14327 Elf_Internal_Sym * psym = dynamic_symbols + i;
14328
14329 print_vma (psym->st_value, LONG_HEX);
14330 printf (" %-7s %3s ",
14331 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14332 get_symbol_index_type (psym->st_shndx));
14333
14334 if (VALID_DYNAMIC_NAME (psym->st_name))
14335 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14336 else
14337 printf (_("<corrupt: %14ld>"), psym->st_name);
14338 }
ccb4c951 14339 else
7fc5ac57
JBG		 14340 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14341 (unsigned long) i);
e0a31db1 14342
ccb4c951 14343 printf ("\n");
82b1b41b
NC		 14344 if (ent == (bfd_vma) -1)
14345 break;
ccb4c951
RS		 14346 }
14347 printf ("\n");
14348 }
14349
82b1b41b 14350 got_print_fail:
ccb4c951
RS		 14351 if (data)
14352 free (data);
14353 }
14354
861fb55a
DJ		 14355 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14356 {
91d6fa6a 14357 bfd_vma ent, end;
861fb55a
DJ		 14358 size_t offset, rel_offset;
14359 unsigned long count, i;
2cf0635d 14360 unsigned char * data;
861fb55a 14361 int addr_size, sym_width;
2cf0635d 14362 Elf_Internal_Rela * rels;
861fb55a
DJ		 14363
14364 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14365 if (pltrel == DT_RELA)
14366 {
14367 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14368 return 0;
14369 }
14370 else
14371 {
14372 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14373 return 0;
14374 }
14375
91d6fa6a 14376 ent = mips_pltgot;
861fb55a
DJ		 14377 addr_size = (is_32bit_elf ? 4 : 8);
14378 end = mips_pltgot + (2 + count) * addr_size;
14379
14380 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 14381 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 14382 1, _("Procedure Linkage Table data"));
59245841
NC		 14383 if (data == NULL)
14384 return 0;
14385
9cf03b7e 14386 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 14387 printf (_(" Reserved entries:\n"));
14388 printf (_(" %*s %*s Purpose\n"),
2b692964 14389 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 14390 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14391 printf (_(" PLT lazy resolver\n"));
91d6fa6a 14392 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14393 printf (_(" Module pointer\n"));
861fb55a
DJ		 14394 printf ("\n");
14395
14396 printf (_(" Entries:\n"));
cc5914eb 14397 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 14398 addr_size * 2, _("Address"),
14399 addr_size * 2, _("Initial"),
14400 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 14401 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14402 for (i = 0; i < count; i++)
14403 {
df97ab2a 14404 unsigned long idx = get_reloc_symindex (rels[i].r_info);
861fb55a 14405
91d6fa6a 14406 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 14407 printf (" ");
e0a31db1 14408
df97ab2a
MF		 14409 if (idx >= num_dynamic_syms)
14410 printf (_("<corrupt symbol index: %lu>"), idx);
861fb55a 14411 else
e0a31db1 14412 {
df97ab2a 14413 Elf_Internal_Sym * psym = dynamic_symbols + idx;
e0a31db1
NC		 14414
14415 print_vma (psym->st_value, LONG_HEX);
14416 printf (" %-7s %3s ",
14417 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14418 get_symbol_index_type (psym->st_shndx));
14419 if (VALID_DYNAMIC_NAME (psym->st_name))
14420 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14421 else
14422 printf (_("<corrupt: %14ld>"), psym->st_name);
14423 }
861fb55a
DJ		 14424 printf ("\n");
14425 }
14426 printf ("\n");
14427
14428 if (data)
14429 free (data);
14430 free (rels);
14431 }
14432
252b5132
RH		 14433 return 1;
14434}
14435
35c08157
KLC		 14436static int
14437process_nds32_specific (FILE * file)
14438{
14439 Elf_Internal_Shdr *sect = NULL;
14440
14441 sect = find_section (".nds32_e_flags");
14442 if (sect != NULL)
14443 {
14444 unsigned int *flag;
14445
14446 printf ("\nNDS32 elf flags section:\n");
14447 flag = get_data (NULL, file, sect->sh_offset, 1,
14448 sect->sh_size, _("NDS32 elf flags section"));
14449
14450 switch ((*flag) & 0x3)
14451 {
14452 case 0:
14453 printf ("(VEC_SIZE):\tNo entry.\n");
14454 break;
14455 case 1:
14456 printf ("(VEC_SIZE):\t4 bytes\n");
14457 break;
14458 case 2:
14459 printf ("(VEC_SIZE):\t16 bytes\n");
14460 break;
14461 case 3:
14462 printf ("(VEC_SIZE):\treserved\n");
14463 break;
14464 }
14465 }
14466
14467 return TRUE;
14468}
14469
047b2264 14470static int
2cf0635d 14471process_gnu_liblist (FILE * file)
047b2264 14472{
2cf0635d
NC		 14473 Elf_Internal_Shdr * section;
14474 Elf_Internal_Shdr * string_sec;
14475 Elf32_External_Lib * elib;
14476 char * strtab;
c256ffe7 14477 size_t strtab_size;
047b2264
JJ		 14478 size_t cnt;
14479 unsigned i;
14480
14481 if (! do_arch)
14482 return 0;
14483
14484 for (i = 0, section = section_headers;
14485 i < elf_header.e_shnum;
b34976b6 14486 i++, section++)
047b2264
JJ		 14487 {
14488 switch (section->sh_type)
14489 {
14490 case SHT_GNU_LIBLIST:
4fbb74a6 14491 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 14492 break;
14493
3f5e193b
NC		 14494 elib = (Elf32_External_Lib *)
14495 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 14496 _("liblist section data"));
047b2264
JJ		 14497
14498 if (elib == NULL)
14499 break;
4fbb74a6 14500 string_sec = section_headers + section->sh_link;
047b2264 14501
3f5e193b
NC		 14502 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14503 string_sec->sh_size,
14504 _("liblist string table"));
047b2264
JJ		 14505 if (strtab == NULL
14506 || section->sh_entsize != sizeof (Elf32_External_Lib))
14507 {
14508 free (elib);
2842702f 14509 free (strtab);
047b2264
JJ		 14510 break;
14511 }
59245841 14512 strtab_size = string_sec->sh_size;
047b2264
JJ		 14513
14514 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
74e1a04b 14515 printable_section_name (section),
0af1713e 14516 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 14517
2b692964 14518 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 14519
14520 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14521 ++cnt)
14522 {
14523 Elf32_Lib liblist;
91d6fa6a 14524 time_t atime;
047b2264 14525 char timebuf[20];
2cf0635d 14526 struct tm * tmp;
047b2264
JJ		 14527
14528 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14529 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 14530 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14531 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14532 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14533
91d6fa6a 14534 tmp = gmtime (&atime);
e9e44622
JJ		 14535 snprintf (timebuf, sizeof (timebuf),
14536 "%04u-%02u-%02uT%02u:%02u:%02u",
14537 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14538 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 14539
14540 printf ("%3lu: ", (unsigned long) cnt);
14541 if (do_wide)
c256ffe7 14542 printf ("%-20s", liblist.l_name < strtab_size
2b692964 14543 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 14544 else
c256ffe7 14545 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 14546 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 14547 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14548 liblist.l_version, liblist.l_flags);
14549 }
14550
14551 free (elib);
2842702f 14552 free (strtab);
047b2264
JJ		 14553 }
14554 }
14555
14556 return 1;
14557}
14558
9437c45b 14559static const char *
d3ba0551 14560get_note_type (unsigned e_type)
779fe533
NC		 14561{
14562 static char buff[64];
103f02d3 14563
1ec5cd37
NC		 14564 if (elf_header.e_type == ET_CORE)
14565 switch (e_type)
14566 {
57346661 14567 case NT_AUXV:
1ec5cd37 14568 return _("NT_AUXV (auxiliary vector)");
57346661 14569 case NT_PRSTATUS:
1ec5cd37 14570 return _("NT_PRSTATUS (prstatus structure)");
57346661 14571 case NT_FPREGSET:
1ec5cd37 14572 return _("NT_FPREGSET (floating point registers)");
57346661 14573 case NT_PRPSINFO:
1ec5cd37 14574 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 14575 case NT_TASKSTRUCT:
1ec5cd37 14576 return _("NT_TASKSTRUCT (task structure)");
57346661 14577 case NT_PRXFPREG:
1ec5cd37 14578 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 14579 case NT_PPC_VMX:
14580 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 14581 case NT_PPC_VSX:
14582 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 14583 case NT_386_TLS:
14584 return _("NT_386_TLS (x86 TLS information)");
14585 case NT_386_IOPERM:
14586 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 14587 case NT_X86_XSTATE:
14588 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 14589 case NT_S390_HIGH_GPRS:
14590 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 14591 case NT_S390_TIMER:
14592 return _("NT_S390_TIMER (s390 timer register)");
14593 case NT_S390_TODCMP:
14594 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14595 case NT_S390_TODPREG:
14596 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14597 case NT_S390_CTRS:
14598 return _("NT_S390_CTRS (s390 control registers)");
14599 case NT_S390_PREFIX:
14600 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 14601 case NT_S390_LAST_BREAK:
14602 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14603 case NT_S390_SYSTEM_CALL:
14604 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 14605 case NT_S390_TDB:
14606 return _("NT_S390_TDB (s390 transaction diagnostic block)");
4ef9f41a
AA		 14607 case NT_S390_VXRS_LOW:
14608 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
14609 case NT_S390_VXRS_HIGH:
14610 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
faa9a424
UW		 14611 case NT_ARM_VFP:
14612 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 14613 case NT_ARM_TLS:
14614 return _("NT_ARM_TLS (AArch TLS registers)");
14615 case NT_ARM_HW_BREAK:
14616 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14617 case NT_ARM_HW_WATCH:
14618 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 14619 case NT_PSTATUS:
1ec5cd37 14620 return _("NT_PSTATUS (pstatus structure)");
57346661 14621 case NT_FPREGS:
1ec5cd37 14622 return _("NT_FPREGS (floating point registers)");
57346661 14623 case NT_PSINFO:
1ec5cd37 14624 return _("NT_PSINFO (psinfo structure)");
57346661 14625 case NT_LWPSTATUS:
1ec5cd37 14626 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 14627 case NT_LWPSINFO:
1ec5cd37 14628 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 14629 case NT_WIN32PSTATUS:
1ec5cd37 14630 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 14631 case NT_SIGINFO:
14632 return _("NT_SIGINFO (siginfo_t data)");
14633 case NT_FILE:
14634 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 14635 default:
14636 break;
14637 }
14638 else
14639 switch (e_type)
14640 {
14641 case NT_VERSION:
14642 return _("NT_VERSION (version)");
14643 case NT_ARCH:
14644 return _("NT_ARCH (architecture)");
14645 default:
14646 break;
14647 }
14648
e9e44622 14649 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 14650 return buff;
779fe533
NC		 14651}
14652
9ece1fa9
TT		 14653static int
14654print_core_note (Elf_Internal_Note *pnote)
14655{
14656 unsigned int addr_size = is_32bit_elf ? 4 : 8;
14657 bfd_vma count, page_size;
14658 unsigned char *descdata, *filenames, *descend;
14659
14660 if (pnote->type != NT_FILE)
14661 return 1;
14662
14663#ifndef BFD64
14664 if (!is_32bit_elf)
14665 {
14666 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
14667 /* Still "successful". */
14668 return 1;
14669 }
14670#endif
14671
14672 if (pnote->descsz < 2 * addr_size)
14673 {
14674 printf (_(" Malformed note - too short for header\n"));
14675 return 0;
14676 }
14677
14678 descdata = (unsigned char *) pnote->descdata;
14679 descend = descdata + pnote->descsz;
14680
14681 if (descdata[pnote->descsz - 1] != '\0')
14682 {
14683 printf (_(" Malformed note - does not end with \\0\n"));
14684 return 0;
14685 }
14686
14687 count = byte_get (descdata, addr_size);
14688 descdata += addr_size;
14689
14690 page_size = byte_get (descdata, addr_size);
14691 descdata += addr_size;
14692
14693 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
14694 {
14695 printf (_(" Malformed note - too short for supplied file count\n"));
14696 return 0;
14697 }
14698
14699 printf (_(" Page size: "));
14700 print_vma (page_size, DEC);
14701 printf ("\n");
14702
14703 printf (_(" %*s%*s%*s\n"),
14704 (int) (2 + 2 * addr_size), _("Start"),
14705 (int) (4 + 2 * addr_size), _("End"),
14706 (int) (4 + 2 * addr_size), _("Page Offset"));
14707 filenames = descdata + count * 3 * addr_size;
14708 while (--count > 0)
14709 {
14710 bfd_vma start, end, file_ofs;
14711
14712 if (filenames == descend)
14713 {
14714 printf (_(" Malformed note - filenames end too early\n"));
14715 return 0;
14716 }
14717
14718 start = byte_get (descdata, addr_size);
14719 descdata += addr_size;
14720 end = byte_get (descdata, addr_size);
14721 descdata += addr_size;
14722 file_ofs = byte_get (descdata, addr_size);
14723 descdata += addr_size;
14724
14725 printf (" ");
14726 print_vma (start, FULL_HEX);
14727 printf (" ");
14728 print_vma (end, FULL_HEX);
14729 printf (" ");
14730 print_vma (file_ofs, FULL_HEX);
14731 printf ("\n %s\n", filenames);
14732
14733 filenames += 1 + strlen ((char *) filenames);
14734 }
14735
14736 return 1;
14737}
14738
1118d252
RM		 14739static const char *
14740get_gnu_elf_note_type (unsigned e_type)
14741{
14742 static char buff[64];
14743
14744 switch (e_type)
14745 {
14746 case NT_GNU_ABI_TAG:
14747 return _("NT_GNU_ABI_TAG (ABI version tag)");
14748 case NT_GNU_HWCAP:
14749 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
14750 case NT_GNU_BUILD_ID:
14751 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 14752 case NT_GNU_GOLD_VERSION:
14753 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 14754 default:
14755 break;
14756 }
14757
14758 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14759 return buff;
14760}
14761
664f90a3
TT		 14762static int
14763print_gnu_note (Elf_Internal_Note *pnote)
14764{
14765 switch (pnote->type)
14766 {
14767 case NT_GNU_BUILD_ID:
14768 {
14769 unsigned long i;
14770
14771 printf (_(" Build ID: "));
14772 for (i = 0; i < pnote->descsz; ++i)
14773 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 14774 printf ("\n");
664f90a3
TT		 14775 }
14776 break;
14777
14778 case NT_GNU_ABI_TAG:
14779 {
14780 unsigned long os, major, minor, subminor;
14781 const char *osname;
14782
3102e897
NC		 14783 /* PR 17531: file: 030-599401-0.004. */
14784 if (pnote->descsz < 16)
14785 {
14786 printf (_(" <corrupt GNU_ABI_TAG>\n"));
14787 break;
14788 }
14789
664f90a3
TT		 14790 os = byte_get ((unsigned char *) pnote->descdata, 4);
14791 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
14792 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
14793 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
14794
14795 switch (os)
14796 {
14797 case GNU_ABI_TAG_LINUX:
14798 osname = "Linux";
14799 break;
14800 case GNU_ABI_TAG_HURD:
14801 osname = "Hurd";
14802 break;
14803 case GNU_ABI_TAG_SOLARIS:
14804 osname = "Solaris";
14805 break;
14806 case GNU_ABI_TAG_FREEBSD:
14807 osname = "FreeBSD";
14808 break;
14809 case GNU_ABI_TAG_NETBSD:
14810 osname = "NetBSD";
14811 break;
14812 default:
14813 osname = "Unknown";
14814 break;
14815 }
14816
14817 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
14818 major, minor, subminor);
14819 }
14820 break;
926c5385
CC		 14821
14822 case NT_GNU_GOLD_VERSION:
14823 {
14824 unsigned long i;
14825
14826 printf (_(" Version: "));
14827 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
14828 printf ("%c", pnote->descdata[i]);
14829 printf ("\n");
14830 }
14831 break;
664f90a3
TT		 14832 }
14833
14834 return 1;
14835}
14836
685080f2
NC		 14837static const char *
14838get_v850_elf_note_type (enum v850_notes n_type)
14839{
14840 static char buff[64];
14841
14842 switch (n_type)
14843 {
14844 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
14845 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
14846 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
14847 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
14848 case V850_NOTE_CACHE_INFO: return _("Use of cache");
14849 case V850_NOTE_MMU_INFO: return _("Use of MMU");
14850 default:
14851 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
14852 return buff;
14853 }
14854}
14855
14856static int
14857print_v850_note (Elf_Internal_Note * pnote)
14858{
14859 unsigned int val;
14860
14861 if (pnote->descsz != 4)
14862 return 0;
14863 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
14864
14865 if (val == 0)
14866 {
14867 printf (_("not set\n"));
14868 return 1;
14869 }
14870
14871 switch (pnote->type)
14872 {
14873 case V850_NOTE_ALIGNMENT:
14874 switch (val)
14875 {
14876 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
14877 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
14878 }
14879 break;
14880
14881 case V850_NOTE_DATA_SIZE:
14882 switch (val)
14883 {
14884 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
14885 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
14886 }
14887 break;
14888
14889 case V850_NOTE_FPU_INFO:
14890 switch (val)
14891 {
14892 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
14893 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
14894 }
14895 break;
14896
14897 case V850_NOTE_MMU_INFO:
14898 case V850_NOTE_CACHE_INFO:
14899 case V850_NOTE_SIMD_INFO:
14900 if (val == EF_RH850_SIMD)
14901 {
14902 printf (_("yes\n"));
14903 return 1;
14904 }
14905 break;
14906
14907 default:
14908 /* An 'unknown note type' message will already have been displayed. */
14909 break;
14910 }
14911
14912 printf (_("unknown value: %x\n"), val);
14913 return 0;
14914}
14915
9437c45b 14916static const char *
d3ba0551 14917get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 14918{
14919 static char buff[64];
14920
b4db1224 14921 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 14922 {
14923 /* NetBSD core "procinfo" structure. */
14924 return _("NetBSD procinfo structure");
14925 }
14926
14927 /* As of Jan 2002 there are no other machine-independent notes
14928 defined for NetBSD core files. If the note type is less
14929 than the start of the machine-dependent note types, we don't
14930 understand it. */
14931
b4db1224 14932 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 14933 {
e9e44622 14934 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 14935 return buff;
14936 }
14937
14938 switch (elf_header.e_machine)
14939 {
14940 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
14941 and PT_GETFPREGS == mach+2. */
14942
14943 case EM_OLD_ALPHA:
14944 case EM_ALPHA:
14945 case EM_SPARC:
14946 case EM_SPARC32PLUS:
14947 case EM_SPARCV9:
14948 switch (e_type)
14949 {
2b692964 14950 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 14951 return _("PT_GETREGS (reg structure)");
2b692964 14952 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 14953 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 14954 default:
14955 break;
14956 }
14957 break;
14958
14959 /* On all other arch's, PT_GETREGS == mach+1 and
14960 PT_GETFPREGS == mach+3. */
14961 default:
14962 switch (e_type)
14963 {
2b692964 14964 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 14965 return _("PT_GETREGS (reg structure)");
2b692964 14966 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 14967 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 14968 default:
14969 break;
14970 }
14971 }
14972
9cf03b7e 14973 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 14974 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 14975 return buff;
14976}
14977
70616151
TT		 14978static const char *
14979get_stapsdt_note_type (unsigned e_type)
14980{
14981 static char buff[64];
14982
14983 switch (e_type)
14984 {
14985 case NT_STAPSDT:
14986 return _("NT_STAPSDT (SystemTap probe descriptors)");
14987
14988 default:
14989 break;
14990 }
14991
14992 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14993 return buff;
14994}
14995
c6a9fc58
TT		 14996static int
14997print_stapsdt_note (Elf_Internal_Note *pnote)
14998{
14999 int addr_size = is_32bit_elf ? 4 : 8;
15000 char *data = pnote->descdata;
15001 char *data_end = pnote->descdata + pnote->descsz;
15002 bfd_vma pc, base_addr, semaphore;
15003 char *provider, *probe, *arg_fmt;
15004
15005 pc = byte_get ((unsigned char *) data, addr_size);
15006 data += addr_size;
15007 base_addr = byte_get ((unsigned char *) data, addr_size);
15008 data += addr_size;
15009 semaphore = byte_get ((unsigned char *) data, addr_size);
15010 data += addr_size;
15011
15012 provider = data;
15013 data += strlen (data) + 1;
15014 probe = data;
15015 data += strlen (data) + 1;
15016 arg_fmt = data;
15017 data += strlen (data) + 1;
15018
15019 printf (_(" Provider: %s\n"), provider);
15020 printf (_(" Name: %s\n"), probe);
15021 printf (_(" Location: "));
15022 print_vma (pc, FULL_HEX);
15023 printf (_(", Base: "));
15024 print_vma (base_addr, FULL_HEX);
15025 printf (_(", Semaphore: "));
15026 print_vma (semaphore, FULL_HEX);
9cf03b7e 15027 printf ("\n");
c6a9fc58
TT		 15028 printf (_(" Arguments: %s\n"), arg_fmt);
15029
15030 return data == data_end;
15031}
15032
00e98fc7
TG		 15033static const char *
15034get_ia64_vms_note_type (unsigned e_type)
15035{
15036 static char buff[64];
15037
15038 switch (e_type)
15039 {
15040 case NT_VMS_MHD:
15041 return _("NT_VMS_MHD (module header)");
15042 case NT_VMS_LNM:
15043 return _("NT_VMS_LNM (language name)");
15044 case NT_VMS_SRC:
15045 return _("NT_VMS_SRC (source files)");
15046 case NT_VMS_TITLE:
9cf03b7e 15047 return "NT_VMS_TITLE";
00e98fc7
TG		 15048 case NT_VMS_EIDC:
15049 return _("NT_VMS_EIDC (consistency check)");
15050 case NT_VMS_FPMODE:
15051 return _("NT_VMS_FPMODE (FP mode)");
15052 case NT_VMS_LINKTIME:
9cf03b7e 15053 return "NT_VMS_LINKTIME";
00e98fc7
TG		 15054 case NT_VMS_IMGNAM:
15055 return _("NT_VMS_IMGNAM (image name)");
15056 case NT_VMS_IMGID:
15057 return _("NT_VMS_IMGID (image id)");
15058 case NT_VMS_LINKID:
15059 return _("NT_VMS_LINKID (link id)");
15060 case NT_VMS_IMGBID:
15061 return _("NT_VMS_IMGBID (build id)");
15062 case NT_VMS_GSTNAM:
15063 return _("NT_VMS_GSTNAM (sym table name)");
15064 case NT_VMS_ORIG_DYN:
9cf03b7e 15065 return "NT_VMS_ORIG_DYN";
00e98fc7 15066 case NT_VMS_PATCHTIME:
9cf03b7e 15067 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 15068 default:
15069 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15070 return buff;
15071 }
15072}
15073
15074static int
15075print_ia64_vms_note (Elf_Internal_Note * pnote)
15076{
15077 switch (pnote->type)
15078 {
15079 case NT_VMS_MHD:
15080 if (pnote->descsz > 36)
15081 {
15082 size_t l = strlen (pnote->descdata + 34);
15083 printf (_(" Creation date : %.17s\n"), pnote->descdata);
15084 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
15085 printf (_(" Module name : %s\n"), pnote->descdata + 34);
15086 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
15087 }
15088 else
15089 printf (_(" Invalid size\n"));
15090 break;
15091 case NT_VMS_LNM:
15092 printf (_(" Language: %s\n"), pnote->descdata);
15093 break;
15094#ifdef BFD64
15095 case NT_VMS_FPMODE:
9cf03b7e 15096 printf (_(" Floating Point mode: "));
4a5cb34f 15097 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15098 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
00e98fc7
TG		 15099 break;
15100 case NT_VMS_LINKTIME:
15101 printf (_(" Link time: "));
15102 print_vms_time
15103 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15104 printf ("\n");
15105 break;
15106 case NT_VMS_PATCHTIME:
15107 printf (_(" Patch time: "));
15108 print_vms_time
15109 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15110 printf ("\n");
15111 break;
15112 case NT_VMS_ORIG_DYN:
15113 printf (_(" Major id: %u, minor id: %u\n"),
15114 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15115 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 15116 printf (_(" Last modified : "));
00e98fc7
TG		 15117 print_vms_time
15118 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 15119 printf (_("\n Link flags : "));
4a5cb34f 15120 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15121 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
00e98fc7 15122 printf (_(" Header flags: 0x%08x\n"),
948f632f 15123 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
00e98fc7
TG		 15124 printf (_(" Image id : %s\n"), pnote->descdata + 32);
15125 break;
15126#endif
15127 case NT_VMS_IMGNAM:
15128 printf (_(" Image name: %s\n"), pnote->descdata);
15129 break;
15130 case NT_VMS_GSTNAM:
15131 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
15132 break;
15133 case NT_VMS_IMGID:
15134 printf (_(" Image id: %s\n"), pnote->descdata);
15135 break;
15136 case NT_VMS_LINKID:
15137 printf (_(" Linker id: %s\n"), pnote->descdata);
15138 break;
15139 default:
15140 break;
15141 }
15142 return 1;
15143}
15144
6d118b09
NC		 15145/* Note that by the ELF standard, the name field is already null byte
15146 terminated, and namesz includes the terminating null byte.
15147 I.E. the value of namesz for the name "FSF" is 4.
15148
e3c8793a 15149 If the value of namesz is zero, there is no name present. */
779fe533 15150static int
2cf0635d 15151process_note (Elf_Internal_Note * pnote)
779fe533 15152{
2cf0635d
NC		 15153 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15154 const char * nt;
9437c45b
JT		 15155
15156 if (pnote->namesz == 0)
1ec5cd37
NC		 15157 /* If there is no note name, then use the default set of
15158 note type strings. */
15159 nt = get_note_type (pnote->type);
15160
1118d252
RM		 15161 else if (const_strneq (pnote->namedata, "GNU"))
15162 /* GNU-specific object file notes. */
15163 nt = get_gnu_elf_note_type (pnote->type);
15164
0112cd26 15165 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 15166 /* NetBSD-specific core file notes. */
15167 nt = get_netbsd_elfcore_note_type (pnote->type);
15168
b15fa79e
AM		 15169 else if (strneq (pnote->namedata, "SPU/", 4))
15170 {
15171 /* SPU-specific core file notes. */
15172 nt = pnote->namedata + 4;
15173 name = "SPU";
15174 }
15175
00e98fc7
TG		 15176 else if (const_strneq (pnote->namedata, "IPF/VMS"))
15177 /* VMS/ia64-specific file notes. */
15178 nt = get_ia64_vms_note_type (pnote->type);
15179
70616151
TT		 15180 else if (const_strneq (pnote->namedata, "stapsdt"))
15181 nt = get_stapsdt_note_type (pnote->type);
15182
9437c45b 15183 else
1ec5cd37
NC		 15184 /* Don't recognize this note name; just use the default set of
15185 note type strings. */
00e98fc7 15186 nt = get_note_type (pnote->type);
9437c45b 15187
2aee03ae 15188 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 15189
15190 if (const_strneq (pnote->namedata, "IPF/VMS"))
15191 return print_ia64_vms_note (pnote);
664f90a3
TT		 15192 else if (const_strneq (pnote->namedata, "GNU"))
15193 return print_gnu_note (pnote);
c6a9fc58
TT		 15194 else if (const_strneq (pnote->namedata, "stapsdt"))
15195 return print_stapsdt_note (pnote);
9ece1fa9
TT		 15196 else if (const_strneq (pnote->namedata, "CORE"))
15197 return print_core_note (pnote);
00e98fc7
TG		 15198 else
15199 return 1;
779fe533
NC		 15200}
15201
6d118b09 15202
779fe533 15203static int
2cf0635d 15204process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 15205{
2cf0635d
NC		 15206 Elf_External_Note * pnotes;
15207 Elf_External_Note * external;
b34976b6 15208 int res = 1;
103f02d3 15209
779fe533
NC		 15210 if (length <= 0)
15211 return 0;
103f02d3 15212
3f5e193b 15213 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 15214 _("notes"));
dd24e3da 15215 if (pnotes == NULL)
a6e9f9df 15216 return 0;
779fe533 15217
103f02d3 15218 external = pnotes;
103f02d3 15219
9dd3a467 15220 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 15221 (unsigned long) offset, (unsigned long) length);
2aee03ae 15222 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 15223
15b42fb0 15224 while ((char *) external < (char *) pnotes + length)
779fe533 15225 {
b34976b6 15226 Elf_Internal_Note inote;
15b42fb0
AM		 15227 size_t min_notesz;
15228 char *next;
2cf0635d 15229 char * temp = NULL;
15b42fb0 15230 size_t data_remaining = ((char *) pnotes + length) - (char *) external;
6d118b09 15231
00e98fc7 15232 if (!is_ia64_vms ())
15b42fb0 15233 {
9dd3a467
NC		 15234 /* PR binutils/15191
15235 Make sure that there is enough data to read. */
15b42fb0
AM		 15236 min_notesz = offsetof (Elf_External_Note, name);
15237 if (data_remaining < min_notesz)
9dd3a467
NC		 15238 {
15239 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15240 (int) data_remaining);
15241 break;
15242 }
15b42fb0
AM		 15243 inote.type = BYTE_GET (external->type);
15244 inote.namesz = BYTE_GET (external->namesz);
15245 inote.namedata = external->name;
15246 inote.descsz = BYTE_GET (external->descsz);
15247 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
834f871c
NC		 15248 /* PR 17531: file: 3443835e. */
15249 if (inote.descdata < (char *) pnotes)
15250 {
15251 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15252 inote.descdata = inote.namedata;
15253 inote.namesz = 0;
15254 }
15b42fb0
AM		 15255 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15256 next = inote.descdata + align_power (inote.descsz, 2);
15257 }
00e98fc7 15258 else
15b42fb0
AM		 15259 {
15260 Elf64_External_VMS_Note *vms_external;
00e98fc7 15261
9dd3a467
NC		 15262 /* PR binutils/15191
15263 Make sure that there is enough data to read. */
15b42fb0
AM		 15264 min_notesz = offsetof (Elf64_External_VMS_Note, name);
15265 if (data_remaining < min_notesz)
9dd3a467
NC		 15266 {
15267 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15268 (int) data_remaining);
15269 break;
15270 }
3e55a963 15271
15b42fb0
AM		 15272 vms_external = (Elf64_External_VMS_Note *) external;
15273 inote.type = BYTE_GET (vms_external->type);
15274 inote.namesz = BYTE_GET (vms_external->namesz);
15275 inote.namedata = vms_external->name;
15276 inote.descsz = BYTE_GET (vms_external->descsz);
15277 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15278 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15279 next = inote.descdata + align_power (inote.descsz, 3);
15280 }
15281
15282 if (inote.descdata < (char *) external + min_notesz
15283 || next < (char *) external + min_notesz
5d921cbd
NC		 15284 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15285 || inote.namedata + inote.namesz < inote.namedata
15286 || inote.descdata + inote.descsz < inote.descdata
15b42fb0 15287 || data_remaining < (size_t)(next - (char *) external))
3e55a963 15288 {
15b42fb0 15289 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 15290 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 15291 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 15292 inote.type, inote.namesz, inote.descsz);
15293 break;
15294 }
15295
15b42fb0 15296 external = (Elf_External_Note *) next;
dd24e3da 15297
6d118b09
NC		 15298 /* Verify that name is null terminated. It appears that at least
15299 one version of Linux (RedHat 6.0) generates corefiles that don't
15300 comply with the ELF spec by failing to include the null byte in
15301 namesz. */
8b971f9f 15302 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 15303 {
3f5e193b 15304 temp = (char *) malloc (inote.namesz + 1);
6d118b09
NC		 15305 if (temp == NULL)
15306 {
8b73c356 15307 error (_("Out of memory allocating space for inote name\n"));
6d118b09
NC		 15308 res = 0;
15309 break;
15310 }
76da6bbe 15311
6d118b09
NC		 15312 strncpy (temp, inote.namedata, inote.namesz);
15313 temp[inote.namesz] = 0;
76da6bbe 15314
6d118b09
NC		 15315 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15316 inote.namedata = temp;
15317 }
15318
15319 res &= process_note (& inote);
103f02d3 15320
6d118b09
NC		 15321 if (temp != NULL)
15322 {
15323 free (temp);
15324 temp = NULL;
15325 }
779fe533
NC		 15326 }
15327
15328 free (pnotes);
103f02d3 15329
779fe533
NC		 15330 return res;
15331}
15332
15333static int
2cf0635d 15334process_corefile_note_segments (FILE * file)
779fe533 15335{
2cf0635d 15336 Elf_Internal_Phdr * segment;
b34976b6
AM		 15337 unsigned int i;
15338 int res = 1;
103f02d3 15339
d93f0186 15340 if (! get_program_headers (file))
779fe533 15341 return 0;
103f02d3 15342
779fe533
NC		 15343 for (i = 0, segment = program_headers;
15344 i < elf_header.e_phnum;
b34976b6 15345 i++, segment++)
779fe533
NC		 15346 {
15347 if (segment->p_type == PT_NOTE)
103f02d3 15348 res &= process_corefile_note_segment (file,
30800947
NC		 15349 (bfd_vma) segment->p_offset,
15350 (bfd_vma) segment->p_filesz);
779fe533 15351 }
103f02d3 15352
779fe533
NC		 15353 return res;
15354}
15355
685080f2
NC		 15356static int
15357process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
15358{
15359 Elf_External_Note * pnotes;
15360 Elf_External_Note * external;
15361 int res = 1;
15362
15363 if (length <= 0)
15364 return 0;
15365
15366 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15367 _("v850 notes"));
15368 if (pnotes == NULL)
15369 return 0;
15370
15371 external = pnotes;
15372
15373 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15374 (unsigned long) offset, (unsigned long) length);
15375
15376 while (external < (Elf_External_Note *) ((char *) pnotes + length))
15377 {
15378 Elf_External_Note * next;
15379 Elf_Internal_Note inote;
15380
15381 inote.type = BYTE_GET (external->type);
15382 inote.namesz = BYTE_GET (external->namesz);
15383 inote.namedata = external->name;
15384 inote.descsz = BYTE_GET (external->descsz);
15385 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15386 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15387
15388 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
15389
15390 if ( ((char *) next > ((char *) pnotes) + length)
15391 || ((char *) next < (char *) pnotes))
15392 {
15393 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15394 (unsigned long) ((char *) external - (char *) pnotes));
15395 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15396 inote.type, inote.namesz, inote.descsz);
15397 break;
15398 }
15399
15400 external = next;
15401
15402 /* Prevent out-of-bounds indexing. */
15403 if ( inote.namedata + inote.namesz > (char *) pnotes + length
15404 || inote.namedata + inote.namesz < inote.namedata)
15405 {
15406 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15407 (unsigned long) ((char *) external - (char *) pnotes));
15408 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15409 inote.type, inote.namesz, inote.descsz);
15410 break;
15411 }
15412
15413 printf (" %s: ", get_v850_elf_note_type (inote.type));
15414
15415 if (! print_v850_note (& inote))
15416 {
15417 res = 0;
15418 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15419 inote.namesz, inote.descsz);
15420 }
15421 }
15422
15423 free (pnotes);
15424
15425 return res;
15426}
15427
779fe533 15428static int
2cf0635d 15429process_note_sections (FILE * file)
1ec5cd37 15430{
2cf0635d 15431 Elf_Internal_Shdr * section;
1ec5cd37 15432 unsigned long i;
df565f32 15433 int n = 0;
1ec5cd37
NC		 15434 int res = 1;
15435
15436 for (i = 0, section = section_headers;
fa1908fd 15437 i < elf_header.e_shnum && section != NULL;
1ec5cd37 15438 i++, section++)
685080f2
NC		 15439 {
15440 if (section->sh_type == SHT_NOTE)
15441 {
15442 res &= process_corefile_note_segment (file,
15443 (bfd_vma) section->sh_offset,
15444 (bfd_vma) section->sh_size);
15445 n++;
15446 }
15447
15448 if (( elf_header.e_machine == EM_V800
15449 || elf_header.e_machine == EM_V850
15450 || elf_header.e_machine == EM_CYGNUS_V850)
15451 && section->sh_type == SHT_RENESAS_INFO)
15452 {
15453 res &= process_v850_notes (file,
15454 (bfd_vma) section->sh_offset,
15455 (bfd_vma) section->sh_size);
15456 n++;
15457 }
15458 }
df565f32
NC		 15459
15460 if (n == 0)
15461 /* Try processing NOTE segments instead. */
15462 return process_corefile_note_segments (file);
1ec5cd37
NC		 15463
15464 return res;
15465}
15466
15467static int
2cf0635d 15468process_notes (FILE * file)
779fe533
NC		 15469{
15470 /* If we have not been asked to display the notes then do nothing. */
15471 if (! do_notes)
15472 return 1;
103f02d3 15473
779fe533 15474 if (elf_header.e_type != ET_CORE)
1ec5cd37 15475 return process_note_sections (file);
103f02d3 15476
779fe533 15477 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 15478 if (elf_header.e_phnum > 0)
15479 return process_corefile_note_segments (file);
779fe533 15480
1ec5cd37
NC		 15481 printf (_("No note segments present in the core file.\n"));
15482 return 1;
779fe533
NC		 15483}
15484
252b5132 15485static int
2cf0635d 15486process_arch_specific (FILE * file)
252b5132 15487{
a952a375
NC		 15488 if (! do_arch)
15489 return 1;
15490
252b5132
RH		 15491 switch (elf_header.e_machine)
15492 {
11c1ff18
PB		 15493 case EM_ARM:
15494 return process_arm_specific (file);
252b5132 15495 case EM_MIPS:
4fe85591 15496 case EM_MIPS_RS3_LE:
252b5132
RH		 15497 return process_mips_specific (file);
15498 break;
35c08157
KLC		 15499 case EM_NDS32:
15500 return process_nds32_specific (file);
15501 break;
34c8bcba
JM		 15502 case EM_PPC:
15503 return process_power_specific (file);
15504 break;
9e8c70f9
DM		 15505 case EM_SPARC:
15506 case EM_SPARC32PLUS:
15507 case EM_SPARCV9:
15508 return process_sparc_specific (file);
15509 break;
59e6276b
JM		 15510 case EM_TI_C6000:
15511 return process_tic6x_specific (file);
15512 break;
13761a11
NC		 15513 case EM_MSP430:
15514 return process_msp430x_specific (file);
252b5132
RH		 15515 default:
15516 break;
15517 }
15518 return 1;
15519}
15520
15521static int
2cf0635d 15522get_file_header (FILE * file)
252b5132 15523{
9ea033b2
NC		 15524 /* Read in the identity array. */
15525 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 15526 return 0;
15527
9ea033b2 15528 /* Determine how to read the rest of the header. */
b34976b6 15529 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 15530 {
15531 default: /* fall through */
15532 case ELFDATANONE: /* fall through */
adab8cdc
AO		 15533 case ELFDATA2LSB:
15534 byte_get = byte_get_little_endian;
15535 byte_put = byte_put_little_endian;
15536 break;
15537 case ELFDATA2MSB:
15538 byte_get = byte_get_big_endian;
15539 byte_put = byte_put_big_endian;
15540 break;
9ea033b2
NC		 15541 }
15542
15543 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 15544 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 15545
15546 /* Read in the rest of the header. */
15547 if (is_32bit_elf)
15548 {
15549 Elf32_External_Ehdr ehdr32;
252b5132 15550
9ea033b2
NC		 15551 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
15552 return 0;
103f02d3 15553
9ea033b2
NC		 15554 elf_header.e_type = BYTE_GET (ehdr32.e_type);
15555 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
15556 elf_header.e_version = BYTE_GET (ehdr32.e_version);
15557 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
15558 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
15559 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
15560 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
15561 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
15562 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
15563 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
15564 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
15565 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
15566 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
15567 }
252b5132 15568 else
9ea033b2
NC		 15569 {
15570 Elf64_External_Ehdr ehdr64;
a952a375
NC		 15571
15572 /* If we have been compiled with sizeof (bfd_vma) == 4, then
15573 we will not be able to cope with the 64bit data found in
15574 64 ELF files. Detect this now and abort before we start
50c2245b 15575 overwriting things. */
a952a375
NC		 15576 if (sizeof (bfd_vma) < 8)
15577 {
e3c8793a
NC		 15578 error (_("This instance of readelf has been built without support for a\n\
1557964 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 15580 return 0;
15581 }
103f02d3 15582
9ea033b2
NC		 15583 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
15584 return 0;
103f02d3 15585
9ea033b2
NC		 15586 elf_header.e_type = BYTE_GET (ehdr64.e_type);
15587 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
15588 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 15589 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
15590 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
15591 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 15592 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
15593 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
15594 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
15595 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
15596 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
15597 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
15598 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
15599 }
252b5132 15600
7ece0d85
JJ		 15601 if (elf_header.e_shoff)
15602 {
15603 /* There may be some extensions in the first section header. Don't
15604 bomb if we can't read it. */
15605 if (is_32bit_elf)
049b0c3a 15606 get_32bit_section_headers (file, TRUE);
7ece0d85 15607 else
049b0c3a 15608 get_64bit_section_headers (file, TRUE);
7ece0d85 15609 }
560f3c1c 15610
252b5132
RH		 15611 return 1;
15612}
15613
fb52b2f4
NC		 15614/* Process one ELF object file according to the command line options.
15615 This file may actually be stored in an archive. The file is
15616 positioned at the start of the ELF object. */
15617
ff78d6d6 15618static int
2cf0635d 15619process_object (char * file_name, FILE * file)
252b5132 15620{
252b5132
RH		 15621 unsigned int i;
15622
252b5132
RH		 15623 if (! get_file_header (file))
15624 {
15625 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 15626 return 1;
252b5132
RH		 15627 }
15628
15629 /* Initialise per file variables. */
60bca95a 15630 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 15631 version_info[i] = 0;
15632
60bca95a 15633 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 15634 dynamic_info[i] = 0;
5115b233 15635 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 15636
15637 /* Process the file. */
15638 if (show_name)
15639 printf (_("\nFile: %s\n"), file_name);
15640
18bd398b
NC		 15641 /* Initialise the dump_sects array from the cmdline_dump_sects array.
15642 Note we do this even if cmdline_dump_sects is empty because we
15643 must make sure that the dump_sets array is zeroed out before each
15644 object file is processed. */
15645 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 15646 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 15647
15648 if (num_cmdline_dump_sects > 0)
15649 {
15650 if (num_dump_sects == 0)
15651 /* A sneaky way of allocating the dump_sects array. */
09c11c86 15652 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 15653
15654 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 15655 memcpy (dump_sects, cmdline_dump_sects,
15656 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 15657 }
d70c5fc7 15658
252b5132 15659 if (! process_file_header ())
fb52b2f4 15660 return 1;
252b5132 15661
d1f5c6e3 15662 if (! process_section_headers (file))
2f62977e 15663 {
d1f5c6e3
L		 15664 /* Without loaded section headers we cannot process lots of
15665 things. */
2f62977e 15666 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 15667
2f62977e 15668 if (! do_using_dynamic)
2c610e4b 15669 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 15670 }
252b5132 15671
d1f5c6e3
L		 15672 if (! process_section_groups (file))
15673 {
15674 /* Without loaded section groups we cannot process unwind. */
15675 do_unwind = 0;
15676 }
15677
2f62977e 15678 if (process_program_headers (file))
b2d38a17 15679 process_dynamic_section (file);
252b5132
RH		 15680
15681 process_relocs (file);
15682
4d6ed7c8
NC		 15683 process_unwind (file);
15684
252b5132
RH		 15685 process_symbol_table (file);
15686
15687 process_syminfo (file);
15688
15689 process_version_sections (file);
15690
15691 process_section_contents (file);
f5842774 15692
1ec5cd37 15693 process_notes (file);
103f02d3 15694
047b2264
JJ		 15695 process_gnu_liblist (file);
15696
252b5132
RH		 15697 process_arch_specific (file);
15698
d93f0186
NC		 15699 if (program_headers)
15700 {
15701 free (program_headers);
15702 program_headers = NULL;
15703 }
15704
252b5132
RH		 15705 if (section_headers)
15706 {
15707 free (section_headers);
15708 section_headers = NULL;
15709 }
15710
15711 if (string_table)
15712 {
15713 free (string_table);
15714 string_table = NULL;
d40ac9bd 15715 string_table_length = 0;
252b5132
RH		 15716 }
15717
15718 if (dynamic_strings)
15719 {
15720 free (dynamic_strings);
15721 dynamic_strings = NULL;
d79b3d50 15722 dynamic_strings_length = 0;
252b5132
RH		 15723 }
15724
15725 if (dynamic_symbols)
15726 {
15727 free (dynamic_symbols);
15728 dynamic_symbols = NULL;
19936277 15729 num_dynamic_syms = 0;
252b5132
RH		 15730 }
15731
15732 if (dynamic_syminfo)
15733 {
15734 free (dynamic_syminfo);
15735 dynamic_syminfo = NULL;
15736 }
ff78d6d6 15737
293c573e
MR		 15738 if (dynamic_section)
15739 {
15740 free (dynamic_section);
15741 dynamic_section = NULL;
15742 }
15743
e4b17d5c
L		 15744 if (section_headers_groups)
15745 {
15746 free (section_headers_groups);
15747 section_headers_groups = NULL;
15748 }
15749
15750 if (section_groups)
15751 {
2cf0635d
NC		 15752 struct group_list * g;
15753 struct group_list * next;
e4b17d5c
L		 15754
15755 for (i = 0; i < group_count; i++)
15756 {
15757 for (g = section_groups [i].root; g != NULL; g = next)
15758 {
15759 next = g->next;
15760 free (g);
15761 }
15762 }
15763
15764 free (section_groups);
15765 section_groups = NULL;
15766 }
15767
19e6b90e 15768 free_debug_memory ();
18bd398b 15769
ff78d6d6 15770 return 0;
252b5132
RH		 15771}
15772
2cf0635d
NC		 15773/* Process an ELF archive.
15774 On entry the file is positioned just after the ARMAG string. */
15775
15776static int
15777process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
15778{
15779 struct archive_info arch;
15780 struct archive_info nested_arch;
15781 size_t got;
2cf0635d
NC		 15782 int ret;
15783
15784 show_name = 1;
15785
15786 /* The ARCH structure is used to hold information about this archive. */
15787 arch.file_name = NULL;
15788 arch.file = NULL;
15789 arch.index_array = NULL;
15790 arch.sym_table = NULL;
15791 arch.longnames = NULL;
15792
15793 /* The NESTED_ARCH structure is used as a single-item cache of information
15794 about a nested archive (when members of a thin archive reside within
15795 another regular archive file). */
15796 nested_arch.file_name = NULL;
15797 nested_arch.file = NULL;
15798 nested_arch.index_array = NULL;
15799 nested_arch.sym_table = NULL;
15800 nested_arch.longnames = NULL;
15801
15802 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
15803 {
15804 ret = 1;
15805 goto out;
4145f1d5 15806 }
fb52b2f4 15807
4145f1d5
NC		 15808 if (do_archive_index)
15809 {
2cf0635d 15810 if (arch.sym_table == NULL)
4145f1d5
NC		 15811 error (_("%s: unable to dump the index as none was found\n"), file_name);
15812 else
15813 {
591f7597 15814 unsigned long i, l;
4145f1d5
NC		 15815 unsigned long current_pos;
15816
591f7597
NC		 15817 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
15818 file_name, (unsigned long) arch.index_num, arch.sym_size);
4145f1d5
NC		 15819 current_pos = ftell (file);
15820
2cf0635d 15821 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 15822 {
2cf0635d
NC		 15823 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
15824 {
15825 char * member_name;
4145f1d5 15826
2cf0635d
NC		 15827 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
15828
15829 if (member_name != NULL)
15830 {
15831 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
15832
15833 if (qualified_name != NULL)
15834 {
c2a7d3f5
NC		 15835 printf (_("Contents of binary %s at offset "), qualified_name);
15836 (void) print_vma (arch.index_array[i], PREFIX_HEX);
15837 putchar ('\n');
2cf0635d
NC		 15838 free (qualified_name);
15839 }
4145f1d5
NC		 15840 }
15841 }
2cf0635d
NC		 15842
15843 if (l >= arch.sym_size)
4145f1d5
NC		 15844 {
15845 error (_("%s: end of the symbol table reached before the end of the index\n"),
15846 file_name);
cb8f3167 15847 break;
4145f1d5 15848 }
591f7597
NC		 15849 /* PR 17531: file: 0b6630b2. */
15850 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
15851 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
4145f1d5
NC		 15852 }
15853
c2a7d3f5
NC		 15854 if (arch.uses_64bit_indicies)
15855 l = (l + 7) & ~ 7;
15856 else
15857 l += l & 1;
15858
2cf0635d 15859 if (l < arch.sym_size)
c2a7d3f5
NC		 15860 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
15861 file_name, arch.sym_size - l);
4145f1d5 15862
4145f1d5
NC		 15863 if (fseek (file, current_pos, SEEK_SET) != 0)
15864 {
15865 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 15866 ret = 1;
15867 goto out;
4145f1d5 15868 }
fb52b2f4 15869 }
4145f1d5
NC		 15870
15871 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
15872 && !do_segments && !do_header && !do_dump && !do_version
15873 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 15874 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 15875 {
15876 ret = 0; /* Archive index only. */
15877 goto out;
15878 }
fb52b2f4
NC		 15879 }
15880
d989285c 15881 ret = 0;
fb52b2f4
NC		 15882
15883 while (1)
15884 {
2cf0635d
NC		 15885 char * name;
15886 size_t namelen;
15887 char * qualified_name;
15888
15889 /* Read the next archive header. */
15890 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
15891 {
15892 error (_("%s: failed to seek to next archive header\n"), file_name);
15893 return 1;
15894 }
15895 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
15896 if (got != sizeof arch.arhdr)
15897 {
15898 if (got == 0)
15899 break;
15900 error (_("%s: failed to read archive header\n"), file_name);
15901 ret = 1;
15902 break;
15903 }
15904 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
15905 {
15906 error (_("%s: did not find a valid archive header\n"), arch.file_name);
15907 ret = 1;
15908 break;
15909 }
15910
15911 arch.next_arhdr_offset += sizeof arch.arhdr;
15912
15913 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
15914 if (archive_file_size & 01)
15915 ++archive_file_size;
15916
15917 name = get_archive_member_name (&arch, &nested_arch);
15918 if (name == NULL)
fb52b2f4 15919 {
0fd3a477 15920 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 15921 ret = 1;
15922 break;
fb52b2f4 15923 }
2cf0635d 15924 namelen = strlen (name);
fb52b2f4 15925
2cf0635d
NC		 15926 qualified_name = make_qualified_name (&arch, &nested_arch, name);
15927 if (qualified_name == NULL)
fb52b2f4 15928 {
2cf0635d 15929 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 15930 ret = 1;
15931 break;
fb52b2f4
NC		 15932 }
15933
2cf0635d
NC		 15934 if (is_thin_archive && arch.nested_member_origin == 0)
15935 {
15936 /* This is a proxy for an external member of a thin archive. */
15937 FILE * member_file;
15938 char * member_file_name = adjust_relative_path (file_name, name, namelen);
15939 if (member_file_name == NULL)
15940 {
15941 ret = 1;
15942 break;
15943 }
15944
15945 member_file = fopen (member_file_name, "rb");
15946 if (member_file == NULL)
15947 {
15948 error (_("Input file '%s' is not readable.\n"), member_file_name);
15949 free (member_file_name);
15950 ret = 1;
15951 break;
15952 }
15953
15954 archive_file_offset = arch.nested_member_origin;
15955
15956 ret |= process_object (qualified_name, member_file);
15957
15958 fclose (member_file);
15959 free (member_file_name);
15960 }
15961 else if (is_thin_archive)
15962 {
a043396b
NC		 15963 /* PR 15140: Allow for corrupt thin archives. */
15964 if (nested_arch.file == NULL)
15965 {
15966 error (_("%s: contains corrupt thin archive: %s\n"),
15967 file_name, name);
15968 ret = 1;
15969 break;
15970 }
15971
2cf0635d
NC		 15972 /* This is a proxy for a member of a nested archive. */
15973 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
15974
15975 /* The nested archive file will have been opened and setup by
15976 get_archive_member_name. */
15977 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
15978 {
15979 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
15980 ret = 1;
15981 break;
15982 }
15983
15984 ret |= process_object (qualified_name, nested_arch.file);
15985 }
15986 else
15987 {
15988 archive_file_offset = arch.next_arhdr_offset;
15989 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 15990
2cf0635d
NC		 15991 ret |= process_object (qualified_name, file);
15992 }
fb52b2f4 15993
2b52916e
L		 15994 if (dump_sects != NULL)
15995 {
15996 free (dump_sects);
15997 dump_sects = NULL;
15998 num_dump_sects = 0;
15999 }
16000
2cf0635d 16001 free (qualified_name);
fb52b2f4
NC		 16002 }
16003
4145f1d5 16004 out:
2cf0635d
NC		 16005 if (nested_arch.file != NULL)
16006 fclose (nested_arch.file);
16007 release_archive (&nested_arch);
16008 release_archive (&arch);
fb52b2f4 16009
d989285c 16010 return ret;
fb52b2f4
NC		 16011}
16012
16013static int
2cf0635d 16014process_file (char * file_name)
fb52b2f4 16015{
2cf0635d 16016 FILE * file;
fb52b2f4
NC		 16017 struct stat statbuf;
16018 char armag[SARMAG];
16019 int ret;
16020
16021 if (stat (file_name, &statbuf) < 0)
16022 {
f24ddbdd
NC		 16023 if (errno == ENOENT)
16024 error (_("'%s': No such file\n"), file_name);
16025 else
16026 error (_("Could not locate '%s'. System error message: %s\n"),
16027 file_name, strerror (errno));
16028 return 1;
16029 }
16030
16031 if (! S_ISREG (statbuf.st_mode))
16032 {
16033 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 16034 return 1;
16035 }
16036
16037 file = fopen (file_name, "rb");
16038 if (file == NULL)
16039 {
f24ddbdd 16040 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 16041 return 1;
16042 }
16043
16044 if (fread (armag, SARMAG, 1, file) != 1)
16045 {
4145f1d5 16046 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 16047 fclose (file);
16048 return 1;
16049 }
16050
f54498b4
NC		 16051 current_file_size = (bfd_size_type) statbuf.st_size;
16052
fb52b2f4 16053 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 16054 ret = process_archive (file_name, file, FALSE);
16055 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16056 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 16057 else
16058 {
4145f1d5
NC		 16059 if (do_archive_index)
16060 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16061 file_name);
16062
fb52b2f4
NC		 16063 rewind (file);
16064 archive_file_size = archive_file_offset = 0;
16065 ret = process_object (file_name, file);
16066 }
16067
16068 fclose (file);
16069
f54498b4 16070 current_file_size = 0;
fb52b2f4
NC		 16071 return ret;
16072}
16073
252b5132
RH		 16074#ifdef SUPPORT_DISASSEMBLY
16075/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 16076 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 16077 symbols. */
252b5132
RH		 16078
16079void
2cf0635d 16080print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 16081{
16082 fprintf (outfile,"0x%8.8x", addr);
16083}
16084
e3c8793a 16085/* Needed by the i386 disassembler. */
252b5132
RH		 16086void
16087db_task_printsym (unsigned int addr)
16088{
16089 print_address (addr, stderr);
16090}
16091#endif
16092
16093int
2cf0635d 16094main (int argc, char ** argv)
252b5132 16095{
ff78d6d6
L		 16096 int err;
16097
252b5132
RH		 16098#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16099 setlocale (LC_MESSAGES, "");
3882b010
L		 16100#endif
16101#if defined (HAVE_SETLOCALE)
16102 setlocale (LC_CTYPE, "");
252b5132
RH		 16103#endif
16104 bindtextdomain (PACKAGE, LOCALEDIR);
16105 textdomain (PACKAGE);
16106
869b9d07
MM		 16107 expandargv (&argc, &argv);
16108
252b5132
RH		 16109 parse_args (argc, argv);
16110
18bd398b 16111 if (num_dump_sects > 0)
59f14fc0 16112 {
18bd398b 16113 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 16114 cmdline_dump_sects = (dump_type *)
16115 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 16116 if (cmdline_dump_sects == NULL)
591a748a 16117 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 16118 else
16119 {
09c11c86
NC		 16120 memcpy (cmdline_dump_sects, dump_sects,
16121 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 16122 num_cmdline_dump_sects = num_dump_sects;
16123 }
16124 }
16125
18bd398b
NC		 16126 if (optind < (argc - 1))
16127 show_name = 1;
16128
ff78d6d6 16129 err = 0;
252b5132 16130 while (optind < argc)
18bd398b 16131 err |= process_file (argv[optind++]);
252b5132
RH		 16132
16133 if (dump_sects != NULL)
16134 free (dump_sects);
59f14fc0
AS		 16135 if (cmdline_dump_sects != NULL)
16136 free (cmdline_dump_sects);
252b5132 16137
ff78d6d6 16138 return err;
252b5132 16139}
GDB Binutils - Deliverables
This page took 2.694788 seconds and 4 git commands to generate.