projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Limit breakpoint re-set to the current program space
[deliverable/binutils-gdb.git] / binutils / readelf.c
CommitLineData
252b5132 1/* readelf.c -- display contents of an ELF format file
6f2750fe 2 Copyright (C) 1998-2016 Free Software Foundation, Inc.
252b5132
RH		 3
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
12ab83a9 5 Modifications by Nick Clifton <nickc@redhat.com>
252b5132
RH		 6
7 This file is part of GNU Binutils.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
32866df7 11 the Free Software Foundation; either version 3 of the License, or
252b5132
RH		 12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
b43b5d5f
NC		 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 02110-1301, USA. */
252b5132 23\f
9eb20dd8 24/* The difference between readelf and objdump:
252b5132 25
74013231 26 Both programs are capable of displaying the contents of ELF format files,
9eb20dd8 27 so why does the binutils project have two file dumpers ?
0de14b54 28
9eb20dd8
NC		 29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
35
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
38
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
42\f
3db64b00 43#include "sysdep.h"
252b5132 44#include <assert.h>
252b5132 45#include <time.h>
1b315056 46#include <zlib.h>
3bfcb652 47#ifdef HAVE_WCHAR_H
7bfd842d 48#include <wchar.h>
3bfcb652 49#endif
252b5132 50
a952a375 51#if __GNUC__ >= 2
19936277 52/* Define BFD64 here, even if our default architecture is 32 bit ELF
a952a375 53 as this will allow us to read in and parse 64bit and 32bit ELF files.
b34976b6 54 Only do this if we believe that the compiler can support a 64 bit
a952a375 55 data type. For now we only rely on GCC being able to do this. */
19936277 56#define BFD64
a952a375
NC		 57#endif
58
3db64b00
AM		 59#include "bfd.h"
60#include "bucomm.h"
3284fe0c 61#include "elfcomm.h"
19e6b90e 62#include "dwarf.h"
252b5132
RH		 63
64#include "elf/common.h"
65#include "elf/external.h"
66#include "elf/internal.h"
252b5132 67
4b78141a
NC		 68
69/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
73
74#include "elf/h8.h"
75#undef _ELF_H8_H
76
77/* Undo the effects of #including reloc-macros.h. */
78
79#undef START_RELOC_NUMBERS
80#undef RELOC_NUMBER
81#undef FAKE_RELOC
82#undef EMPTY_RELOC
83#undef END_RELOC_NUMBERS
84#undef _RELOC_MACROS_H
85
252b5132
RH		 86/* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
89
90#define RELOC_MACROS_GEN_FUNC
91
a06ea964 92#include "elf/aarch64.h"
252b5132 93#include "elf/alpha.h"
3b16e843 94#include "elf/arc.h"
252b5132 95#include "elf/arm.h"
3b16e843 96#include "elf/avr.h"
1d65ded4 97#include "elf/bfin.h"
60bca95a 98#include "elf/cr16.h"
3b16e843 99#include "elf/cris.h"
1c0d3aa6 100#include "elf/crx.h"
252b5132
RH		 101#include "elf/d10v.h"
102#include "elf/d30v.h"
d172d4ba 103#include "elf/dlx.h"
cfb8c092 104#include "elf/epiphany.h"
252b5132 105#include "elf/fr30.h"
5c70f934 106#include "elf/frv.h"
3f8107ab 107#include "elf/ft32.h"
3b16e843
NC		 108#include "elf/h8.h"
109#include "elf/hppa.h"
110#include "elf/i386.h"
35b1837e 111#include "elf/i370.h"
3b16e843
NC		 112#include "elf/i860.h"
113#include "elf/i960.h"
114#include "elf/ia64.h"
1e4cf259 115#include "elf/ip2k.h"
84e94c90 116#include "elf/lm32.h"
1c0d3aa6 117#include "elf/iq2000.h"
49f58d10 118#include "elf/m32c.h"
3b16e843
NC		 119#include "elf/m32r.h"
120#include "elf/m68k.h"
75751cd9 121#include "elf/m68hc11.h"
252b5132 122#include "elf/mcore.h"
15ab5209 123#include "elf/mep.h"
a3c62988 124#include "elf/metag.h"
7ba29e2a 125#include "elf/microblaze.h"
3b16e843 126#include "elf/mips.h"
3c3bdf30 127#include "elf/mmix.h"
3b16e843
NC		 128#include "elf/mn10200.h"
129#include "elf/mn10300.h"
5506d11a 130#include "elf/moxie.h"
4970f871 131#include "elf/mt.h"
2469cfa2 132#include "elf/msp430.h"
35c08157 133#include "elf/nds32.h"
13761a11 134#include "elf/nios2.h"
73589c9d 135#include "elf/or1k.h"
7d466069 136#include "elf/pj.h"
3b16e843 137#include "elf/ppc.h"
c833c019 138#include "elf/ppc64.h"
99c513f6 139#include "elf/rl78.h"
c7927a3c 140#include "elf/rx.h"
a85d7ed0 141#include "elf/s390.h"
1c0d3aa6 142#include "elf/score.h"
3b16e843
NC		 143#include "elf/sh.h"
144#include "elf/sparc.h"
e9f53129 145#include "elf/spu.h"
40b36596 146#include "elf/tic6x.h"
aa137e4d
NC		 147#include "elf/tilegx.h"
148#include "elf/tilepro.h"
3b16e843 149#include "elf/v850.h"
179d3252 150#include "elf/vax.h"
619ed720 151#include "elf/visium.h"
3b16e843 152#include "elf/x86-64.h"
c29aca4a 153#include "elf/xc16x.h"
f6c1a2d5 154#include "elf/xgate.h"
93fbbb04 155#include "elf/xstormy16.h"
88da6820 156#include "elf/xtensa.h"
252b5132 157
252b5132 158#include "getopt.h"
566b0d53 159#include "libiberty.h"
09c11c86 160#include "safe-ctype.h"
2cf0635d 161#include "filenames.h"
252b5132 162
15b42fb0
AM		 163#ifndef offsetof
164#define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
165#endif
166
6a40cf0c
NC		 167typedef struct elf_section_list
168{
169 Elf_Internal_Shdr * hdr;
170 struct elf_section_list * next;
171} elf_section_list;
172
2cf0635d 173char * program_name = "readelf";
c9c1d674 174static unsigned long archive_file_offset;
85b1c36d 175static unsigned long archive_file_size;
f54498b4 176static bfd_size_type current_file_size;
85b1c36d
BE		 177static unsigned long dynamic_addr;
178static bfd_size_type dynamic_size;
8b73c356 179static size_t dynamic_nent;
2cf0635d 180static char * dynamic_strings;
85b1c36d 181static unsigned long dynamic_strings_length;
2cf0635d 182static char * string_table;
85b1c36d
BE		 183static unsigned long string_table_length;
184static unsigned long num_dynamic_syms;
2cf0635d
NC		 185static Elf_Internal_Sym * dynamic_symbols;
186static Elf_Internal_Syminfo * dynamic_syminfo;
85b1c36d
BE		 187static unsigned long dynamic_syminfo_offset;
188static unsigned int dynamic_syminfo_nent;
f8eae8b2 189static char program_interpreter[PATH_MAX];
bb8a0291 190static bfd_vma dynamic_info[DT_ENCODING];
fdc90cb4 191static bfd_vma dynamic_info_DT_GNU_HASH;
85b1c36d
BE		 192static bfd_vma version_info[16];
193static Elf_Internal_Ehdr elf_header;
2cf0635d
NC		 194static Elf_Internal_Shdr * section_headers;
195static Elf_Internal_Phdr * program_headers;
196static Elf_Internal_Dyn * dynamic_section;
6a40cf0c 197static elf_section_list * symtab_shndx_list;
85b1c36d
BE		 198static int show_name;
199static int do_dynamic;
200static int do_syms;
2c610e4b 201static int do_dyn_syms;
85b1c36d
BE		 202static int do_reloc;
203static int do_sections;
204static int do_section_groups;
5477e8a0 205static int do_section_details;
85b1c36d
BE		 206static int do_segments;
207static int do_unwind;
208static int do_using_dynamic;
209static int do_header;
210static int do_dump;
211static int do_version;
85b1c36d
BE		 212static int do_histogram;
213static int do_debugging;
85b1c36d
BE		 214static int do_arch;
215static int do_notes;
4145f1d5 216static int do_archive_index;
85b1c36d 217static int is_32bit_elf;
0e602686 218static int decompress_dumps;
252b5132 219
e4b17d5c
L		 220struct group_list
221{
2cf0635d 222 struct group_list * next;
e4b17d5c
L		 223 unsigned int section_index;
224};
225
226struct group
227{
2cf0635d 228 struct group_list * root;
e4b17d5c
L		 229 unsigned int group_index;
230};
231
85b1c36d 232static size_t group_count;
2cf0635d
NC		 233static struct group * section_groups;
234static struct group ** section_headers_groups;
e4b17d5c 235
09c11c86
NC		 236
237/* Flag bits indicating particular types of dump. */
238#define HEX_DUMP (1 << 0) /* The -x command line switch. */
239#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
240#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
241#define STRING_DUMP (1 << 3) /* The -p command line switch. */
cf13d699 242#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
09c11c86
NC		 243
244typedef unsigned char dump_type;
245
246/* A linked list of the section names for which dumps were requested. */
aef1f6d0
DJ		 247struct dump_list_entry
248{
2cf0635d 249 char * name;
09c11c86 250 dump_type type;
2cf0635d 251 struct dump_list_entry * next;
aef1f6d0 252};
2cf0635d 253static struct dump_list_entry * dump_sects_byname;
aef1f6d0 254
09c11c86
NC		 255/* A dynamic array of flags indicating for which sections a dump
256 has been requested via command line switches. */
257static dump_type * cmdline_dump_sects = NULL;
258static unsigned int num_cmdline_dump_sects = 0;
18bd398b
NC		 259
260/* A dynamic array of flags indicating for which sections a dump of
261 some kind has been requested. It is reset on a per-object file
aef1f6d0
DJ		 262 basis and then initialised from the cmdline_dump_sects array,
263 the results of interpreting the -w switch, and the
264 dump_sects_byname list. */
09c11c86
NC		 265static dump_type * dump_sects = NULL;
266static unsigned int num_dump_sects = 0;
252b5132 267
252b5132 268
c256ffe7 269/* How to print a vma value. */
843dd992
NC		 270typedef enum print_mode
271{
272 HEX,
273 DEC,
274 DEC_5,
275 UNSIGNED,
276 PREFIX_HEX,
277 FULL_HEX,
278 LONG_HEX
279}
280print_mode;
281
bb4d2ac2
L		 282/* Versioned symbol info. */
283enum versioned_symbol_info
284{
285 symbol_undefined,
286 symbol_hidden,
287 symbol_public
288};
289
290static const char *get_symbol_version_string
291 (FILE *file, int is_dynsym, const char *strtab,
292 unsigned long int strtab_size, unsigned int si,
293 Elf_Internal_Sym *psym, enum versioned_symbol_info *sym_info,
294 unsigned short *vna_other);
295
9c19a809
NC		 296#define UNKNOWN -1
297
2b692964
NC		 298#define SECTION_NAME(X) \
299 ((X) == NULL ? _("<none>") \
300 : string_table == NULL ? _("<no-name>") \
301 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
0b49d371 302 : string_table + (X)->sh_name))
252b5132 303
ee42cf8c 304#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
252b5132 305
ba5cdace
NC		 306#define GET_ELF_SYMBOLS(file, section, sym_count) \
307 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
308 : get_64bit_elf_symbols (file, section, sym_count))
9ea033b2 309
d79b3d50
NC		 310#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
311/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
312 already been called and verified that the string exists. */
313#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
18bd398b 314
61865e30
NC		 315#define REMOVE_ARCH_BITS(ADDR) \
316 do \
317 { \
318 if (elf_header.e_machine == EM_ARM) \
319 (ADDR) &= ~1; \
320 } \
321 while (0)
d79b3d50 322\f
c9c1d674
EG		 323/* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
324 the offset of the current archive member, if we are examining an archive.
59245841
NC		 325 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
326 using malloc and fill that. In either case return the pointer to the start of
327 the retrieved data or NULL if something went wrong. If something does go wrong
c9c1d674
EG		 328 and REASON is not NULL then emit an error message using REASON as part of the
329 context. */
59245841 330
c256ffe7 331static void *
57028622
NC		 332get_data (void * var, FILE * file, unsigned long offset, bfd_size_type size,
333 bfd_size_type nmemb, const char * reason)
a6e9f9df 334{
2cf0635d 335 void * mvar;
57028622 336 bfd_size_type amt = size * nmemb;
a6e9f9df 337
c256ffe7 338 if (size == 0 || nmemb == 0)
a6e9f9df
AM		 339 return NULL;
340
57028622
NC		 341 /* If the size_t type is smaller than the bfd_size_type, eg because
342 you are building a 32-bit tool on a 64-bit host, then make sure
343 that when the sizes are cast to (size_t) no information is lost. */
344 if (sizeof (size_t) < sizeof (bfd_size_type)
345 && ( (bfd_size_type) ((size_t) size) != size
346 || (bfd_size_type) ((size_t) nmemb) != nmemb))
347 {
348 if (reason)
349 error (_("Size truncation prevents reading 0x%llx elements of size 0x%llx for %s\n"),
350 (unsigned long long) nmemb, (unsigned long long) size, reason);
351 return NULL;
352 }
353
354 /* Check for size overflow. */
355 if (amt < nmemb)
356 {
357 if (reason)
358 error (_("Size overflow prevents reading 0x%llx elements of size 0x%llx for %s\n"),
359 (unsigned long long) nmemb, (unsigned long long) size, reason);
360 return NULL;
361 }
362
c9c1d674
EG		 363 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
364 attempting to allocate memory when the read is bound to fail. */
365 if (amt > current_file_size
366 || offset + archive_file_offset + amt > current_file_size)
a6e9f9df 367 {
049b0c3a 368 if (reason)
57028622
NC		 369 error (_("Reading 0x%llx bytes extends past end of file for %s\n"),
370 (unsigned long long) amt, reason);
a6e9f9df
AM		 371 return NULL;
372 }
373
c9c1d674 374 if (fseek (file, archive_file_offset + offset, SEEK_SET))
071436c6
NC		 375 {
376 if (reason)
c9c1d674
EG		 377 error (_("Unable to seek to 0x%lx for %s\n"),
378 (unsigned long) archive_file_offset + offset, reason);
071436c6
NC		 379 return NULL;
380 }
381
a6e9f9df
AM		 382 mvar = var;
383 if (mvar == NULL)
384 {
c256ffe7 385 /* Check for overflow. */
57028622 386 if (nmemb < (~(bfd_size_type) 0 - 1) / size)
c256ffe7 387 /* + 1 so that we can '\0' terminate invalid string table sections. */
57028622 388 mvar = malloc ((size_t) amt + 1);
a6e9f9df
AM		 389
390 if (mvar == NULL)
391 {
049b0c3a 392 if (reason)
57028622
NC		 393 error (_("Out of memory allocating 0x%llx bytes for %s\n"),
394 (unsigned long long) amt, reason);
a6e9f9df
AM		 395 return NULL;
396 }
c256ffe7 397
c9c1d674 398 ((char *) mvar)[amt] = '\0';
a6e9f9df
AM		 399 }
400
57028622 401 if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
a6e9f9df 402 {
049b0c3a 403 if (reason)
57028622
NC		 404 error (_("Unable to read in 0x%llx bytes of %s\n"),
405 (unsigned long long) amt, reason);
a6e9f9df
AM		 406 if (mvar != var)
407 free (mvar);
408 return NULL;
409 }
410
411 return mvar;
412}
413
14a91970 414/* Print a VMA value. */
cb8f3167 415
66543521 416static int
14a91970 417print_vma (bfd_vma vma, print_mode mode)
66543521 418{
66543521
AM		 419 int nc = 0;
420
14a91970 421 switch (mode)
66543521 422 {
14a91970
AM		 423 case FULL_HEX:
424 nc = printf ("0x");
425 /* Drop through. */
66543521 426
14a91970 427 case LONG_HEX:
f7a99963 428#ifdef BFD64
14a91970 429 if (is_32bit_elf)
437c2fb7 430 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
f7a99963 431#endif
14a91970
AM		 432 printf_vma (vma);
433 return nc + 16;
b19aac67 434
14a91970
AM		 435 case DEC_5:
436 if (vma <= 99999)
437 return printf ("%5" BFD_VMA_FMT "d", vma);
438 /* Drop through. */
66543521 439
14a91970
AM		 440 case PREFIX_HEX:
441 nc = printf ("0x");
442 /* Drop through. */
66543521 443
14a91970
AM		 444 case HEX:
445 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 446
14a91970
AM		 447 case DEC:
448 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 449
14a91970
AM		 450 case UNSIGNED:
451 return printf ("%" BFD_VMA_FMT "u", vma);
f7a99963 452 }
66543521 453 return 0;
f7a99963
NC		 454}
455
7bfd842d 456/* Display a symbol on stdout. Handles the display of control characters and
3bfcb652 457 multibye characters (assuming the host environment supports them).
31104126 458
7bfd842d
NC		 459 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
460
461 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
462 padding as necessary.
171191ba
NC		 463
464 Returns the number of emitted characters. */
465
466static unsigned int
7a88bc9c 467print_symbol (int width, const char *symbol)
31104126 468{
171191ba 469 bfd_boolean extra_padding = FALSE;
7bfd842d 470 int num_printed = 0;
3bfcb652 471#ifdef HAVE_MBSTATE_T
7bfd842d 472 mbstate_t state;
3bfcb652 473#endif
7bfd842d 474 int width_remaining;
961c521f 475
7bfd842d 476 if (width < 0)
961c521f 477 {
961c521f
NC		 478 /* Keep the width positive. This also helps. */
479 width = - width;
171191ba 480 extra_padding = TRUE;
0b4362b0 481 }
74e1a04b 482 assert (width != 0);
961c521f 483
7bfd842d
NC		 484 if (do_wide)
485 /* Set the remaining width to a very large value.
486 This simplifies the code below. */
487 width_remaining = INT_MAX;
488 else
489 width_remaining = width;
cb8f3167 490
3bfcb652 491#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 492 /* Initialise the multibyte conversion state. */
493 memset (& state, 0, sizeof (state));
3bfcb652 494#endif
961c521f 495
7bfd842d
NC		 496 while (width_remaining)
497 {
498 size_t n;
7bfd842d 499 const char c = *symbol++;
961c521f 500
7bfd842d 501 if (c == 0)
961c521f
NC		 502 break;
503
7bfd842d
NC		 504 /* Do not print control characters directly as they can affect terminal
505 settings. Such characters usually appear in the names generated
506 by the assembler for local labels. */
507 if (ISCNTRL (c))
961c521f 508 {
7bfd842d 509 if (width_remaining < 2)
961c521f
NC		 510 break;
511
7bfd842d
NC		 512 printf ("^%c", c + 0x40);
513 width_remaining -= 2;
171191ba 514 num_printed += 2;
961c521f 515 }
7bfd842d
NC		 516 else if (ISPRINT (c))
517 {
518 putchar (c);
519 width_remaining --;
520 num_printed ++;
521 }
961c521f
NC		 522 else
523 {
3bfcb652
NC		 524#ifdef HAVE_MBSTATE_T
525 wchar_t w;
526#endif
7bfd842d
NC		 527 /* Let printf do the hard work of displaying multibyte characters. */
528 printf ("%.1s", symbol - 1);
529 width_remaining --;
530 num_printed ++;
531
3bfcb652 532#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 533 /* Try to find out how many bytes made up the character that was
534 just printed. Advance the symbol pointer past the bytes that
535 were displayed. */
536 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
3bfcb652
NC		 537#else
538 n = 1;
539#endif
7bfd842d
NC		 540 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
541 symbol += (n - 1);
961c521f 542 }
961c521f 543 }
171191ba 544
7bfd842d 545 if (extra_padding && num_printed < width)
171191ba
NC		 546 {
547 /* Fill in the remaining spaces. */
7bfd842d
NC		 548 printf ("%-*s", width - num_printed, " ");
549 num_printed = width;
171191ba
NC		 550 }
551
552 return num_printed;
31104126
NC		 553}
554
74e1a04b
NC		 555/* Returns a pointer to a static buffer containing a printable version of
556 the given section's name. Like print_symbol, except that it does not try
557 to print multibyte characters, it just interprets them as hex values. */
558
559static const char *
0d2a7a93 560printable_section_name (const Elf_Internal_Shdr * sec)
74e1a04b
NC		 561{
562#define MAX_PRINT_SEC_NAME_LEN 128
563 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
564 const char * name = SECTION_NAME (sec);
565 char * buf = sec_name_buf;
566 char c;
567 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
568
569 while ((c = * name ++) != 0)
570 {
571 if (ISCNTRL (c))
572 {
573 if (remaining < 2)
574 break;
948f632f 575
74e1a04b
NC		 576 * buf ++ = '^';
577 * buf ++ = c + 0x40;
578 remaining -= 2;
579 }
580 else if (ISPRINT (c))
581 {
582 * buf ++ = c;
583 remaining -= 1;
584 }
585 else
586 {
587 static char hex[17] = "0123456789ABCDEF";
588
589 if (remaining < 4)
590 break;
591 * buf ++ = '<';
592 * buf ++ = hex[(c & 0xf0) >> 4];
593 * buf ++ = hex[c & 0x0f];
594 * buf ++ = '>';
595 remaining -= 4;
596 }
597
598 if (remaining == 0)
599 break;
600 }
601
602 * buf = 0;
603 return sec_name_buf;
604}
605
606static const char *
607printable_section_name_from_index (unsigned long ndx)
608{
609 if (ndx >= elf_header.e_shnum)
610 return _("<corrupt>");
611
612 return printable_section_name (section_headers + ndx);
613}
614
89fac5e3
RS		 615/* Return a pointer to section NAME, or NULL if no such section exists. */
616
617static Elf_Internal_Shdr *
2cf0635d 618find_section (const char * name)
89fac5e3
RS		 619{
620 unsigned int i;
621
622 for (i = 0; i < elf_header.e_shnum; i++)
623 if (streq (SECTION_NAME (section_headers + i), name))
624 return section_headers + i;
625
626 return NULL;
627}
628
0b6ae522
DJ		 629/* Return a pointer to a section containing ADDR, or NULL if no such
630 section exists. */
631
632static Elf_Internal_Shdr *
633find_section_by_address (bfd_vma addr)
634{
635 unsigned int i;
636
637 for (i = 0; i < elf_header.e_shnum; i++)
638 {
639 Elf_Internal_Shdr *sec = section_headers + i;
640 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
641 return sec;
642 }
643
644 return NULL;
645}
646
071436c6
NC		 647static Elf_Internal_Shdr *
648find_section_by_type (unsigned int type)
649{
650 unsigned int i;
651
652 for (i = 0; i < elf_header.e_shnum; i++)
653 {
654 Elf_Internal_Shdr *sec = section_headers + i;
655 if (sec->sh_type == type)
656 return sec;
657 }
658
659 return NULL;
660}
661
657d0d47
CC		 662/* Return a pointer to section NAME, or NULL if no such section exists,
663 restricted to the list of sections given in SET. */
664
665static Elf_Internal_Shdr *
666find_section_in_set (const char * name, unsigned int * set)
667{
668 unsigned int i;
669
670 if (set != NULL)
671 {
672 while ((i = *set++) > 0)
673 if (streq (SECTION_NAME (section_headers + i), name))
674 return section_headers + i;
675 }
676
677 return find_section (name);
678}
679
0b6ae522
DJ		 680/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
681 bytes read. */
682
f6f0e17b
NC		 683static inline unsigned long
684read_uleb128 (unsigned char *data,
685 unsigned int *length_return,
686 const unsigned char * const end)
0b6ae522 687{
f6f0e17b 688 return read_leb128 (data, length_return, FALSE, end);
0b6ae522
DJ		 689}
690
28f997cf
TG		 691/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
692 This OS has so many departures from the ELF standard that we test it at
693 many places. */
694
695static inline int
696is_ia64_vms (void)
697{
698 return elf_header.e_machine == EM_IA_64
699 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
700}
701
bcedfee6 702/* Guess the relocation size commonly used by the specific machines. */
252b5132 703
252b5132 704static int
2dc4cec1 705guess_is_rela (unsigned int e_machine)
252b5132 706{
9c19a809 707 switch (e_machine)
252b5132
RH		 708 {
709 /* Targets that use REL relocations. */
252b5132 710 case EM_386:
22abe556 711 case EM_IAMCU:
63fcb9e9 712 case EM_960:
e9f53129 713 case EM_ARM:
2b0337b0 714 case EM_D10V:
252b5132 715 case EM_CYGNUS_D10V:
e9f53129 716 case EM_DLX:
252b5132 717 case EM_MIPS:
4fe85591 718 case EM_MIPS_RS3_LE:
e9f53129 719 case EM_CYGNUS_M32R:
1c0d3aa6 720 case EM_SCORE:
f6c1a2d5 721 case EM_XGATE:
9c19a809 722 return FALSE;
103f02d3 723
252b5132
RH		 724 /* Targets that use RELA relocations. */
725 case EM_68K:
e9f53129 726 case EM_860:
a06ea964 727 case EM_AARCH64:
cfb8c092 728 case EM_ADAPTEVA_EPIPHANY:
e9f53129
AM		 729 case EM_ALPHA:
730 case EM_ALTERA_NIOS2:
886a2506
NC		 731 case EM_ARC:
732 case EM_ARC_COMPACT:
733 case EM_ARC_COMPACT2:
e9f53129
AM		 734 case EM_AVR:
735 case EM_AVR_OLD:
736 case EM_BLACKFIN:
60bca95a 737 case EM_CR16:
e9f53129
AM		 738 case EM_CRIS:
739 case EM_CRX:
2b0337b0 740 case EM_D30V:
252b5132 741 case EM_CYGNUS_D30V:
2b0337b0 742 case EM_FR30:
3f8107ab 743 case EM_FT32:
252b5132 744 case EM_CYGNUS_FR30:
5c70f934 745 case EM_CYGNUS_FRV:
e9f53129
AM		 746 case EM_H8S:
747 case EM_H8_300:
748 case EM_H8_300H:
800eeca4 749 case EM_IA_64:
1e4cf259
NC		 750 case EM_IP2K:
751 case EM_IP2K_OLD:
3b36097d 752 case EM_IQ2000:
84e94c90 753 case EM_LATTICEMICO32:
ff7eeb89 754 case EM_M32C_OLD:
49f58d10 755 case EM_M32C:
e9f53129
AM		 756 case EM_M32R:
757 case EM_MCORE:
15ab5209 758 case EM_CYGNUS_MEP:
a3c62988 759 case EM_METAG:
e9f53129
AM		 760 case EM_MMIX:
761 case EM_MN10200:
762 case EM_CYGNUS_MN10200:
763 case EM_MN10300:
764 case EM_CYGNUS_MN10300:
5506d11a 765 case EM_MOXIE:
e9f53129
AM		 766 case EM_MSP430:
767 case EM_MSP430_OLD:
d031aafb 768 case EM_MT:
35c08157 769 case EM_NDS32:
64fd6348 770 case EM_NIOS32:
73589c9d 771 case EM_OR1K:
e9f53129
AM		 772 case EM_PPC64:
773 case EM_PPC:
99c513f6 774 case EM_RL78:
c7927a3c 775 case EM_RX:
e9f53129
AM		 776 case EM_S390:
777 case EM_S390_OLD:
778 case EM_SH:
779 case EM_SPARC:
780 case EM_SPARC32PLUS:
781 case EM_SPARCV9:
782 case EM_SPU:
40b36596 783 case EM_TI_C6000:
aa137e4d
NC		 784 case EM_TILEGX:
785 case EM_TILEPRO:
708e2187 786 case EM_V800:
e9f53129
AM		 787 case EM_V850:
788 case EM_CYGNUS_V850:
789 case EM_VAX:
619ed720 790 case EM_VISIUM:
e9f53129 791 case EM_X86_64:
8a9036a4 792 case EM_L1OM:
7a9068fe 793 case EM_K1OM:
e9f53129
AM		 794 case EM_XSTORMY16:
795 case EM_XTENSA:
796 case EM_XTENSA_OLD:
7ba29e2a
NC		 797 case EM_MICROBLAZE:
798 case EM_MICROBLAZE_OLD:
9c19a809 799 return TRUE;
103f02d3 800
e9f53129
AM		 801 case EM_68HC05:
802 case EM_68HC08:
803 case EM_68HC11:
804 case EM_68HC16:
805 case EM_FX66:
806 case EM_ME16:
d1133906 807 case EM_MMA:
d1133906
NC		 808 case EM_NCPU:
809 case EM_NDR1:
e9f53129 810 case EM_PCP:
d1133906 811 case EM_ST100:
e9f53129 812 case EM_ST19:
d1133906 813 case EM_ST7:
e9f53129
AM		 814 case EM_ST9PLUS:
815 case EM_STARCORE:
d1133906 816 case EM_SVX:
e9f53129 817 case EM_TINYJ:
9c19a809
NC		 818 default:
819 warn (_("Don't know about relocations on this machine architecture\n"));
820 return FALSE;
821 }
822}
252b5132 823
9c19a809 824static int
2cf0635d 825slurp_rela_relocs (FILE * file,
d3ba0551
AM		 826 unsigned long rel_offset,
827 unsigned long rel_size,
2cf0635d
NC		 828 Elf_Internal_Rela ** relasp,
829 unsigned long * nrelasp)
9c19a809 830{
2cf0635d 831 Elf_Internal_Rela * relas;
8b73c356 832 size_t nrelas;
4d6ed7c8 833 unsigned int i;
252b5132 834
4d6ed7c8
NC		 835 if (is_32bit_elf)
836 {
2cf0635d 837 Elf32_External_Rela * erelas;
103f02d3 838
3f5e193b 839 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 840 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 841 if (!erelas)
842 return 0;
252b5132 843
4d6ed7c8 844 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 845
3f5e193b
NC		 846 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
847 sizeof (Elf_Internal_Rela));
103f02d3 848
4d6ed7c8
NC		 849 if (relas == NULL)
850 {
c256ffe7 851 free (erelas);
591a748a 852 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 853 return 0;
854 }
103f02d3 855
4d6ed7c8
NC		 856 for (i = 0; i < nrelas; i++)
857 {
858 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
859 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 860 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 861 }
103f02d3 862
4d6ed7c8
NC		 863 free (erelas);
864 }
865 else
866 {
2cf0635d 867 Elf64_External_Rela * erelas;
103f02d3 868
3f5e193b 869 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 870 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 871 if (!erelas)
872 return 0;
4d6ed7c8
NC		 873
874 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 875
3f5e193b
NC		 876 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
877 sizeof (Elf_Internal_Rela));
103f02d3 878
4d6ed7c8
NC		 879 if (relas == NULL)
880 {
c256ffe7 881 free (erelas);
591a748a 882 error (_("out of memory parsing relocs\n"));
4d6ed7c8 883 return 0;
9c19a809 884 }
4d6ed7c8
NC		 885
886 for (i = 0; i < nrelas; i++)
9c19a809 887 {
66543521
AM		 888 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
889 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 890 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 891
892 /* The #ifdef BFD64 below is to prevent a compile time
893 warning. We know that if we do not have a 64 bit data
894 type that we will never execute this code anyway. */
895#ifdef BFD64
896 if (elf_header.e_machine == EM_MIPS
897 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
898 {
899 /* In little-endian objects, r_info isn't really a
900 64-bit little-endian value: it has a 32-bit
901 little-endian symbol index followed by four
902 individual byte fields. Reorder INFO
903 accordingly. */
91d6fa6a
NC		 904 bfd_vma inf = relas[i].r_info;
905 inf = (((inf & 0xffffffff) << 32)
906 | ((inf >> 56) & 0xff)
907 | ((inf >> 40) & 0xff00)
908 | ((inf >> 24) & 0xff0000)
909 | ((inf >> 8) & 0xff000000));
910 relas[i].r_info = inf;
861fb55a
DJ		 911 }
912#endif /* BFD64 */
4d6ed7c8 913 }
103f02d3 914
4d6ed7c8
NC		 915 free (erelas);
916 }
917 *relasp = relas;
918 *nrelasp = nrelas;
919 return 1;
920}
103f02d3 921
4d6ed7c8 922static int
2cf0635d 923slurp_rel_relocs (FILE * file,
d3ba0551
AM		 924 unsigned long rel_offset,
925 unsigned long rel_size,
2cf0635d
NC		 926 Elf_Internal_Rela ** relsp,
927 unsigned long * nrelsp)
4d6ed7c8 928{
2cf0635d 929 Elf_Internal_Rela * rels;
8b73c356 930 size_t nrels;
4d6ed7c8 931 unsigned int i;
103f02d3 932
4d6ed7c8
NC		 933 if (is_32bit_elf)
934 {
2cf0635d 935 Elf32_External_Rel * erels;
103f02d3 936
3f5e193b 937 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 938 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 939 if (!erels)
940 return 0;
103f02d3 941
4d6ed7c8 942 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 943
3f5e193b 944 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 945
4d6ed7c8
NC		 946 if (rels == NULL)
947 {
c256ffe7 948 free (erels);
591a748a 949 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 950 return 0;
951 }
952
953 for (i = 0; i < nrels; i++)
954 {
955 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
956 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 957 rels[i].r_addend = 0;
9ea033b2 958 }
4d6ed7c8
NC		 959
960 free (erels);
9c19a809
NC		 961 }
962 else
963 {
2cf0635d 964 Elf64_External_Rel * erels;
9ea033b2 965
3f5e193b 966 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 967 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 968 if (!erels)
969 return 0;
103f02d3 970
4d6ed7c8 971 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 972
3f5e193b 973 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 974
4d6ed7c8 975 if (rels == NULL)
9c19a809 976 {
c256ffe7 977 free (erels);
591a748a 978 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 979 return 0;
980 }
103f02d3 981
4d6ed7c8
NC		 982 for (i = 0; i < nrels; i++)
983 {
66543521
AM		 984 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
985 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 986 rels[i].r_addend = 0;
861fb55a
DJ		 987
988 /* The #ifdef BFD64 below is to prevent a compile time
989 warning. We know that if we do not have a 64 bit data
990 type that we will never execute this code anyway. */
991#ifdef BFD64
992 if (elf_header.e_machine == EM_MIPS
993 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
994 {
995 /* In little-endian objects, r_info isn't really a
996 64-bit little-endian value: it has a 32-bit
997 little-endian symbol index followed by four
998 individual byte fields. Reorder INFO
999 accordingly. */
91d6fa6a
NC		 1000 bfd_vma inf = rels[i].r_info;
1001 inf = (((inf & 0xffffffff) << 32)
1002 | ((inf >> 56) & 0xff)
1003 | ((inf >> 40) & 0xff00)
1004 | ((inf >> 24) & 0xff0000)
1005 | ((inf >> 8) & 0xff000000));
1006 rels[i].r_info = inf;
861fb55a
DJ		 1007 }
1008#endif /* BFD64 */
4d6ed7c8 1009 }
103f02d3 1010
4d6ed7c8
NC		 1011 free (erels);
1012 }
1013 *relsp = rels;
1014 *nrelsp = nrels;
1015 return 1;
1016}
103f02d3 1017
aca88567
NC		 1018/* Returns the reloc type extracted from the reloc info field. */
1019
1020static unsigned int
1021get_reloc_type (bfd_vma reloc_info)
1022{
1023 if (is_32bit_elf)
1024 return ELF32_R_TYPE (reloc_info);
1025
1026 switch (elf_header.e_machine)
1027 {
1028 case EM_MIPS:
1029 /* Note: We assume that reloc_info has already been adjusted for us. */
1030 return ELF64_MIPS_R_TYPE (reloc_info);
1031
1032 case EM_SPARCV9:
1033 return ELF64_R_TYPE_ID (reloc_info);
1034
1035 default:
1036 return ELF64_R_TYPE (reloc_info);
1037 }
1038}
1039
1040/* Return the symbol index extracted from the reloc info field. */
1041
1042static bfd_vma
1043get_reloc_symindex (bfd_vma reloc_info)
1044{
1045 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1046}
1047
13761a11
NC		 1048static inline bfd_boolean
1049uses_msp430x_relocs (void)
1050{
1051 return
1052 elf_header.e_machine == EM_MSP430 /* Paranoia. */
1053 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1054 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1055 /* TI compiler uses ELFOSABI_NONE. */
1056 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1057}
1058
d3ba0551
AM		 1059/* Display the contents of the relocation data found at the specified
1060 offset. */
ee42cf8c 1061
41e92641 1062static void
2cf0635d 1063dump_relocations (FILE * file,
d3ba0551
AM		 1064 unsigned long rel_offset,
1065 unsigned long rel_size,
2cf0635d 1066 Elf_Internal_Sym * symtab,
d3ba0551 1067 unsigned long nsyms,
2cf0635d 1068 char * strtab,
d79b3d50 1069 unsigned long strtablen,
bb4d2ac2
L		 1070 int is_rela,
1071 int is_dynsym)
4d6ed7c8 1072{
b34976b6 1073 unsigned int i;
2cf0635d 1074 Elf_Internal_Rela * rels;
103f02d3 1075
4d6ed7c8
NC		 1076 if (is_rela == UNKNOWN)
1077 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 1078
4d6ed7c8
NC		 1079 if (is_rela)
1080 {
c8286bd1 1081 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1082 return;
4d6ed7c8
NC		 1083 }
1084 else
1085 {
1086 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1087 return;
252b5132
RH		 1088 }
1089
410f7a12
L		 1090 if (is_32bit_elf)
1091 {
1092 if (is_rela)
2c71103e
NC		 1093 {
1094 if (do_wide)
1095 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1096 else
1097 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1098 }
410f7a12 1099 else
2c71103e
NC		 1100 {
1101 if (do_wide)
1102 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1103 else
1104 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1105 }
410f7a12 1106 }
252b5132 1107 else
410f7a12
L		 1108 {
1109 if (is_rela)
2c71103e
NC		 1110 {
1111 if (do_wide)
8beeaeb7 1112 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 1113 else
1114 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1115 }
410f7a12 1116 else
2c71103e
NC		 1117 {
1118 if (do_wide)
8beeaeb7 1119 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 1120 else
1121 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1122 }
410f7a12 1123 }
252b5132
RH		 1124
1125 for (i = 0; i < rel_size; i++)
1126 {
2cf0635d 1127 const char * rtype;
b34976b6 1128 bfd_vma offset;
91d6fa6a 1129 bfd_vma inf;
b34976b6
AM		 1130 bfd_vma symtab_index;
1131 bfd_vma type;
103f02d3 1132
b34976b6 1133 offset = rels[i].r_offset;
91d6fa6a 1134 inf = rels[i].r_info;
103f02d3 1135
91d6fa6a
NC		 1136 type = get_reloc_type (inf);
1137 symtab_index = get_reloc_symindex (inf);
252b5132 1138
410f7a12
L		 1139 if (is_32bit_elf)
1140 {
39dbeff8
AM		 1141 printf ("%8.8lx %8.8lx ",
1142 (unsigned long) offset & 0xffffffff,
91d6fa6a 1143 (unsigned long) inf & 0xffffffff);
410f7a12
L		 1144 }
1145 else
1146 {
39dbeff8
AM		 1147#if BFD_HOST_64BIT_LONG
1148 printf (do_wide
1149 ? "%16.16lx %16.16lx "
1150 : "%12.12lx %12.12lx ",
91d6fa6a 1151 offset, inf);
39dbeff8 1152#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 1153#ifndef __MSVCRT__
39dbeff8
AM		 1154 printf (do_wide
1155 ? "%16.16llx %16.16llx "
1156 : "%12.12llx %12.12llx ",
91d6fa6a 1157 offset, inf);
6e3d6dc1
NC		 1158#else
1159 printf (do_wide
1160 ? "%16.16I64x %16.16I64x "
1161 : "%12.12I64x %12.12I64x ",
91d6fa6a 1162 offset, inf);
6e3d6dc1 1163#endif
39dbeff8 1164#else
2c71103e
NC		 1165 printf (do_wide
1166 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1167 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 1168 _bfd_int64_high (offset),
1169 _bfd_int64_low (offset),
91d6fa6a
NC		 1170 _bfd_int64_high (inf),
1171 _bfd_int64_low (inf));
9ea033b2 1172#endif
410f7a12 1173 }
103f02d3 1174
252b5132
RH		 1175 switch (elf_header.e_machine)
1176 {
1177 default:
1178 rtype = NULL;
1179 break;
1180
a06ea964
NC		 1181 case EM_AARCH64:
1182 rtype = elf_aarch64_reloc_type (type);
1183 break;
1184
2b0337b0 1185 case EM_M32R:
252b5132 1186 case EM_CYGNUS_M32R:
9ea033b2 1187 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 1188 break;
1189
1190 case EM_386:
22abe556 1191 case EM_IAMCU:
9ea033b2 1192 rtype = elf_i386_reloc_type (type);
252b5132
RH		 1193 break;
1194
ba2685cc
AM		 1195 case EM_68HC11:
1196 case EM_68HC12:
1197 rtype = elf_m68hc11_reloc_type (type);
1198 break;
75751cd9 1199
252b5132 1200 case EM_68K:
9ea033b2 1201 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1202 break;
1203
63fcb9e9 1204 case EM_960:
9ea033b2 1205 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1206 break;
1207
adde6300 1208 case EM_AVR:
2b0337b0 1209 case EM_AVR_OLD:
adde6300
AM		 1210 rtype = elf_avr_reloc_type (type);
1211 break;
1212
9ea033b2
NC		 1213 case EM_OLD_SPARCV9:
1214 case EM_SPARC32PLUS:
1215 case EM_SPARCV9:
252b5132 1216 case EM_SPARC:
9ea033b2 1217 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1218 break;
1219
e9f53129
AM		 1220 case EM_SPU:
1221 rtype = elf_spu_reloc_type (type);
1222 break;
1223
708e2187
NC		 1224 case EM_V800:
1225 rtype = v800_reloc_type (type);
1226 break;
2b0337b0 1227 case EM_V850:
252b5132 1228 case EM_CYGNUS_V850:
9ea033b2 1229 rtype = v850_reloc_type (type);
252b5132
RH		 1230 break;
1231
2b0337b0 1232 case EM_D10V:
252b5132 1233 case EM_CYGNUS_D10V:
9ea033b2 1234 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1235 break;
1236
2b0337b0 1237 case EM_D30V:
252b5132 1238 case EM_CYGNUS_D30V:
9ea033b2 1239 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1240 break;
1241
d172d4ba
NC		 1242 case EM_DLX:
1243 rtype = elf_dlx_reloc_type (type);
1244 break;
1245
252b5132 1246 case EM_SH:
9ea033b2 1247 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1248 break;
1249
2b0337b0 1250 case EM_MN10300:
252b5132 1251 case EM_CYGNUS_MN10300:
9ea033b2 1252 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1253 break;
1254
2b0337b0 1255 case EM_MN10200:
252b5132 1256 case EM_CYGNUS_MN10200:
9ea033b2 1257 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1258 break;
1259
2b0337b0 1260 case EM_FR30:
252b5132 1261 case EM_CYGNUS_FR30:
9ea033b2 1262 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1263 break;
1264
ba2685cc
AM		 1265 case EM_CYGNUS_FRV:
1266 rtype = elf_frv_reloc_type (type);
1267 break;
5c70f934 1268
3f8107ab
AM		 1269 case EM_FT32:
1270 rtype = elf_ft32_reloc_type (type);
1271 break;
1272
252b5132 1273 case EM_MCORE:
9ea033b2 1274 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1275 break;
1276
3c3bdf30
NC		 1277 case EM_MMIX:
1278 rtype = elf_mmix_reloc_type (type);
1279 break;
1280
5506d11a
AM		 1281 case EM_MOXIE:
1282 rtype = elf_moxie_reloc_type (type);
1283 break;
1284
2469cfa2 1285 case EM_MSP430:
13761a11
NC		 1286 if (uses_msp430x_relocs ())
1287 {
1288 rtype = elf_msp430x_reloc_type (type);
1289 break;
1290 }
2469cfa2
NC		 1291 case EM_MSP430_OLD:
1292 rtype = elf_msp430_reloc_type (type);
1293 break;
1294
35c08157
KLC		 1295 case EM_NDS32:
1296 rtype = elf_nds32_reloc_type (type);
1297 break;
1298
252b5132 1299 case EM_PPC:
9ea033b2 1300 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1301 break;
1302
c833c019
AM		 1303 case EM_PPC64:
1304 rtype = elf_ppc64_reloc_type (type);
1305 break;
1306
252b5132 1307 case EM_MIPS:
4fe85591 1308 case EM_MIPS_RS3_LE:
9ea033b2 1309 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1310 break;
1311
1312 case EM_ALPHA:
9ea033b2 1313 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1314 break;
1315
1316 case EM_ARM:
9ea033b2 1317 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1318 break;
1319
584da044 1320 case EM_ARC:
886a2506
NC		 1321 case EM_ARC_COMPACT:
1322 case EM_ARC_COMPACT2:
9ea033b2 1323 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1324 break;
1325
1326 case EM_PARISC:
69e617ca 1327 rtype = elf_hppa_reloc_type (type);
252b5132 1328 break;
7d466069 1329
b8720f9d
JL		 1330 case EM_H8_300:
1331 case EM_H8_300H:
1332 case EM_H8S:
1333 rtype = elf_h8_reloc_type (type);
1334 break;
1335
73589c9d
CS		 1336 case EM_OR1K:
1337 rtype = elf_or1k_reloc_type (type);
3b16e843
NC		 1338 break;
1339
7d466069 1340 case EM_PJ:
2b0337b0 1341 case EM_PJ_OLD:
7d466069
ILT		 1342 rtype = elf_pj_reloc_type (type);
1343 break;
800eeca4
JW		 1344 case EM_IA_64:
1345 rtype = elf_ia64_reloc_type (type);
1346 break;
1b61cf92
HPN		 1347
1348 case EM_CRIS:
1349 rtype = elf_cris_reloc_type (type);
1350 break;
535c37ff
JE		 1351
1352 case EM_860:
1353 rtype = elf_i860_reloc_type (type);
1354 break;
bcedfee6
NC		 1355
1356 case EM_X86_64:
8a9036a4 1357 case EM_L1OM:
7a9068fe 1358 case EM_K1OM:
bcedfee6
NC		 1359 rtype = elf_x86_64_reloc_type (type);
1360 break;
a85d7ed0 1361
35b1837e
AM		 1362 case EM_S370:
1363 rtype = i370_reloc_type (type);
1364 break;
1365
53c7db4b
KH		 1366 case EM_S390_OLD:
1367 case EM_S390:
1368 rtype = elf_s390_reloc_type (type);
1369 break;
93fbbb04 1370
1c0d3aa6
NC		 1371 case EM_SCORE:
1372 rtype = elf_score_reloc_type (type);
1373 break;
1374
93fbbb04
GK		 1375 case EM_XSTORMY16:
1376 rtype = elf_xstormy16_reloc_type (type);
1377 break;
179d3252 1378
1fe1f39c
NC		 1379 case EM_CRX:
1380 rtype = elf_crx_reloc_type (type);
1381 break;
1382
179d3252
JT		 1383 case EM_VAX:
1384 rtype = elf_vax_reloc_type (type);
1385 break;
1e4cf259 1386
619ed720
EB		 1387 case EM_VISIUM:
1388 rtype = elf_visium_reloc_type (type);
1389 break;
1390
cfb8c092
NC		 1391 case EM_ADAPTEVA_EPIPHANY:
1392 rtype = elf_epiphany_reloc_type (type);
1393 break;
1394
1e4cf259
NC		 1395 case EM_IP2K:
1396 case EM_IP2K_OLD:
1397 rtype = elf_ip2k_reloc_type (type);
1398 break;
3b36097d
SC		 1399
1400 case EM_IQ2000:
1401 rtype = elf_iq2000_reloc_type (type);
1402 break;
88da6820
NC		 1403
1404 case EM_XTENSA_OLD:
1405 case EM_XTENSA:
1406 rtype = elf_xtensa_reloc_type (type);
1407 break;
a34e3ecb 1408
84e94c90
NC		 1409 case EM_LATTICEMICO32:
1410 rtype = elf_lm32_reloc_type (type);
1411 break;
1412
ff7eeb89 1413 case EM_M32C_OLD:
49f58d10
JB		 1414 case EM_M32C:
1415 rtype = elf_m32c_reloc_type (type);
1416 break;
1417
d031aafb
NS		 1418 case EM_MT:
1419 rtype = elf_mt_reloc_type (type);
a34e3ecb 1420 break;
1d65ded4
CM		 1421
1422 case EM_BLACKFIN:
1423 rtype = elf_bfin_reloc_type (type);
1424 break;
15ab5209
DB		 1425
1426 case EM_CYGNUS_MEP:
1427 rtype = elf_mep_reloc_type (type);
1428 break;
60bca95a
NC		 1429
1430 case EM_CR16:
1431 rtype = elf_cr16_reloc_type (type);
1432 break;
dd24e3da 1433
7ba29e2a
NC		 1434 case EM_MICROBLAZE:
1435 case EM_MICROBLAZE_OLD:
1436 rtype = elf_microblaze_reloc_type (type);
1437 break;
c7927a3c 1438
99c513f6
DD		 1439 case EM_RL78:
1440 rtype = elf_rl78_reloc_type (type);
1441 break;
1442
c7927a3c
NC		 1443 case EM_RX:
1444 rtype = elf_rx_reloc_type (type);
1445 break;
c29aca4a 1446
a3c62988
NC		 1447 case EM_METAG:
1448 rtype = elf_metag_reloc_type (type);
1449 break;
1450
c29aca4a
NC		 1451 case EM_XC16X:
1452 case EM_C166:
1453 rtype = elf_xc16x_reloc_type (type);
1454 break;
40b36596
JM		 1455
1456 case EM_TI_C6000:
1457 rtype = elf_tic6x_reloc_type (type);
1458 break;
aa137e4d
NC		 1459
1460 case EM_TILEGX:
1461 rtype = elf_tilegx_reloc_type (type);
1462 break;
1463
1464 case EM_TILEPRO:
1465 rtype = elf_tilepro_reloc_type (type);
1466 break;
f6c1a2d5
NC		 1467
1468 case EM_XGATE:
1469 rtype = elf_xgate_reloc_type (type);
1470 break;
36591ba1
SL		 1471
1472 case EM_ALTERA_NIOS2:
1473 rtype = elf_nios2_reloc_type (type);
1474 break;
252b5132
RH		 1475 }
1476
1477 if (rtype == NULL)
39dbeff8 1478 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1479 else
8beeaeb7 1480 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1481
7ace3541 1482 if (elf_header.e_machine == EM_ALPHA
157c2599 1483 && rtype != NULL
7ace3541
RH		 1484 && streq (rtype, "R_ALPHA_LITUSE")
1485 && is_rela)
1486 {
1487 switch (rels[i].r_addend)
1488 {
1489 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1490 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1491 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1492 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1493 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1494 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1495 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1496 default: rtype = NULL;
1497 }
1498 if (rtype)
1499 printf (" (%s)", rtype);
1500 else
1501 {
1502 putchar (' ');
1503 printf (_("<unknown addend: %lx>"),
1504 (unsigned long) rels[i].r_addend);
1505 }
1506 }
1507 else if (symtab_index)
252b5132 1508 {
af3fc3bc 1509 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1510 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1511 else
19936277 1512 {
2cf0635d 1513 Elf_Internal_Sym * psym;
bb4d2ac2
L		 1514 const char * version_string;
1515 enum versioned_symbol_info sym_info;
1516 unsigned short vna_other;
19936277 1517
af3fc3bc 1518 psym = symtab + symtab_index;
103f02d3 1519
bb4d2ac2
L		 1520 version_string
1521 = get_symbol_version_string (file, is_dynsym,
1522 strtab, strtablen,
1523 symtab_index,
1524 psym,
1525 &sym_info,
1526 &vna_other);
1527
af3fc3bc 1528 printf (" ");
171191ba 1529
d8045f23
NC		 1530 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1531 {
1532 const char * name;
1533 unsigned int len;
1534 unsigned int width = is_32bit_elf ? 8 : 14;
1535
1536 /* Relocations against GNU_IFUNC symbols do not use the value
1537 of the symbol as the address to relocate against. Instead
1538 they invoke the function named by the symbol and use its
1539 result as the address for relocation.
1540
1541 To indicate this to the user, do not display the value of
1542 the symbol in the "Symbols's Value" field. Instead show
1543 its name followed by () as a hint that the symbol is
1544 invoked. */
1545
1546 if (strtab == NULL
1547 || psym->st_name == 0
1548 || psym->st_name >= strtablen)
1549 name = "??";
1550 else
1551 name = strtab + psym->st_name;
1552
1553 len = print_symbol (width, name);
bb4d2ac2
L		 1554 if (version_string)
1555 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1556 version_string);
d8045f23
NC		 1557 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1558 }
1559 else
1560 {
1561 print_vma (psym->st_value, LONG_HEX);
171191ba 1562
d8045f23
NC		 1563 printf (is_32bit_elf ? " " : " ");
1564 }
103f02d3 1565
af3fc3bc 1566 if (psym->st_name == 0)
f1ef08cb 1567 {
2cf0635d 1568 const char * sec_name = "<null>";
f1ef08cb
AM		 1569 char name_buf[40];
1570
1571 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1572 {
4fbb74a6 1573 if (psym->st_shndx < elf_header.e_shnum)
74e1a04b 1574 sec_name = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1575 else if (psym->st_shndx == SHN_ABS)
1576 sec_name = "ABS";
1577 else if (psym->st_shndx == SHN_COMMON)
1578 sec_name = "COMMON";
ac145307
BS		 1579 else if ((elf_header.e_machine == EM_MIPS
1580 && psym->st_shndx == SHN_MIPS_SCOMMON)
1581 || (elf_header.e_machine == EM_TI_C6000
1582 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1583 sec_name = "SCOMMON";
1584 else if (elf_header.e_machine == EM_MIPS
1585 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1586 sec_name = "SUNDEF";
8a9036a4 1587 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1588 || elf_header.e_machine == EM_L1OM
1589 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1590 && psym->st_shndx == SHN_X86_64_LCOMMON)
1591 sec_name = "LARGE_COMMON";
9ce701e2
L		 1592 else if (elf_header.e_machine == EM_IA_64
1593 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1594 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1595 sec_name = "ANSI_COM";
28f997cf 1596 else if (is_ia64_vms ()
148b93f2
NC		 1597 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1598 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1599 else
1600 {
1601 sprintf (name_buf, "<section 0x%x>",
1602 (unsigned int) psym->st_shndx);
1603 sec_name = name_buf;
1604 }
1605 }
1606 print_symbol (22, sec_name);
1607 }
af3fc3bc 1608 else if (strtab == NULL)
d79b3d50 1609 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1610 else if (psym->st_name >= strtablen)
d79b3d50 1611 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1612 else
bb4d2ac2
L		 1613 {
1614 print_symbol (22, strtab + psym->st_name);
1615 if (version_string)
1616 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1617 version_string);
1618 }
103f02d3 1619
af3fc3bc 1620 if (is_rela)
171191ba 1621 {
7360e63f 1622 bfd_vma off = rels[i].r_addend;
171191ba 1623
7360e63f 1624 if ((bfd_signed_vma) off < 0)
598aaa76 1625 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1626 else
598aaa76 1627 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1628 }
19936277 1629 }
252b5132 1630 }
1b228002 1631 else if (is_rela)
f7a99963 1632 {
7360e63f 1633 bfd_vma off = rels[i].r_addend;
e04d7088
L		 1634
1635 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
7360e63f 1636 if ((bfd_signed_vma) off < 0)
e04d7088
L		 1637 printf ("-%" BFD_VMA_FMT "x", - off);
1638 else
1639 printf ("%" BFD_VMA_FMT "x", off);
f7a99963 1640 }
252b5132 1641
157c2599
NC		 1642 if (elf_header.e_machine == EM_SPARCV9
1643 && rtype != NULL
1644 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1645 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1646
252b5132 1647 putchar ('\n');
2c71103e 1648
aca88567 1649#ifdef BFD64
53c7db4b 1650 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1651 {
91d6fa6a
NC		 1652 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1653 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1654 const char * rtype2 = elf_mips_reloc_type (type2);
1655 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1656
2c71103e
NC		 1657 printf (" Type2: ");
1658
1659 if (rtype2 == NULL)
39dbeff8
AM		 1660 printf (_("unrecognized: %-7lx"),
1661 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1662 else
1663 printf ("%-17.17s", rtype2);
1664
18bd398b 1665 printf ("\n Type3: ");
2c71103e
NC		 1666
1667 if (rtype3 == NULL)
39dbeff8
AM		 1668 printf (_("unrecognized: %-7lx"),
1669 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1670 else
1671 printf ("%-17.17s", rtype3);
1672
53c7db4b 1673 putchar ('\n');
2c71103e 1674 }
aca88567 1675#endif /* BFD64 */
252b5132
RH		 1676 }
1677
c8286bd1 1678 free (rels);
252b5132
RH		 1679}
1680
1681static const char *
d3ba0551 1682get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1683{
1684 switch (type)
1685 {
1686 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1687 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1688 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1689 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1690 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1691 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1692 case DT_MIPS_MSYM: return "MIPS_MSYM";
1693 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1694 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1695 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1696 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1697 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1698 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1699 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1700 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1701 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1702 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
a5499fa4 1703 case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
252b5132
RH		 1704 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1705 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1706 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1707 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1708 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1709 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1710 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1711 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1712 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1713 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1714 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1715 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1716 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1717 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1718 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1719 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1720 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1721 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1722 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1723 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1724 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1725 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1726 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1727 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1728 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1729 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1730 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1731 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1732 default:
1733 return NULL;
1734 }
1735}
1736
9a097730 1737static const char *
d3ba0551 1738get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1739{
1740 switch (type)
1741 {
1742 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1743 default:
1744 return NULL;
1745 }
103f02d3
UD		 1746}
1747
7490d522
AM		 1748static const char *
1749get_ppc_dynamic_type (unsigned long type)
1750{
1751 switch (type)
1752 {
a7f2871e 1753 case DT_PPC_GOT: return "PPC_GOT";
e8910a83 1754 case DT_PPC_OPT: return "PPC_OPT";
7490d522
AM		 1755 default:
1756 return NULL;
1757 }
1758}
1759
f1cb7e17 1760static const char *
d3ba0551 1761get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1762{
1763 switch (type)
1764 {
a7f2871e
AM		 1765 case DT_PPC64_GLINK: return "PPC64_GLINK";
1766 case DT_PPC64_OPD: return "PPC64_OPD";
1767 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
e8910a83 1768 case DT_PPC64_OPT: return "PPC64_OPT";
f1cb7e17
AM		 1769 default:
1770 return NULL;
1771 }
1772}
1773
103f02d3 1774static const char *
d3ba0551 1775get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1776{
1777 switch (type)
1778 {
1779 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1780 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1781 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1782 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1783 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1784 case DT_HP_PREINIT: return "HP_PREINIT";
1785 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1786 case DT_HP_NEEDED: return "HP_NEEDED";
1787 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1788 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1789 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1790 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1791 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1792 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1793 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1794 case DT_HP_FILTERED: return "HP_FILTERED";
1795 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1796 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1797 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1798 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1799 case DT_PLT: return "PLT";
1800 case DT_PLT_SIZE: return "PLT_SIZE";
1801 case DT_DLT: return "DLT";
1802 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1803 default:
1804 return NULL;
1805 }
1806}
9a097730 1807
ecc51f48 1808static const char *
d3ba0551 1809get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1810{
1811 switch (type)
1812 {
148b93f2
NC		 1813 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1814 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1815 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1816 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1817 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1818 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1819 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1820 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1821 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1822 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1823 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1824 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1825 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1826 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1827 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1828 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1829 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1830 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1831 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1832 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1833 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1834 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1835 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1836 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1837 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1838 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1839 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1840 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1841 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1842 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1843 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1844 default:
1845 return NULL;
1846 }
1847}
1848
fabcb361
RH		 1849static const char *
1850get_alpha_dynamic_type (unsigned long type)
1851{
1852 switch (type)
1853 {
1854 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1855 default:
1856 return NULL;
1857 }
1858}
1859
1c0d3aa6
NC		 1860static const char *
1861get_score_dynamic_type (unsigned long type)
1862{
1863 switch (type)
1864 {
1865 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1866 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1867 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1868 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1869 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1870 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1871 default:
1872 return NULL;
1873 }
1874}
1875
40b36596
JM		 1876static const char *
1877get_tic6x_dynamic_type (unsigned long type)
1878{
1879 switch (type)
1880 {
1881 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1882 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1883 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1884 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1885 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1886 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1887 default:
1888 return NULL;
1889 }
1890}
1c0d3aa6 1891
36591ba1
SL		 1892static const char *
1893get_nios2_dynamic_type (unsigned long type)
1894{
1895 switch (type)
1896 {
1897 case DT_NIOS2_GP: return "NIOS2_GP";
1898 default:
1899 return NULL;
1900 }
1901}
1902
252b5132 1903static const char *
d3ba0551 1904get_dynamic_type (unsigned long type)
252b5132 1905{
e9e44622 1906 static char buff[64];
252b5132
RH		 1907
1908 switch (type)
1909 {
1910 case DT_NULL: return "NULL";
1911 case DT_NEEDED: return "NEEDED";
1912 case DT_PLTRELSZ: return "PLTRELSZ";
1913 case DT_PLTGOT: return "PLTGOT";
1914 case DT_HASH: return "HASH";
1915 case DT_STRTAB: return "STRTAB";
1916 case DT_SYMTAB: return "SYMTAB";
1917 case DT_RELA: return "RELA";
1918 case DT_RELASZ: return "RELASZ";
1919 case DT_RELAENT: return "RELAENT";
1920 case DT_STRSZ: return "STRSZ";
1921 case DT_SYMENT: return "SYMENT";
1922 case DT_INIT: return "INIT";
1923 case DT_FINI: return "FINI";
1924 case DT_SONAME: return "SONAME";
1925 case DT_RPATH: return "RPATH";
1926 case DT_SYMBOLIC: return "SYMBOLIC";
1927 case DT_REL: return "REL";
1928 case DT_RELSZ: return "RELSZ";
1929 case DT_RELENT: return "RELENT";
1930 case DT_PLTREL: return "PLTREL";
1931 case DT_DEBUG: return "DEBUG";
1932 case DT_TEXTREL: return "TEXTREL";
1933 case DT_JMPREL: return "JMPREL";
1934 case DT_BIND_NOW: return "BIND_NOW";
1935 case DT_INIT_ARRAY: return "INIT_ARRAY";
1936 case DT_FINI_ARRAY: return "FINI_ARRAY";
1937 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1938 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1939 case DT_RUNPATH: return "RUNPATH";
1940 case DT_FLAGS: return "FLAGS";
2d0e6f43 1941
d1133906
NC		 1942 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1943 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1944
05107a46 1945 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1946 case DT_PLTPADSZ: return "PLTPADSZ";
1947 case DT_MOVEENT: return "MOVEENT";
1948 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1949 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1950 case DT_POSFLAG_1: return "POSFLAG_1";
1951 case DT_SYMINSZ: return "SYMINSZ";
1952 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1953
252b5132 1954 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1955 case DT_CONFIG: return "CONFIG";
1956 case DT_DEPAUDIT: return "DEPAUDIT";
1957 case DT_AUDIT: return "AUDIT";
1958 case DT_PLTPAD: return "PLTPAD";
1959 case DT_MOVETAB: return "MOVETAB";
252b5132 1960 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1961
252b5132 1962 case DT_VERSYM: return "VERSYM";
103f02d3 1963
67a4f2b7
AO		 1964 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1965 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1966 case DT_RELACOUNT: return "RELACOUNT";
1967 case DT_RELCOUNT: return "RELCOUNT";
1968 case DT_FLAGS_1: return "FLAGS_1";
1969 case DT_VERDEF: return "VERDEF";
1970 case DT_VERDEFNUM: return "VERDEFNUM";
1971 case DT_VERNEED: return "VERNEED";
1972 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1973
019148e4 1974 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1975 case DT_USED: return "USED";
1976 case DT_FILTER: return "FILTER";
103f02d3 1977
047b2264
JJ		 1978 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1979 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1980 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1981 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1982 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1983 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1984
252b5132
RH		 1985 default:
1986 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1987 {
2cf0635d 1988 const char * result;
103f02d3 1989
252b5132
RH		 1990 switch (elf_header.e_machine)
1991 {
1992 case EM_MIPS:
4fe85591 1993 case EM_MIPS_RS3_LE:
252b5132
RH		 1994 result = get_mips_dynamic_type (type);
1995 break;
9a097730
RH		 1996 case EM_SPARCV9:
1997 result = get_sparc64_dynamic_type (type);
1998 break;
7490d522
AM		 1999 case EM_PPC:
2000 result = get_ppc_dynamic_type (type);
2001 break;
f1cb7e17
AM		 2002 case EM_PPC64:
2003 result = get_ppc64_dynamic_type (type);
2004 break;
ecc51f48
NC		 2005 case EM_IA_64:
2006 result = get_ia64_dynamic_type (type);
2007 break;
fabcb361
RH		 2008 case EM_ALPHA:
2009 result = get_alpha_dynamic_type (type);
2010 break;
1c0d3aa6
NC		 2011 case EM_SCORE:
2012 result = get_score_dynamic_type (type);
2013 break;
40b36596
JM		 2014 case EM_TI_C6000:
2015 result = get_tic6x_dynamic_type (type);
2016 break;
36591ba1
SL		 2017 case EM_ALTERA_NIOS2:
2018 result = get_nios2_dynamic_type (type);
2019 break;
252b5132
RH		 2020 default:
2021 result = NULL;
2022 break;
2023 }
2024
2025 if (result != NULL)
2026 return result;
2027
e9e44622 2028 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 2029 }
eec8f817
DA		 2030 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2031 || (elf_header.e_machine == EM_PARISC
2032 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 2033 {
2cf0635d 2034 const char * result;
103f02d3
UD		 2035
2036 switch (elf_header.e_machine)
2037 {
2038 case EM_PARISC:
2039 result = get_parisc_dynamic_type (type);
2040 break;
148b93f2
NC		 2041 case EM_IA_64:
2042 result = get_ia64_dynamic_type (type);
2043 break;
103f02d3
UD		 2044 default:
2045 result = NULL;
2046 break;
2047 }
2048
2049 if (result != NULL)
2050 return result;
2051
e9e44622
JJ		 2052 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2053 type);
103f02d3 2054 }
252b5132 2055 else
e9e44622 2056 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 2057
252b5132
RH		 2058 return buff;
2059 }
2060}
2061
2062static char *
d3ba0551 2063get_file_type (unsigned e_type)
252b5132 2064{
b34976b6 2065 static char buff[32];
252b5132
RH		 2066
2067 switch (e_type)
2068 {
2069 case ET_NONE: return _("NONE (None)");
2070 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 2071 case ET_EXEC: return _("EXEC (Executable file)");
2072 case ET_DYN: return _("DYN (Shared object file)");
2073 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 2074
2075 default:
2076 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 2077 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 2078 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 2079 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 2080 else
e9e44622 2081 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 2082 return buff;
2083 }
2084}
2085
2086static char *
d3ba0551 2087get_machine_name (unsigned e_machine)
252b5132 2088{
b34976b6 2089 static char buff[64]; /* XXX */
252b5132
RH		 2090
2091 switch (e_machine)
2092 {
c45021f2 2093 case EM_NONE: return _("None");
a06ea964 2094 case EM_AARCH64: return "AArch64";
c45021f2
NC		 2095 case EM_M32: return "WE32100";
2096 case EM_SPARC: return "Sparc";
e9f53129 2097 case EM_SPU: return "SPU";
c45021f2
NC		 2098 case EM_386: return "Intel 80386";
2099 case EM_68K: return "MC68000";
2100 case EM_88K: return "MC88000";
22abe556 2101 case EM_IAMCU: return "Intel MCU";
c45021f2
NC		 2102 case EM_860: return "Intel 80860";
2103 case EM_MIPS: return "MIPS R3000";
2104 case EM_S370: return "IBM System/370";
7036c0e1 2105 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 2106 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 2107 case EM_PARISC: return "HPPA";
252b5132 2108 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 2109 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 2110 case EM_960: return "Intel 90860";
2111 case EM_PPC: return "PowerPC";
285d1771 2112 case EM_PPC64: return "PowerPC64";
c45021f2 2113 case EM_FR20: return "Fujitsu FR20";
3f8107ab 2114 case EM_FT32: return "FTDI FT32";
c45021f2 2115 case EM_RH32: return "TRW RH32";
b34976b6 2116 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 2117 case EM_ARM: return "ARM";
2118 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 2119 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 2120 case EM_SPARCV9: return "Sparc v9";
2121 case EM_TRICORE: return "Siemens Tricore";
584da044 2122 case EM_ARC: return "ARC";
886a2506
NC		 2123 case EM_ARC_COMPACT: return "ARCompact";
2124 case EM_ARC_COMPACT2: return "ARCv2";
c2dcd04e
NC		 2125 case EM_H8_300: return "Renesas H8/300";
2126 case EM_H8_300H: return "Renesas H8/300H";
2127 case EM_H8S: return "Renesas H8S";
2128 case EM_H8_500: return "Renesas H8/500";
30800947 2129 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 2130 case EM_MIPS_X: return "Stanford MIPS-X";
2131 case EM_COLDFIRE: return "Motorola Coldfire";
c45021f2 2132 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 2133 case EM_CYGNUS_D10V:
2134 case EM_D10V: return "d10v";
2135 case EM_CYGNUS_D30V:
b34976b6 2136 case EM_D30V: return "d30v";
2b0337b0 2137 case EM_CYGNUS_M32R:
26597c86 2138 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 2139 case EM_CYGNUS_V850:
708e2187 2140 case EM_V800: return "Renesas V850 (using RH850 ABI)";
f6c1a2d5 2141 case EM_V850: return "Renesas V850";
2b0337b0
AO		 2142 case EM_CYGNUS_MN10300:
2143 case EM_MN10300: return "mn10300";
2144 case EM_CYGNUS_MN10200:
2145 case EM_MN10200: return "mn10200";
5506d11a 2146 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 2147 case EM_CYGNUS_FR30:
2148 case EM_FR30: return "Fujitsu FR30";
b34976b6 2149 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 2150 case EM_PJ_OLD:
b34976b6 2151 case EM_PJ: return "picoJava";
7036c0e1
AJ		 2152 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2153 case EM_PCP: return "Siemens PCP";
2154 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2155 case EM_NDR1: return "Denso NDR1 microprocesspr";
2156 case EM_STARCORE: return "Motorola Star*Core processor";
2157 case EM_ME16: return "Toyota ME16 processor";
2158 case EM_ST100: return "STMicroelectronics ST100 processor";
2159 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 2160 case EM_PDSP: return "Sony DSP processor";
2161 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2162 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 2163 case EM_FX66: return "Siemens FX66 microcontroller";
2164 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2165 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2166 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
6927f982 2167 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ		 2168 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2169 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2170 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2171 case EM_SVX: return "Silicon Graphics SVx";
2172 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2173 case EM_VAX: return "Digital VAX";
619ed720 2174 case EM_VISIUM: return "CDS VISIUMcore processor";
2b0337b0 2175 case EM_AVR_OLD:
b34976b6 2176 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 2177 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 2178 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2179 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2180 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 2181 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 2182 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 2183 case EM_PRISM: return "Vitesse Prism";
bcedfee6 2184 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 2185 case EM_L1OM: return "Intel L1OM";
7a9068fe 2186 case EM_K1OM: return "Intel K1OM";
b7498e0e 2187 case EM_S390_OLD:
b34976b6 2188 case EM_S390: return "IBM S/390";
1c0d3aa6 2189 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 2190 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
73589c9d 2191 case EM_OR1K: return "OpenRISC 1000";
1fe1f39c 2192 case EM_CRX: return "National Semiconductor CRX microprocessor";
cfb8c092 2193 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
d172d4ba 2194 case EM_DLX: return "OpenDLX";
1e4cf259 2195 case EM_IP2K_OLD:
b34976b6 2196 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 2197 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 2198 case EM_XTENSA_OLD:
2199 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 2200 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2201 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2202 case EM_NS32K: return "National Semiconductor 32000 series";
2203 case EM_TPC: return "Tenor Network TPC processor";
2204 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2205 case EM_MAX: return "MAX Processor";
2206 case EM_CR: return "National Semiconductor CompactRISC";
2207 case EM_F2MC16: return "Fujitsu F2MC16";
2208 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 2209 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 2210 case EM_M32C_OLD:
49f58d10 2211 case EM_M32C: return "Renesas M32c";
d031aafb 2212 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 2213 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 2214 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2215 case EM_SEP: return "Sharp embedded microprocessor";
2216 case EM_ARCA: return "Arca RISC microprocessor";
2217 case EM_UNICORE: return "Unicore";
2218 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2219 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 2220 case EM_NIOS32: return "Altera Nios";
2221 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 2222 case EM_C166:
d70c5fc7 2223 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 2224 case EM_M16C: return "Renesas M16C series microprocessors";
2225 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2226 case EM_CE: return "Freescale Communication Engine RISC core";
2227 case EM_TSK3000: return "Altium TSK3000 core";
2228 case EM_RS08: return "Freescale RS08 embedded processor";
2229 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2230 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2231 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2232 case EM_SE_C17: return "Seiko Epson C17 family";
2233 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2234 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2235 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2236 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2237 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2238 case EM_R32C: return "Renesas R32C series microprocessors";
2239 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2240 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2241 case EM_8051: return "Intel 8051 and variants";
2242 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2243 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2244 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2245 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2246 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2247 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2248 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 2249 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 2250 case EM_CR16:
f6c1a2d5 2251 case EM_MICROBLAZE:
7ba29e2a 2252 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
99c513f6 2253 case EM_RL78: return "Renesas RL78";
c7927a3c 2254 case EM_RX: return "Renesas RX";
a3c62988 2255 case EM_METAG: return "Imagination Technologies Meta processor architecture";
11636f9e
JM		 2256 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2257 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2258 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2259 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2260 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2261 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2262 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2263 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 2264 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 2265 case EM_CUDA: return "NVIDIA CUDA architecture";
f6c1a2d5 2266 case EM_XGATE: return "Motorola XGATE embedded processor";
252b5132 2267 default:
35d9dd2f 2268 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2269 return buff;
2270 }
2271}
2272
f3485b74 2273static void
d3ba0551 2274decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2275{
2276 unsigned eabi;
2277 int unknown = 0;
2278
2279 eabi = EF_ARM_EABI_VERSION (e_flags);
2280 e_flags &= ~ EF_ARM_EABIMASK;
2281
2282 /* Handle "generic" ARM flags. */
2283 if (e_flags & EF_ARM_RELEXEC)
2284 {
2285 strcat (buf, ", relocatable executable");
2286 e_flags &= ~ EF_ARM_RELEXEC;
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
886a2506
NC		 2770 case EM_ARC_COMPACT2:
2771 switch (e_flags & EF_ARC_MACH_MSK)
2772 {
2773 case EF_ARC_CPU_ARCV2EM:
2774 strcat (buf, ", ARC EM");
2775 break;
2776 case EF_ARC_CPU_ARCV2HS:
2777 strcat (buf, ", ARC HS");
2778 break;
2779 default:
2780 strcat (buf, ", unrecognized flag for ARCv2");
2781 break;
2782 }
2783 switch (e_flags & EF_ARC_OSABI_MSK)
2784 {
2785 /* Only upstream 3.9+ kernels will support ARCv2
2786 ISA. */
2787 case E_ARC_OSABI_V3:
2788 strcat (buf, ", v3 no-legacy-syscalls ABI");
2789 break;
2790 }
2791 break;
2792
2793 case EM_ARC_COMPACT:
2794 switch (e_flags & EF_ARC_MACH_MSK)
2795 {
2796 case E_ARC_MACH_ARC600:
2797 strcat (buf, ", ARC 600");
2798 break;
2799 case E_ARC_MACH_ARC601:
2800 strcat (buf, ", ARC 601");
2801 break;
2802 case E_ARC_MACH_ARC700:
2803 strcat (buf, ", ARC 700");
2804 break;
2805 default:
2806 strcat (buf, ", Generic ARCompact");
2807 break;
2808 }
2809 switch (e_flags & EF_ARC_OSABI_MSK)
2810 {
2811 case E_ARC_OSABI_ORIG:
2812 strcat (buf, ", legacy syscall ABI");
2813 break;
2814 case E_ARC_OSABI_V2:
2815 /* For 3.2+ Linux kernels which use asm-generic
2816 hdrs. */
2817 strcat (buf, ", v2 syscall ABI");
2818 break;
2819 case E_ARC_OSABI_V3:
2820 /* Upstream 3.9+ kernels which don't use any legacy
2821 syscalls. */
2822 strcat (buf, ", v3 no-legacy-syscalls ABI");
2823 break;
2824 }
2825 break;
2826
f3485b74
NC		 2827 case EM_ARM:
2828 decode_ARM_machine_flags (e_flags, buf);
2829 break;
76da6bbe 2830
343433df
AB		 2831 case EM_AVR:
2832 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2833 break;
2834
781303ce
MF		 2835 case EM_BLACKFIN:
2836 if (e_flags & EF_BFIN_PIC)
2837 strcat (buf, ", PIC");
2838
2839 if (e_flags & EF_BFIN_FDPIC)
2840 strcat (buf, ", FDPIC");
2841
2842 if (e_flags & EF_BFIN_CODE_IN_L1)
2843 strcat (buf, ", code in L1");
2844
2845 if (e_flags & EF_BFIN_DATA_IN_L1)
2846 strcat (buf, ", data in L1");
2847
2848 break;
2849
ec2dfb42
AO		 2850 case EM_CYGNUS_FRV:
2851 switch (e_flags & EF_FRV_CPU_MASK)
2852 {
2853 case EF_FRV_CPU_GENERIC:
2854 break;
2855
2856 default:
2857 strcat (buf, ", fr???");
2858 break;
57346661 2859
ec2dfb42
AO		 2860 case EF_FRV_CPU_FR300:
2861 strcat (buf, ", fr300");
2862 break;
2863
2864 case EF_FRV_CPU_FR400:
2865 strcat (buf, ", fr400");
2866 break;
2867 case EF_FRV_CPU_FR405:
2868 strcat (buf, ", fr405");
2869 break;
2870
2871 case EF_FRV_CPU_FR450:
2872 strcat (buf, ", fr450");
2873 break;
2874
2875 case EF_FRV_CPU_FR500:
2876 strcat (buf, ", fr500");
2877 break;
2878 case EF_FRV_CPU_FR550:
2879 strcat (buf, ", fr550");
2880 break;
2881
2882 case EF_FRV_CPU_SIMPLE:
2883 strcat (buf, ", simple");
2884 break;
2885 case EF_FRV_CPU_TOMCAT:
2886 strcat (buf, ", tomcat");
2887 break;
2888 }
1c877e87 2889 break;
ec2dfb42 2890
53c7db4b 2891 case EM_68K:
425c6cb0 2892 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2893 strcat (buf, ", m68000");
425c6cb0 2894 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2895 strcat (buf, ", cpu32");
2896 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2897 strcat (buf, ", fido_a");
425c6cb0 2898 else
266abb8f 2899 {
2cf0635d
NC		 2900 char const * isa = _("unknown");
2901 char const * mac = _("unknown mac");
2902 char const * additional = NULL;
0112cd26 2903
c694fd50 2904 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2905 {
c694fd50 2906 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2907 isa = "A";
2908 additional = ", nodiv";
2909 break;
c694fd50 2910 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2911 isa = "A";
2912 break;
c694fd50 2913 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2914 isa = "A+";
2915 break;
c694fd50 2916 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2917 isa = "B";
2918 additional = ", nousp";
2919 break;
c694fd50 2920 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2921 isa = "B";
2922 break;
f608cd77
NS		 2923 case EF_M68K_CF_ISA_C:
2924 isa = "C";
2925 break;
2926 case EF_M68K_CF_ISA_C_NODIV:
2927 isa = "C";
2928 additional = ", nodiv";
2929 break;
266abb8f
NS		 2930 }
2931 strcat (buf, ", cf, isa ");
2932 strcat (buf, isa);
0b2e31dc
NS		 2933 if (additional)
2934 strcat (buf, additional);
c694fd50 2935 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2936 strcat (buf, ", float");
c694fd50 2937 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2938 {
2939 case 0:
2940 mac = NULL;
2941 break;
c694fd50 2942 case EF_M68K_CF_MAC:
266abb8f
NS		 2943 mac = "mac";
2944 break;
c694fd50 2945 case EF_M68K_CF_EMAC:
266abb8f
NS		 2946 mac = "emac";
2947 break;
f608cd77
NS		 2948 case EF_M68K_CF_EMAC_B:
2949 mac = "emac_b";
2950 break;
266abb8f
NS		 2951 }
2952 if (mac)
2953 {
2954 strcat (buf, ", ");
2955 strcat (buf, mac);
2956 }
266abb8f 2957 }
53c7db4b 2958 break;
33c63f9d 2959
153a2776
NC		 2960 case EM_CYGNUS_MEP:
2961 switch (e_flags & EF_MEP_CPU_MASK)
2962 {
2963 case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
2964 case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
2965 case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
2966 case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
2967 case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
2968 case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
2969 default: strcat (buf, _(", <unknown MeP cpu type>")); break;
2970 }
2971
2972 switch (e_flags & EF_MEP_COP_MASK)
2973 {
2974 case EF_MEP_COP_NONE: break;
2975 case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
2976 case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
2977 case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
2978 case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
2979 default: strcat (buf, _("<unknown MeP copro type>")); break;
2980 }
2981
2982 if (e_flags & EF_MEP_LIBRARY)
2983 strcat (buf, ", Built for Library");
2984
2985 if (e_flags & EF_MEP_INDEX_MASK)
2986 sprintf (buf + strlen (buf), ", Configuration Index: %#x",
2987 e_flags & EF_MEP_INDEX_MASK);
2988
2989 if (e_flags & ~ EF_MEP_ALL_FLAGS)
2990 sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
2991 e_flags & ~ EF_MEP_ALL_FLAGS);
2992 break;
2993
252b5132
RH		 2994 case EM_PPC:
2995 if (e_flags & EF_PPC_EMB)
2996 strcat (buf, ", emb");
2997
2998 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2999 strcat (buf, _(", relocatable"));
252b5132
RH		 3000
3001 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 3002 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 3003 break;
3004
ee67d69a
AM		 3005 case EM_PPC64:
3006 if (e_flags & EF_PPC64_ABI)
3007 {
3008 char abi[] = ", abiv0";
3009
3010 abi[6] += e_flags & EF_PPC64_ABI;
3011 strcat (buf, abi);
3012 }
3013 break;
3014
708e2187
NC		 3015 case EM_V800:
3016 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3017 strcat (buf, ", RH850 ABI");
0b4362b0 3018
708e2187
NC		 3019 if (e_flags & EF_V800_850E3)
3020 strcat (buf, ", V3 architecture");
3021
3022 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3023 strcat (buf, ", FPU not used");
3024
3025 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3026 strcat (buf, ", regmode: COMMON");
3027
3028 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3029 strcat (buf, ", r4 not used");
3030
3031 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3032 strcat (buf, ", r30 not used");
3033
3034 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3035 strcat (buf, ", r5 not used");
3036
3037 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3038 strcat (buf, ", r2 not used");
3039
3040 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3041 {
3042 switch (e_flags & - e_flags)
3043 {
3044 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3045 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
708e2187
NC		 3046 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3047 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
708e2187
NC		 3048 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3049 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3050 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3051 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3052 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3053 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3054 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3055 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3056 default: break;
3057 }
3058 }
3059 break;
3060
2b0337b0 3061 case EM_V850:
252b5132
RH		 3062 case EM_CYGNUS_V850:
3063 switch (e_flags & EF_V850_ARCH)
3064 {
78c8d46c
NC		 3065 case E_V850E3V5_ARCH:
3066 strcat (buf, ", v850e3v5");
3067 break;
1cd986c5
NC		 3068 case E_V850E2V3_ARCH:
3069 strcat (buf, ", v850e2v3");
3070 break;
3071 case E_V850E2_ARCH:
3072 strcat (buf, ", v850e2");
3073 break;
3074 case E_V850E1_ARCH:
3075 strcat (buf, ", v850e1");
8ad30312 3076 break;
252b5132
RH		 3077 case E_V850E_ARCH:
3078 strcat (buf, ", v850e");
3079 break;
252b5132
RH		 3080 case E_V850_ARCH:
3081 strcat (buf, ", v850");
3082 break;
3083 default:
2b692964 3084 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 3085 break;
3086 }
3087 break;
3088
2b0337b0 3089 case EM_M32R:
252b5132
RH		 3090 case EM_CYGNUS_M32R:
3091 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3092 strcat (buf, ", m32r");
252b5132
RH		 3093 break;
3094
3095 case EM_MIPS:
4fe85591 3096 case EM_MIPS_RS3_LE:
252b5132
RH		 3097 if (e_flags & EF_MIPS_NOREORDER)
3098 strcat (buf, ", noreorder");
3099
3100 if (e_flags & EF_MIPS_PIC)
3101 strcat (buf, ", pic");
3102
3103 if (e_flags & EF_MIPS_CPIC)
3104 strcat (buf, ", cpic");
3105
d1bdd336
TS		 3106 if (e_flags & EF_MIPS_UCODE)
3107 strcat (buf, ", ugen_reserved");
3108
252b5132
RH		 3109 if (e_flags & EF_MIPS_ABI2)
3110 strcat (buf, ", abi2");
3111
43521d43
TS		 3112 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3113 strcat (buf, ", odk first");
3114
a5d22d2a
TS		 3115 if (e_flags & EF_MIPS_32BITMODE)
3116 strcat (buf, ", 32bitmode");
3117
ba92f887
MR		 3118 if (e_flags & EF_MIPS_NAN2008)
3119 strcat (buf, ", nan2008");
3120
fef1b0b3
SE		 3121 if (e_flags & EF_MIPS_FP64)
3122 strcat (buf, ", fp64");
3123
156c2f8b
NC		 3124 switch ((e_flags & EF_MIPS_MACH))
3125 {
3126 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3127 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3128 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 3129 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 3130 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3131 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3132 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3133 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 3134 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 3135 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 3136 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3137 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 3138 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 3139 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 3140 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
d32e5c54 3141 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
52b6b6b9 3142 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 3143 case 0:
3144 /* We simply ignore the field in this case to avoid confusion:
3145 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3146 extension. */
3147 break;
2b692964 3148 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 3149 }
43521d43
TS		 3150
3151 switch ((e_flags & EF_MIPS_ABI))
3152 {
3153 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3154 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3155 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3156 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3157 case 0:
3158 /* We simply ignore the field in this case to avoid confusion:
3159 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3160 This means it is likely to be an o32 file, but not for
3161 sure. */
3162 break;
2b692964 3163 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 3164 }
3165
3166 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3167 strcat (buf, ", mdmx");
3168
3169 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3170 strcat (buf, ", mips16");
3171
df58fc94
RS		 3172 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3173 strcat (buf, ", micromips");
3174
43521d43
TS		 3175 switch ((e_flags & EF_MIPS_ARCH))
3176 {
3177 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3178 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3179 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3180 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3181 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3182 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 3183 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
7361da2c 3184 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
43521d43 3185 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 3186 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
7361da2c 3187 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
2b692964 3188 default: strcat (buf, _(", unknown ISA")); break;
43521d43 3189 }
252b5132 3190 break;
351b4b40 3191
35c08157
KLC		 3192 case EM_NDS32:
3193 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3194 break;
3195
ccde1100
AO		 3196 case EM_SH:
3197 switch ((e_flags & EF_SH_MACH_MASK))
3198 {
3199 case EF_SH1: strcat (buf, ", sh1"); break;
3200 case EF_SH2: strcat (buf, ", sh2"); break;
3201 case EF_SH3: strcat (buf, ", sh3"); break;
3202 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3203 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3204 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3205 case EF_SH3E: strcat (buf, ", sh3e"); break;
3206 case EF_SH4: strcat (buf, ", sh4"); break;
3207 case EF_SH5: strcat (buf, ", sh5"); break;
3208 case EF_SH2E: strcat (buf, ", sh2e"); break;
3209 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 3210 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 3211 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3212 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 3213 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 3214 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3215 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3216 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3217 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3218 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3219 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 3220 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 3221 }
3222
cec6a5b8
MR		 3223 if (e_flags & EF_SH_PIC)
3224 strcat (buf, ", pic");
3225
3226 if (e_flags & EF_SH_FDPIC)
3227 strcat (buf, ", fdpic");
ccde1100 3228 break;
948f632f 3229
73589c9d
CS		 3230 case EM_OR1K:
3231 if (e_flags & EF_OR1K_NODELAY)
3232 strcat (buf, ", no delay");
3233 break;
57346661 3234
351b4b40
RH		 3235 case EM_SPARCV9:
3236 if (e_flags & EF_SPARC_32PLUS)
3237 strcat (buf, ", v8+");
3238
3239 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 3240 strcat (buf, ", ultrasparcI");
3241
3242 if (e_flags & EF_SPARC_SUN_US3)
3243 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 3244
3245 if (e_flags & EF_SPARC_HAL_R1)
3246 strcat (buf, ", halr1");
3247
3248 if (e_flags & EF_SPARC_LEDATA)
3249 strcat (buf, ", ledata");
3250
3251 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3252 strcat (buf, ", tso");
3253
3254 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3255 strcat (buf, ", pso");
3256
3257 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3258 strcat (buf, ", rmo");
3259 break;
7d466069 3260
103f02d3
UD		 3261 case EM_PARISC:
3262 switch (e_flags & EF_PARISC_ARCH)
3263 {
3264 case EFA_PARISC_1_0:
3265 strcpy (buf, ", PA-RISC 1.0");
3266 break;
3267 case EFA_PARISC_1_1:
3268 strcpy (buf, ", PA-RISC 1.1");
3269 break;
3270 case EFA_PARISC_2_0:
3271 strcpy (buf, ", PA-RISC 2.0");
3272 break;
3273 default:
3274 break;
3275 }
3276 if (e_flags & EF_PARISC_TRAPNIL)
3277 strcat (buf, ", trapnil");
3278 if (e_flags & EF_PARISC_EXT)
3279 strcat (buf, ", ext");
3280 if (e_flags & EF_PARISC_LSB)
3281 strcat (buf, ", lsb");
3282 if (e_flags & EF_PARISC_WIDE)
3283 strcat (buf, ", wide");
3284 if (e_flags & EF_PARISC_NO_KABP)
3285 strcat (buf, ", no kabp");
3286 if (e_flags & EF_PARISC_LAZYSWAP)
3287 strcat (buf, ", lazyswap");
30800947 3288 break;
76da6bbe 3289
7d466069 3290 case EM_PJ:
2b0337b0 3291 case EM_PJ_OLD:
7d466069
ILT		 3292 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3293 strcat (buf, ", new calling convention");
3294
3295 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3296 strcat (buf, ", gnu calling convention");
3297 break;
4d6ed7c8
NC		 3298
3299 case EM_IA_64:
3300 if ((e_flags & EF_IA_64_ABI64))
3301 strcat (buf, ", 64-bit");
3302 else
3303 strcat (buf, ", 32-bit");
3304 if ((e_flags & EF_IA_64_REDUCEDFP))
3305 strcat (buf, ", reduced fp model");
3306 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3307 strcat (buf, ", no function descriptors, constant gp");
3308 else if ((e_flags & EF_IA_64_CONS_GP))
3309 strcat (buf, ", constant gp");
3310 if ((e_flags & EF_IA_64_ABSOLUTE))
3311 strcat (buf, ", absolute");
28f997cf
TG		 3312 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3313 {
3314 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3315 strcat (buf, ", vms_linkages");
3316 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3317 {
3318 case EF_IA_64_VMS_COMCOD_SUCCESS:
3319 break;
3320 case EF_IA_64_VMS_COMCOD_WARNING:
3321 strcat (buf, ", warning");
3322 break;
3323 case EF_IA_64_VMS_COMCOD_ERROR:
3324 strcat (buf, ", error");
3325 break;
3326 case EF_IA_64_VMS_COMCOD_ABORT:
3327 strcat (buf, ", abort");
3328 break;
3329 default:
bee0ee85
NC		 3330 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3331 e_flags & EF_IA_64_VMS_COMCOD);
3332 strcat (buf, ", <unknown>");
28f997cf
TG		 3333 }
3334 }
4d6ed7c8 3335 break;
179d3252
JT		 3336
3337 case EM_VAX:
3338 if ((e_flags & EF_VAX_NONPIC))
3339 strcat (buf, ", non-PIC");
3340 if ((e_flags & EF_VAX_DFLOAT))
3341 strcat (buf, ", D-Float");
3342 if ((e_flags & EF_VAX_GFLOAT))
3343 strcat (buf, ", G-Float");
3344 break;
c7927a3c 3345
619ed720
EB		 3346 case EM_VISIUM:
3347 if (e_flags & EF_VISIUM_ARCH_MCM)
3348 strcat (buf, ", mcm");
3349 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3350 strcat (buf, ", mcm24");
3351 if (e_flags & EF_VISIUM_ARCH_GR6)
3352 strcat (buf, ", gr6");
3353 break;
3354
4046d87a 3355 case EM_RL78:
1740ba0c
NC		 3356 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3357 {
3358 case E_FLAG_RL78_ANY_CPU: break;
3359 case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3360 case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3361 case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3362 }
856ea05c
KP		 3363 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3364 strcat (buf, ", 64-bit doubles");
4046d87a 3365 break;
0b4362b0 3366
c7927a3c
NC		 3367 case EM_RX:
3368 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3369 strcat (buf, ", 64-bit doubles");
3370 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 3371 strcat (buf, ", dsp");
d4cb0ea0 3372 if (e_flags & E_FLAG_RX_PID)
0b4362b0 3373 strcat (buf, ", pid");
708e2187
NC		 3374 if (e_flags & E_FLAG_RX_ABI)
3375 strcat (buf, ", RX ABI");
3525236c
NC		 3376 if (e_flags & E_FLAG_RX_SINSNS_SET)
3377 strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3378 ? ", uses String instructions" : ", bans String instructions");
a117b0a5
YS		 3379 if (e_flags & E_FLAG_RX_V2)
3380 strcat (buf, ", V2");
d4cb0ea0 3381 break;
55786da2
AK		 3382
3383 case EM_S390:
3384 if (e_flags & EF_S390_HIGH_GPRS)
3385 strcat (buf, ", highgprs");
d4cb0ea0 3386 break;
40b36596
JM		 3387
3388 case EM_TI_C6000:
3389 if ((e_flags & EF_C6000_REL))
3390 strcat (buf, ", relocatable module");
d4cb0ea0 3391 break;
13761a11
NC		 3392
3393 case EM_MSP430:
3394 strcat (buf, _(": architecture variant: "));
3395 switch (e_flags & EF_MSP430_MACH)
3396 {
3397 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3398 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3399 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3400 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3401 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3402 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3403 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3404 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3405 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3406 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3407 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3408 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3409 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3410 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3411 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3412 default:
3413 strcat (buf, _(": unknown")); break;
3414 }
3415
3416 if (e_flags & ~ EF_MSP430_MACH)
3417 strcat (buf, _(": unknown extra flag bits also present"));
252b5132
RH		 3418 }
3419 }
3420
3421 return buf;
3422}
3423
252b5132 3424static const char *
d3ba0551
AM		 3425get_osabi_name (unsigned int osabi)
3426{
3427 static char buff[32];
3428
3429 switch (osabi)
3430 {
3431 case ELFOSABI_NONE: return "UNIX - System V";
3432 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3433 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 3434 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 3435 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3436 case ELFOSABI_AIX: return "UNIX - AIX";
3437 case ELFOSABI_IRIX: return "UNIX - IRIX";
3438 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3439 case ELFOSABI_TRU64: return "UNIX - TRU64";
3440 case ELFOSABI_MODESTO: return "Novell - Modesto";
3441 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3442 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3443 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 3444 case ELFOSABI_AROS: return "AROS";
11636f9e 3445 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 3446 default:
40b36596
JM		 3447 if (osabi >= 64)
3448 switch (elf_header.e_machine)
3449 {
3450 case EM_ARM:
3451 switch (osabi)
3452 {
3453 case ELFOSABI_ARM: return "ARM";
3454 default:
3455 break;
3456 }
3457 break;
3458
3459 case EM_MSP430:
3460 case EM_MSP430_OLD:
619ed720 3461 case EM_VISIUM:
40b36596
JM		 3462 switch (osabi)
3463 {
3464 case ELFOSABI_STANDALONE: return _("Standalone App");
3465 default:
3466 break;
3467 }
3468 break;
3469
3470 case EM_TI_C6000:
3471 switch (osabi)
3472 {
3473 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3474 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3475 default:
3476 break;
3477 }
3478 break;
3479
3480 default:
3481 break;
3482 }
e9e44622 3483 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 3484 return buff;
3485 }
3486}
3487
a06ea964
NC		 3488static const char *
3489get_aarch64_segment_type (unsigned long type)
3490{
3491 switch (type)
3492 {
3493 case PT_AARCH64_ARCHEXT:
3494 return "AARCH64_ARCHEXT";
3495 default:
3496 break;
3497 }
3498
3499 return NULL;
3500}
3501
b294bdf8
MM		 3502static const char *
3503get_arm_segment_type (unsigned long type)
3504{
3505 switch (type)
3506 {
3507 case PT_ARM_EXIDX:
3508 return "EXIDX";
3509 default:
3510 break;
3511 }
3512
3513 return NULL;
3514}
3515
d3ba0551
AM		 3516static const char *
3517get_mips_segment_type (unsigned long type)
252b5132
RH		 3518{
3519 switch (type)
3520 {
3521 case PT_MIPS_REGINFO:
3522 return "REGINFO";
3523 case PT_MIPS_RTPROC:
3524 return "RTPROC";
3525 case PT_MIPS_OPTIONS:
3526 return "OPTIONS";
351cdf24
MF		 3527 case PT_MIPS_ABIFLAGS:
3528 return "ABIFLAGS";
252b5132
RH		 3529 default:
3530 break;
3531 }
3532
3533 return NULL;
3534}
3535
103f02d3 3536static const char *
d3ba0551 3537get_parisc_segment_type (unsigned long type)
103f02d3
UD		 3538{
3539 switch (type)
3540 {
3541 case PT_HP_TLS: return "HP_TLS";
3542 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3543 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3544 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3545 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3546 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3547 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3548 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3549 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3550 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3551 case PT_HP_PARALLEL: return "HP_PARALLEL";
3552 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 3553 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3554 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3555 case PT_HP_STACK: return "HP_STACK";
3556 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 3557 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3558 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 3559 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 3560 default:
3561 break;
3562 }
3563
3564 return NULL;
3565}
3566
4d6ed7c8 3567static const char *
d3ba0551 3568get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 3569{
3570 switch (type)
3571 {
3572 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3573 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 3574 case PT_HP_TLS: return "HP_TLS";
3575 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3576 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3577 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 3578 default:
3579 break;
3580 }
3581
3582 return NULL;
3583}
3584
40b36596
JM		 3585static const char *
3586get_tic6x_segment_type (unsigned long type)
3587{
3588 switch (type)
3589 {
3590 case PT_C6000_PHATTR: return "C6000_PHATTR";
3591 default:
3592 break;
3593 }
3594
3595 return NULL;
3596}
3597
252b5132 3598static const char *
d3ba0551 3599get_segment_type (unsigned long p_type)
252b5132 3600{
b34976b6 3601 static char buff[32];
252b5132
RH		 3602
3603 switch (p_type)
3604 {
b34976b6
AM		 3605 case PT_NULL: return "NULL";
3606 case PT_LOAD: return "LOAD";
252b5132 3607 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 3608 case PT_INTERP: return "INTERP";
3609 case PT_NOTE: return "NOTE";
3610 case PT_SHLIB: return "SHLIB";
3611 case PT_PHDR: return "PHDR";
13ae64f3 3612 case PT_TLS: return "TLS";
252b5132 3613
65765700
JJ		 3614 case PT_GNU_EH_FRAME:
3615 return "GNU_EH_FRAME";
2b05f1b7 3616 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 3617 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 3618
252b5132
RH		 3619 default:
3620 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3621 {
2cf0635d 3622 const char * result;
103f02d3 3623
252b5132
RH		 3624 switch (elf_header.e_machine)
3625 {
a06ea964
NC		 3626 case EM_AARCH64:
3627 result = get_aarch64_segment_type (p_type);
3628 break;
b294bdf8
MM		 3629 case EM_ARM:
3630 result = get_arm_segment_type (p_type);
3631 break;
252b5132 3632 case EM_MIPS:
4fe85591 3633 case EM_MIPS_RS3_LE:
252b5132
RH		 3634 result = get_mips_segment_type (p_type);
3635 break;
103f02d3
UD		 3636 case EM_PARISC:
3637 result = get_parisc_segment_type (p_type);
3638 break;
4d6ed7c8
NC		 3639 case EM_IA_64:
3640 result = get_ia64_segment_type (p_type);
3641 break;
40b36596
JM		 3642 case EM_TI_C6000:
3643 result = get_tic6x_segment_type (p_type);
3644 break;
252b5132
RH		 3645 default:
3646 result = NULL;
3647 break;
3648 }
103f02d3 3649
252b5132
RH		 3650 if (result != NULL)
3651 return result;
103f02d3 3652
252b5132
RH		 3653 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3654 }
3655 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3656 {
2cf0635d 3657 const char * result;
103f02d3
UD		 3658
3659 switch (elf_header.e_machine)
3660 {
3661 case EM_PARISC:
3662 result = get_parisc_segment_type (p_type);
3663 break;
00428cca
AM		 3664 case EM_IA_64:
3665 result = get_ia64_segment_type (p_type);
3666 break;
103f02d3
UD		 3667 default:
3668 result = NULL;
3669 break;
3670 }
3671
3672 if (result != NULL)
3673 return result;
3674
3675 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3676 }
252b5132 3677 else
e9e44622 3678 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3679
3680 return buff;
3681 }
3682}
3683
3684static const char *
d3ba0551 3685get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3686{
3687 switch (sh_type)
3688 {
b34976b6
AM		 3689 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3690 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3691 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3692 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3693 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3694 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3695 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3696 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3697 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3698 case SHT_MIPS_RELD: return "MIPS_RELD";
3699 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3700 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3701 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3702 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3703 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3704 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3705 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3706 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3707 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3708 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3709 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3710 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3711 case SHT_MIPS_LINE: return "MIPS_LINE";
3712 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3713 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3714 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3715 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3716 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3717 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3718 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3719 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3720 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3721 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3722 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3723 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3724 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3725 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3726 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132 3727 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
351cdf24 3728 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
252b5132
RH		 3729 default:
3730 break;
3731 }
3732 return NULL;
3733}
3734
103f02d3 3735static const char *
d3ba0551 3736get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3737{
3738 switch (sh_type)
3739 {
3740 case SHT_PARISC_EXT: return "PARISC_EXT";
3741 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3742 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3743 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3744 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3745 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3746 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3747 default:
3748 break;
3749 }
3750 return NULL;
3751}
3752
4d6ed7c8 3753static const char *
d3ba0551 3754get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3755{
18bd398b 3756 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3757 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3758 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3759
4d6ed7c8
NC		 3760 switch (sh_type)
3761 {
148b93f2
NC		 3762 case SHT_IA_64_EXT: return "IA_64_EXT";
3763 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3764 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3765 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3766 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3767 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3768 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3769 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3770 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3771 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3772 default:
3773 break;
3774 }
3775 return NULL;
3776}
3777
d2b2c203
DJ		 3778static const char *
3779get_x86_64_section_type_name (unsigned int sh_type)
3780{
3781 switch (sh_type)
3782 {
3783 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3784 default:
3785 break;
3786 }
3787 return NULL;
3788}
3789
a06ea964
NC		 3790static const char *
3791get_aarch64_section_type_name (unsigned int sh_type)
3792{
3793 switch (sh_type)
3794 {
3795 case SHT_AARCH64_ATTRIBUTES:
3796 return "AARCH64_ATTRIBUTES";
3797 default:
3798 break;
3799 }
3800 return NULL;
3801}
3802
40a18ebd
NC		 3803static const char *
3804get_arm_section_type_name (unsigned int sh_type)
3805{
3806 switch (sh_type)
3807 {
7f6fed87
NC		 3808 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3809 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3810 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3811 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3812 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3813 default:
3814 break;
3815 }
3816 return NULL;
3817}
3818
40b36596
JM		 3819static const char *
3820get_tic6x_section_type_name (unsigned int sh_type)
3821{
3822 switch (sh_type)
3823 {
3824 case SHT_C6000_UNWIND:
3825 return "C6000_UNWIND";
3826 case SHT_C6000_PREEMPTMAP:
3827 return "C6000_PREEMPTMAP";
3828 case SHT_C6000_ATTRIBUTES:
3829 return "C6000_ATTRIBUTES";
3830 case SHT_TI_ICODE:
3831 return "TI_ICODE";
3832 case SHT_TI_XREF:
3833 return "TI_XREF";
3834 case SHT_TI_HANDLER:
3835 return "TI_HANDLER";
3836 case SHT_TI_INITINFO:
3837 return "TI_INITINFO";
3838 case SHT_TI_PHATTRS:
3839 return "TI_PHATTRS";
3840 default:
3841 break;
3842 }
3843 return NULL;
3844}
3845
13761a11
NC		 3846static const char *
3847get_msp430x_section_type_name (unsigned int sh_type)
3848{
3849 switch (sh_type)
3850 {
3851 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3852 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3853 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3854 default: return NULL;
3855 }
3856}
3857
685080f2
NC		 3858static const char *
3859get_v850_section_type_name (unsigned int sh_type)
3860{
3861 switch (sh_type)
3862 {
3863 case SHT_V850_SCOMMON: return "V850 Small Common";
3864 case SHT_V850_TCOMMON: return "V850 Tiny Common";
3865 case SHT_V850_ZCOMMON: return "V850 Zero Common";
3866 case SHT_RENESAS_IOP: return "RENESAS IOP";
3867 case SHT_RENESAS_INFO: return "RENESAS INFO";
3868 default: return NULL;
3869 }
3870}
3871
252b5132 3872static const char *
d3ba0551 3873get_section_type_name (unsigned int sh_type)
252b5132 3874{
b34976b6 3875 static char buff[32];
252b5132
RH		 3876
3877 switch (sh_type)
3878 {
3879 case SHT_NULL: return "NULL";
3880 case SHT_PROGBITS: return "PROGBITS";
3881 case SHT_SYMTAB: return "SYMTAB";
3882 case SHT_STRTAB: return "STRTAB";
3883 case SHT_RELA: return "RELA";
3884 case SHT_HASH: return "HASH";
3885 case SHT_DYNAMIC: return "DYNAMIC";
3886 case SHT_NOTE: return "NOTE";
3887 case SHT_NOBITS: return "NOBITS";
3888 case SHT_REL: return "REL";
3889 case SHT_SHLIB: return "SHLIB";
3890 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3891 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3892 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3893 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3894 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3895 case SHT_GROUP: return "GROUP";
3896 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3897 case SHT_GNU_verdef: return "VERDEF";
3898 case SHT_GNU_verneed: return "VERNEED";
3899 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3900 case 0x6ffffff0: return "VERSYM";
3901 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3902 case 0x7ffffffd: return "AUXILIARY";
3903 case 0x7fffffff: return "FILTER";
047b2264 3904 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3905
3906 default:
3907 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3908 {
2cf0635d 3909 const char * result;
252b5132
RH		 3910
3911 switch (elf_header.e_machine)
3912 {
3913 case EM_MIPS:
4fe85591 3914 case EM_MIPS_RS3_LE:
252b5132
RH		 3915 result = get_mips_section_type_name (sh_type);
3916 break;
103f02d3
UD		 3917 case EM_PARISC:
3918 result = get_parisc_section_type_name (sh_type);
3919 break;
4d6ed7c8
NC		 3920 case EM_IA_64:
3921 result = get_ia64_section_type_name (sh_type);
3922 break;
d2b2c203 3923 case EM_X86_64:
8a9036a4 3924 case EM_L1OM:
7a9068fe 3925 case EM_K1OM:
d2b2c203
DJ		 3926 result = get_x86_64_section_type_name (sh_type);
3927 break;
a06ea964
NC		 3928 case EM_AARCH64:
3929 result = get_aarch64_section_type_name (sh_type);
3930 break;
40a18ebd
NC		 3931 case EM_ARM:
3932 result = get_arm_section_type_name (sh_type);
3933 break;
40b36596
JM		 3934 case EM_TI_C6000:
3935 result = get_tic6x_section_type_name (sh_type);
3936 break;
13761a11
NC		 3937 case EM_MSP430:
3938 result = get_msp430x_section_type_name (sh_type);
3939 break;
685080f2
NC		 3940 case EM_V800:
3941 case EM_V850:
3942 case EM_CYGNUS_V850:
3943 result = get_v850_section_type_name (sh_type);
3944 break;
252b5132
RH		 3945 default:
3946 result = NULL;
3947 break;
3948 }
3949
3950 if (result != NULL)
3951 return result;
3952
c91d0dfb 3953 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3954 }
3955 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3956 {
2cf0635d 3957 const char * result;
148b93f2
NC		 3958
3959 switch (elf_header.e_machine)
3960 {
3961 case EM_IA_64:
3962 result = get_ia64_section_type_name (sh_type);
3963 break;
3964 default:
3965 result = NULL;
3966 break;
3967 }
3968
3969 if (result != NULL)
3970 return result;
3971
3972 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3973 }
252b5132 3974 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
685080f2
NC		 3975 {
3976 switch (elf_header.e_machine)
3977 {
3978 case EM_V800:
3979 case EM_V850:
3980 case EM_CYGNUS_V850:
3981 return get_v850_section_type_name (sh_type);
3982 default:
3983 break;
3984 }
3985
3986 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3987 }
252b5132 3988 else
a7dbfd1c
NC		 3989 /* This message is probably going to be displayed in a 15
3990 character wide field, so put the hex value first. */
3991 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3992
252b5132
RH		 3993 return buff;
3994 }
3995}
3996
2979dc34 3997#define OPTION_DEBUG_DUMP 512
2c610e4b 3998#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3999#define OPTION_DWARF_DEPTH 514
4000#define OPTION_DWARF_START 515
4723351a 4001#define OPTION_DWARF_CHECK 516
2979dc34 4002
85b1c36d 4003static struct option options[] =
252b5132 4004{
b34976b6 4005 {"all", no_argument, 0, 'a'},
252b5132
RH		 4006 {"file-header", no_argument, 0, 'h'},
4007 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 4008 {"headers", no_argument, 0, 'e'},
4009 {"histogram", no_argument, 0, 'I'},
4010 {"segments", no_argument, 0, 'l'},
4011 {"sections", no_argument, 0, 'S'},
252b5132 4012 {"section-headers", no_argument, 0, 'S'},
f5842774 4013 {"section-groups", no_argument, 0, 'g'},
5477e8a0 4014 {"section-details", no_argument, 0, 't'},
595cf52e 4015 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 4016 {"symbols", no_argument, 0, 's'},
4017 {"syms", no_argument, 0, 's'},
2c610e4b 4018 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 4019 {"relocs", no_argument, 0, 'r'},
4020 {"notes", no_argument, 0, 'n'},
4021 {"dynamic", no_argument, 0, 'd'},
a952a375 4022 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 4023 {"version-info", no_argument, 0, 'V'},
4024 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 4025 {"unwind", no_argument, 0, 'u'},
4145f1d5 4026 {"archive-index", no_argument, 0, 'c'},
b34976b6 4027 {"hex-dump", required_argument, 0, 'x'},
cf13d699 4028 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 4029 {"string-dump", required_argument, 0, 'p'},
0e602686 4030 {"decompress", no_argument, 0, 'z'},
252b5132
RH		 4031#ifdef SUPPORT_DISASSEMBLY
4032 {"instruction-dump", required_argument, 0, 'i'},
4033#endif
cf13d699 4034 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 4035
fd2f0033
TT		 4036 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
4037 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 4038 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 4039
b34976b6
AM		 4040 {"version", no_argument, 0, 'v'},
4041 {"wide", no_argument, 0, 'W'},
4042 {"help", no_argument, 0, 'H'},
4043 {0, no_argument, 0, 0}
252b5132
RH		 4044};
4045
4046static void
2cf0635d 4047usage (FILE * stream)
252b5132 4048{
92f01d61
JM		 4049 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4050 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4051 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 4052 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4053 -h --file-header Display the ELF file header\n\
4054 -l --program-headers Display the program headers\n\
4055 --segments An alias for --program-headers\n\
4056 -S --section-headers Display the sections' header\n\
4057 --sections An alias for --section-headers\n\
f5842774 4058 -g --section-groups Display the section groups\n\
5477e8a0 4059 -t --section-details Display the section details\n\
8b53311e
NC		 4060 -e --headers Equivalent to: -h -l -S\n\
4061 -s --syms Display the symbol table\n\
3f08eb35 4062 --symbols An alias for --syms\n\
2c610e4b 4063 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 4064 -n --notes Display the core notes (if present)\n\
4065 -r --relocs Display the relocations (if present)\n\
4066 -u --unwind Display the unwind info (if present)\n\
b2d38a17 4067 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 4068 -V --version-info Display the version sections (if present)\n\
1b31d05e 4069 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 4070 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 4071 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 4072 -x --hex-dump=<number|name>\n\
4073 Dump the contents of section <number|name> as bytes\n\
4074 -p --string-dump=<number|name>\n\
4075 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 4076 -R --relocated-dump=<number|name>\n\
4077 Dump the contents of section <number|name> as relocated bytes\n\
0e602686 4078 -z --decompress Decompress section before dumping it\n\
f9f0e732 4079 -w[lLiaprmfFsoRt] or\n\
1ed06042 4080 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 4081 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 4082 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4083 =addr,=cu_index]\n\
8b53311e 4084 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 4085 fprintf (stream, _("\
4086 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4087 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4088 or deeper\n"));
252b5132 4089#ifdef SUPPORT_DISASSEMBLY
92f01d61 4090 fprintf (stream, _("\
09c11c86
NC		 4091 -i --instruction-dump=<number|name>\n\
4092 Disassemble the contents of section <number|name>\n"));
252b5132 4093#endif
92f01d61 4094 fprintf (stream, _("\
8b53311e
NC		 4095 -I --histogram Display histogram of bucket list lengths\n\
4096 -W --wide Allow output width to exceed 80 characters\n\
07012eee 4097 @<file> Read options from <file>\n\
8b53311e
NC		 4098 -H --help Display this information\n\
4099 -v --version Display the version number of readelf\n"));
1118d252 4100
92f01d61
JM		 4101 if (REPORT_BUGS_TO[0] && stream == stdout)
4102 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 4103
92f01d61 4104 exit (stream == stdout ? 0 : 1);
252b5132
RH		 4105}
4106
18bd398b
NC		 4107/* Record the fact that the user wants the contents of section number
4108 SECTION to be displayed using the method(s) encoded as flags bits
4109 in TYPE. Note, TYPE can be zero if we are creating the array for
4110 the first time. */
4111
252b5132 4112static void
09c11c86 4113request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 4114{
4115 if (section >= num_dump_sects)
4116 {
2cf0635d 4117 dump_type * new_dump_sects;
252b5132 4118
3f5e193b
NC		 4119 new_dump_sects = (dump_type *) calloc (section + 1,
4120 sizeof (* dump_sects));
252b5132
RH		 4121
4122 if (new_dump_sects == NULL)
591a748a 4123 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 4124 else
4125 {
4126 /* Copy current flag settings. */
09c11c86 4127 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 4128
4129 free (dump_sects);
4130
4131 dump_sects = new_dump_sects;
4132 num_dump_sects = section + 1;
4133 }
4134 }
4135
4136 if (dump_sects)
b34976b6 4137 dump_sects[section] |= type;
252b5132
RH		 4138
4139 return;
4140}
4141
aef1f6d0
DJ		 4142/* Request a dump by section name. */
4143
4144static void
2cf0635d 4145request_dump_byname (const char * section, dump_type type)
aef1f6d0 4146{
2cf0635d 4147 struct dump_list_entry * new_request;
aef1f6d0 4148
3f5e193b
NC		 4149 new_request = (struct dump_list_entry *)
4150 malloc (sizeof (struct dump_list_entry));
aef1f6d0 4151 if (!new_request)
591a748a 4152 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4153
4154 new_request->name = strdup (section);
4155 if (!new_request->name)
591a748a 4156 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4157
4158 new_request->type = type;
4159
4160 new_request->next = dump_sects_byname;
4161 dump_sects_byname = new_request;
4162}
4163
cf13d699
NC		 4164static inline void
4165request_dump (dump_type type)
4166{
4167 int section;
4168 char * cp;
4169
4170 do_dump++;
4171 section = strtoul (optarg, & cp, 0);
4172
4173 if (! *cp && section >= 0)
4174 request_dump_bynumber (section, type);
4175 else
4176 request_dump_byname (optarg, type);
4177}
4178
4179
252b5132 4180static void
2cf0635d 4181parse_args (int argc, char ** argv)
252b5132
RH		 4182{
4183 int c;
4184
4185 if (argc < 2)
92f01d61 4186 usage (stderr);
252b5132
RH		 4187
4188 while ((c = getopt_long
0e602686 4189 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
252b5132 4190 {
252b5132
RH		 4191 switch (c)
4192 {
4193 case 0:
4194 /* Long options. */
4195 break;
4196 case 'H':
92f01d61 4197 usage (stdout);
252b5132
RH		 4198 break;
4199
4200 case 'a':
b34976b6
AM		 4201 do_syms++;
4202 do_reloc++;
4203 do_unwind++;
4204 do_dynamic++;
4205 do_header++;
4206 do_sections++;
f5842774 4207 do_section_groups++;
b34976b6
AM		 4208 do_segments++;
4209 do_version++;
4210 do_histogram++;
4211 do_arch++;
4212 do_notes++;
252b5132 4213 break;
f5842774
L		 4214 case 'g':
4215 do_section_groups++;
4216 break;
5477e8a0 4217 case 't':
595cf52e 4218 case 'N':
5477e8a0
L		 4219 do_sections++;
4220 do_section_details++;
595cf52e 4221 break;
252b5132 4222 case 'e':
b34976b6
AM		 4223 do_header++;
4224 do_sections++;
4225 do_segments++;
252b5132 4226 break;
a952a375 4227 case 'A':
b34976b6 4228 do_arch++;
a952a375 4229 break;
252b5132 4230 case 'D':
b34976b6 4231 do_using_dynamic++;
252b5132
RH		 4232 break;
4233 case 'r':
b34976b6 4234 do_reloc++;
252b5132 4235 break;
4d6ed7c8 4236 case 'u':
b34976b6 4237 do_unwind++;
4d6ed7c8 4238 break;
252b5132 4239 case 'h':
b34976b6 4240 do_header++;
252b5132
RH		 4241 break;
4242 case 'l':
b34976b6 4243 do_segments++;
252b5132
RH		 4244 break;
4245 case 's':
b34976b6 4246 do_syms++;
252b5132
RH		 4247 break;
4248 case 'S':
b34976b6 4249 do_sections++;
252b5132
RH		 4250 break;
4251 case 'd':
b34976b6 4252 do_dynamic++;
252b5132 4253 break;
a952a375 4254 case 'I':
b34976b6 4255 do_histogram++;
a952a375 4256 break;
779fe533 4257 case 'n':
b34976b6 4258 do_notes++;
779fe533 4259 break;
4145f1d5
NC		 4260 case 'c':
4261 do_archive_index++;
4262 break;
252b5132 4263 case 'x':
cf13d699 4264 request_dump (HEX_DUMP);
aef1f6d0 4265 break;
09c11c86 4266 case 'p':
cf13d699
NC		 4267 request_dump (STRING_DUMP);
4268 break;
4269 case 'R':
4270 request_dump (RELOC_DUMP);
09c11c86 4271 break;
0e602686
NC		 4272 case 'z':
4273 decompress_dumps++;
4274 break;
252b5132 4275 case 'w':
b34976b6 4276 do_dump++;
252b5132 4277 if (optarg == 0)
613ff48b
CC		 4278 {
4279 do_debugging = 1;
4280 dwarf_select_sections_all ();
4281 }
252b5132
RH		 4282 else
4283 {
4284 do_debugging = 0;
4cb93e3b 4285 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 4286 }
4287 break;
2979dc34 4288 case OPTION_DEBUG_DUMP:
b34976b6 4289 do_dump++;
2979dc34
JJ		 4290 if (optarg == 0)
4291 do_debugging = 1;
4292 else
4293 {
2979dc34 4294 do_debugging = 0;
4cb93e3b 4295 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 4296 }
4297 break;
fd2f0033
TT		 4298 case OPTION_DWARF_DEPTH:
4299 {
4300 char *cp;
4301
4302 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4303 }
4304 break;
4305 case OPTION_DWARF_START:
4306 {
4307 char *cp;
4308
4309 dwarf_start_die = strtoul (optarg, & cp, 0);
4310 }
4311 break;
4723351a
CC		 4312 case OPTION_DWARF_CHECK:
4313 dwarf_check = 1;
4314 break;
2c610e4b
L		 4315 case OPTION_DYN_SYMS:
4316 do_dyn_syms++;
4317 break;
252b5132
RH		 4318#ifdef SUPPORT_DISASSEMBLY
4319 case 'i':
cf13d699
NC		 4320 request_dump (DISASS_DUMP);
4321 break;
252b5132
RH		 4322#endif
4323 case 'v':
4324 print_version (program_name);
4325 break;
4326 case 'V':
b34976b6 4327 do_version++;
252b5132 4328 break;
d974e256 4329 case 'W':
b34976b6 4330 do_wide++;
d974e256 4331 break;
252b5132 4332 default:
252b5132
RH		 4333 /* xgettext:c-format */
4334 error (_("Invalid option '-%c'\n"), c);
4335 /* Drop through. */
4336 case '?':
92f01d61 4337 usage (stderr);
252b5132
RH		 4338 }
4339 }
4340
4d6ed7c8 4341 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 4342 && !do_segments && !do_header && !do_dump && !do_version
f5842774 4343 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 4344 && !do_section_groups && !do_archive_index
4345 && !do_dyn_syms)
92f01d61 4346 usage (stderr);
252b5132
RH		 4347}
4348
4349static const char *
d3ba0551 4350get_elf_class (unsigned int elf_class)
252b5132 4351{
b34976b6 4352 static char buff[32];
103f02d3 4353
252b5132
RH		 4354 switch (elf_class)
4355 {
4356 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 4357 case ELFCLASS32: return "ELF32";
4358 case ELFCLASS64: return "ELF64";
ab5e7794 4359 default:
e9e44622 4360 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 4361 return buff;
252b5132
RH		 4362 }
4363}
4364
4365static const char *
d3ba0551 4366get_data_encoding (unsigned int encoding)
252b5132 4367{
b34976b6 4368 static char buff[32];
103f02d3 4369
252b5132
RH		 4370 switch (encoding)
4371 {
4372 case ELFDATANONE: return _("none");
33c63f9d
CM		 4373 case ELFDATA2LSB: return _("2's complement, little endian");
4374 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 4375 default:
e9e44622 4376 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 4377 return buff;
252b5132
RH		 4378 }
4379}
4380
252b5132 4381/* Decode the data held in 'elf_header'. */
ee42cf8c 4382
252b5132 4383static int
d3ba0551 4384process_file_header (void)
252b5132 4385{
b34976b6
AM		 4386 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4387 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4388 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4389 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 4390 {
4391 error
4392 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4393 return 0;
4394 }
4395
2dc4cec1
L		 4396 init_dwarf_regnames (elf_header.e_machine);
4397
252b5132
RH		 4398 if (do_header)
4399 {
4400 int i;
4401
4402 printf (_("ELF Header:\n"));
4403 printf (_(" Magic: "));
b34976b6
AM		 4404 for (i = 0; i < EI_NIDENT; i++)
4405 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 4406 printf ("\n");
4407 printf (_(" Class: %s\n"),
b34976b6 4408 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 4409 printf (_(" Data: %s\n"),
b34976b6 4410 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 4411 printf (_(" Version: %d %s\n"),
b34976b6
AM		 4412 elf_header.e_ident[EI_VERSION],
4413 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 4414 ? "(current)"
b34976b6 4415 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 4416 ? _("<unknown: %lx>")
789be9f7 4417 : "")));
252b5132 4418 printf (_(" OS/ABI: %s\n"),
b34976b6 4419 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 4420 printf (_(" ABI Version: %d\n"),
b34976b6 4421 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 4422 printf (_(" Type: %s\n"),
4423 get_file_type (elf_header.e_type));
4424 printf (_(" Machine: %s\n"),
4425 get_machine_name (elf_header.e_machine));
4426 printf (_(" Version: 0x%lx\n"),
4427 (unsigned long) elf_header.e_version);
76da6bbe 4428
f7a99963
NC		 4429 printf (_(" Entry point address: "));
4430 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4431 printf (_("\n Start of program headers: "));
4432 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4433 printf (_(" (bytes into file)\n Start of section headers: "));
4434 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4435 printf (_(" (bytes into file)\n"));
76da6bbe 4436
252b5132
RH		 4437 printf (_(" Flags: 0x%lx%s\n"),
4438 (unsigned long) elf_header.e_flags,
4439 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4440 printf (_(" Size of this header: %ld (bytes)\n"),
4441 (long) elf_header.e_ehsize);
4442 printf (_(" Size of program headers: %ld (bytes)\n"),
4443 (long) elf_header.e_phentsize);
2046a35d 4444 printf (_(" Number of program headers: %ld"),
252b5132 4445 (long) elf_header.e_phnum);
2046a35d
AM		 4446 if (section_headers != NULL
4447 && elf_header.e_phnum == PN_XNUM
4448 && section_headers[0].sh_info != 0)
cc5914eb 4449 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 4450 putc ('\n', stdout);
252b5132
RH		 4451 printf (_(" Size of section headers: %ld (bytes)\n"),
4452 (long) elf_header.e_shentsize);
560f3c1c 4453 printf (_(" Number of section headers: %ld"),
252b5132 4454 (long) elf_header.e_shnum);
4fbb74a6 4455 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 4456 printf (" (%ld)", (long) section_headers[0].sh_size);
4457 putc ('\n', stdout);
4458 printf (_(" Section header string table index: %ld"),
252b5132 4459 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 4460 if (section_headers != NULL
4461 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 4462 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 4463 else if (elf_header.e_shstrndx != SHN_UNDEF
4464 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 4465 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 4466 putc ('\n', stdout);
4467 }
4468
4469 if (section_headers != NULL)
4470 {
2046a35d
AM		 4471 if (elf_header.e_phnum == PN_XNUM
4472 && section_headers[0].sh_info != 0)
4473 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 4474 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 4475 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 4476 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 4477 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 4478 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 4479 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 4480 free (section_headers);
4481 section_headers = NULL;
252b5132 4482 }
103f02d3 4483
9ea033b2
NC		 4484 return 1;
4485}
4486
e0a31db1 4487static bfd_boolean
91d6fa6a 4488get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4489{
2cf0635d
NC		 4490 Elf32_External_Phdr * phdrs;
4491 Elf32_External_Phdr * external;
4492 Elf_Internal_Phdr * internal;
b34976b6 4493 unsigned int i;
e0a31db1
NC		 4494 unsigned int size = elf_header.e_phentsize;
4495 unsigned int num = elf_header.e_phnum;
4496
4497 /* PR binutils/17531: Cope with unexpected section header sizes. */
4498 if (size == 0 || num == 0)
4499 return FALSE;
4500 if (size < sizeof * phdrs)
4501 {
4502 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4503 return FALSE;
4504 }
4505 if (size > sizeof * phdrs)
4506 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4507
3f5e193b 4508 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1
NC		 4509 size, num, _("program headers"));
4510 if (phdrs == NULL)
4511 return FALSE;
9ea033b2 4512
91d6fa6a 4513 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4514 i < elf_header.e_phnum;
b34976b6 4515 i++, internal++, external++)
252b5132 4516 {
9ea033b2
NC		 4517 internal->p_type = BYTE_GET (external->p_type);
4518 internal->p_offset = BYTE_GET (external->p_offset);
4519 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4520 internal->p_paddr = BYTE_GET (external->p_paddr);
4521 internal->p_filesz = BYTE_GET (external->p_filesz);
4522 internal->p_memsz = BYTE_GET (external->p_memsz);
4523 internal->p_flags = BYTE_GET (external->p_flags);
4524 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 4525 }
4526
9ea033b2 4527 free (phdrs);
e0a31db1 4528 return TRUE;
252b5132
RH		 4529}
4530
e0a31db1 4531static bfd_boolean
91d6fa6a 4532get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4533{
2cf0635d
NC		 4534 Elf64_External_Phdr * phdrs;
4535 Elf64_External_Phdr * external;
4536 Elf_Internal_Phdr * internal;
b34976b6 4537 unsigned int i;
e0a31db1
NC		 4538 unsigned int size = elf_header.e_phentsize;
4539 unsigned int num = elf_header.e_phnum;
4540
4541 /* PR binutils/17531: Cope with unexpected section header sizes. */
4542 if (size == 0 || num == 0)
4543 return FALSE;
4544 if (size < sizeof * phdrs)
4545 {
4546 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4547 return FALSE;
4548 }
4549 if (size > sizeof * phdrs)
4550 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4551
3f5e193b 4552 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1 4553 size, num, _("program headers"));
a6e9f9df 4554 if (!phdrs)
e0a31db1 4555 return FALSE;
9ea033b2 4556
91d6fa6a 4557 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4558 i < elf_header.e_phnum;
b34976b6 4559 i++, internal++, external++)
9ea033b2
NC		 4560 {
4561 internal->p_type = BYTE_GET (external->p_type);
4562 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 4563 internal->p_offset = BYTE_GET (external->p_offset);
4564 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4565 internal->p_paddr = BYTE_GET (external->p_paddr);
4566 internal->p_filesz = BYTE_GET (external->p_filesz);
4567 internal->p_memsz = BYTE_GET (external->p_memsz);
4568 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 4569 }
4570
4571 free (phdrs);
e0a31db1 4572 return TRUE;
9ea033b2 4573}
252b5132 4574
d93f0186
NC		 4575/* Returns 1 if the program headers were read into `program_headers'. */
4576
4577static int
2cf0635d 4578get_program_headers (FILE * file)
d93f0186 4579{
2cf0635d 4580 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 4581
4582 /* Check cache of prior read. */
4583 if (program_headers != NULL)
4584 return 1;
4585
3f5e193b
NC		 4586 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4587 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 4588
4589 if (phdrs == NULL)
4590 {
8b73c356
NC		 4591 error (_("Out of memory reading %u program headers\n"),
4592 elf_header.e_phnum);
d93f0186
NC		 4593 return 0;
4594 }
4595
4596 if (is_32bit_elf
4597 ? get_32bit_program_headers (file, phdrs)
4598 : get_64bit_program_headers (file, phdrs))
4599 {
4600 program_headers = phdrs;
4601 return 1;
4602 }
4603
4604 free (phdrs);
4605 return 0;
4606}
4607
2f62977e
NC		 4608/* Returns 1 if the program headers were loaded. */
4609
252b5132 4610static int
2cf0635d 4611process_program_headers (FILE * file)
252b5132 4612{
2cf0635d 4613 Elf_Internal_Phdr * segment;
b34976b6 4614 unsigned int i;
252b5132
RH		 4615
4616 if (elf_header.e_phnum == 0)
4617 {
82f2dbf7
NC		 4618 /* PR binutils/12467. */
4619 if (elf_header.e_phoff != 0)
4620 warn (_("possibly corrupt ELF header - it has a non-zero program"
9035ed51 4621 " header offset, but no program headers\n"));
82f2dbf7 4622 else if (do_segments)
252b5132 4623 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 4624 return 0;
252b5132
RH		 4625 }
4626
4627 if (do_segments && !do_header)
4628 {
f7a99963
NC		 4629 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4630 printf (_("Entry point "));
4631 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4632 printf (_("\nThere are %d program headers, starting at offset "),
4633 elf_header.e_phnum);
4634 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4635 printf ("\n");
252b5132
RH		 4636 }
4637
d93f0186 4638 if (! get_program_headers (file))
252b5132 4639 return 0;
103f02d3 4640
252b5132
RH		 4641 if (do_segments)
4642 {
3a1a2036
NC		 4643 if (elf_header.e_phnum > 1)
4644 printf (_("\nProgram Headers:\n"));
4645 else
4646 printf (_("\nProgram Headers:\n"));
76da6bbe 4647
f7a99963
NC		 4648 if (is_32bit_elf)
4649 printf
4650 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 4651 else if (do_wide)
4652 printf
4653 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 4654 else
4655 {
4656 printf
4657 (_(" Type Offset VirtAddr PhysAddr\n"));
4658 printf
4659 (_(" FileSiz MemSiz Flags Align\n"));
4660 }
252b5132
RH		 4661 }
4662
252b5132 4663 dynamic_addr = 0;
1b228002 4664 dynamic_size = 0;
252b5132
RH		 4665
4666 for (i = 0, segment = program_headers;
4667 i < elf_header.e_phnum;
b34976b6 4668 i++, segment++)
252b5132
RH		 4669 {
4670 if (do_segments)
4671 {
103f02d3 4672 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 4673
4674 if (is_32bit_elf)
4675 {
4676 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4677 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4678 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4679 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4680 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4681 printf ("%c%c%c ",
4682 (segment->p_flags & PF_R ? 'R' : ' '),
4683 (segment->p_flags & PF_W ? 'W' : ' '),
4684 (segment->p_flags & PF_X ? 'E' : ' '));
4685 printf ("%#lx", (unsigned long) segment->p_align);
4686 }
d974e256
JJ		 4687 else if (do_wide)
4688 {
4689 if ((unsigned long) segment->p_offset == segment->p_offset)
4690 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4691 else
4692 {
4693 print_vma (segment->p_offset, FULL_HEX);
4694 putchar (' ');
4695 }
4696
4697 print_vma (segment->p_vaddr, FULL_HEX);
4698 putchar (' ');
4699 print_vma (segment->p_paddr, FULL_HEX);
4700 putchar (' ');
4701
4702 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4703 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4704 else
4705 {
4706 print_vma (segment->p_filesz, FULL_HEX);
4707 putchar (' ');
4708 }
4709
4710 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4711 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4712 else
4713 {
f48e6c45 4714 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 4715 }
4716
4717 printf (" %c%c%c ",
4718 (segment->p_flags & PF_R ? 'R' : ' '),
4719 (segment->p_flags & PF_W ? 'W' : ' '),
4720 (segment->p_flags & PF_X ? 'E' : ' '));
4721
4722 if ((unsigned long) segment->p_align == segment->p_align)
4723 printf ("%#lx", (unsigned long) segment->p_align);
4724 else
4725 {
4726 print_vma (segment->p_align, PREFIX_HEX);
4727 }
4728 }
f7a99963
NC		 4729 else
4730 {
4731 print_vma (segment->p_offset, FULL_HEX);
4732 putchar (' ');
4733 print_vma (segment->p_vaddr, FULL_HEX);
4734 putchar (' ');
4735 print_vma (segment->p_paddr, FULL_HEX);
4736 printf ("\n ");
4737 print_vma (segment->p_filesz, FULL_HEX);
4738 putchar (' ');
4739 print_vma (segment->p_memsz, FULL_HEX);
4740 printf (" %c%c%c ",
4741 (segment->p_flags & PF_R ? 'R' : ' '),
4742 (segment->p_flags & PF_W ? 'W' : ' '),
4743 (segment->p_flags & PF_X ? 'E' : ' '));
4744 print_vma (segment->p_align, HEX);
4745 }
252b5132
RH		 4746 }
4747
f54498b4
NC		 4748 if (do_segments)
4749 putc ('\n', stdout);
4750
252b5132
RH		 4751 switch (segment->p_type)
4752 {
252b5132
RH		 4753 case PT_DYNAMIC:
4754 if (dynamic_addr)
4755 error (_("more than one dynamic segment\n"));
4756
20737c13
AM		 4757 /* By default, assume that the .dynamic section is the first
4758 section in the DYNAMIC segment. */
4759 dynamic_addr = segment->p_offset;
4760 dynamic_size = segment->p_filesz;
f54498b4
NC		 4761 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4762 if (dynamic_addr + dynamic_size >= current_file_size)
4763 {
4764 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4765 dynamic_addr = dynamic_size = 0;
4766 }
20737c13 4767
b2d38a17
NC		 4768 /* Try to locate the .dynamic section. If there is
4769 a section header table, we can easily locate it. */
4770 if (section_headers != NULL)
4771 {
2cf0635d 4772 Elf_Internal_Shdr * sec;
b2d38a17 4773
89fac5e3
RS		 4774 sec = find_section (".dynamic");
4775 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4776 {
28f997cf
TG		 4777 /* A corresponding .dynamic section is expected, but on
4778 IA-64/OpenVMS it is OK for it to be missing. */
4779 if (!is_ia64_vms ())
4780 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 4781 break;
4782 }
4783
42bb2e33 4784 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 4785 {
4786 dynamic_size = 0;
4787 break;
4788 }
42bb2e33 4789
b2d38a17
NC		 4790 dynamic_addr = sec->sh_offset;
4791 dynamic_size = sec->sh_size;
4792
4793 if (dynamic_addr < segment->p_offset
4794 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 4795 warn (_("the .dynamic section is not contained"
4796 " within the dynamic segment\n"));
b2d38a17 4797 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 4798 warn (_("the .dynamic section is not the first section"
4799 " in the dynamic segment.\n"));
b2d38a17 4800 }
252b5132
RH		 4801 break;
4802
4803 case PT_INTERP:
fb52b2f4
NC		 4804 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4805 SEEK_SET))
252b5132
RH		 4806 error (_("Unable to find program interpreter name\n"));
4807 else
4808 {
f8eae8b2 4809 char fmt [32];
9495b2e6 4810 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
f8eae8b2
L		 4811
4812 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4813 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4814
252b5132 4815 program_interpreter[0] = 0;
7bd7b3ef
AM		 4816 if (fscanf (file, fmt, program_interpreter) <= 0)
4817 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 4818
4819 if (do_segments)
f54498b4 4820 printf (_(" [Requesting program interpreter: %s]\n"),
252b5132
RH		 4821 program_interpreter);
4822 }
4823 break;
4824 }
252b5132
RH		 4825 }
4826
c256ffe7 4827 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 4828 {
4829 printf (_("\n Section to Segment mapping:\n"));
4830 printf (_(" Segment Sections...\n"));
4831
252b5132
RH		 4832 for (i = 0; i < elf_header.e_phnum; i++)
4833 {
9ad5cbcf 4834 unsigned int j;
2cf0635d 4835 Elf_Internal_Shdr * section;
252b5132
RH		 4836
4837 segment = program_headers + i;
b391a3e3 4838 section = section_headers + 1;
252b5132
RH		 4839
4840 printf (" %2.2d ", i);
4841
b34976b6 4842 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4843 {
f4638467
AM		 4844 if (!ELF_TBSS_SPECIAL (section, segment)
4845 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
74e1a04b 4846 printf ("%s ", printable_section_name (section));
252b5132
RH		 4847 }
4848
4849 putc ('\n',stdout);
4850 }
4851 }
4852
252b5132
RH		 4853 return 1;
4854}
4855
4856
d93f0186
NC		 4857/* Find the file offset corresponding to VMA by using the program headers. */
4858
4859static long
2cf0635d 4860offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4861{
2cf0635d 4862 Elf_Internal_Phdr * seg;
d93f0186
NC		 4863
4864 if (! get_program_headers (file))
4865 {
4866 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4867 return (long) vma;
4868 }
4869
4870 for (seg = program_headers;
4871 seg < program_headers + elf_header.e_phnum;
4872 ++seg)
4873 {
4874 if (seg->p_type != PT_LOAD)
4875 continue;
4876
4877 if (vma >= (seg->p_vaddr & -seg->p_align)
4878 && vma + size <= seg->p_vaddr + seg->p_filesz)
4879 return vma - seg->p_vaddr + seg->p_offset;
4880 }
4881
4882 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4883 (unsigned long) vma);
d93f0186
NC		 4884 return (long) vma;
4885}
4886
4887
049b0c3a
NC		 4888/* Allocate memory and load the sections headers into the global pointer
4889 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4890 generate any error messages if the load fails. */
4891
4892static bfd_boolean
4893get_32bit_section_headers (FILE * file, bfd_boolean probe)
252b5132 4894{
2cf0635d
NC		 4895 Elf32_External_Shdr * shdrs;
4896 Elf_Internal_Shdr * internal;
b34976b6 4897 unsigned int i;
049b0c3a
NC		 4898 unsigned int size = elf_header.e_shentsize;
4899 unsigned int num = probe ? 1 : elf_header.e_shnum;
4900
4901 /* PR binutils/17531: Cope with unexpected section header sizes. */
4902 if (size == 0 || num == 0)
4903 return FALSE;
4904 if (size < sizeof * shdrs)
4905 {
4906 if (! probe)
4907 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4908 return FALSE;
4909 }
4910 if (!probe && size > sizeof * shdrs)
4911 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
252b5132 4912
3f5e193b 4913 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4914 size, num,
4915 probe ? NULL : _("section headers"));
4916 if (shdrs == NULL)
4917 return FALSE;
252b5132 4918
049b0c3a
NC		 4919 if (section_headers != NULL)
4920 free (section_headers);
3f5e193b
NC		 4921 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4922 sizeof (Elf_Internal_Shdr));
252b5132
RH		 4923 if (section_headers == NULL)
4924 {
049b0c3a 4925 if (!probe)
8b73c356 4926 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4927 return FALSE;
252b5132
RH		 4928 }
4929
4930 for (i = 0, internal = section_headers;
560f3c1c 4931 i < num;
b34976b6 4932 i++, internal++)
252b5132
RH		 4933 {
4934 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4935 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4936 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4937 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4938 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4939 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4940 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4941 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4942 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4943 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4944 }
4945
4946 free (shdrs);
049b0c3a 4947 return TRUE;
252b5132
RH		 4948}
4949
049b0c3a
NC		 4950static bfd_boolean
4951get_64bit_section_headers (FILE * file, bfd_boolean probe)
9ea033b2 4952{
2cf0635d
NC		 4953 Elf64_External_Shdr * shdrs;
4954 Elf_Internal_Shdr * internal;
b34976b6 4955 unsigned int i;
049b0c3a
NC		 4956 unsigned int size = elf_header.e_shentsize;
4957 unsigned int num = probe ? 1 : elf_header.e_shnum;
4958
4959 /* PR binutils/17531: Cope with unexpected section header sizes. */
4960 if (size == 0 || num == 0)
4961 return FALSE;
4962 if (size < sizeof * shdrs)
4963 {
4964 if (! probe)
4965 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4966 return FALSE;
4967 }
4968 if (! probe && size > sizeof * shdrs)
4969 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
9ea033b2 4970
3f5e193b 4971 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4972 size, num,
4973 probe ? NULL : _("section headers"));
4974 if (shdrs == NULL)
4975 return FALSE;
9ea033b2 4976
049b0c3a
NC		 4977 if (section_headers != NULL)
4978 free (section_headers);
3f5e193b
NC		 4979 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4980 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4981 if (section_headers == NULL)
4982 {
049b0c3a 4983 if (! probe)
8b73c356 4984 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4985 return FALSE;
9ea033b2
NC		 4986 }
4987
4988 for (i = 0, internal = section_headers;
560f3c1c 4989 i < num;
b34976b6 4990 i++, internal++)
9ea033b2
NC		 4991 {
4992 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4993 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4994 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4995 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4996 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4997 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4998 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4999 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5000 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5001 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5002 }
5003
5004 free (shdrs);
049b0c3a 5005 return TRUE;
9ea033b2
NC		 5006}
5007
252b5132 5008static Elf_Internal_Sym *
ba5cdace
NC		 5009get_32bit_elf_symbols (FILE * file,
5010 Elf_Internal_Shdr * section,
5011 unsigned long * num_syms_return)
252b5132 5012{
ba5cdace 5013 unsigned long number = 0;
dd24e3da 5014 Elf32_External_Sym * esyms = NULL;
ba5cdace 5015 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 5016 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5017 Elf_Internal_Sym * psym;
b34976b6 5018 unsigned int j;
252b5132 5019
c9c1d674
EG		 5020 if (section->sh_size == 0)
5021 {
5022 if (num_syms_return != NULL)
5023 * num_syms_return = 0;
5024 return NULL;
5025 }
5026
dd24e3da 5027 /* Run some sanity checks first. */
c9c1d674 5028 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5029 {
c9c1d674
EG		 5030 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5031 printable_section_name (section), (unsigned long) section->sh_entsize);
ba5cdace 5032 goto exit_point;
dd24e3da
NC		 5033 }
5034
f54498b4
NC		 5035 if (section->sh_size > current_file_size)
5036 {
5037 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
74e1a04b 5038 printable_section_name (section), (unsigned long) section->sh_size);
f54498b4
NC		 5039 goto exit_point;
5040 }
5041
dd24e3da
NC		 5042 number = section->sh_size / section->sh_entsize;
5043
5044 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5045 {
c9c1d674 5046 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5047 (unsigned long) section->sh_size,
5048 printable_section_name (section),
5049 (unsigned long) section->sh_entsize);
ba5cdace 5050 goto exit_point;
dd24e3da
NC		 5051 }
5052
3f5e193b
NC		 5053 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5054 section->sh_size, _("symbols"));
dd24e3da 5055 if (esyms == NULL)
ba5cdace 5056 goto exit_point;
252b5132 5057
6a40cf0c
NC		 5058 {
5059 elf_section_list * entry;
5060
5061 shndx = NULL;
5062 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5063 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
c9c1d674 5064 {
6a40cf0c
NC		 5065 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5066 entry->hdr->sh_offset,
5067 1, entry->hdr->sh_size,
5068 _("symbol table section indicies"));
5069 if (shndx == NULL)
5070 goto exit_point;
5071 /* PR17531: file: heap-buffer-overflow */
5072 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5073 {
5074 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5075 printable_section_name (entry->hdr),
5076 (unsigned long) entry->hdr->sh_size,
5077 (unsigned long) section->sh_size);
5078 goto exit_point;
5079 }
c9c1d674 5080 }
6a40cf0c 5081 }
9ad5cbcf 5082
3f5e193b 5083 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 5084
5085 if (isyms == NULL)
5086 {
8b73c356
NC		 5087 error (_("Out of memory reading %lu symbols\n"),
5088 (unsigned long) number);
dd24e3da 5089 goto exit_point;
252b5132
RH		 5090 }
5091
dd24e3da 5092 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 5093 {
5094 psym->st_name = BYTE_GET (esyms[j].st_name);
5095 psym->st_value = BYTE_GET (esyms[j].st_value);
5096 psym->st_size = BYTE_GET (esyms[j].st_size);
5097 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 5098 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5099 psym->st_shndx
5100 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5101 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5102 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 5103 psym->st_info = BYTE_GET (esyms[j].st_info);
5104 psym->st_other = BYTE_GET (esyms[j].st_other);
5105 }
5106
dd24e3da 5107 exit_point:
ba5cdace 5108 if (shndx != NULL)
9ad5cbcf 5109 free (shndx);
ba5cdace 5110 if (esyms != NULL)
dd24e3da 5111 free (esyms);
252b5132 5112
ba5cdace
NC		 5113 if (num_syms_return != NULL)
5114 * num_syms_return = isyms == NULL ? 0 : number;
5115
252b5132
RH		 5116 return isyms;
5117}
5118
9ea033b2 5119static Elf_Internal_Sym *
ba5cdace
NC		 5120get_64bit_elf_symbols (FILE * file,
5121 Elf_Internal_Shdr * section,
5122 unsigned long * num_syms_return)
9ea033b2 5123{
ba5cdace
NC		 5124 unsigned long number = 0;
5125 Elf64_External_Sym * esyms = NULL;
5126 Elf_External_Sym_Shndx * shndx = NULL;
5127 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5128 Elf_Internal_Sym * psym;
b34976b6 5129 unsigned int j;
9ea033b2 5130
c9c1d674
EG		 5131 if (section->sh_size == 0)
5132 {
5133 if (num_syms_return != NULL)
5134 * num_syms_return = 0;
5135 return NULL;
5136 }
5137
dd24e3da 5138 /* Run some sanity checks first. */
c9c1d674 5139 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5140 {
c9c1d674 5141 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
8066deb1
AM		 5142 printable_section_name (section),
5143 (unsigned long) section->sh_entsize);
ba5cdace 5144 goto exit_point;
dd24e3da
NC		 5145 }
5146
f54498b4
NC		 5147 if (section->sh_size > current_file_size)
5148 {
5149 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
8066deb1
AM		 5150 printable_section_name (section),
5151 (unsigned long) section->sh_size);
f54498b4
NC		 5152 goto exit_point;
5153 }
5154
dd24e3da
NC		 5155 number = section->sh_size / section->sh_entsize;
5156
5157 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5158 {
c9c1d674 5159 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5160 (unsigned long) section->sh_size,
5161 printable_section_name (section),
5162 (unsigned long) section->sh_entsize);
ba5cdace 5163 goto exit_point;
dd24e3da
NC		 5164 }
5165
3f5e193b
NC		 5166 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5167 section->sh_size, _("symbols"));
a6e9f9df 5168 if (!esyms)
ba5cdace 5169 goto exit_point;
9ea033b2 5170
6a40cf0c
NC		 5171 {
5172 elf_section_list * entry;
5173
5174 shndx = NULL;
5175 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5176 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
c9c1d674 5177 {
6a40cf0c
NC		 5178 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5179 entry->hdr->sh_offset,
5180 1, entry->hdr->sh_size,
5181 _("symbol table section indicies"));
5182 if (shndx == NULL)
5183 goto exit_point;
5184 /* PR17531: file: heap-buffer-overflow */
5185 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5186 {
5187 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5188 printable_section_name (entry->hdr),
5189 (unsigned long) entry->hdr->sh_size,
5190 (unsigned long) section->sh_size);
5191 goto exit_point;
5192 }
c9c1d674 5193 }
6a40cf0c 5194 }
9ad5cbcf 5195
3f5e193b 5196 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 5197
5198 if (isyms == NULL)
5199 {
8b73c356
NC		 5200 error (_("Out of memory reading %lu symbols\n"),
5201 (unsigned long) number);
ba5cdace 5202 goto exit_point;
9ea033b2
NC		 5203 }
5204
ba5cdace 5205 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 5206 {
5207 psym->st_name = BYTE_GET (esyms[j].st_name);
5208 psym->st_info = BYTE_GET (esyms[j].st_info);
5209 psym->st_other = BYTE_GET (esyms[j].st_other);
5210 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 5211
4fbb74a6 5212 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5213 psym->st_shndx
5214 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5215 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5216 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 5217
66543521
AM		 5218 psym->st_value = BYTE_GET (esyms[j].st_value);
5219 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 5220 }
5221
ba5cdace
NC		 5222 exit_point:
5223 if (shndx != NULL)
9ad5cbcf 5224 free (shndx);
ba5cdace
NC		 5225 if (esyms != NULL)
5226 free (esyms);
5227
5228 if (num_syms_return != NULL)
5229 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 5230
5231 return isyms;
5232}
5233
d1133906 5234static const char *
d3ba0551 5235get_elf_section_flags (bfd_vma sh_flags)
d1133906 5236{
5477e8a0 5237 static char buff[1024];
2cf0635d 5238 char * p = buff;
8d5ff12c 5239 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 5240 int sindex;
5241 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 5242 bfd_vma os_flags = 0;
5243 bfd_vma proc_flags = 0;
5244 bfd_vma unknown_flags = 0;
148b93f2 5245 static const struct
5477e8a0 5246 {
2cf0635d 5247 const char * str;
5477e8a0
L		 5248 int len;
5249 }
5250 flags [] =
5251 {
cfcac11d
NC		 5252 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5253 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5254 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5255 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5256 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5257 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5258 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5259 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5260 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5261 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5262 /* IA-64 specific. */
5263 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5264 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5265 /* IA-64 OpenVMS specific. */
5266 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5267 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5268 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5269 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5270 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5271 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 5272 /* Generic. */
cfcac11d 5273 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 5274 /* SPARC specific. */
77115a4a 5275 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
ac4c9b04
MG		 5276 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5277 /* ARM specific. */
5278 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5279 /* 22 */ { STRING_COMMA_LEN ("ARM_NOREAD") },
5280 /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
5477e8a0
L		 5281 };
5282
5283 if (do_section_details)
5284 {
8d5ff12c
L		 5285 sprintf (buff, "[%*.*lx]: ",
5286 field_size, field_size, (unsigned long) sh_flags);
5287 p += field_size + 4;
5477e8a0 5288 }
76da6bbe 5289
d1133906
NC		 5290 while (sh_flags)
5291 {
5292 bfd_vma flag;
5293
5294 flag = sh_flags & - sh_flags;
5295 sh_flags &= ~ flag;
76da6bbe 5296
5477e8a0 5297 if (do_section_details)
d1133906 5298 {
5477e8a0
L		 5299 switch (flag)
5300 {
91d6fa6a
NC		 5301 case SHF_WRITE: sindex = 0; break;
5302 case SHF_ALLOC: sindex = 1; break;
5303 case SHF_EXECINSTR: sindex = 2; break;
5304 case SHF_MERGE: sindex = 3; break;
5305 case SHF_STRINGS: sindex = 4; break;
5306 case SHF_INFO_LINK: sindex = 5; break;
5307 case SHF_LINK_ORDER: sindex = 6; break;
5308 case SHF_OS_NONCONFORMING: sindex = 7; break;
5309 case SHF_GROUP: sindex = 8; break;
5310 case SHF_TLS: sindex = 9; break;
18ae9cc1 5311 case SHF_EXCLUDE: sindex = 18; break;
77115a4a 5312 case SHF_COMPRESSED: sindex = 20; break;
76da6bbe 5313
5477e8a0 5314 default:
91d6fa6a 5315 sindex = -1;
cfcac11d 5316 switch (elf_header.e_machine)
148b93f2 5317 {
cfcac11d 5318 case EM_IA_64:
148b93f2 5319 if (flag == SHF_IA_64_SHORT)
91d6fa6a 5320 sindex = 10;
148b93f2 5321 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 5322 sindex = 11;
148b93f2
NC		 5323#ifdef BFD64
5324 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5325 switch (flag)
5326 {
91d6fa6a
NC		 5327 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5328 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5329 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5330 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5331 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5332 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 5333 default: break;
5334 }
5335#endif
cfcac11d
NC		 5336 break;
5337
caa83f8b 5338 case EM_386:
22abe556 5339 case EM_IAMCU:
caa83f8b 5340 case EM_X86_64:
7f502d6c 5341 case EM_L1OM:
7a9068fe 5342 case EM_K1OM:
cfcac11d
NC		 5343 case EM_OLD_SPARCV9:
5344 case EM_SPARC32PLUS:
5345 case EM_SPARCV9:
5346 case EM_SPARC:
18ae9cc1 5347 if (flag == SHF_ORDERED)
91d6fa6a 5348 sindex = 19;
cfcac11d 5349 break;
ac4c9b04
MG		 5350
5351 case EM_ARM:
5352 switch (flag)
5353 {
5354 case SHF_ENTRYSECT: sindex = 21; break;
5355 case SHF_ARM_NOREAD: sindex = 22; break;
5356 case SHF_COMDEF: sindex = 23; break;
5357 default: break;
5358 }
5359 break;
5360
cfcac11d
NC		 5361 default:
5362 break;
148b93f2 5363 }
5477e8a0
L		 5364 }
5365
91d6fa6a 5366 if (sindex != -1)
5477e8a0 5367 {
8d5ff12c
L		 5368 if (p != buff + field_size + 4)
5369 {
5370 if (size < (10 + 2))
bee0ee85
NC		 5371 {
5372 warn (_("Internal error: not enough buffer room for section flag info"));
5373 return _("<unknown>");
5374 }
8d5ff12c
L		 5375 size -= 2;
5376 *p++ = ',';
5377 *p++ = ' ';
5378 }
5379
91d6fa6a
NC		 5380 size -= flags [sindex].len;
5381 p = stpcpy (p, flags [sindex].str);
5477e8a0 5382 }
3b22753a 5383 else if (flag & SHF_MASKOS)
8d5ff12c 5384 os_flags |= flag;
d1133906 5385 else if (flag & SHF_MASKPROC)
8d5ff12c 5386 proc_flags |= flag;
d1133906 5387 else
8d5ff12c 5388 unknown_flags |= flag;
5477e8a0
L		 5389 }
5390 else
5391 {
5392 switch (flag)
5393 {
5394 case SHF_WRITE: *p = 'W'; break;
5395 case SHF_ALLOC: *p = 'A'; break;
5396 case SHF_EXECINSTR: *p = 'X'; break;
5397 case SHF_MERGE: *p = 'M'; break;
5398 case SHF_STRINGS: *p = 'S'; break;
5399 case SHF_INFO_LINK: *p = 'I'; break;
5400 case SHF_LINK_ORDER: *p = 'L'; break;
5401 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5402 case SHF_GROUP: *p = 'G'; break;
5403 case SHF_TLS: *p = 'T'; break;
18ae9cc1 5404 case SHF_EXCLUDE: *p = 'E'; break;
77115a4a 5405 case SHF_COMPRESSED: *p = 'C'; break;
5477e8a0
L		 5406
5407 default:
8a9036a4 5408 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 5409 || elf_header.e_machine == EM_L1OM
5410 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 5411 && flag == SHF_X86_64_LARGE)
5412 *p = 'l';
5413 else if (flag & SHF_MASKOS)
5414 {
5415 *p = 'o';
5416 sh_flags &= ~ SHF_MASKOS;
5417 }
5418 else if (flag & SHF_MASKPROC)
5419 {
5420 *p = 'p';
5421 sh_flags &= ~ SHF_MASKPROC;
5422 }
5423 else
5424 *p = 'x';
5425 break;
5426 }
5427 p++;
d1133906
NC		 5428 }
5429 }
76da6bbe 5430
8d5ff12c
L		 5431 if (do_section_details)
5432 {
5433 if (os_flags)
5434 {
5435 size -= 5 + field_size;
5436 if (p != buff + field_size + 4)
5437 {
5438 if (size < (2 + 1))
bee0ee85
NC		 5439 {
5440 warn (_("Internal error: not enough buffer room for section flag info"));
5441 return _("<unknown>");
5442 }
8d5ff12c
L		 5443 size -= 2;
5444 *p++ = ',';
5445 *p++ = ' ';
5446 }
5447 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5448 (unsigned long) os_flags);
5449 p += 5 + field_size;
5450 }
5451 if (proc_flags)
5452 {
5453 size -= 7 + field_size;
5454 if (p != buff + field_size + 4)
5455 {
5456 if (size < (2 + 1))
bee0ee85
NC		 5457 {
5458 warn (_("Internal error: not enough buffer room for section flag info"));
5459 return _("<unknown>");
5460 }
8d5ff12c
L		 5461 size -= 2;
5462 *p++ = ',';
5463 *p++ = ' ';
5464 }
5465 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5466 (unsigned long) proc_flags);
5467 p += 7 + field_size;
5468 }
5469 if (unknown_flags)
5470 {
5471 size -= 10 + field_size;
5472 if (p != buff + field_size + 4)
5473 {
5474 if (size < (2 + 1))
bee0ee85
NC		 5475 {
5476 warn (_("Internal error: not enough buffer room for section flag info"));
5477 return _("<unknown>");
5478 }
8d5ff12c
L		 5479 size -= 2;
5480 *p++ = ',';
5481 *p++ = ' ';
5482 }
2b692964 5483 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 5484 (unsigned long) unknown_flags);
5485 p += 10 + field_size;
5486 }
5487 }
5488
e9e44622 5489 *p = '\0';
d1133906
NC		 5490 return buff;
5491}
5492
77115a4a
L		 5493static unsigned int
5494get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf)
5495{
5496 if (is_32bit_elf)
5497 {
5498 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5499 chdr->ch_type = BYTE_GET (echdr->ch_type);
5500 chdr->ch_size = BYTE_GET (echdr->ch_size);
5501 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5502 return sizeof (*echdr);
5503 }
5504 else
5505 {
5506 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5507 chdr->ch_type = BYTE_GET (echdr->ch_type);
5508 chdr->ch_size = BYTE_GET (echdr->ch_size);
5509 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5510 return sizeof (*echdr);
5511 }
5512}
5513
252b5132 5514static int
2cf0635d 5515process_section_headers (FILE * file)
252b5132 5516{
2cf0635d 5517 Elf_Internal_Shdr * section;
b34976b6 5518 unsigned int i;
252b5132
RH		 5519
5520 section_headers = NULL;
5521
5522 if (elf_header.e_shnum == 0)
5523 {
82f2dbf7
NC		 5524 /* PR binutils/12467. */
5525 if (elf_header.e_shoff != 0)
5526 warn (_("possibly corrupt ELF file header - it has a non-zero"
5527 " section header offset, but no section headers\n"));
5528 else if (do_sections)
252b5132
RH		 5529 printf (_("\nThere are no sections in this file.\n"));
5530
5531 return 1;
5532 }
5533
5534 if (do_sections && !do_header)
9ea033b2 5535 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 5536 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5537
9ea033b2
NC		 5538 if (is_32bit_elf)
5539 {
049b0c3a 5540 if (! get_32bit_section_headers (file, FALSE))
9ea033b2
NC		 5541 return 0;
5542 }
049b0c3a 5543 else if (! get_64bit_section_headers (file, FALSE))
252b5132
RH		 5544 return 0;
5545
5546 /* Read in the string table, so that we have names to display. */
0b49d371 5547 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 5548 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 5549 {
4fbb74a6 5550 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 5551
c256ffe7
JJ		 5552 if (section->sh_size != 0)
5553 {
3f5e193b
NC		 5554 string_table = (char *) get_data (NULL, file, section->sh_offset,
5555 1, section->sh_size,
5556 _("string table"));
0de14b54 5557
c256ffe7
JJ		 5558 string_table_length = string_table != NULL ? section->sh_size : 0;
5559 }
252b5132
RH		 5560 }
5561
5562 /* Scan the sections for the dynamic symbol table
e3c8793a 5563 and dynamic string table and debug sections. */
252b5132
RH		 5564 dynamic_symbols = NULL;
5565 dynamic_strings = NULL;
5566 dynamic_syminfo = NULL;
6a40cf0c 5567 symtab_shndx_list = NULL;
103f02d3 5568
89fac5e3
RS		 5569 eh_addr_size = is_32bit_elf ? 4 : 8;
5570 switch (elf_header.e_machine)
5571 {
5572 case EM_MIPS:
5573 case EM_MIPS_RS3_LE:
5574 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5575 FDE addresses. However, the ABI also has a semi-official ILP32
5576 variant for which the normal FDE address size rules apply.
5577
5578 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5579 section, where XX is the size of longs in bits. Unfortunately,
5580 earlier compilers provided no way of distinguishing ILP32 objects
5581 from LP64 objects, so if there's any doubt, we should assume that
5582 the official LP64 form is being used. */
5583 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5584 && find_section (".gcc_compiled_long32") == NULL)
5585 eh_addr_size = 8;
5586 break;
0f56a26a
DD		 5587
5588 case EM_H8_300:
5589 case EM_H8_300H:
5590 switch (elf_header.e_flags & EF_H8_MACH)
5591 {
5592 case E_H8_MACH_H8300:
5593 case E_H8_MACH_H8300HN:
5594 case E_H8_MACH_H8300SN:
5595 case E_H8_MACH_H8300SXN:
5596 eh_addr_size = 2;
5597 break;
5598 case E_H8_MACH_H8300H:
5599 case E_H8_MACH_H8300S:
5600 case E_H8_MACH_H8300SX:
5601 eh_addr_size = 4;
5602 break;
5603 }
f4236fe4
DD		 5604 break;
5605
ff7eeb89 5606 case EM_M32C_OLD:
f4236fe4
DD		 5607 case EM_M32C:
5608 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5609 {
5610 case EF_M32C_CPU_M16C:
5611 eh_addr_size = 2;
5612 break;
5613 }
5614 break;
89fac5e3
RS		 5615 }
5616
76ca31c0
NC		 5617#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5618 do \
5619 { \
5620 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5621 if (section->sh_entsize != expected_entsize) \
9dd3a467 5622 { \
76ca31c0
NC		 5623 char buf[40]; \
5624 sprintf_vma (buf, section->sh_entsize); \
5625 /* Note: coded this way so that there is a single string for \
5626 translation. */ \
5627 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5628 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5629 (unsigned) expected_entsize); \
9dd3a467 5630 section->sh_entsize = expected_entsize; \
76ca31c0
NC		 5631 } \
5632 } \
08d8fa11 5633 while (0)
9dd3a467
NC		 5634
5635#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 5636 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5637 sizeof (Elf64_External_##type))
5638
252b5132
RH		 5639 for (i = 0, section = section_headers;
5640 i < elf_header.e_shnum;
b34976b6 5641 i++, section++)
252b5132 5642 {
2cf0635d 5643 char * name = SECTION_NAME (section);
252b5132
RH		 5644
5645 if (section->sh_type == SHT_DYNSYM)
5646 {
5647 if (dynamic_symbols != NULL)
5648 {
5649 error (_("File contains multiple dynamic symbol tables\n"));
5650 continue;
5651 }
5652
08d8fa11 5653 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 5654 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 5655 }
5656 else if (section->sh_type == SHT_STRTAB
18bd398b 5657 && streq (name, ".dynstr"))
252b5132
RH		 5658 {
5659 if (dynamic_strings != NULL)
5660 {
5661 error (_("File contains multiple dynamic string tables\n"));
5662 continue;
5663 }
5664
3f5e193b
NC		 5665 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5666 1, section->sh_size,
5667 _("dynamic strings"));
59245841 5668 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 5669 }
9ad5cbcf
AM		 5670 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5671 {
6a40cf0c
NC		 5672 elf_section_list * entry = xmalloc (sizeof * entry);
5673 entry->hdr = section;
5674 entry->next = symtab_shndx_list;
5675 symtab_shndx_list = entry;
9ad5cbcf 5676 }
08d8fa11
JJ		 5677 else if (section->sh_type == SHT_SYMTAB)
5678 CHECK_ENTSIZE (section, i, Sym);
5679 else if (section->sh_type == SHT_GROUP)
5680 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5681 else if (section->sh_type == SHT_REL)
5682 CHECK_ENTSIZE (section, i, Rel);
5683 else if (section->sh_type == SHT_RELA)
5684 CHECK_ENTSIZE (section, i, Rela);
252b5132 5685 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 5686 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 5687 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 5688 || do_debug_str || do_debug_loc || do_debug_ranges
5689 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 5690 && (const_strneq (name, ".debug_")
5691 || const_strneq (name, ".zdebug_")))
252b5132 5692 {
1b315056
CS		 5693 if (name[1] == 'z')
5694 name += sizeof (".zdebug_") - 1;
5695 else
5696 name += sizeof (".debug_") - 1;
252b5132
RH		 5697
5698 if (do_debugging
4723351a
CC		 5699 || (do_debug_info && const_strneq (name, "info"))
5700 || (do_debug_info && const_strneq (name, "types"))
5701 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 5702 || (do_debug_lines && strcmp (name, "line") == 0)
5703 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 5704 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5705 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
459d52c8
DE		 5706 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5707 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4723351a
CC		 5708 || (do_debug_aranges && const_strneq (name, "aranges"))
5709 || (do_debug_ranges && const_strneq (name, "ranges"))
5710 || (do_debug_frames && const_strneq (name, "frame"))
5711 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5712 || (do_debug_macinfo && const_strneq (name, "macro"))
5713 || (do_debug_str && const_strneq (name, "str"))
5714 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 5715 || (do_debug_addr && const_strneq (name, "addr"))
5716 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5717 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 5718 )
09c11c86 5719 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 5720 }
a262ae96 5721 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 5722 else if ((do_debugging || do_debug_info)
0112cd26 5723 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 5724 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 5725 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 5726 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 5727 else if (do_gdb_index && streq (name, ".gdb_index"))
5728 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 5729 /* Trace sections for Itanium VMS. */
5730 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5731 || do_trace_aranges)
5732 && const_strneq (name, ".trace_"))
5733 {
5734 name += sizeof (".trace_") - 1;
5735
5736 if (do_debugging
5737 || (do_trace_info && streq (name, "info"))
5738 || (do_trace_abbrevs && streq (name, "abbrev"))
5739 || (do_trace_aranges && streq (name, "aranges"))
5740 )
5741 request_dump_bynumber (i, DEBUG_DUMP);
5742 }
252b5132
RH		 5743 }
5744
5745 if (! do_sections)
5746 return 1;
5747
3a1a2036
NC		 5748 if (elf_header.e_shnum > 1)
5749 printf (_("\nSection Headers:\n"));
5750 else
5751 printf (_("\nSection Header:\n"));
76da6bbe 5752
f7a99963 5753 if (is_32bit_elf)
595cf52e 5754 {
5477e8a0 5755 if (do_section_details)
595cf52e
L		 5756 {
5757 printf (_(" [Nr] Name\n"));
5477e8a0 5758 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 5759 }
5760 else
5761 printf
5762 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5763 }
d974e256 5764 else if (do_wide)
595cf52e 5765 {
5477e8a0 5766 if (do_section_details)
595cf52e
L		 5767 {
5768 printf (_(" [Nr] Name\n"));
5477e8a0 5769 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 5770 }
5771 else
5772 printf
5773 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5774 }
f7a99963
NC		 5775 else
5776 {
5477e8a0 5777 if (do_section_details)
595cf52e
L		 5778 {
5779 printf (_(" [Nr] Name\n"));
5477e8a0
L		 5780 printf (_(" Type Address Offset Link\n"));
5781 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 5782 }
5783 else
5784 {
5785 printf (_(" [Nr] Name Type Address Offset\n"));
5786 printf (_(" Size EntSize Flags Link Info Align\n"));
5787 }
f7a99963 5788 }
252b5132 5789
5477e8a0
L		 5790 if (do_section_details)
5791 printf (_(" Flags\n"));
5792
252b5132
RH		 5793 for (i = 0, section = section_headers;
5794 i < elf_header.e_shnum;
b34976b6 5795 i++, section++)
252b5132 5796 {
7bfd842d 5797 printf (" [%2u] ", i);
5477e8a0 5798 if (do_section_details)
74e1a04b 5799 printf ("%s\n ", printable_section_name (section));
595cf52e 5800 else
74e1a04b 5801 print_symbol (-17, SECTION_NAME (section));
0b4362b0 5802
ea52a088
NC		 5803 printf (do_wide ? " %-15s " : " %-15.15s ",
5804 get_section_type_name (section->sh_type));
0b4362b0 5805
f7a99963
NC		 5806 if (is_32bit_elf)
5807 {
cfcac11d
NC		 5808 const char * link_too_big = NULL;
5809
f7a99963 5810 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 5811
f7a99963
NC		 5812 printf ( " %6.6lx %6.6lx %2.2lx",
5813 (unsigned long) section->sh_offset,
5814 (unsigned long) section->sh_size,
5815 (unsigned long) section->sh_entsize);
d1133906 5816
5477e8a0
L		 5817 if (do_section_details)
5818 fputs (" ", stdout);
5819 else
5820 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5821
cfcac11d
NC		 5822 if (section->sh_link >= elf_header.e_shnum)
5823 {
5824 link_too_big = "";
5825 /* The sh_link value is out of range. Normally this indicates
caa83f8b 5826 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 5827 switch (elf_header.e_machine)
5828 {
caa83f8b 5829 case EM_386:
22abe556 5830 case EM_IAMCU:
caa83f8b 5831 case EM_X86_64:
7f502d6c 5832 case EM_L1OM:
7a9068fe 5833 case EM_K1OM:
cfcac11d
NC		 5834 case EM_OLD_SPARCV9:
5835 case EM_SPARC32PLUS:
5836 case EM_SPARCV9:
5837 case EM_SPARC:
5838 if (section->sh_link == (SHN_BEFORE & 0xffff))
5839 link_too_big = "BEFORE";
5840 else if (section->sh_link == (SHN_AFTER & 0xffff))
5841 link_too_big = "AFTER";
5842 break;
5843 default:
5844 break;
5845 }
5846 }
5847
5848 if (do_section_details)
5849 {
5850 if (link_too_big != NULL && * link_too_big)
5851 printf ("<%s> ", link_too_big);
5852 else
5853 printf ("%2u ", section->sh_link);
5854 printf ("%3u %2lu\n", section->sh_info,
5855 (unsigned long) section->sh_addralign);
5856 }
5857 else
5858 printf ("%2u %3u %2lu\n",
5859 section->sh_link,
5860 section->sh_info,
5861 (unsigned long) section->sh_addralign);
5862
5863 if (link_too_big && ! * link_too_big)
5864 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5865 i, section->sh_link);
f7a99963 5866 }
d974e256
JJ		 5867 else if (do_wide)
5868 {
5869 print_vma (section->sh_addr, LONG_HEX);
5870
5871 if ((long) section->sh_offset == section->sh_offset)
5872 printf (" %6.6lx", (unsigned long) section->sh_offset);
5873 else
5874 {
5875 putchar (' ');
5876 print_vma (section->sh_offset, LONG_HEX);
5877 }
5878
5879 if ((unsigned long) section->sh_size == section->sh_size)
5880 printf (" %6.6lx", (unsigned long) section->sh_size);
5881 else
5882 {
5883 putchar (' ');
5884 print_vma (section->sh_size, LONG_HEX);
5885 }
5886
5887 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5888 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5889 else
5890 {
5891 putchar (' ');
5892 print_vma (section->sh_entsize, LONG_HEX);
5893 }
5894
5477e8a0
L		 5895 if (do_section_details)
5896 fputs (" ", stdout);
5897 else
5898 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 5899
72de5009 5900 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 5901
5902 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 5903 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 5904 else
5905 {
5906 print_vma (section->sh_addralign, DEC);
5907 putchar ('\n');
5908 }
5909 }
5477e8a0 5910 else if (do_section_details)
595cf52e 5911 {
5477e8a0 5912 printf (" %-15.15s ",
595cf52e 5913 get_section_type_name (section->sh_type));
595cf52e
L		 5914 print_vma (section->sh_addr, LONG_HEX);
5915 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 5916 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 5917 else
5918 {
5919 printf (" ");
5920 print_vma (section->sh_offset, LONG_HEX);
5921 }
72de5009 5922 printf (" %u\n ", section->sh_link);
595cf52e 5923 print_vma (section->sh_size, LONG_HEX);
5477e8a0 5924 putchar (' ');
595cf52e
L		 5925 print_vma (section->sh_entsize, LONG_HEX);
5926
72de5009
AM		 5927 printf (" %-16u %lu\n",
5928 section->sh_info,
595cf52e
L		 5929 (unsigned long) section->sh_addralign);
5930 }
f7a99963
NC		 5931 else
5932 {
5933 putchar (' ');
5934 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 5935 if ((long) section->sh_offset == section->sh_offset)
5936 printf (" %8.8lx", (unsigned long) section->sh_offset);
5937 else
5938 {
5939 printf (" ");
5940 print_vma (section->sh_offset, LONG_HEX);
5941 }
f7a99963
NC		 5942 printf ("\n ");
5943 print_vma (section->sh_size, LONG_HEX);
5944 printf (" ");
5945 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 5946
d1133906 5947 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5948
72de5009
AM		 5949 printf (" %2u %3u %lu\n",
5950 section->sh_link,
5951 section->sh_info,
f7a99963
NC		 5952 (unsigned long) section->sh_addralign);
5953 }
5477e8a0
L		 5954
5955 if (do_section_details)
77115a4a
L		 5956 {
5957 printf (" %s\n", get_elf_section_flags (section->sh_flags));
5958 if ((section->sh_flags & SHF_COMPRESSED) != 0)
5959 {
5960 /* Minimum section size is 12 bytes for 32-bit compression
5961 header + 12 bytes for compressed data header. */
5962 unsigned char buf[24];
5963 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
5964 if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
5965 sizeof (buf), _("compression header")))
5966 {
5967 Elf_Internal_Chdr chdr;
5968 get_compression_header (&chdr, buf);
5969 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
5970 printf (" ZLIB, ");
5971 else
5972 printf (_(" [<unknown>: 0x%x], "),
5973 chdr.ch_type);
5974 print_vma (chdr.ch_size, LONG_HEX);
5975 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
5976 }
5977 }
5978 }
252b5132
RH		 5979 }
5980
5477e8a0 5981 if (!do_section_details)
3dbcc61d
NC		 5982 {
5983 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 5984 || elf_header.e_machine == EM_L1OM
5985 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 5986 printf (_("Key to Flags:\n\
5987 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5988 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5989 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5990 else
5991 printf (_("Key to Flags:\n\
e3c8793a 5992 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 5993 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 5994 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
0b4362b0 5995 }
d1133906 5996
252b5132
RH		 5997 return 1;
5998}
5999
f5842774
L		 6000static const char *
6001get_group_flags (unsigned int flags)
6002{
6003 static char buff[32];
6004 switch (flags)
6005 {
220453ec
AM		 6006 case 0:
6007 return "";
6008
f5842774 6009 case GRP_COMDAT:
220453ec 6010 return "COMDAT ";
f5842774
L		 6011
6012 default:
220453ec 6013 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 6014 break;
6015 }
6016 return buff;
6017}
6018
6019static int
2cf0635d 6020process_section_groups (FILE * file)
f5842774 6021{
2cf0635d 6022 Elf_Internal_Shdr * section;
f5842774 6023 unsigned int i;
2cf0635d
NC		 6024 struct group * group;
6025 Elf_Internal_Shdr * symtab_sec;
6026 Elf_Internal_Shdr * strtab_sec;
6027 Elf_Internal_Sym * symtab;
ba5cdace 6028 unsigned long num_syms;
2cf0635d 6029 char * strtab;
c256ffe7 6030 size_t strtab_size;
d1f5c6e3
L		 6031
6032 /* Don't process section groups unless needed. */
6033 if (!do_unwind && !do_section_groups)
6034 return 1;
f5842774
L		 6035
6036 if (elf_header.e_shnum == 0)
6037 {
6038 if (do_section_groups)
82f2dbf7 6039 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 6040
6041 return 1;
6042 }
6043
6044 if (section_headers == NULL)
6045 {
6046 error (_("Section headers are not available!\n"));
fa1908fd
NC		 6047 /* PR 13622: This can happen with a corrupt ELF header. */
6048 return 0;
f5842774
L		 6049 }
6050
3f5e193b
NC		 6051 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
6052 sizeof (struct group *));
e4b17d5c
L		 6053
6054 if (section_headers_groups == NULL)
6055 {
8b73c356
NC		 6056 error (_("Out of memory reading %u section group headers\n"),
6057 elf_header.e_shnum);
e4b17d5c
L		 6058 return 0;
6059 }
6060
f5842774 6061 /* Scan the sections for the group section. */
d1f5c6e3 6062 group_count = 0;
f5842774
L		 6063 for (i = 0, section = section_headers;
6064 i < elf_header.e_shnum;
6065 i++, section++)
e4b17d5c
L		 6066 if (section->sh_type == SHT_GROUP)
6067 group_count++;
6068
d1f5c6e3
L		 6069 if (group_count == 0)
6070 {
6071 if (do_section_groups)
6072 printf (_("\nThere are no section groups in this file.\n"));
6073
6074 return 1;
6075 }
6076
3f5e193b 6077 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 6078
6079 if (section_groups == NULL)
6080 {
8b73c356
NC		 6081 error (_("Out of memory reading %lu groups\n"),
6082 (unsigned long) group_count);
e4b17d5c
L		 6083 return 0;
6084 }
6085
d1f5c6e3
L		 6086 symtab_sec = NULL;
6087 strtab_sec = NULL;
6088 symtab = NULL;
ba5cdace 6089 num_syms = 0;
d1f5c6e3 6090 strtab = NULL;
c256ffe7 6091 strtab_size = 0;
e4b17d5c
L		 6092 for (i = 0, section = section_headers, group = section_groups;
6093 i < elf_header.e_shnum;
6094 i++, section++)
f5842774
L		 6095 {
6096 if (section->sh_type == SHT_GROUP)
6097 {
74e1a04b
NC		 6098 const char * name = printable_section_name (section);
6099 const char * group_name;
2cf0635d
NC		 6100 unsigned char * start;
6101 unsigned char * indices;
f5842774 6102 unsigned int entry, j, size;
2cf0635d
NC		 6103 Elf_Internal_Shdr * sec;
6104 Elf_Internal_Sym * sym;
f5842774
L		 6105
6106 /* Get the symbol table. */
4fbb74a6
AM		 6107 if (section->sh_link >= elf_header.e_shnum
6108 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 6109 != SHT_SYMTAB))
f5842774
L		 6110 {
6111 error (_("Bad sh_link in group section `%s'\n"), name);
6112 continue;
6113 }
d1f5c6e3
L		 6114
6115 if (symtab_sec != sec)
6116 {
6117 symtab_sec = sec;
6118 if (symtab)
6119 free (symtab);
ba5cdace 6120 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 6121 }
f5842774 6122
dd24e3da
NC		 6123 if (symtab == NULL)
6124 {
6125 error (_("Corrupt header in group section `%s'\n"), name);
6126 continue;
6127 }
6128
ba5cdace
NC		 6129 if (section->sh_info >= num_syms)
6130 {
6131 error (_("Bad sh_info in group section `%s'\n"), name);
6132 continue;
6133 }
6134
f5842774
L		 6135 sym = symtab + section->sh_info;
6136
6137 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6138 {
4fbb74a6
AM		 6139 if (sym->st_shndx == 0
6140 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 6141 {
6142 error (_("Bad sh_info in group section `%s'\n"), name);
6143 continue;
6144 }
ba2685cc 6145
4fbb74a6 6146 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 6147 strtab_sec = NULL;
6148 if (strtab)
6149 free (strtab);
f5842774 6150 strtab = NULL;
c256ffe7 6151 strtab_size = 0;
f5842774
L		 6152 }
6153 else
6154 {
6155 /* Get the string table. */
4fbb74a6 6156 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 6157 {
6158 strtab_sec = NULL;
6159 if (strtab)
6160 free (strtab);
6161 strtab = NULL;
6162 strtab_size = 0;
6163 }
6164 else if (strtab_sec
4fbb74a6 6165 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 6166 {
6167 strtab_sec = sec;
6168 if (strtab)
6169 free (strtab);
071436c6 6170
3f5e193b 6171 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
071436c6
NC		 6172 1, strtab_sec->sh_size,
6173 _("string table"));
c256ffe7 6174 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 6175 }
c256ffe7 6176 group_name = sym->st_name < strtab_size
2b692964 6177 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 6178 }
6179
c9c1d674
EG		 6180 /* PR 17531: file: loop. */
6181 if (section->sh_entsize > section->sh_size)
6182 {
6183 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6184 printable_section_name (section),
8066deb1
AM		 6185 (unsigned long) section->sh_entsize,
6186 (unsigned long) section->sh_size);
c9c1d674
EG		 6187 break;
6188 }
6189
3f5e193b
NC		 6190 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6191 1, section->sh_size,
6192 _("section data"));
59245841
NC		 6193 if (start == NULL)
6194 continue;
f5842774
L		 6195
6196 indices = start;
6197 size = (section->sh_size / section->sh_entsize) - 1;
6198 entry = byte_get (indices, 4);
6199 indices += 4;
e4b17d5c
L		 6200
6201 if (do_section_groups)
6202 {
2b692964 6203 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 6204 get_group_flags (entry), i, name, group_name, size);
ba2685cc 6205
e4b17d5c
L		 6206 printf (_(" [Index] Name\n"));
6207 }
6208
6209 group->group_index = i;
6210
f5842774
L		 6211 for (j = 0; j < size; j++)
6212 {
2cf0635d 6213 struct group_list * g;
e4b17d5c 6214
f5842774
L		 6215 entry = byte_get (indices, 4);
6216 indices += 4;
6217
4fbb74a6 6218 if (entry >= elf_header.e_shnum)
391cb864 6219 {
57028622
NC		 6220 static unsigned num_group_errors = 0;
6221
6222 if (num_group_errors ++ < 10)
6223 {
6224 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6225 entry, i, elf_header.e_shnum - 1);
6226 if (num_group_errors == 10)
6227 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6228 }
391cb864
L		 6229 continue;
6230 }
391cb864 6231
4fbb74a6 6232 if (section_headers_groups [entry] != NULL)
e4b17d5c 6233 {
d1f5c6e3
L		 6234 if (entry)
6235 {
57028622
NC		 6236 static unsigned num_errs = 0;
6237
6238 if (num_errs ++ < 10)
6239 {
6240 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6241 entry, i,
6242 section_headers_groups [entry]->group_index);
6243 if (num_errs == 10)
6244 warn (_("Further error messages about already contained group sections suppressed\n"));
6245 }
d1f5c6e3
L		 6246 continue;
6247 }
6248 else
6249 {
6250 /* Intel C/C++ compiler may put section 0 in a
6251 section group. We just warn it the first time
6252 and ignore it afterwards. */
6253 static int warned = 0;
6254 if (!warned)
6255 {
6256 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 6257 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 6258 warned++;
6259 }
6260 }
e4b17d5c
L		 6261 }
6262
4fbb74a6 6263 section_headers_groups [entry] = group;
e4b17d5c
L		 6264
6265 if (do_section_groups)
6266 {
4fbb74a6 6267 sec = section_headers + entry;
74e1a04b 6268 printf (" [%5u] %s\n", entry, printable_section_name (sec));
ba2685cc
AM		 6269 }
6270
3f5e193b 6271 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 6272 g->section_index = entry;
6273 g->next = group->root;
6274 group->root = g;
f5842774
L		 6275 }
6276
f5842774
L		 6277 if (start)
6278 free (start);
e4b17d5c
L		 6279
6280 group++;
f5842774
L		 6281 }
6282 }
6283
d1f5c6e3
L		 6284 if (symtab)
6285 free (symtab);
6286 if (strtab)
6287 free (strtab);
f5842774
L		 6288 return 1;
6289}
6290
28f997cf
TG		 6291/* Data used to display dynamic fixups. */
6292
6293struct ia64_vms_dynfixup
6294{
6295 bfd_vma needed_ident; /* Library ident number. */
6296 bfd_vma needed; /* Index in the dstrtab of the library name. */
6297 bfd_vma fixup_needed; /* Index of the library. */
6298 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6299 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6300};
6301
6302/* Data used to display dynamic relocations. */
6303
6304struct ia64_vms_dynimgrela
6305{
6306 bfd_vma img_rela_cnt; /* Number of relocations. */
6307 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6308};
6309
6310/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6311 library). */
6312
6313static void
6314dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6315 const char *strtab, unsigned int strtab_sz)
6316{
6317 Elf64_External_VMS_IMAGE_FIXUP *imfs;
6318 long i;
6319 const char *lib_name;
6320
6321 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6322 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6323 _("dynamic section image fixups"));
6324 if (!imfs)
6325 return;
6326
6327 if (fixup->needed < strtab_sz)
6328 lib_name = strtab + fixup->needed;
6329 else
6330 {
6331 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 6332 (unsigned long) fixup->needed);
28f997cf
TG		 6333 lib_name = "???";
6334 }
6335 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6336 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6337 printf
6338 (_("Seg Offset Type SymVec DataType\n"));
6339
6340 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6341 {
6342 unsigned int type;
6343 const char *rtype;
6344
6345 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6346 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6347 type = BYTE_GET (imfs [i].type);
6348 rtype = elf_ia64_reloc_type (type);
6349 if (rtype == NULL)
6350 printf (" 0x%08x ", type);
6351 else
6352 printf (" %-32s ", rtype);
6353 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6354 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6355 }
6356
6357 free (imfs);
6358}
6359
6360/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6361
6362static void
6363dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6364{
6365 Elf64_External_VMS_IMAGE_RELA *imrs;
6366 long i;
6367
6368 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6369 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 6370 _("dynamic section image relocations"));
28f997cf
TG		 6371 if (!imrs)
6372 return;
6373
6374 printf (_("\nImage relocs\n"));
6375 printf
6376 (_("Seg Offset Type Addend Seg Sym Off\n"));
6377
6378 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6379 {
6380 unsigned int type;
6381 const char *rtype;
6382
6383 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6384 printf ("%08" BFD_VMA_FMT "x ",
6385 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6386 type = BYTE_GET (imrs [i].type);
6387 rtype = elf_ia64_reloc_type (type);
6388 if (rtype == NULL)
6389 printf ("0x%08x ", type);
6390 else
6391 printf ("%-31s ", rtype);
6392 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6393 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6394 printf ("%08" BFD_VMA_FMT "x\n",
6395 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6396 }
6397
6398 free (imrs);
6399}
6400
6401/* Display IA-64 OpenVMS dynamic relocations and fixups. */
6402
6403static int
6404process_ia64_vms_dynamic_relocs (FILE *file)
6405{
6406 struct ia64_vms_dynfixup fixup;
6407 struct ia64_vms_dynimgrela imgrela;
6408 Elf_Internal_Dyn *entry;
6409 int res = 0;
6410 bfd_vma strtab_off = 0;
6411 bfd_vma strtab_sz = 0;
6412 char *strtab = NULL;
6413
6414 memset (&fixup, 0, sizeof (fixup));
6415 memset (&imgrela, 0, sizeof (imgrela));
6416
6417 /* Note: the order of the entries is specified by the OpenVMS specs. */
6418 for (entry = dynamic_section;
6419 entry < dynamic_section + dynamic_nent;
6420 entry++)
6421 {
6422 switch (entry->d_tag)
6423 {
6424 case DT_IA_64_VMS_STRTAB_OFFSET:
6425 strtab_off = entry->d_un.d_val;
6426 break;
6427 case DT_STRSZ:
6428 strtab_sz = entry->d_un.d_val;
6429 if (strtab == NULL)
6430 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6431 1, strtab_sz, _("dynamic string section"));
6432 break;
6433
6434 case DT_IA_64_VMS_NEEDED_IDENT:
6435 fixup.needed_ident = entry->d_un.d_val;
6436 break;
6437 case DT_NEEDED:
6438 fixup.needed = entry->d_un.d_val;
6439 break;
6440 case DT_IA_64_VMS_FIXUP_NEEDED:
6441 fixup.fixup_needed = entry->d_un.d_val;
6442 break;
6443 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6444 fixup.fixup_rela_cnt = entry->d_un.d_val;
6445 break;
6446 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6447 fixup.fixup_rela_off = entry->d_un.d_val;
6448 res++;
6449 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6450 break;
6451
6452 case DT_IA_64_VMS_IMG_RELA_CNT:
6453 imgrela.img_rela_cnt = entry->d_un.d_val;
6454 break;
6455 case DT_IA_64_VMS_IMG_RELA_OFF:
6456 imgrela.img_rela_off = entry->d_un.d_val;
6457 res++;
6458 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6459 break;
6460
6461 default:
6462 break;
6463 }
6464 }
6465
6466 if (strtab != NULL)
6467 free (strtab);
6468
6469 return res;
6470}
6471
85b1c36d 6472static struct
566b0d53 6473{
2cf0635d 6474 const char * name;
566b0d53
L		 6475 int reloc;
6476 int size;
6477 int rela;
6478} dynamic_relocations [] =
6479{
6480 { "REL", DT_REL, DT_RELSZ, FALSE },
6481 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6482 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6483};
6484
252b5132 6485/* Process the reloc section. */
18bd398b 6486
252b5132 6487static int
2cf0635d 6488process_relocs (FILE * file)
252b5132 6489{
b34976b6
AM		 6490 unsigned long rel_size;
6491 unsigned long rel_offset;
252b5132
RH		 6492
6493
6494 if (!do_reloc)
6495 return 1;
6496
6497 if (do_using_dynamic)
6498 {
566b0d53 6499 int is_rela;
2cf0635d 6500 const char * name;
566b0d53
L		 6501 int has_dynamic_reloc;
6502 unsigned int i;
0de14b54 6503
566b0d53 6504 has_dynamic_reloc = 0;
252b5132 6505
566b0d53 6506 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 6507 {
566b0d53
L		 6508 is_rela = dynamic_relocations [i].rela;
6509 name = dynamic_relocations [i].name;
6510 rel_size = dynamic_info [dynamic_relocations [i].size];
6511 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 6512
566b0d53
L		 6513 has_dynamic_reloc |= rel_size;
6514
6515 if (is_rela == UNKNOWN)
aa903cfb 6516 {
566b0d53
L		 6517 if (dynamic_relocations [i].reloc == DT_JMPREL)
6518 switch (dynamic_info[DT_PLTREL])
6519 {
6520 case DT_REL:
6521 is_rela = FALSE;
6522 break;
6523 case DT_RELA:
6524 is_rela = TRUE;
6525 break;
6526 }
aa903cfb 6527 }
252b5132 6528
566b0d53
L		 6529 if (rel_size)
6530 {
6531 printf
6532 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6533 name, rel_offset, rel_size);
252b5132 6534
d93f0186
NC		 6535 dump_relocations (file,
6536 offset_from_vma (file, rel_offset, rel_size),
6537 rel_size,
566b0d53 6538 dynamic_symbols, num_dynamic_syms,
bb4d2ac2
L		 6539 dynamic_strings, dynamic_strings_length,
6540 is_rela, 1);
566b0d53 6541 }
252b5132 6542 }
566b0d53 6543
28f997cf
TG		 6544 if (is_ia64_vms ())
6545 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6546
566b0d53 6547 if (! has_dynamic_reloc)
252b5132
RH		 6548 printf (_("\nThere are no dynamic relocations in this file.\n"));
6549 }
6550 else
6551 {
2cf0635d 6552 Elf_Internal_Shdr * section;
b34976b6
AM		 6553 unsigned long i;
6554 int found = 0;
252b5132
RH		 6555
6556 for (i = 0, section = section_headers;
6557 i < elf_header.e_shnum;
b34976b6 6558 i++, section++)
252b5132
RH		 6559 {
6560 if ( section->sh_type != SHT_RELA
6561 && section->sh_type != SHT_REL)
6562 continue;
6563
6564 rel_offset = section->sh_offset;
6565 rel_size = section->sh_size;
6566
6567 if (rel_size)
6568 {
2cf0635d 6569 Elf_Internal_Shdr * strsec;
b34976b6 6570 int is_rela;
103f02d3 6571
252b5132
RH		 6572 printf (_("\nRelocation section "));
6573
6574 if (string_table == NULL)
19936277 6575 printf ("%d", section->sh_name);
252b5132 6576 else
74e1a04b 6577 printf ("'%s'", printable_section_name (section));
252b5132
RH		 6578
6579 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6580 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6581
d79b3d50
NC		 6582 is_rela = section->sh_type == SHT_RELA;
6583
4fbb74a6
AM		 6584 if (section->sh_link != 0
6585 && section->sh_link < elf_header.e_shnum)
af3fc3bc 6586 {
2cf0635d
NC		 6587 Elf_Internal_Shdr * symsec;
6588 Elf_Internal_Sym * symtab;
d79b3d50 6589 unsigned long nsyms;
c256ffe7 6590 unsigned long strtablen = 0;
2cf0635d 6591 char * strtab = NULL;
57346661 6592
4fbb74a6 6593 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 6594 if (symsec->sh_type != SHT_SYMTAB
6595 && symsec->sh_type != SHT_DYNSYM)
6596 continue;
6597
ba5cdace 6598 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 6599
af3fc3bc
AM		 6600 if (symtab == NULL)
6601 continue;
252b5132 6602
4fbb74a6
AM		 6603 if (symsec->sh_link != 0
6604 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 6605 {
4fbb74a6 6606 strsec = section_headers + symsec->sh_link;
103f02d3 6607
3f5e193b 6608 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
071436c6
NC		 6609 1, strsec->sh_size,
6610 _("string table"));
c256ffe7
JJ		 6611 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6612 }
252b5132 6613
d79b3d50 6614 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2
L		 6615 symtab, nsyms, strtab, strtablen,
6616 is_rela,
6617 symsec->sh_type == SHT_DYNSYM);
d79b3d50
NC		 6618 if (strtab)
6619 free (strtab);
6620 free (symtab);
6621 }
6622 else
6623 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2 6624 NULL, 0, NULL, 0, is_rela, 0);
252b5132
RH		 6625
6626 found = 1;
6627 }
6628 }
6629
6630 if (! found)
6631 printf (_("\nThere are no relocations in this file.\n"));
6632 }
6633
6634 return 1;
6635}
6636
4d6ed7c8
NC		 6637/* An absolute address consists of a section and an offset. If the
6638 section is NULL, the offset itself is the address, otherwise, the
6639 address equals to LOAD_ADDRESS(section) + offset. */
6640
6641struct absaddr
948f632f
DA		 6642{
6643 unsigned short section;
6644 bfd_vma offset;
6645};
4d6ed7c8 6646
1949de15
L		 6647#define ABSADDR(a) \
6648 ((a).section \
6649 ? section_headers [(a).section].sh_addr + (a).offset \
6650 : (a).offset)
6651
948f632f
DA		 6652/* Find the nearest symbol at or below ADDR. Returns the symbol
6653 name, if found, and the offset from the symbol to ADDR. */
4d6ed7c8 6654
4d6ed7c8 6655static void
2cf0635d 6656find_symbol_for_address (Elf_Internal_Sym * symtab,
948f632f
DA		 6657 unsigned long nsyms,
6658 const char * strtab,
6659 unsigned long strtab_size,
6660 struct absaddr addr,
6661 const char ** symname,
6662 bfd_vma * offset)
4d6ed7c8 6663{
d3ba0551 6664 bfd_vma dist = 0x100000;
2cf0635d 6665 Elf_Internal_Sym * sym;
948f632f
DA		 6666 Elf_Internal_Sym * beg;
6667 Elf_Internal_Sym * end;
2cf0635d 6668 Elf_Internal_Sym * best = NULL;
4d6ed7c8 6669
0b6ae522 6670 REMOVE_ARCH_BITS (addr.offset);
948f632f
DA		 6671 beg = symtab;
6672 end = symtab + nsyms;
0b6ae522 6673
948f632f 6674 while (beg < end)
4d6ed7c8 6675 {
948f632f
DA		 6676 bfd_vma value;
6677
6678 sym = beg + (end - beg) / 2;
0b6ae522 6679
948f632f 6680 value = sym->st_value;
0b6ae522
DJ		 6681 REMOVE_ARCH_BITS (value);
6682
948f632f 6683 if (sym->st_name != 0
4d6ed7c8 6684 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 6685 && addr.offset >= value
6686 && addr.offset - value < dist)
4d6ed7c8
NC		 6687 {
6688 best = sym;
0b6ae522 6689 dist = addr.offset - value;
4d6ed7c8
NC		 6690 if (!dist)
6691 break;
6692 }
948f632f
DA		 6693
6694 if (addr.offset < value)
6695 end = sym;
6696 else
6697 beg = sym + 1;
4d6ed7c8 6698 }
1b31d05e 6699
4d6ed7c8
NC		 6700 if (best)
6701 {
57346661 6702 *symname = (best->st_name >= strtab_size
2b692964 6703 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 6704 *offset = dist;
6705 return;
6706 }
1b31d05e 6707
4d6ed7c8
NC		 6708 *symname = NULL;
6709 *offset = addr.offset;
6710}
6711
948f632f
DA		 6712static int
6713symcmp (const void *p, const void *q)
6714{
6715 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
6716 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
6717
6718 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
6719}
6720
6721/* Process the unwind section. */
6722
6723#include "unwind-ia64.h"
6724
6725struct ia64_unw_table_entry
6726{
6727 struct absaddr start;
6728 struct absaddr end;
6729 struct absaddr info;
6730};
6731
6732struct ia64_unw_aux_info
6733{
6734 struct ia64_unw_table_entry *table; /* Unwind table. */
6735 unsigned long table_len; /* Length of unwind table. */
6736 unsigned char * info; /* Unwind info. */
6737 unsigned long info_size; /* Size of unwind info. */
6738 bfd_vma info_addr; /* Starting address of unwind info. */
6739 bfd_vma seg_base; /* Starting address of segment. */
6740 Elf_Internal_Sym * symtab; /* The symbol table. */
6741 unsigned long nsyms; /* Number of symbols. */
6742 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
6743 unsigned long nfuns; /* Number of entries in funtab. */
6744 char * strtab; /* The string table. */
6745 unsigned long strtab_size; /* Size of string table. */
6746};
6747
4d6ed7c8 6748static void
2cf0635d 6749dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 6750{
2cf0635d 6751 struct ia64_unw_table_entry * tp;
948f632f 6752 unsigned long j, nfuns;
4d6ed7c8 6753 int in_body;
7036c0e1 6754
948f632f
DA		 6755 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
6756 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
6757 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
6758 aux->funtab[nfuns++] = aux->symtab[j];
6759 aux->nfuns = nfuns;
6760 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
6761
4d6ed7c8
NC		 6762 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6763 {
6764 bfd_vma stamp;
6765 bfd_vma offset;
2cf0635d
NC		 6766 const unsigned char * dp;
6767 const unsigned char * head;
53774b7e 6768 const unsigned char * end;
2cf0635d 6769 const char * procname;
4d6ed7c8 6770
948f632f 6771 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661 6772 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 6773
6774 fputs ("\n<", stdout);
6775
6776 if (procname)
6777 {
6778 fputs (procname, stdout);
6779
6780 if (offset)
6781 printf ("+%lx", (unsigned long) offset);
6782 }
6783
6784 fputs (">: [", stdout);
6785 print_vma (tp->start.offset, PREFIX_HEX);
6786 fputc ('-', stdout);
6787 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 6788 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 6789 (unsigned long) (tp->info.offset - aux->seg_base));
6790
53774b7e
NC		 6791 /* PR 17531: file: 86232b32. */
6792 if (aux->info == NULL)
6793 continue;
6794
6795 /* PR 17531: file: 0997b4d1. */
6796 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6797 {
6798 warn (_("Invalid offset %lx in table entry %ld\n"),
6799 (long) tp->info.offset, (long) (tp - aux->table));
6800 continue;
6801 }
6802
1949de15 6803 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 6804 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 6805
86f55779 6806 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 6807 (unsigned) UNW_VER (stamp),
6808 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6809 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6810 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 6811 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 6812
6813 if (UNW_VER (stamp) != 1)
6814 {
2b692964 6815 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 6816 continue;
6817 }
6818
6819 in_body = 0;
53774b7e
NC		 6820 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6821 /* PR 17531: file: 16ceda89. */
6822 if (end > aux->info + aux->info_size)
6823 end = aux->info + aux->info_size;
6824 for (dp = head + 8; dp < end;)
b4477bc8 6825 dp = unw_decode (dp, in_body, & in_body, end);
4d6ed7c8 6826 }
948f632f
DA		 6827
6828 free (aux->funtab);
4d6ed7c8
NC		 6829}
6830
53774b7e 6831static bfd_boolean
2cf0635d
NC		 6832slurp_ia64_unwind_table (FILE * file,
6833 struct ia64_unw_aux_info * aux,
6834 Elf_Internal_Shdr * sec)
4d6ed7c8 6835{
89fac5e3 6836 unsigned long size, nrelas, i;
2cf0635d
NC		 6837 Elf_Internal_Phdr * seg;
6838 struct ia64_unw_table_entry * tep;
6839 Elf_Internal_Shdr * relsec;
6840 Elf_Internal_Rela * rela;
6841 Elf_Internal_Rela * rp;
6842 unsigned char * table;
6843 unsigned char * tp;
6844 Elf_Internal_Sym * sym;
6845 const char * relname;
4d6ed7c8 6846
53774b7e
NC		 6847 aux->table_len = 0;
6848
4d6ed7c8
NC		 6849 /* First, find the starting address of the segment that includes
6850 this section: */
6851
6852 if (elf_header.e_phnum)
6853 {
d93f0186 6854 if (! get_program_headers (file))
53774b7e 6855 return FALSE;
4d6ed7c8 6856
d93f0186
NC		 6857 for (seg = program_headers;
6858 seg < program_headers + elf_header.e_phnum;
6859 ++seg)
4d6ed7c8
NC		 6860 {
6861 if (seg->p_type != PT_LOAD)
6862 continue;
6863
6864 if (sec->sh_addr >= seg->p_vaddr
6865 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6866 {
6867 aux->seg_base = seg->p_vaddr;
6868 break;
6869 }
6870 }
4d6ed7c8
NC		 6871 }
6872
6873 /* Second, build the unwind table from the contents of the unwind section: */
6874 size = sec->sh_size;
3f5e193b
NC		 6875 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6876 _("unwind table"));
a6e9f9df 6877 if (!table)
53774b7e 6878 return FALSE;
4d6ed7c8 6879
53774b7e 6880 aux->table_len = size / (3 * eh_addr_size);
3f5e193b 6881 aux->table = (struct ia64_unw_table_entry *)
53774b7e 6882 xcmalloc (aux->table_len, sizeof (aux->table[0]));
89fac5e3 6883 tep = aux->table;
53774b7e
NC		 6884
6885 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
4d6ed7c8
NC		 6886 {
6887 tep->start.section = SHN_UNDEF;
6888 tep->end.section = SHN_UNDEF;
6889 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 6890 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6891 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6892 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 6893 tep->start.offset += aux->seg_base;
6894 tep->end.offset += aux->seg_base;
6895 tep->info.offset += aux->seg_base;
6896 }
6897 free (table);
6898
41e92641 6899 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 6900 for (relsec = section_headers;
6901 relsec < section_headers + elf_header.e_shnum;
6902 ++relsec)
6903 {
6904 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6905 || relsec->sh_info >= elf_header.e_shnum
6906 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 6907 continue;
6908
6909 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6910 & rela, & nrelas))
53774b7e
NC		 6911 {
6912 free (aux->table);
6913 aux->table = NULL;
6914 aux->table_len = 0;
6915 return FALSE;
6916 }
4d6ed7c8
NC		 6917
6918 for (rp = rela; rp < rela + nrelas; ++rp)
6919 {
aca88567
NC		 6920 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6921 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 6922
82b1b41b
NC		 6923 /* PR 17531: file: 9fa67536. */
6924 if (relname == NULL)
6925 {
6926 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
6927 continue;
6928 }
948f632f 6929
0112cd26 6930 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 6931 {
82b1b41b 6932 warn (_("Skipping unexpected relocation type: %s\n"), relname);
4d6ed7c8
NC		 6933 continue;
6934 }
6935
89fac5e3 6936 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 6937
53774b7e
NC		 6938 /* PR 17531: file: 5bc8d9bf. */
6939 if (i >= aux->table_len)
6940 {
6941 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
6942 continue;
6943 }
6944
6945 switch (rp->r_offset / eh_addr_size % 3)
4d6ed7c8
NC		 6946 {
6947 case 0:
6948 aux->table[i].start.section = sym->st_shndx;
e466bc6e 6949 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6950 break;
6951 case 1:
6952 aux->table[i].end.section = sym->st_shndx;
e466bc6e 6953 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6954 break;
6955 case 2:
6956 aux->table[i].info.section = sym->st_shndx;
e466bc6e 6957 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6958 break;
6959 default:
6960 break;
6961 }
6962 }
6963
6964 free (rela);
6965 }
6966
53774b7e 6967 return TRUE;
4d6ed7c8
NC		 6968}
6969
1b31d05e 6970static void
2cf0635d 6971ia64_process_unwind (FILE * file)
4d6ed7c8 6972{
2cf0635d
NC		 6973 Elf_Internal_Shdr * sec;
6974 Elf_Internal_Shdr * unwsec = NULL;
6975 Elf_Internal_Shdr * strsec;
89fac5e3 6976 unsigned long i, unwcount = 0, unwstart = 0;
57346661 6977 struct ia64_unw_aux_info aux;
f1467e33 6978
4d6ed7c8
NC		 6979 memset (& aux, 0, sizeof (aux));
6980
4d6ed7c8
NC		 6981 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6982 {
c256ffe7 6983 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6984 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 6985 {
ba5cdace 6986 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 6987
4fbb74a6 6988 strsec = section_headers + sec->sh_link;
4082ef84
NC		 6989 if (aux.strtab != NULL)
6990 {
6991 error (_("Multiple auxillary string tables encountered\n"));
6992 free (aux.strtab);
6993 }
3f5e193b
NC		 6994 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6995 1, strsec->sh_size,
6996 _("string table"));
c256ffe7 6997 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 6998 }
6999 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 7000 unwcount++;
7001 }
7002
7003 if (!unwcount)
7004 printf (_("\nThere are no unwind sections in this file.\n"));
7005
7006 while (unwcount-- > 0)
7007 {
2cf0635d 7008 char * suffix;
579f31ac
JJ		 7009 size_t len, len2;
7010
4082ef84 7011 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
579f31ac
JJ		 7012 i < elf_header.e_shnum; ++i, ++sec)
7013 if (sec->sh_type == SHT_IA_64_UNWIND)
7014 {
7015 unwsec = sec;
7016 break;
7017 }
4082ef84
NC		 7018 /* We have already counted the number of SHT_IA64_UNWIND
7019 sections so the loop above should never fail. */
7020 assert (unwsec != NULL);
579f31ac
JJ		 7021
7022 unwstart = i + 1;
7023 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7024
e4b17d5c
L		 7025 if ((unwsec->sh_flags & SHF_GROUP) != 0)
7026 {
7027 /* We need to find which section group it is in. */
4082ef84 7028 struct group_list * g;
e4b17d5c 7029
4082ef84
NC		 7030 if (section_headers_groups == NULL
7031 || section_headers_groups [i] == NULL)
7032 i = elf_header.e_shnum;
7033 else
e4b17d5c 7034 {
4082ef84 7035 g = section_headers_groups [i]->root;
18bd398b 7036
4082ef84
NC		 7037 for (; g != NULL; g = g->next)
7038 {
7039 sec = section_headers + g->section_index;
e4b17d5c 7040
4082ef84
NC		 7041 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7042 break;
7043 }
7044
7045 if (g == NULL)
7046 i = elf_header.e_shnum;
7047 }
e4b17d5c 7048 }
18bd398b 7049 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 7050 {
18bd398b 7051 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 7052 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7053 suffix = SECTION_NAME (unwsec) + len;
7054 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7055 ++i, ++sec)
18bd398b
NC		 7056 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7057 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 7058 break;
7059 }
7060 else
7061 {
7062 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 7063 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 7064 len = sizeof (ELF_STRING_ia64_unwind) - 1;
7065 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7066 suffix = "";
18bd398b 7067 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 7068 suffix = SECTION_NAME (unwsec) + len;
7069 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7070 ++i, ++sec)
18bd398b
NC		 7071 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7072 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 7073 break;
7074 }
7075
7076 if (i == elf_header.e_shnum)
7077 {
7078 printf (_("\nCould not find unwind info section for "));
7079
7080 if (string_table == NULL)
7081 printf ("%d", unwsec->sh_name);
7082 else
74e1a04b 7083 printf ("'%s'", printable_section_name (unwsec));
579f31ac
JJ		 7084 }
7085 else
4d6ed7c8 7086 {
4d6ed7c8 7087 aux.info_addr = sec->sh_addr;
3f5e193b 7088 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
4082ef84
NC		 7089 sec->sh_size,
7090 _("unwind info"));
59245841 7091 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 7092
579f31ac 7093 printf (_("\nUnwind section "));
4d6ed7c8 7094
579f31ac
JJ		 7095 if (string_table == NULL)
7096 printf ("%d", unwsec->sh_name);
7097 else
74e1a04b 7098 printf ("'%s'", printable_section_name (unwsec));
4d6ed7c8 7099
579f31ac 7100 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 7101 (unsigned long) unwsec->sh_offset,
89fac5e3 7102 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 7103
53774b7e
NC		 7104 if (slurp_ia64_unwind_table (file, & aux, unwsec)
7105 && aux.table_len > 0)
579f31ac
JJ		 7106 dump_ia64_unwind (& aux);
7107
7108 if (aux.table)
7109 free ((char *) aux.table);
7110 if (aux.info)
7111 free ((char *) aux.info);
7112 aux.table = NULL;
7113 aux.info = NULL;
7114 }
4d6ed7c8 7115 }
4d6ed7c8 7116
4d6ed7c8
NC		 7117 if (aux.symtab)
7118 free (aux.symtab);
7119 if (aux.strtab)
7120 free ((char *) aux.strtab);
4d6ed7c8
NC		 7121}
7122
3f5e193b
NC		 7123struct hppa_unw_table_entry
7124 {
7125 struct absaddr start;
7126 struct absaddr end;
948f632f 7127 unsigned int Cannot_unwind:1; /* 0 */
3f5e193b
NC		 7128 unsigned int Millicode:1; /* 1 */
7129 unsigned int Millicode_save_sr0:1; /* 2 */
7130 unsigned int Region_description:2; /* 3..4 */
7131 unsigned int reserved1:1; /* 5 */
7132 unsigned int Entry_SR:1; /* 6 */
7133 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
7134 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
7135 unsigned int Args_stored:1; /* 16 */
948f632f
DA		 7136 unsigned int Variable_Frame:1; /* 17 */
7137 unsigned int Separate_Package_Body:1; /* 18 */
3f5e193b 7138 unsigned int Frame_Extension_Millicode:1; /* 19 */
948f632f
DA		 7139 unsigned int Stack_Overflow_Check:1; /* 20 */
7140 unsigned int Two_Instruction_SP_Increment:1;/* 21 */
3f5e193b
NC		 7141 unsigned int Ada_Region:1; /* 22 */
7142 unsigned int cxx_info:1; /* 23 */
948f632f
DA		 7143 unsigned int cxx_try_catch:1; /* 24 */
7144 unsigned int sched_entry_seq:1; /* 25 */
3f5e193b 7145 unsigned int reserved2:1; /* 26 */
948f632f
DA		 7146 unsigned int Save_SP:1; /* 27 */
7147 unsigned int Save_RP:1; /* 28 */
3f5e193b
NC		 7148 unsigned int Save_MRP_in_frame:1; /* 29 */
7149 unsigned int extn_ptr_defined:1; /* 30 */
948f632f 7150 unsigned int Cleanup_defined:1; /* 31 */
3f5e193b 7151
948f632f
DA		 7152 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7153 unsigned int HP_UX_interrupt_marker:1; /* 1 */
3f5e193b 7154 unsigned int Large_frame:1; /* 2 */
948f632f 7155 unsigned int Pseudo_SP_Set:1; /* 3 */
3f5e193b
NC		 7156 unsigned int reserved4:1; /* 4 */
7157 unsigned int Total_frame_size:27; /* 5..31 */
7158 };
7159
57346661 7160struct hppa_unw_aux_info
948f632f
DA		 7161{
7162 struct hppa_unw_table_entry * table; /* Unwind table. */
7163 unsigned long table_len; /* Length of unwind table. */
7164 bfd_vma seg_base; /* Starting address of segment. */
7165 Elf_Internal_Sym * symtab; /* The symbol table. */
7166 unsigned long nsyms; /* Number of symbols. */
7167 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7168 unsigned long nfuns; /* Number of entries in funtab. */
7169 char * strtab; /* The string table. */
7170 unsigned long strtab_size; /* Size of string table. */
7171};
57346661
AM		 7172
7173static void
2cf0635d 7174dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 7175{
2cf0635d 7176 struct hppa_unw_table_entry * tp;
948f632f
DA		 7177 unsigned long j, nfuns;
7178
7179 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7180 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7181 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7182 aux->funtab[nfuns++] = aux->symtab[j];
7183 aux->nfuns = nfuns;
7184 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
57346661 7185
57346661
AM		 7186 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7187 {
7188 bfd_vma offset;
2cf0635d 7189 const char * procname;
57346661 7190
948f632f 7191 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661
AM		 7192 aux->strtab_size, tp->start, &procname,
7193 &offset);
7194
7195 fputs ("\n<", stdout);
7196
7197 if (procname)
7198 {
7199 fputs (procname, stdout);
7200
7201 if (offset)
7202 printf ("+%lx", (unsigned long) offset);
7203 }
7204
7205 fputs (">: [", stdout);
7206 print_vma (tp->start.offset, PREFIX_HEX);
7207 fputc ('-', stdout);
7208 print_vma (tp->end.offset, PREFIX_HEX);
7209 printf ("]\n\t");
7210
18bd398b
NC		 7211#define PF(_m) if (tp->_m) printf (#_m " ");
7212#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 7213 PF(Cannot_unwind);
7214 PF(Millicode);
7215 PF(Millicode_save_sr0);
18bd398b 7216 /* PV(Region_description); */
57346661
AM		 7217 PF(Entry_SR);
7218 PV(Entry_FR);
7219 PV(Entry_GR);
7220 PF(Args_stored);
7221 PF(Variable_Frame);
7222 PF(Separate_Package_Body);
7223 PF(Frame_Extension_Millicode);
7224 PF(Stack_Overflow_Check);
7225 PF(Two_Instruction_SP_Increment);
7226 PF(Ada_Region);
7227 PF(cxx_info);
7228 PF(cxx_try_catch);
7229 PF(sched_entry_seq);
7230 PF(Save_SP);
7231 PF(Save_RP);
7232 PF(Save_MRP_in_frame);
7233 PF(extn_ptr_defined);
7234 PF(Cleanup_defined);
7235 PF(MPE_XL_interrupt_marker);
7236 PF(HP_UX_interrupt_marker);
7237 PF(Large_frame);
7238 PF(Pseudo_SP_Set);
7239 PV(Total_frame_size);
7240#undef PF
7241#undef PV
7242 }
7243
18bd398b 7244 printf ("\n");
948f632f
DA		 7245
7246 free (aux->funtab);
57346661
AM		 7247}
7248
7249static int
2cf0635d
NC		 7250slurp_hppa_unwind_table (FILE * file,
7251 struct hppa_unw_aux_info * aux,
7252 Elf_Internal_Shdr * sec)
57346661 7253{
1c0751b2 7254 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 7255 Elf_Internal_Phdr * seg;
7256 struct hppa_unw_table_entry * tep;
7257 Elf_Internal_Shdr * relsec;
7258 Elf_Internal_Rela * rela;
7259 Elf_Internal_Rela * rp;
7260 unsigned char * table;
7261 unsigned char * tp;
7262 Elf_Internal_Sym * sym;
7263 const char * relname;
57346661 7264
57346661
AM		 7265 /* First, find the starting address of the segment that includes
7266 this section. */
7267
7268 if (elf_header.e_phnum)
7269 {
7270 if (! get_program_headers (file))
7271 return 0;
7272
7273 for (seg = program_headers;
7274 seg < program_headers + elf_header.e_phnum;
7275 ++seg)
7276 {
7277 if (seg->p_type != PT_LOAD)
7278 continue;
7279
7280 if (sec->sh_addr >= seg->p_vaddr
7281 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7282 {
7283 aux->seg_base = seg->p_vaddr;
7284 break;
7285 }
7286 }
7287 }
7288
7289 /* Second, build the unwind table from the contents of the unwind
7290 section. */
7291 size = sec->sh_size;
3f5e193b
NC		 7292 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7293 _("unwind table"));
57346661
AM		 7294 if (!table)
7295 return 0;
7296
1c0751b2
DA		 7297 unw_ent_size = 16;
7298 nentries = size / unw_ent_size;
7299 size = unw_ent_size * nentries;
57346661 7300
3f5e193b
NC		 7301 tep = aux->table = (struct hppa_unw_table_entry *)
7302 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 7303
1c0751b2 7304 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 7305 {
7306 unsigned int tmp1, tmp2;
7307
7308 tep->start.section = SHN_UNDEF;
7309 tep->end.section = SHN_UNDEF;
7310
1c0751b2
DA		 7311 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7312 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7313 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7314 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7315
7316 tep->start.offset += aux->seg_base;
7317 tep->end.offset += aux->seg_base;
57346661
AM		 7318
7319 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7320 tep->Millicode = (tmp1 >> 30) & 0x1;
7321 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7322 tep->Region_description = (tmp1 >> 27) & 0x3;
7323 tep->reserved1 = (tmp1 >> 26) & 0x1;
7324 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7325 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7326 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7327 tep->Args_stored = (tmp1 >> 15) & 0x1;
7328 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7329 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7330 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7331 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7332 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7333 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7334 tep->cxx_info = (tmp1 >> 8) & 0x1;
7335 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7336 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7337 tep->reserved2 = (tmp1 >> 5) & 0x1;
7338 tep->Save_SP = (tmp1 >> 4) & 0x1;
7339 tep->Save_RP = (tmp1 >> 3) & 0x1;
7340 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7341 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7342 tep->Cleanup_defined = tmp1 & 0x1;
7343
7344 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7345 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7346 tep->Large_frame = (tmp2 >> 29) & 0x1;
7347 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7348 tep->reserved4 = (tmp2 >> 27) & 0x1;
7349 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 7350 }
7351 free (table);
7352
7353 /* Third, apply any relocations to the unwind table. */
57346661
AM		 7354 for (relsec = section_headers;
7355 relsec < section_headers + elf_header.e_shnum;
7356 ++relsec)
7357 {
7358 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7359 || relsec->sh_info >= elf_header.e_shnum
7360 || section_headers + relsec->sh_info != sec)
57346661
AM		 7361 continue;
7362
7363 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7364 & rela, & nrelas))
7365 return 0;
7366
7367 for (rp = rela; rp < rela + nrelas; ++rp)
7368 {
aca88567
NC		 7369 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7370 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 7371
7372 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 7373 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 7374 {
7375 warn (_("Skipping unexpected relocation type %s\n"), relname);
7376 continue;
7377 }
7378
7379 i = rp->r_offset / unw_ent_size;
7380
89fac5e3 7381 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 7382 {
7383 case 0:
7384 aux->table[i].start.section = sym->st_shndx;
1e456d54 7385 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 7386 break;
7387 case 1:
7388 aux->table[i].end.section = sym->st_shndx;
1e456d54 7389 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 7390 break;
7391 default:
7392 break;
7393 }
7394 }
7395
7396 free (rela);
7397 }
7398
1c0751b2 7399 aux->table_len = nentries;
57346661
AM		 7400
7401 return 1;
7402}
7403
1b31d05e 7404static void
2cf0635d 7405hppa_process_unwind (FILE * file)
57346661 7406{
57346661 7407 struct hppa_unw_aux_info aux;
2cf0635d
NC		 7408 Elf_Internal_Shdr * unwsec = NULL;
7409 Elf_Internal_Shdr * strsec;
7410 Elf_Internal_Shdr * sec;
18bd398b 7411 unsigned long i;
57346661 7412
c256ffe7 7413 if (string_table == NULL)
1b31d05e
NC		 7414 return;
7415
7416 memset (& aux, 0, sizeof (aux));
57346661
AM		 7417
7418 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7419 {
c256ffe7 7420 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7421 && sec->sh_link < elf_header.e_shnum)
57346661 7422 {
ba5cdace 7423 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 7424
4fbb74a6 7425 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7426 if (aux.strtab != NULL)
7427 {
7428 error (_("Multiple auxillary string tables encountered\n"));
7429 free (aux.strtab);
7430 }
3f5e193b
NC		 7431 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7432 1, strsec->sh_size,
7433 _("string table"));
c256ffe7 7434 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 7435 }
18bd398b 7436 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 7437 unwsec = sec;
7438 }
7439
7440 if (!unwsec)
7441 printf (_("\nThere are no unwind sections in this file.\n"));
7442
7443 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7444 {
18bd398b 7445 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 7446 {
74e1a04b
NC		 7447 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7448 printable_section_name (sec),
57346661 7449 (unsigned long) sec->sh_offset,
89fac5e3 7450 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 7451
7452 slurp_hppa_unwind_table (file, &aux, sec);
7453 if (aux.table_len > 0)
7454 dump_hppa_unwind (&aux);
7455
7456 if (aux.table)
7457 free ((char *) aux.table);
7458 aux.table = NULL;
7459 }
7460 }
7461
7462 if (aux.symtab)
7463 free (aux.symtab);
7464 if (aux.strtab)
7465 free ((char *) aux.strtab);
57346661
AM		 7466}
7467
0b6ae522
DJ		 7468struct arm_section
7469{
a734115a
NC		 7470 unsigned char * data; /* The unwind data. */
7471 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7472 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7473 unsigned long nrelas; /* The number of relocations. */
7474 unsigned int rel_type; /* REL or RELA ? */
7475 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 7476};
7477
7478struct arm_unw_aux_info
7479{
a734115a
NC		 7480 FILE * file; /* The file containing the unwind sections. */
7481 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7482 unsigned long nsyms; /* Number of symbols. */
948f632f
DA		 7483 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7484 unsigned long nfuns; /* Number of these symbols. */
a734115a
NC		 7485 char * strtab; /* The file's string table. */
7486 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 7487};
7488
7489static const char *
7490arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7491 bfd_vma fn, struct absaddr addr)
7492{
7493 const char *procname;
7494 bfd_vma sym_offset;
7495
7496 if (addr.section == SHN_UNDEF)
7497 addr.offset = fn;
7498
948f632f 7499 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
0b6ae522
DJ		 7500 aux->strtab_size, addr, &procname,
7501 &sym_offset);
7502
7503 print_vma (fn, PREFIX_HEX);
7504
7505 if (procname)
7506 {
7507 fputs (" <", stdout);
7508 fputs (procname, stdout);
7509
7510 if (sym_offset)
7511 printf ("+0x%lx", (unsigned long) sym_offset);
7512 fputc ('>', stdout);
7513 }
7514
7515 return procname;
7516}
7517
7518static void
7519arm_free_section (struct arm_section *arm_sec)
7520{
7521 if (arm_sec->data != NULL)
7522 free (arm_sec->data);
7523
7524 if (arm_sec->rela != NULL)
7525 free (arm_sec->rela);
7526}
7527
a734115a
NC		 7528/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7529 cached section and install SEC instead.
7530 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7531 and return its valued in * WORDP, relocating if necessary.
1b31d05e 7532 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 7533 relocation's offset in ADDR.
1b31d05e
NC		 7534 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7535 into the string table of the symbol associated with the reloc. If no
7536 reloc was applied store -1 there.
7537 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 7538
7539static bfd_boolean
1b31d05e
NC		 7540get_unwind_section_word (struct arm_unw_aux_info * aux,
7541 struct arm_section * arm_sec,
7542 Elf_Internal_Shdr * sec,
7543 bfd_vma word_offset,
7544 unsigned int * wordp,
7545 struct absaddr * addr,
7546 bfd_vma * sym_name)
0b6ae522
DJ		 7547{
7548 Elf_Internal_Rela *rp;
7549 Elf_Internal_Sym *sym;
7550 const char * relname;
7551 unsigned int word;
7552 bfd_boolean wrapped;
7553
e0a31db1
NC		 7554 if (sec == NULL || arm_sec == NULL)
7555 return FALSE;
7556
0b6ae522
DJ		 7557 addr->section = SHN_UNDEF;
7558 addr->offset = 0;
7559
1b31d05e
NC		 7560 if (sym_name != NULL)
7561 *sym_name = (bfd_vma) -1;
7562
a734115a 7563 /* If necessary, update the section cache. */
0b6ae522
DJ		 7564 if (sec != arm_sec->sec)
7565 {
7566 Elf_Internal_Shdr *relsec;
7567
7568 arm_free_section (arm_sec);
7569
7570 arm_sec->sec = sec;
7571 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7572 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 7573 arm_sec->rela = NULL;
7574 arm_sec->nrelas = 0;
7575
7576 for (relsec = section_headers;
7577 relsec < section_headers + elf_header.e_shnum;
7578 ++relsec)
7579 {
7580 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 7581 || section_headers + relsec->sh_info != sec
7582 /* PR 15745: Check the section type as well. */
7583 || (relsec->sh_type != SHT_REL
7584 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 7585 continue;
7586
a734115a 7587 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 7588 if (relsec->sh_type == SHT_REL)
7589 {
7590 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7591 relsec->sh_size,
7592 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7593 return FALSE;
0b6ae522 7594 }
1ae40aa4 7595 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 7596 {
7597 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7598 relsec->sh_size,
7599 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7600 return FALSE;
0b6ae522 7601 }
1ae40aa4 7602 break;
0b6ae522
DJ		 7603 }
7604
7605 arm_sec->next_rela = arm_sec->rela;
7606 }
7607
a734115a 7608 /* If there is no unwind data we can do nothing. */
0b6ae522 7609 if (arm_sec->data == NULL)
a734115a 7610 return FALSE;
0b6ae522 7611
e0a31db1 7612 /* If the offset is invalid then fail. */
1a915552
NC		 7613 if (word_offset > (sec->sh_size - 4)
7614 /* PR 18879 */
7615 || (sec->sh_size < 5 && word_offset >= sec->sh_size)
7616 || ((bfd_signed_vma) word_offset) < 0)
e0a31db1
NC		 7617 return FALSE;
7618
a734115a 7619 /* Get the word at the required offset. */
0b6ae522
DJ		 7620 word = byte_get (arm_sec->data + word_offset, 4);
7621
0eff7165
NC		 7622 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7623 if (arm_sec->rela == NULL)
7624 {
7625 * wordp = word;
7626 return TRUE;
7627 }
7628
a734115a 7629 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 7630 wrapped = FALSE;
7631 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7632 {
7633 bfd_vma prelval, offset;
7634
7635 if (rp->r_offset > word_offset && !wrapped)
7636 {
7637 rp = arm_sec->rela;
7638 wrapped = TRUE;
7639 }
7640 if (rp->r_offset > word_offset)
7641 break;
7642
7643 if (rp->r_offset & 3)
7644 {
7645 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7646 (unsigned long) rp->r_offset);
7647 continue;
7648 }
7649
7650 if (rp->r_offset < word_offset)
7651 continue;
7652
74e1a04b
NC		 7653 /* PR 17531: file: 027-161405-0.004 */
7654 if (aux->symtab == NULL)
7655 continue;
7656
0b6ae522
DJ		 7657 if (arm_sec->rel_type == SHT_REL)
7658 {
7659 offset = word & 0x7fffffff;
7660 if (offset & 0x40000000)
7661 offset |= ~ (bfd_vma) 0x7fffffff;
7662 }
a734115a 7663 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 7664 offset = rp->r_addend;
a734115a 7665 else
74e1a04b
NC		 7666 {
7667 error (_("Unknown section relocation type %d encountered\n"),
7668 arm_sec->rel_type);
7669 break;
7670 }
0b6ae522 7671
071436c6
NC		 7672 /* PR 17531 file: 027-1241568-0.004. */
7673 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7674 {
7675 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7676 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7677 break;
7678 }
7679
7680 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
0b6ae522
DJ		 7681 offset += sym->st_value;
7682 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7683
a734115a
NC		 7684 /* Check that we are processing the expected reloc type. */
7685 if (elf_header.e_machine == EM_ARM)
7686 {
7687 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7688 if (relname == NULL)
7689 {
7690 warn (_("Skipping unknown ARM relocation type: %d\n"),
7691 (int) ELF32_R_TYPE (rp->r_info));
7692 continue;
7693 }
a734115a
NC		 7694
7695 if (streq (relname, "R_ARM_NONE"))
7696 continue;
0b4362b0 7697
a734115a
NC		 7698 if (! streq (relname, "R_ARM_PREL31"))
7699 {
071436c6 7700 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
a734115a
NC		 7701 continue;
7702 }
7703 }
7704 else if (elf_header.e_machine == EM_TI_C6000)
7705 {
7706 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7707 if (relname == NULL)
7708 {
7709 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7710 (int) ELF32_R_TYPE (rp->r_info));
7711 continue;
7712 }
0b4362b0 7713
a734115a
NC		 7714 if (streq (relname, "R_C6000_NONE"))
7715 continue;
7716
7717 if (! streq (relname, "R_C6000_PREL31"))
7718 {
071436c6 7719 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
a734115a
NC		 7720 continue;
7721 }
7722
7723 prelval >>= 1;
7724 }
7725 else
74e1a04b
NC		 7726 {
7727 /* This function currently only supports ARM and TI unwinders. */
7728 warn (_("Only TI and ARM unwinders are currently supported\n"));
7729 break;
7730 }
fa197c1c 7731
0b6ae522
DJ		 7732 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7733 addr->section = sym->st_shndx;
7734 addr->offset = offset;
74e1a04b 7735
1b31d05e
NC		 7736 if (sym_name)
7737 * sym_name = sym->st_name;
0b6ae522
DJ		 7738 break;
7739 }
7740
7741 *wordp = word;
7742 arm_sec->next_rela = rp;
7743
a734115a 7744 return TRUE;
0b6ae522
DJ		 7745}
7746
a734115a
NC		 7747static const char *tic6x_unwind_regnames[16] =
7748{
0b4362b0
RM		 7749 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7750 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 7751 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7752};
fa197c1c 7753
0b6ae522 7754static void
fa197c1c 7755decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 7756{
fa197c1c
PB		 7757 int i;
7758
7759 for (i = 12; mask; mask >>= 1, i--)
7760 {
7761 if (mask & 1)
7762 {
7763 fputs (tic6x_unwind_regnames[i], stdout);
7764 if (mask > 1)
7765 fputs (", ", stdout);
7766 }
7767 }
7768}
0b6ae522
DJ		 7769
7770#define ADVANCE \
7771 if (remaining == 0 && more_words) \
7772 { \
7773 data_offset += 4; \
1b31d05e
NC		 7774 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7775 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 7776 return; \
7777 remaining = 4; \
7778 more_words--; \
7779 } \
7780
7781#define GET_OP(OP) \
7782 ADVANCE; \
7783 if (remaining) \
7784 { \
7785 remaining--; \
7786 (OP) = word >> 24; \
7787 word <<= 8; \
7788 } \
7789 else \
7790 { \
2b692964 7791 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 7792 return; \
7793 } \
cc5914eb 7794 printf ("0x%02x ", OP)
0b6ae522 7795
fa197c1c 7796static void
948f632f
DA		 7797decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
7798 unsigned int word,
7799 unsigned int remaining,
7800 unsigned int more_words,
7801 bfd_vma data_offset,
7802 Elf_Internal_Shdr * data_sec,
7803 struct arm_section * data_arm_sec)
fa197c1c
PB		 7804{
7805 struct absaddr addr;
0b6ae522
DJ		 7806
7807 /* Decode the unwinding instructions. */
7808 while (1)
7809 {
7810 unsigned int op, op2;
7811
7812 ADVANCE;
7813 if (remaining == 0)
7814 break;
7815 remaining--;
7816 op = word >> 24;
7817 word <<= 8;
7818
cc5914eb 7819 printf (" 0x%02x ", op);
0b6ae522
DJ		 7820
7821 if ((op & 0xc0) == 0x00)
7822 {
7823 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7824
cc5914eb 7825 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 7826 }
7827 else if ((op & 0xc0) == 0x40)
7828 {
7829 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7830
cc5914eb 7831 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 7832 }
7833 else if ((op & 0xf0) == 0x80)
7834 {
7835 GET_OP (op2);
7836 if (op == 0x80 && op2 == 0)
7837 printf (_("Refuse to unwind"));
7838 else
7839 {
7840 unsigned int mask = ((op & 0x0f) << 8) | op2;
7841 int first = 1;
7842 int i;
2b692964 7843
0b6ae522
DJ		 7844 printf ("pop {");
7845 for (i = 0; i < 12; i++)
7846 if (mask & (1 << i))
7847 {
7848 if (first)
7849 first = 0;
7850 else
7851 printf (", ");
7852 printf ("r%d", 4 + i);
7853 }
7854 printf ("}");
7855 }
7856 }
7857 else if ((op & 0xf0) == 0x90)
7858 {
7859 if (op == 0x9d || op == 0x9f)
7860 printf (_(" [Reserved]"));
7861 else
cc5914eb 7862 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 7863 }
7864 else if ((op & 0xf0) == 0xa0)
7865 {
7866 int end = 4 + (op & 0x07);
7867 int first = 1;
7868 int i;
61865e30 7869
0b6ae522
DJ		 7870 printf (" pop {");
7871 for (i = 4; i <= end; i++)
7872 {
7873 if (first)
7874 first = 0;
7875 else
7876 printf (", ");
7877 printf ("r%d", i);
7878 }
7879 if (op & 0x08)
7880 {
1b31d05e 7881 if (!first)
0b6ae522
DJ		 7882 printf (", ");
7883 printf ("r14");
7884 }
7885 printf ("}");
7886 }
7887 else if (op == 0xb0)
7888 printf (_(" finish"));
7889 else if (op == 0xb1)
7890 {
7891 GET_OP (op2);
7892 if (op2 == 0 || (op2 & 0xf0) != 0)
7893 printf (_("[Spare]"));
7894 else
7895 {
7896 unsigned int mask = op2 & 0x0f;
7897 int first = 1;
7898 int i;
61865e30 7899
0b6ae522
DJ		 7900 printf ("pop {");
7901 for (i = 0; i < 12; i++)
7902 if (mask & (1 << i))
7903 {
7904 if (first)
7905 first = 0;
7906 else
7907 printf (", ");
7908 printf ("r%d", i);
7909 }
7910 printf ("}");
7911 }
7912 }
7913 else if (op == 0xb2)
7914 {
b115cf96 7915 unsigned char buf[9];
0b6ae522
DJ		 7916 unsigned int i, len;
7917 unsigned long offset;
61865e30 7918
b115cf96 7919 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 7920 {
7921 GET_OP (buf[i]);
7922 if ((buf[i] & 0x80) == 0)
7923 break;
7924 }
4082ef84
NC		 7925 if (i == sizeof (buf))
7926 printf (_("corrupt change to vsp"));
7927 else
7928 {
7929 offset = read_uleb128 (buf, &len, buf + i + 1);
7930 assert (len == i + 1);
7931 offset = offset * 4 + 0x204;
7932 printf ("vsp = vsp + %ld", offset);
7933 }
0b6ae522 7934 }
61865e30 7935 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 7936 {
61865e30
NC		 7937 unsigned int first, last;
7938
7939 GET_OP (op2);
7940 first = op2 >> 4;
7941 last = op2 & 0x0f;
7942 if (op == 0xc8)
7943 first = first + 16;
7944 printf ("pop {D%d", first);
7945 if (last)
7946 printf ("-D%d", first + last);
7947 printf ("}");
7948 }
7949 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7950 {
7951 unsigned int count = op & 0x07;
7952
7953 printf ("pop {D8");
7954 if (count)
7955 printf ("-D%d", 8 + count);
7956 printf ("}");
7957 }
7958 else if (op >= 0xc0 && op <= 0xc5)
7959 {
7960 unsigned int count = op & 0x07;
7961
7962 printf (" pop {wR10");
7963 if (count)
7964 printf ("-wR%d", 10 + count);
7965 printf ("}");
7966 }
7967 else if (op == 0xc6)
7968 {
7969 unsigned int first, last;
7970
7971 GET_OP (op2);
7972 first = op2 >> 4;
7973 last = op2 & 0x0f;
7974 printf ("pop {wR%d", first);
7975 if (last)
7976 printf ("-wR%d", first + last);
7977 printf ("}");
7978 }
7979 else if (op == 0xc7)
7980 {
7981 GET_OP (op2);
7982 if (op2 == 0 || (op2 & 0xf0) != 0)
7983 printf (_("[Spare]"));
0b6ae522
DJ		 7984 else
7985 {
61865e30
NC		 7986 unsigned int mask = op2 & 0x0f;
7987 int first = 1;
7988 int i;
7989
7990 printf ("pop {");
7991 for (i = 0; i < 4; i++)
7992 if (mask & (1 << i))
7993 {
7994 if (first)
7995 first = 0;
7996 else
7997 printf (", ");
7998 printf ("wCGR%d", i);
7999 }
8000 printf ("}");
0b6ae522
DJ		 8001 }
8002 }
61865e30
NC		 8003 else
8004 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 8005 printf ("\n");
8006 }
fa197c1c
PB		 8007}
8008
8009static void
948f632f
DA		 8010decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
8011 unsigned int word,
8012 unsigned int remaining,
8013 unsigned int more_words,
8014 bfd_vma data_offset,
8015 Elf_Internal_Shdr * data_sec,
8016 struct arm_section * data_arm_sec)
fa197c1c
PB		 8017{
8018 struct absaddr addr;
8019
8020 /* Decode the unwinding instructions. */
8021 while (1)
8022 {
8023 unsigned int op, op2;
8024
8025 ADVANCE;
8026 if (remaining == 0)
8027 break;
8028 remaining--;
8029 op = word >> 24;
8030 word <<= 8;
8031
9cf03b7e 8032 printf (" 0x%02x ", op);
fa197c1c
PB		 8033
8034 if ((op & 0xc0) == 0x00)
8035 {
8036 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 8037 printf (" sp = sp + %d", offset);
fa197c1c
PB		 8038 }
8039 else if ((op & 0xc0) == 0x80)
8040 {
8041 GET_OP (op2);
8042 if (op == 0x80 && op2 == 0)
8043 printf (_("Refuse to unwind"));
8044 else
8045 {
8046 unsigned int mask = ((op & 0x1f) << 8) | op2;
8047 if (op & 0x20)
8048 printf ("pop compact {");
8049 else
8050 printf ("pop {");
8051
8052 decode_tic6x_unwind_regmask (mask);
8053 printf("}");
8054 }
8055 }
8056 else if ((op & 0xf0) == 0xc0)
8057 {
8058 unsigned int reg;
8059 unsigned int nregs;
8060 unsigned int i;
8061 const char *name;
a734115a
NC		 8062 struct
8063 {
fa197c1c
PB		 8064 unsigned int offset;
8065 unsigned int reg;
8066 } regpos[16];
8067
8068 /* Scan entire instruction first so that GET_OP output is not
8069 interleaved with disassembly. */
8070 nregs = 0;
8071 for (i = 0; nregs < (op & 0xf); i++)
8072 {
8073 GET_OP (op2);
8074 reg = op2 >> 4;
8075 if (reg != 0xf)
8076 {
8077 regpos[nregs].offset = i * 2;
8078 regpos[nregs].reg = reg;
8079 nregs++;
8080 }
8081
8082 reg = op2 & 0xf;
8083 if (reg != 0xf)
8084 {
8085 regpos[nregs].offset = i * 2 + 1;
8086 regpos[nregs].reg = reg;
8087 nregs++;
8088 }
8089 }
8090
8091 printf (_("pop frame {"));
8092 reg = nregs - 1;
8093 for (i = i * 2; i > 0; i--)
8094 {
8095 if (regpos[reg].offset == i - 1)
8096 {
8097 name = tic6x_unwind_regnames[regpos[reg].reg];
8098 if (reg > 0)
8099 reg--;
8100 }
8101 else
8102 name = _("[pad]");
8103
8104 fputs (name, stdout);
8105 if (i > 1)
8106 printf (", ");
8107 }
8108
8109 printf ("}");
8110 }
8111 else if (op == 0xd0)
8112 printf (" MOV FP, SP");
8113 else if (op == 0xd1)
8114 printf (" __c6xabi_pop_rts");
8115 else if (op == 0xd2)
8116 {
8117 unsigned char buf[9];
8118 unsigned int i, len;
8119 unsigned long offset;
a734115a 8120
fa197c1c
PB		 8121 for (i = 0; i < sizeof (buf); i++)
8122 {
8123 GET_OP (buf[i]);
8124 if ((buf[i] & 0x80) == 0)
8125 break;
8126 }
0eff7165
NC		 8127 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8128 if (i == sizeof (buf))
8129 {
8130 printf ("<corrupt sp adjust>\n");
8131 warn (_("Corrupt stack pointer adjustment detected\n"));
8132 return;
8133 }
948f632f 8134
f6f0e17b 8135 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 8136 assert (len == i + 1);
8137 offset = offset * 8 + 0x408;
8138 printf (_("sp = sp + %ld"), offset);
8139 }
8140 else if ((op & 0xf0) == 0xe0)
8141 {
8142 if ((op & 0x0f) == 7)
8143 printf (" RETURN");
8144 else
8145 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8146 }
8147 else
8148 {
8149 printf (_(" [unsupported opcode]"));
8150 }
8151 putchar ('\n');
8152 }
8153}
8154
8155static bfd_vma
a734115a 8156arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 8157{
8158 bfd_vma offset;
8159
8160 offset = word & 0x7fffffff;
8161 if (offset & 0x40000000)
8162 offset |= ~ (bfd_vma) 0x7fffffff;
8163
8164 if (elf_header.e_machine == EM_TI_C6000)
8165 offset <<= 1;
8166
8167 return offset + where;
8168}
8169
8170static void
1b31d05e
NC		 8171decode_arm_unwind (struct arm_unw_aux_info * aux,
8172 unsigned int word,
8173 unsigned int remaining,
8174 bfd_vma data_offset,
8175 Elf_Internal_Shdr * data_sec,
8176 struct arm_section * data_arm_sec)
fa197c1c
PB		 8177{
8178 int per_index;
8179 unsigned int more_words = 0;
37e14bc3 8180 struct absaddr addr;
1b31d05e 8181 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 8182
8183 if (remaining == 0)
8184 {
1b31d05e
NC		 8185 /* Fetch the first word.
8186 Note - when decoding an object file the address extracted
8187 here will always be 0. So we also pass in the sym_name
8188 parameter so that we can find the symbol associated with
8189 the personality routine. */
8190 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8191 & word, & addr, & sym_name))
fa197c1c 8192 return;
1b31d05e 8193
fa197c1c
PB		 8194 remaining = 4;
8195 }
8196
8197 if ((word & 0x80000000) == 0)
8198 {
8199 /* Expand prel31 for personality routine. */
8200 bfd_vma fn;
8201 const char *procname;
8202
a734115a 8203 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 8204 printf (_(" Personality routine: "));
1b31d05e
NC		 8205 if (fn == 0
8206 && addr.section == SHN_UNDEF && addr.offset == 0
8207 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8208 {
8209 procname = aux->strtab + sym_name;
8210 print_vma (fn, PREFIX_HEX);
8211 if (procname)
8212 {
8213 fputs (" <", stdout);
8214 fputs (procname, stdout);
8215 fputc ('>', stdout);
8216 }
8217 }
8218 else
8219 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 8220 fputc ('\n', stdout);
8221
8222 /* The GCC personality routines use the standard compact
8223 encoding, starting with one byte giving the number of
8224 words. */
8225 if (procname != NULL
8226 && (const_strneq (procname, "__gcc_personality_v0")
8227 || const_strneq (procname, "__gxx_personality_v0")
8228 || const_strneq (procname, "__gcj_personality_v0")
8229 || const_strneq (procname, "__gnu_objc_personality_v0")))
8230 {
8231 remaining = 0;
8232 more_words = 1;
8233 ADVANCE;
8234 if (!remaining)
8235 {
8236 printf (_(" [Truncated data]\n"));
8237 return;
8238 }
8239 more_words = word >> 24;
8240 word <<= 8;
8241 remaining--;
8242 per_index = -1;
8243 }
8244 else
8245 return;
8246 }
8247 else
8248 {
1b31d05e 8249 /* ARM EHABI Section 6.3:
0b4362b0 8250
1b31d05e 8251 An exception-handling table entry for the compact model looks like:
0b4362b0 8252
1b31d05e
NC		 8253 31 30-28 27-24 23-0
8254 -- ----- ----- ----
8255 1 0 index Data for personalityRoutine[index] */
8256
8257 if (elf_header.e_machine == EM_ARM
8258 && (word & 0x70000000))
83c257ca 8259 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 8260
fa197c1c 8261 per_index = (word >> 24) & 0x7f;
1b31d05e 8262 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 8263 if (per_index == 0)
8264 {
8265 more_words = 0;
8266 word <<= 8;
8267 remaining--;
8268 }
8269 else if (per_index < 3)
8270 {
8271 more_words = (word >> 16) & 0xff;
8272 word <<= 16;
8273 remaining -= 2;
8274 }
8275 }
8276
8277 switch (elf_header.e_machine)
8278 {
8279 case EM_ARM:
8280 if (per_index < 3)
8281 {
8282 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8283 data_offset, data_sec, data_arm_sec);
8284 }
8285 else
1b31d05e
NC		 8286 {
8287 warn (_("Unknown ARM compact model index encountered\n"));
8288 printf (_(" [reserved]\n"));
8289 }
fa197c1c
PB		 8290 break;
8291
8292 case EM_TI_C6000:
8293 if (per_index < 3)
8294 {
8295 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 8296 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 8297 }
8298 else if (per_index < 5)
8299 {
8300 if (((word >> 17) & 0x7f) == 0x7f)
8301 printf (_(" Restore stack from frame pointer\n"));
8302 else
8303 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8304 printf (_(" Registers restored: "));
8305 if (per_index == 4)
8306 printf (" (compact) ");
8307 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8308 putchar ('\n');
8309 printf (_(" Return register: %s\n"),
8310 tic6x_unwind_regnames[word & 0xf]);
8311 }
8312 else
1b31d05e 8313 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 8314 break;
8315
8316 default:
74e1a04b 8317 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
1b31d05e 8318 elf_header.e_machine);
fa197c1c 8319 }
0b6ae522
DJ		 8320
8321 /* Decode the descriptors. Not implemented. */
8322}
8323
8324static void
8325dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8326{
8327 struct arm_section exidx_arm_sec, extab_arm_sec;
8328 unsigned int i, exidx_len;
948f632f 8329 unsigned long j, nfuns;
0b6ae522
DJ		 8330
8331 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8332 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8333 exidx_len = exidx_sec->sh_size / 8;
8334
948f632f
DA		 8335 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8336 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8337 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8338 aux->funtab[nfuns++] = aux->symtab[j];
8339 aux->nfuns = nfuns;
8340 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8341
0b6ae522
DJ		 8342 for (i = 0; i < exidx_len; i++)
8343 {
8344 unsigned int exidx_fn, exidx_entry;
8345 struct absaddr fn_addr, entry_addr;
8346 bfd_vma fn;
8347
8348 fputc ('\n', stdout);
8349
1b31d05e
NC		 8350 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8351 8 * i, & exidx_fn, & fn_addr, NULL)
8352 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8353 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 8354 {
948f632f 8355 free (aux->funtab);
1b31d05e
NC		 8356 arm_free_section (& exidx_arm_sec);
8357 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 8358 return;
8359 }
8360
83c257ca
NC		 8361 /* ARM EHABI, Section 5:
8362 An index table entry consists of 2 words.
8363 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8364 if (exidx_fn & 0x80000000)
8365 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8366
a734115a 8367 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 8368
a734115a 8369 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 8370 fputs (": ", stdout);
8371
8372 if (exidx_entry == 1)
8373 {
8374 print_vma (exidx_entry, PREFIX_HEX);
8375 fputs (" [cantunwind]\n", stdout);
8376 }
8377 else if (exidx_entry & 0x80000000)
8378 {
8379 print_vma (exidx_entry, PREFIX_HEX);
8380 fputc ('\n', stdout);
8381 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8382 }
8383 else
8384 {
8f73510c 8385 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 8386 Elf_Internal_Shdr *table_sec;
8387
8388 fputs ("@", stdout);
a734115a 8389 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 8390 print_vma (table, PREFIX_HEX);
8391 printf ("\n");
8392
8393 /* Locate the matching .ARM.extab. */
8394 if (entry_addr.section != SHN_UNDEF
8395 && entry_addr.section < elf_header.e_shnum)
8396 {
8397 table_sec = section_headers + entry_addr.section;
8398 table_offset = entry_addr.offset;
1a915552
NC		 8399 /* PR 18879 */
8400 if (table_offset > table_sec->sh_size
8401 || ((bfd_signed_vma) table_offset) < 0)
8402 {
8403 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8404 (unsigned long) table_offset,
8405 printable_section_name (table_sec));
8406 continue;
8407 }
0b6ae522
DJ		 8408 }
8409 else
8410 {
8411 table_sec = find_section_by_address (table);
8412 if (table_sec != NULL)
8413 table_offset = table - table_sec->sh_addr;
8414 }
8415 if (table_sec == NULL)
8416 {
8417 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8418 (unsigned long) table);
8419 continue;
8420 }
8421 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8422 &extab_arm_sec);
8423 }
8424 }
8425
8426 printf ("\n");
8427
948f632f 8428 free (aux->funtab);
0b6ae522
DJ		 8429 arm_free_section (&exidx_arm_sec);
8430 arm_free_section (&extab_arm_sec);
8431}
8432
fa197c1c 8433/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 8434
8435static void
0b6ae522
DJ		 8436arm_process_unwind (FILE *file)
8437{
8438 struct arm_unw_aux_info aux;
8439 Elf_Internal_Shdr *unwsec = NULL;
8440 Elf_Internal_Shdr *strsec;
8441 Elf_Internal_Shdr *sec;
8442 unsigned long i;
fa197c1c 8443 unsigned int sec_type;
0b6ae522 8444
fa197c1c
PB		 8445 switch (elf_header.e_machine)
8446 {
8447 case EM_ARM:
8448 sec_type = SHT_ARM_EXIDX;
8449 break;
8450
8451 case EM_TI_C6000:
8452 sec_type = SHT_C6000_UNWIND;
8453 break;
8454
0b4362b0 8455 default:
74e1a04b 8456 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
1b31d05e
NC		 8457 elf_header.e_machine);
8458 return;
fa197c1c
PB		 8459 }
8460
0b6ae522 8461 if (string_table == NULL)
1b31d05e
NC		 8462 return;
8463
8464 memset (& aux, 0, sizeof (aux));
8465 aux.file = file;
0b6ae522
DJ		 8466
8467 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8468 {
8469 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8470 {
ba5cdace 8471 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 8472
8473 strsec = section_headers + sec->sh_link;
74e1a04b
NC		 8474
8475 /* PR binutils/17531 file: 011-12666-0.004. */
8476 if (aux.strtab != NULL)
8477 {
4082ef84 8478 error (_("Multiple string tables found in file.\n"));
74e1a04b
NC		 8479 free (aux.strtab);
8480 }
0b6ae522
DJ		 8481 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8482 1, strsec->sh_size, _("string table"));
8483 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8484 }
fa197c1c 8485 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 8486 unwsec = sec;
8487 }
8488
1b31d05e 8489 if (unwsec == NULL)
0b6ae522 8490 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 8491 else
8492 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8493 {
8494 if (sec->sh_type == sec_type)
8495 {
8496 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
74e1a04b 8497 printable_section_name (sec),
1b31d05e
NC		 8498 (unsigned long) sec->sh_offset,
8499 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 8500
1b31d05e
NC		 8501 dump_arm_unwind (&aux, sec);
8502 }
8503 }
0b6ae522
DJ		 8504
8505 if (aux.symtab)
8506 free (aux.symtab);
8507 if (aux.strtab)
8508 free ((char *) aux.strtab);
0b6ae522
DJ		 8509}
8510
1b31d05e 8511static void
2cf0635d 8512process_unwind (FILE * file)
57346661 8513{
2cf0635d
NC		 8514 struct unwind_handler
8515 {
57346661 8516 int machtype;
1b31d05e 8517 void (* handler)(FILE *);
2cf0635d
NC		 8518 } handlers[] =
8519 {
0b6ae522 8520 { EM_ARM, arm_process_unwind },
57346661
AM		 8521 { EM_IA_64, ia64_process_unwind },
8522 { EM_PARISC, hppa_process_unwind },
fa197c1c 8523 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 8524 { 0, 0 }
8525 };
8526 int i;
8527
8528 if (!do_unwind)
1b31d05e 8529 return;
57346661
AM		 8530
8531 for (i = 0; handlers[i].handler != NULL; i++)
8532 if (elf_header.e_machine == handlers[i].machtype)
9f758fdc
NC		 8533 {
8534 handlers[i].handler (file);
8535 return;
8536 }
57346661 8537
1b31d05e
NC		 8538 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8539 get_machine_name (elf_header.e_machine));
57346661
AM		 8540}
8541
252b5132 8542static void
2cf0635d 8543dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 8544{
8545 switch (entry->d_tag)
8546 {
8547 case DT_MIPS_FLAGS:
8548 if (entry->d_un.d_val == 0)
4b68bca3 8549 printf (_("NONE"));
252b5132
RH		 8550 else
8551 {
8552 static const char * opts[] =
8553 {
8554 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8555 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8556 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8557 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8558 "RLD_ORDER_SAFE"
8559 };
8560 unsigned int cnt;
8561 int first = 1;
2b692964 8562
60bca95a 8563 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 8564 if (entry->d_un.d_val & (1 << cnt))
8565 {
8566 printf ("%s%s", first ? "" : " ", opts[cnt]);
8567 first = 0;
8568 }
252b5132
RH		 8569 }
8570 break;
103f02d3 8571
252b5132 8572 case DT_MIPS_IVERSION:
d79b3d50 8573 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 8574 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8575 else
76ca31c0
NC		 8576 {
8577 char buf[40];
8578 sprintf_vma (buf, entry->d_un.d_ptr);
8579 /* Note: coded this way so that there is a single string for translation. */
8580 printf (_("<corrupt: %s>"), buf);
8581 }
252b5132 8582 break;
103f02d3 8583
252b5132
RH		 8584 case DT_MIPS_TIME_STAMP:
8585 {
8586 char timebuf[20];
2cf0635d 8587 struct tm * tmp;
91d6fa6a 8588 time_t atime = entry->d_un.d_val;
82b1b41b 8589
91d6fa6a 8590 tmp = gmtime (&atime);
82b1b41b
NC		 8591 /* PR 17531: file: 6accc532. */
8592 if (tmp == NULL)
8593 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8594 else
8595 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8596 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8597 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 8598 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 8599 }
8600 break;
103f02d3 8601
252b5132
RH		 8602 case DT_MIPS_RLD_VERSION:
8603 case DT_MIPS_LOCAL_GOTNO:
8604 case DT_MIPS_CONFLICTNO:
8605 case DT_MIPS_LIBLISTNO:
8606 case DT_MIPS_SYMTABNO:
8607 case DT_MIPS_UNREFEXTNO:
8608 case DT_MIPS_HIPAGENO:
8609 case DT_MIPS_DELTA_CLASS_NO:
8610 case DT_MIPS_DELTA_INSTANCE_NO:
8611 case DT_MIPS_DELTA_RELOC_NO:
8612 case DT_MIPS_DELTA_SYM_NO:
8613 case DT_MIPS_DELTA_CLASSSYM_NO:
8614 case DT_MIPS_COMPACT_SIZE:
4b68bca3 8615 print_vma (entry->d_un.d_ptr, DEC);
252b5132 8616 break;
103f02d3
UD		 8617
8618 default:
4b68bca3 8619 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 8620 }
4b68bca3 8621 putchar ('\n');
103f02d3
UD		 8622}
8623
103f02d3 8624static void
2cf0635d 8625dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 8626{
8627 switch (entry->d_tag)
8628 {
8629 case DT_HP_DLD_FLAGS:
8630 {
8631 static struct
8632 {
8633 long int bit;
2cf0635d 8634 const char * str;
5e220199
NC		 8635 }
8636 flags[] =
8637 {
8638 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8639 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8640 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8641 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8642 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8643 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8644 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8645 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8646 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8647 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 8648 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8649 { DT_HP_GST, "HP_GST" },
8650 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8651 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8652 { DT_HP_NODELETE, "HP_NODELETE" },
8653 { DT_HP_GROUP, "HP_GROUP" },
8654 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 8655 };
103f02d3 8656 int first = 1;
5e220199 8657 size_t cnt;
f7a99963 8658 bfd_vma val = entry->d_un.d_val;
103f02d3 8659
60bca95a 8660 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 8661 if (val & flags[cnt].bit)
30800947
NC		 8662 {
8663 if (! first)
8664 putchar (' ');
8665 fputs (flags[cnt].str, stdout);
8666 first = 0;
8667 val ^= flags[cnt].bit;
8668 }
76da6bbe 8669
103f02d3 8670 if (val != 0 || first)
f7a99963
NC		 8671 {
8672 if (! first)
8673 putchar (' ');
8674 print_vma (val, HEX);
8675 }
103f02d3
UD		 8676 }
8677 break;
76da6bbe 8678
252b5132 8679 default:
f7a99963
NC		 8680 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8681 break;
252b5132 8682 }
35b1837e 8683 putchar ('\n');
252b5132
RH		 8684}
8685
28f997cf
TG		 8686#ifdef BFD64
8687
8688/* VMS vs Unix time offset and factor. */
8689
8690#define VMS_EPOCH_OFFSET 35067168000000000LL
8691#define VMS_GRANULARITY_FACTOR 10000000
8692
8693/* Display a VMS time in a human readable format. */
8694
8695static void
8696print_vms_time (bfd_int64_t vmstime)
8697{
8698 struct tm *tm;
8699 time_t unxtime;
8700
8701 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8702 tm = gmtime (&unxtime);
8703 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8704 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8705 tm->tm_hour, tm->tm_min, tm->tm_sec);
8706}
8707#endif /* BFD64 */
8708
ecc51f48 8709static void
2cf0635d 8710dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 8711{
8712 switch (entry->d_tag)
8713 {
0de14b54 8714 case DT_IA_64_PLT_RESERVE:
bdf4d63a 8715 /* First 3 slots reserved. */
ecc51f48
NC		 8716 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8717 printf (" -- ");
8718 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 8719 break;
8720
28f997cf
TG		 8721 case DT_IA_64_VMS_LINKTIME:
8722#ifdef BFD64
8723 print_vms_time (entry->d_un.d_val);
8724#endif
8725 break;
8726
8727 case DT_IA_64_VMS_LNKFLAGS:
8728 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8729 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8730 printf (" CALL_DEBUG");
8731 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8732 printf (" NOP0BUFS");
8733 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8734 printf (" P0IMAGE");
8735 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8736 printf (" MKTHREADS");
8737 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8738 printf (" UPCALLS");
8739 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8740 printf (" IMGSTA");
8741 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8742 printf (" INITIALIZE");
8743 if (entry->d_un.d_val & VMS_LF_MAIN)
8744 printf (" MAIN");
8745 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8746 printf (" EXE_INIT");
8747 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8748 printf (" TBK_IN_IMG");
8749 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8750 printf (" DBG_IN_IMG");
8751 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8752 printf (" TBK_IN_DSF");
8753 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8754 printf (" DBG_IN_DSF");
8755 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8756 printf (" SIGNATURES");
8757 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8758 printf (" REL_SEG_OFF");
8759 break;
8760
bdf4d63a
JJ		 8761 default:
8762 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8763 break;
ecc51f48 8764 }
bdf4d63a 8765 putchar ('\n');
ecc51f48
NC		 8766}
8767
252b5132 8768static int
2cf0635d 8769get_32bit_dynamic_section (FILE * file)
252b5132 8770{
2cf0635d
NC		 8771 Elf32_External_Dyn * edyn;
8772 Elf32_External_Dyn * ext;
8773 Elf_Internal_Dyn * entry;
103f02d3 8774
3f5e193b
NC		 8775 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8776 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8777 if (!edyn)
8778 return 0;
103f02d3 8779
071436c6
NC		 8780 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8781 might not have the luxury of section headers. Look for the DT_NULL
8782 terminator to determine the number of entries. */
ba2685cc 8783 for (ext = edyn, dynamic_nent = 0;
53c3012c 8784 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 8785 ext++)
8786 {
8787 dynamic_nent++;
8788 if (BYTE_GET (ext->d_tag) == DT_NULL)
8789 break;
8790 }
252b5132 8791
3f5e193b
NC		 8792 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8793 sizeof (* entry));
b2d38a17 8794 if (dynamic_section == NULL)
252b5132 8795 {
8b73c356
NC		 8796 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8797 (unsigned long) dynamic_nent);
9ea033b2
NC		 8798 free (edyn);
8799 return 0;
8800 }
252b5132 8801
fb514b26 8802 for (ext = edyn, entry = dynamic_section;
ba2685cc 8803 entry < dynamic_section + dynamic_nent;
fb514b26 8804 ext++, entry++)
9ea033b2 8805 {
fb514b26
AM		 8806 entry->d_tag = BYTE_GET (ext->d_tag);
8807 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8808 }
8809
9ea033b2
NC		 8810 free (edyn);
8811
8812 return 1;
8813}
8814
8815static int
2cf0635d 8816get_64bit_dynamic_section (FILE * file)
9ea033b2 8817{
2cf0635d
NC		 8818 Elf64_External_Dyn * edyn;
8819 Elf64_External_Dyn * ext;
8820 Elf_Internal_Dyn * entry;
103f02d3 8821
071436c6 8822 /* Read in the data. */
3f5e193b
NC		 8823 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8824 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8825 if (!edyn)
8826 return 0;
103f02d3 8827
071436c6
NC		 8828 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8829 might not have the luxury of section headers. Look for the DT_NULL
8830 terminator to determine the number of entries. */
ba2685cc 8831 for (ext = edyn, dynamic_nent = 0;
53c3012c
AM		 8832 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
8833 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 8834 ext++)
8835 {
8836 dynamic_nent++;
66543521 8837 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 8838 break;
8839 }
252b5132 8840
3f5e193b
NC		 8841 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8842 sizeof (* entry));
b2d38a17 8843 if (dynamic_section == NULL)
252b5132 8844 {
8b73c356
NC		 8845 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8846 (unsigned long) dynamic_nent);
252b5132
RH		 8847 free (edyn);
8848 return 0;
8849 }
8850
071436c6 8851 /* Convert from external to internal formats. */
fb514b26 8852 for (ext = edyn, entry = dynamic_section;
ba2685cc 8853 entry < dynamic_section + dynamic_nent;
fb514b26 8854 ext++, entry++)
252b5132 8855 {
66543521
AM		 8856 entry->d_tag = BYTE_GET (ext->d_tag);
8857 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8858 }
8859
8860 free (edyn);
8861
9ea033b2
NC		 8862 return 1;
8863}
8864
e9e44622
JJ		 8865static void
8866print_dynamic_flags (bfd_vma flags)
d1133906 8867{
e9e44622 8868 int first = 1;
13ae64f3 8869
d1133906
NC		 8870 while (flags)
8871 {
8872 bfd_vma flag;
8873
8874 flag = flags & - flags;
8875 flags &= ~ flag;
8876
e9e44622
JJ		 8877 if (first)
8878 first = 0;
8879 else
8880 putc (' ', stdout);
13ae64f3 8881
d1133906
NC		 8882 switch (flag)
8883 {
e9e44622
JJ		 8884 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
8885 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
8886 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
8887 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
8888 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 8889 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 8890 }
8891 }
e9e44622 8892 puts ("");
d1133906
NC		 8893}
8894
b2d38a17
NC		 8895/* Parse and display the contents of the dynamic section. */
8896
9ea033b2 8897static int
2cf0635d 8898process_dynamic_section (FILE * file)
9ea033b2 8899{
2cf0635d 8900 Elf_Internal_Dyn * entry;
9ea033b2
NC		 8901
8902 if (dynamic_size == 0)
8903 {
8904 if (do_dynamic)
b2d38a17 8905 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 8906
8907 return 1;
8908 }
8909
8910 if (is_32bit_elf)
8911 {
b2d38a17 8912 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 8913 return 0;
8914 }
b2d38a17 8915 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 8916 return 0;
8917
252b5132
RH		 8918 /* Find the appropriate symbol table. */
8919 if (dynamic_symbols == NULL)
8920 {
86dba8ee
AM		 8921 for (entry = dynamic_section;
8922 entry < dynamic_section + dynamic_nent;
8923 ++entry)
252b5132 8924 {
c8286bd1 8925 Elf_Internal_Shdr section;
252b5132
RH		 8926
8927 if (entry->d_tag != DT_SYMTAB)
8928 continue;
8929
8930 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8931
8932 /* Since we do not know how big the symbol table is,
8933 we default to reading in the entire file (!) and
8934 processing that. This is overkill, I know, but it
e3c8793a 8935 should work. */
d93f0186 8936 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 8937
fb52b2f4
NC		 8938 if (archive_file_offset != 0)
8939 section.sh_size = archive_file_size - section.sh_offset;
8940 else
8941 {
8942 if (fseek (file, 0, SEEK_END))
591a748a 8943 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 8944
8945 section.sh_size = ftell (file) - section.sh_offset;
8946 }
252b5132 8947
9ea033b2 8948 if (is_32bit_elf)
9ad5cbcf 8949 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 8950 else
9ad5cbcf 8951 section.sh_entsize = sizeof (Elf64_External_Sym);
071436c6 8952 section.sh_name = string_table_length;
252b5132 8953
ba5cdace 8954 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 8955 if (num_dynamic_syms < 1)
252b5132
RH		 8956 {
8957 error (_("Unable to determine the number of symbols to load\n"));
8958 continue;
8959 }
252b5132
RH		 8960 }
8961 }
8962
8963 /* Similarly find a string table. */
8964 if (dynamic_strings == NULL)
8965 {
86dba8ee
AM		 8966 for (entry = dynamic_section;
8967 entry < dynamic_section + dynamic_nent;
8968 ++entry)
252b5132
RH		 8969 {
8970 unsigned long offset;
b34976b6 8971 long str_tab_len;
252b5132
RH		 8972
8973 if (entry->d_tag != DT_STRTAB)
8974 continue;
8975
8976 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8977
8978 /* Since we do not know how big the string table is,
8979 we default to reading in the entire file (!) and
8980 processing that. This is overkill, I know, but it
e3c8793a 8981 should work. */
252b5132 8982
d93f0186 8983 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 8984
8985 if (archive_file_offset != 0)
8986 str_tab_len = archive_file_size - offset;
8987 else
8988 {
8989 if (fseek (file, 0, SEEK_END))
8990 error (_("Unable to seek to end of file\n"));
8991 str_tab_len = ftell (file) - offset;
8992 }
252b5132
RH		 8993
8994 if (str_tab_len < 1)
8995 {
8996 error
8997 (_("Unable to determine the length of the dynamic string table\n"));
8998 continue;
8999 }
9000
3f5e193b
NC		 9001 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
9002 str_tab_len,
9003 _("dynamic string table"));
59245841 9004 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 9005 break;
9006 }
9007 }
9008
9009 /* And find the syminfo section if available. */
9010 if (dynamic_syminfo == NULL)
9011 {
3e8bba36 9012 unsigned long syminsz = 0;
252b5132 9013
86dba8ee
AM		 9014 for (entry = dynamic_section;
9015 entry < dynamic_section + dynamic_nent;
9016 ++entry)
252b5132
RH		 9017 {
9018 if (entry->d_tag == DT_SYMINENT)
9019 {
9020 /* Note: these braces are necessary to avoid a syntax
9021 error from the SunOS4 C compiler. */
049b0c3a
NC		 9022 /* PR binutils/17531: A corrupt file can trigger this test.
9023 So do not use an assert, instead generate an error message. */
9024 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
071436c6 9025 error (_("Bad value (%d) for SYMINENT entry\n"),
049b0c3a 9026 (int) entry->d_un.d_val);
252b5132
RH		 9027 }
9028 else if (entry->d_tag == DT_SYMINSZ)
9029 syminsz = entry->d_un.d_val;
9030 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 9031 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
9032 syminsz);
252b5132
RH		 9033 }
9034
9035 if (dynamic_syminfo_offset != 0 && syminsz != 0)
9036 {
2cf0635d
NC		 9037 Elf_External_Syminfo * extsyminfo;
9038 Elf_External_Syminfo * extsym;
9039 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 9040
9041 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 9042 extsyminfo = (Elf_External_Syminfo *)
9043 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
9044 _("symbol information"));
a6e9f9df
AM		 9045 if (!extsyminfo)
9046 return 0;
252b5132 9047
3f5e193b 9048 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 9049 if (dynamic_syminfo == NULL)
9050 {
8b73c356
NC		 9051 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9052 (unsigned long) syminsz);
252b5132
RH		 9053 return 0;
9054 }
9055
9056 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 9057 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9058 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9059 ++syminfo, ++extsym)
252b5132 9060 {
86dba8ee
AM		 9061 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9062 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 9063 }
9064
9065 free (extsyminfo);
9066 }
9067 }
9068
9069 if (do_dynamic && dynamic_addr)
8b73c356
NC		 9070 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9071 dynamic_addr, (unsigned long) dynamic_nent);
252b5132
RH		 9072 if (do_dynamic)
9073 printf (_(" Tag Type Name/Value\n"));
9074
86dba8ee
AM		 9075 for (entry = dynamic_section;
9076 entry < dynamic_section + dynamic_nent;
9077 entry++)
252b5132
RH		 9078 {
9079 if (do_dynamic)
f7a99963 9080 {
2cf0635d 9081 const char * dtype;
e699b9ff 9082
f7a99963
NC		 9083 putchar (' ');
9084 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 9085 dtype = get_dynamic_type (entry->d_tag);
9086 printf (" (%s)%*s", dtype,
9087 ((is_32bit_elf ? 27 : 19)
9088 - (int) strlen (dtype)),
f7a99963
NC		 9089 " ");
9090 }
252b5132
RH		 9091
9092 switch (entry->d_tag)
9093 {
d1133906
NC		 9094 case DT_FLAGS:
9095 if (do_dynamic)
e9e44622 9096 print_dynamic_flags (entry->d_un.d_val);
d1133906 9097 break;
76da6bbe 9098
252b5132
RH		 9099 case DT_AUXILIARY:
9100 case DT_FILTER:
019148e4
L		 9101 case DT_CONFIG:
9102 case DT_DEPAUDIT:
9103 case DT_AUDIT:
252b5132
RH		 9104 if (do_dynamic)
9105 {
019148e4 9106 switch (entry->d_tag)
b34976b6 9107 {
019148e4
L		 9108 case DT_AUXILIARY:
9109 printf (_("Auxiliary library"));
9110 break;
9111
9112 case DT_FILTER:
9113 printf (_("Filter library"));
9114 break;
9115
b34976b6 9116 case DT_CONFIG:
019148e4
L		 9117 printf (_("Configuration file"));
9118 break;
9119
9120 case DT_DEPAUDIT:
9121 printf (_("Dependency audit library"));
9122 break;
9123
9124 case DT_AUDIT:
9125 printf (_("Audit library"));
9126 break;
9127 }
252b5132 9128
d79b3d50
NC		 9129 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9130 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 9131 else
f7a99963
NC		 9132 {
9133 printf (": ");
9134 print_vma (entry->d_un.d_val, PREFIX_HEX);
9135 putchar ('\n');
9136 }
252b5132
RH		 9137 }
9138 break;
9139
dcefbbbd 9140 case DT_FEATURE:
252b5132
RH		 9141 if (do_dynamic)
9142 {
9143 printf (_("Flags:"));
86f55779 9144
252b5132
RH		 9145 if (entry->d_un.d_val == 0)
9146 printf (_(" None\n"));
9147 else
9148 {
9149 unsigned long int val = entry->d_un.d_val;
86f55779 9150
252b5132
RH		 9151 if (val & DTF_1_PARINIT)
9152 {
9153 printf (" PARINIT");
9154 val ^= DTF_1_PARINIT;
9155 }
dcefbbbd
L		 9156 if (val & DTF_1_CONFEXP)
9157 {
9158 printf (" CONFEXP");
9159 val ^= DTF_1_CONFEXP;
9160 }
252b5132
RH		 9161 if (val != 0)
9162 printf (" %lx", val);
9163 puts ("");
9164 }
9165 }
9166 break;
9167
9168 case DT_POSFLAG_1:
9169 if (do_dynamic)
9170 {
9171 printf (_("Flags:"));
86f55779 9172
252b5132
RH		 9173 if (entry->d_un.d_val == 0)
9174 printf (_(" None\n"));
9175 else
9176 {
9177 unsigned long int val = entry->d_un.d_val;
86f55779 9178
252b5132
RH		 9179 if (val & DF_P1_LAZYLOAD)
9180 {
9181 printf (" LAZYLOAD");
9182 val ^= DF_P1_LAZYLOAD;
9183 }
9184 if (val & DF_P1_GROUPPERM)
9185 {
9186 printf (" GROUPPERM");
9187 val ^= DF_P1_GROUPPERM;
9188 }
9189 if (val != 0)
9190 printf (" %lx", val);
9191 puts ("");
9192 }
9193 }
9194 break;
9195
9196 case DT_FLAGS_1:
9197 if (do_dynamic)
9198 {
9199 printf (_("Flags:"));
9200 if (entry->d_un.d_val == 0)
9201 printf (_(" None\n"));
9202 else
9203 {
9204 unsigned long int val = entry->d_un.d_val;
86f55779 9205
252b5132
RH		 9206 if (val & DF_1_NOW)
9207 {
9208 printf (" NOW");
9209 val ^= DF_1_NOW;
9210 }
9211 if (val & DF_1_GLOBAL)
9212 {
9213 printf (" GLOBAL");
9214 val ^= DF_1_GLOBAL;
9215 }
9216 if (val & DF_1_GROUP)
9217 {
9218 printf (" GROUP");
9219 val ^= DF_1_GROUP;
9220 }
9221 if (val & DF_1_NODELETE)
9222 {
9223 printf (" NODELETE");
9224 val ^= DF_1_NODELETE;
9225 }
9226 if (val & DF_1_LOADFLTR)
9227 {
9228 printf (" LOADFLTR");
9229 val ^= DF_1_LOADFLTR;
9230 }
9231 if (val & DF_1_INITFIRST)
9232 {
9233 printf (" INITFIRST");
9234 val ^= DF_1_INITFIRST;
9235 }
9236 if (val & DF_1_NOOPEN)
9237 {
9238 printf (" NOOPEN");
9239 val ^= DF_1_NOOPEN;
9240 }
9241 if (val & DF_1_ORIGIN)
9242 {
9243 printf (" ORIGIN");
9244 val ^= DF_1_ORIGIN;
9245 }
9246 if (val & DF_1_DIRECT)
9247 {
9248 printf (" DIRECT");
9249 val ^= DF_1_DIRECT;
9250 }
9251 if (val & DF_1_TRANS)
9252 {
9253 printf (" TRANS");
9254 val ^= DF_1_TRANS;
9255 }
9256 if (val & DF_1_INTERPOSE)
9257 {
9258 printf (" INTERPOSE");
9259 val ^= DF_1_INTERPOSE;
9260 }
f7db6139 9261 if (val & DF_1_NODEFLIB)
dcefbbbd 9262 {
f7db6139
L		 9263 printf (" NODEFLIB");
9264 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 9265 }
9266 if (val & DF_1_NODUMP)
9267 {
9268 printf (" NODUMP");
9269 val ^= DF_1_NODUMP;
9270 }
34b60028 9271 if (val & DF_1_CONFALT)
dcefbbbd 9272 {
34b60028
L		 9273 printf (" CONFALT");
9274 val ^= DF_1_CONFALT;
9275 }
9276 if (val & DF_1_ENDFILTEE)
9277 {
9278 printf (" ENDFILTEE");
9279 val ^= DF_1_ENDFILTEE;
9280 }
9281 if (val & DF_1_DISPRELDNE)
9282 {
9283 printf (" DISPRELDNE");
9284 val ^= DF_1_DISPRELDNE;
9285 }
9286 if (val & DF_1_DISPRELPND)
9287 {
9288 printf (" DISPRELPND");
9289 val ^= DF_1_DISPRELPND;
9290 }
9291 if (val & DF_1_NODIRECT)
9292 {
9293 printf (" NODIRECT");
9294 val ^= DF_1_NODIRECT;
9295 }
9296 if (val & DF_1_IGNMULDEF)
9297 {
9298 printf (" IGNMULDEF");
9299 val ^= DF_1_IGNMULDEF;
9300 }
9301 if (val & DF_1_NOKSYMS)
9302 {
9303 printf (" NOKSYMS");
9304 val ^= DF_1_NOKSYMS;
9305 }
9306 if (val & DF_1_NOHDR)
9307 {
9308 printf (" NOHDR");
9309 val ^= DF_1_NOHDR;
9310 }
9311 if (val & DF_1_EDITED)
9312 {
9313 printf (" EDITED");
9314 val ^= DF_1_EDITED;
9315 }
9316 if (val & DF_1_NORELOC)
9317 {
9318 printf (" NORELOC");
9319 val ^= DF_1_NORELOC;
9320 }
9321 if (val & DF_1_SYMINTPOSE)
9322 {
9323 printf (" SYMINTPOSE");
9324 val ^= DF_1_SYMINTPOSE;
9325 }
9326 if (val & DF_1_GLOBAUDIT)
9327 {
9328 printf (" GLOBAUDIT");
9329 val ^= DF_1_GLOBAUDIT;
9330 }
9331 if (val & DF_1_SINGLETON)
9332 {
9333 printf (" SINGLETON");
9334 val ^= DF_1_SINGLETON;
dcefbbbd 9335 }
5c383f02
RO		 9336 if (val & DF_1_STUB)
9337 {
9338 printf (" STUB");
9339 val ^= DF_1_STUB;
9340 }
9341 if (val & DF_1_PIE)
9342 {
9343 printf (" PIE");
9344 val ^= DF_1_PIE;
9345 }
252b5132
RH		 9346 if (val != 0)
9347 printf (" %lx", val);
9348 puts ("");
9349 }
9350 }
9351 break;
9352
9353 case DT_PLTREL:
566b0d53 9354 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9355 if (do_dynamic)
9356 puts (get_dynamic_type (entry->d_un.d_val));
9357 break;
9358
9359 case DT_NULL :
9360 case DT_NEEDED :
9361 case DT_PLTGOT :
9362 case DT_HASH :
9363 case DT_STRTAB :
9364 case DT_SYMTAB :
9365 case DT_RELA :
9366 case DT_INIT :
9367 case DT_FINI :
9368 case DT_SONAME :
9369 case DT_RPATH :
9370 case DT_SYMBOLIC:
9371 case DT_REL :
9372 case DT_DEBUG :
9373 case DT_TEXTREL :
9374 case DT_JMPREL :
019148e4 9375 case DT_RUNPATH :
252b5132
RH		 9376 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9377
9378 if (do_dynamic)
9379 {
2cf0635d 9380 char * name;
252b5132 9381
d79b3d50
NC		 9382 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9383 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9384 else
d79b3d50 9385 name = NULL;
252b5132
RH		 9386
9387 if (name)
9388 {
9389 switch (entry->d_tag)
9390 {
9391 case DT_NEEDED:
9392 printf (_("Shared library: [%s]"), name);
9393
18bd398b 9394 if (streq (name, program_interpreter))
f7a99963 9395 printf (_(" program interpreter"));
252b5132
RH		 9396 break;
9397
9398 case DT_SONAME:
f7a99963 9399 printf (_("Library soname: [%s]"), name);
252b5132
RH		 9400 break;
9401
9402 case DT_RPATH:
f7a99963 9403 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 9404 break;
9405
019148e4
L		 9406 case DT_RUNPATH:
9407 printf (_("Library runpath: [%s]"), name);
9408 break;
9409
252b5132 9410 default:
f7a99963
NC		 9411 print_vma (entry->d_un.d_val, PREFIX_HEX);
9412 break;
252b5132
RH		 9413 }
9414 }
9415 else
f7a99963
NC		 9416 print_vma (entry->d_un.d_val, PREFIX_HEX);
9417
9418 putchar ('\n');
252b5132
RH		 9419 }
9420 break;
9421
9422 case DT_PLTRELSZ:
9423 case DT_RELASZ :
9424 case DT_STRSZ :
9425 case DT_RELSZ :
9426 case DT_RELAENT :
9427 case DT_SYMENT :
9428 case DT_RELENT :
566b0d53 9429 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9430 case DT_PLTPADSZ:
9431 case DT_MOVEENT :
9432 case DT_MOVESZ :
9433 case DT_INIT_ARRAYSZ:
9434 case DT_FINI_ARRAYSZ:
047b2264
JJ		 9435 case DT_GNU_CONFLICTSZ:
9436 case DT_GNU_LIBLISTSZ:
252b5132 9437 if (do_dynamic)
f7a99963
NC		 9438 {
9439 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 9440 printf (_(" (bytes)\n"));
f7a99963 9441 }
252b5132
RH		 9442 break;
9443
9444 case DT_VERDEFNUM:
9445 case DT_VERNEEDNUM:
9446 case DT_RELACOUNT:
9447 case DT_RELCOUNT:
9448 if (do_dynamic)
f7a99963
NC		 9449 {
9450 print_vma (entry->d_un.d_val, UNSIGNED);
9451 putchar ('\n');
9452 }
252b5132
RH		 9453 break;
9454
9455 case DT_SYMINSZ:
9456 case DT_SYMINENT:
9457 case DT_SYMINFO:
9458 case DT_USED:
9459 case DT_INIT_ARRAY:
9460 case DT_FINI_ARRAY:
9461 if (do_dynamic)
9462 {
d79b3d50
NC		 9463 if (entry->d_tag == DT_USED
9464 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 9465 {
2cf0635d 9466 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9467
b34976b6 9468 if (*name)
252b5132
RH		 9469 {
9470 printf (_("Not needed object: [%s]\n"), name);
9471 break;
9472 }
9473 }
103f02d3 9474
f7a99963
NC		 9475 print_vma (entry->d_un.d_val, PREFIX_HEX);
9476 putchar ('\n');
252b5132
RH		 9477 }
9478 break;
9479
9480 case DT_BIND_NOW:
9481 /* The value of this entry is ignored. */
35b1837e
AM		 9482 if (do_dynamic)
9483 putchar ('\n');
252b5132 9484 break;
103f02d3 9485
047b2264
JJ		 9486 case DT_GNU_PRELINKED:
9487 if (do_dynamic)
9488 {
2cf0635d 9489 struct tm * tmp;
91d6fa6a 9490 time_t atime = entry->d_un.d_val;
047b2264 9491
91d6fa6a 9492 tmp = gmtime (&atime);
071436c6
NC		 9493 /* PR 17533 file: 041-1244816-0.004. */
9494 if (tmp == NULL)
5a2cbcf4
L		 9495 printf (_("<corrupt time val: %lx"),
9496 (unsigned long) atime);
071436c6
NC		 9497 else
9498 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9499 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9500 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 9501
9502 }
9503 break;
9504
fdc90cb4
JJ		 9505 case DT_GNU_HASH:
9506 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9507 if (do_dynamic)
9508 {
9509 print_vma (entry->d_un.d_val, PREFIX_HEX);
9510 putchar ('\n');
9511 }
9512 break;
9513
252b5132
RH		 9514 default:
9515 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 9516 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 9517 entry->d_un.d_val;
9518
9519 if (do_dynamic)
9520 {
9521 switch (elf_header.e_machine)
9522 {
9523 case EM_MIPS:
4fe85591 9524 case EM_MIPS_RS3_LE:
b2d38a17 9525 dynamic_section_mips_val (entry);
252b5132 9526 break;
103f02d3 9527 case EM_PARISC:
b2d38a17 9528 dynamic_section_parisc_val (entry);
103f02d3 9529 break;
ecc51f48 9530 case EM_IA_64:
b2d38a17 9531 dynamic_section_ia64_val (entry);
ecc51f48 9532 break;
252b5132 9533 default:
f7a99963
NC		 9534 print_vma (entry->d_un.d_val, PREFIX_HEX);
9535 putchar ('\n');
252b5132
RH		 9536 }
9537 }
9538 break;
9539 }
9540 }
9541
9542 return 1;
9543}
9544
9545static char *
d3ba0551 9546get_ver_flags (unsigned int flags)
252b5132 9547{
b34976b6 9548 static char buff[32];
252b5132
RH		 9549
9550 buff[0] = 0;
9551
9552 if (flags == 0)
9553 return _("none");
9554
9555 if (flags & VER_FLG_BASE)
9556 strcat (buff, "BASE ");
9557
9558 if (flags & VER_FLG_WEAK)
9559 {
9560 if (flags & VER_FLG_BASE)
9561 strcat (buff, "| ");
9562
9563 strcat (buff, "WEAK ");
9564 }
9565
44ec90b9
RO		 9566 if (flags & VER_FLG_INFO)
9567 {
9568 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9569 strcat (buff, "| ");
9570
9571 strcat (buff, "INFO ");
9572 }
9573
9574 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 9575 strcat (buff, _("| <unknown>"));
252b5132
RH		 9576
9577 return buff;
9578}
9579
9580/* Display the contents of the version sections. */
98fb390a 9581
252b5132 9582static int
2cf0635d 9583process_version_sections (FILE * file)
252b5132 9584{
2cf0635d 9585 Elf_Internal_Shdr * section;
b34976b6
AM		 9586 unsigned i;
9587 int found = 0;
252b5132
RH		 9588
9589 if (! do_version)
9590 return 1;
9591
9592 for (i = 0, section = section_headers;
9593 i < elf_header.e_shnum;
b34976b6 9594 i++, section++)
252b5132
RH		 9595 {
9596 switch (section->sh_type)
9597 {
9598 case SHT_GNU_verdef:
9599 {
2cf0635d 9600 Elf_External_Verdef * edefs;
b34976b6
AM		 9601 unsigned int idx;
9602 unsigned int cnt;
2cf0635d 9603 char * endbuf;
252b5132
RH		 9604
9605 found = 1;
9606
74e1a04b
NC		 9607 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9608 printable_section_name (section),
9609 section->sh_info);
252b5132
RH		 9610
9611 printf (_(" Addr: 0x"));
9612 printf_vma (section->sh_addr);
74e1a04b 9613 printf (_(" Offset: %#08lx Link: %u (%s)"),
1b228002 9614 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9615 printable_section_name_from_index (section->sh_link));
252b5132 9616
3f5e193b
NC		 9617 edefs = (Elf_External_Verdef *)
9618 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9619 _("version definition section"));
a6e9f9df
AM		 9620 if (!edefs)
9621 break;
59245841 9622 endbuf = (char *) edefs + section->sh_size;
252b5132 9623
b34976b6 9624 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 9625 {
2cf0635d
NC		 9626 char * vstart;
9627 Elf_External_Verdef * edef;
b34976b6 9628 Elf_Internal_Verdef ent;
2cf0635d 9629 Elf_External_Verdaux * eaux;
b34976b6
AM		 9630 Elf_Internal_Verdaux aux;
9631 int j;
9632 int isum;
103f02d3 9633
7e26601c
NC		 9634 /* Check for very large indicies. */
9635 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 9636 break;
9637
252b5132 9638 vstart = ((char *) edefs) + idx;
54806181
AM		 9639 if (vstart + sizeof (*edef) > endbuf)
9640 break;
252b5132
RH		 9641
9642 edef = (Elf_External_Verdef *) vstart;
9643
9644 ent.vd_version = BYTE_GET (edef->vd_version);
9645 ent.vd_flags = BYTE_GET (edef->vd_flags);
9646 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9647 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9648 ent.vd_hash = BYTE_GET (edef->vd_hash);
9649 ent.vd_aux = BYTE_GET (edef->vd_aux);
9650 ent.vd_next = BYTE_GET (edef->vd_next);
9651
9652 printf (_(" %#06x: Rev: %d Flags: %s"),
9653 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9654
9655 printf (_(" Index: %d Cnt: %d "),
9656 ent.vd_ndx, ent.vd_cnt);
9657
dd24e3da 9658 /* Check for overflow. */
7e26601c 9659 if (ent.vd_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 9660 break;
9661
252b5132
RH		 9662 vstart += ent.vd_aux;
9663
9664 eaux = (Elf_External_Verdaux *) vstart;
9665
9666 aux.vda_name = BYTE_GET (eaux->vda_name);
9667 aux.vda_next = BYTE_GET (eaux->vda_next);
9668
d79b3d50
NC		 9669 if (VALID_DYNAMIC_NAME (aux.vda_name))
9670 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9671 else
9672 printf (_("Name index: %ld\n"), aux.vda_name);
9673
9674 isum = idx + ent.vd_aux;
9675
b34976b6 9676 for (j = 1; j < ent.vd_cnt; j++)
252b5132 9677 {
dd24e3da 9678 /* Check for overflow. */
7e26601c 9679 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 9680 break;
9681
252b5132
RH		 9682 isum += aux.vda_next;
9683 vstart += aux.vda_next;
9684
9685 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 9686 if (vstart + sizeof (*eaux) > endbuf)
9687 break;
252b5132
RH		 9688
9689 aux.vda_name = BYTE_GET (eaux->vda_name);
9690 aux.vda_next = BYTE_GET (eaux->vda_next);
9691
d79b3d50 9692 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 9693 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 9694 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9695 else
9696 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9697 isum, j, aux.vda_name);
9698 }
dd24e3da 9699
54806181
AM		 9700 if (j < ent.vd_cnt)
9701 printf (_(" Version def aux past end of section\n"));
252b5132 9702
5d921cbd
NC		 9703 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9704 if (idx + ent.vd_next <= idx)
9705 break;
9706
252b5132
RH		 9707 idx += ent.vd_next;
9708 }
dd24e3da 9709
54806181
AM		 9710 if (cnt < section->sh_info)
9711 printf (_(" Version definition past end of section\n"));
252b5132
RH		 9712
9713 free (edefs);
9714 }
9715 break;
103f02d3 9716
252b5132
RH		 9717 case SHT_GNU_verneed:
9718 {
2cf0635d 9719 Elf_External_Verneed * eneed;
b34976b6
AM		 9720 unsigned int idx;
9721 unsigned int cnt;
2cf0635d 9722 char * endbuf;
252b5132
RH		 9723
9724 found = 1;
9725
72de5009 9726 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
74e1a04b 9727 printable_section_name (section), section->sh_info);
252b5132
RH		 9728
9729 printf (_(" Addr: 0x"));
9730 printf_vma (section->sh_addr);
72de5009 9731 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9732 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9733 printable_section_name_from_index (section->sh_link));
252b5132 9734
3f5e193b
NC		 9735 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9736 section->sh_offset, 1,
9737 section->sh_size,
9cf03b7e 9738 _("Version Needs section"));
a6e9f9df
AM		 9739 if (!eneed)
9740 break;
59245841 9741 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 9742
9743 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9744 {
2cf0635d 9745 Elf_External_Verneed * entry;
b34976b6
AM		 9746 Elf_Internal_Verneed ent;
9747 int j;
9748 int isum;
2cf0635d 9749 char * vstart;
252b5132 9750
7e26601c 9751 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 9752 break;
9753
252b5132 9754 vstart = ((char *) eneed) + idx;
54806181
AM		 9755 if (vstart + sizeof (*entry) > endbuf)
9756 break;
252b5132
RH		 9757
9758 entry = (Elf_External_Verneed *) vstart;
9759
9760 ent.vn_version = BYTE_GET (entry->vn_version);
9761 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
9762 ent.vn_file = BYTE_GET (entry->vn_file);
9763 ent.vn_aux = BYTE_GET (entry->vn_aux);
9764 ent.vn_next = BYTE_GET (entry->vn_next);
9765
9766 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
9767
d79b3d50
NC		 9768 if (VALID_DYNAMIC_NAME (ent.vn_file))
9769 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 9770 else
9771 printf (_(" File: %lx"), ent.vn_file);
9772
9773 printf (_(" Cnt: %d\n"), ent.vn_cnt);
9774
dd24e3da 9775 /* Check for overflow. */
7e26601c 9776 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da 9777 break;
252b5132
RH		 9778 vstart += ent.vn_aux;
9779
9780 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9781 {
2cf0635d 9782 Elf_External_Vernaux * eaux;
b34976b6 9783 Elf_Internal_Vernaux aux;
252b5132 9784
54806181
AM		 9785 if (vstart + sizeof (*eaux) > endbuf)
9786 break;
252b5132
RH		 9787 eaux = (Elf_External_Vernaux *) vstart;
9788
9789 aux.vna_hash = BYTE_GET (eaux->vna_hash);
9790 aux.vna_flags = BYTE_GET (eaux->vna_flags);
9791 aux.vna_other = BYTE_GET (eaux->vna_other);
9792 aux.vna_name = BYTE_GET (eaux->vna_name);
9793 aux.vna_next = BYTE_GET (eaux->vna_next);
9794
d79b3d50 9795 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 9796 printf (_(" %#06x: Name: %s"),
d79b3d50 9797 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 9798 else
ecc2063b 9799 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 9800 isum, aux.vna_name);
9801
9802 printf (_(" Flags: %s Version: %d\n"),
9803 get_ver_flags (aux.vna_flags), aux.vna_other);
9804
dd24e3da 9805 /* Check for overflow. */
53774b7e
NC		 9806 if (aux.vna_next > (size_t) (endbuf - vstart)
9807 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9808 {
9809 warn (_("Invalid vna_next field of %lx\n"),
9810 aux.vna_next);
9811 j = ent.vn_cnt;
9812 break;
9813 }
252b5132
RH		 9814 isum += aux.vna_next;
9815 vstart += aux.vna_next;
9816 }
9cf03b7e 9817
54806181 9818 if (j < ent.vn_cnt)
9cf03b7e 9819 warn (_("Missing Version Needs auxillary information\n"));
252b5132 9820
bcf83b2a 9821 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
c24cf8b6
NC		 9822 {
9823 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9824 cnt = section->sh_info;
9825 break;
9826 }
252b5132
RH		 9827 idx += ent.vn_next;
9828 }
9cf03b7e 9829
54806181 9830 if (cnt < section->sh_info)
9cf03b7e 9831 warn (_("Missing Version Needs information\n"));
103f02d3 9832
252b5132
RH		 9833 free (eneed);
9834 }
9835 break;
9836
9837 case SHT_GNU_versym:
9838 {
2cf0635d 9839 Elf_Internal_Shdr * link_section;
8b73c356
NC		 9840 size_t total;
9841 unsigned int cnt;
2cf0635d
NC		 9842 unsigned char * edata;
9843 unsigned short * data;
9844 char * strtab;
9845 Elf_Internal_Sym * symbols;
9846 Elf_Internal_Shdr * string_sec;
ba5cdace 9847 unsigned long num_syms;
d3ba0551 9848 long off;
252b5132 9849
4fbb74a6 9850 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9851 break;
9852
4fbb74a6 9853 link_section = section_headers + section->sh_link;
08d8fa11 9854 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 9855
4fbb74a6 9856 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9857 break;
9858
252b5132
RH		 9859 found = 1;
9860
ba5cdace 9861 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 9862 if (symbols == NULL)
9863 break;
252b5132 9864
4fbb74a6 9865 string_sec = section_headers + link_section->sh_link;
252b5132 9866
3f5e193b
NC		 9867 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9868 string_sec->sh_size,
9869 _("version string table"));
a6e9f9df 9870 if (!strtab)
0429c154
MS		 9871 {
9872 free (symbols);
9873 break;
9874 }
252b5132 9875
8b73c356
NC		 9876 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9877 printable_section_name (section), (unsigned long) total);
252b5132
RH		 9878
9879 printf (_(" Addr: "));
9880 printf_vma (section->sh_addr);
72de5009 9881 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9882 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9883 printable_section_name (link_section));
252b5132 9884
d3ba0551
AM		 9885 off = offset_from_vma (file,
9886 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9887 total * sizeof (short));
3f5e193b
NC		 9888 edata = (unsigned char *) get_data (NULL, file, off, total,
9889 sizeof (short),
9890 _("version symbol data"));
a6e9f9df
AM		 9891 if (!edata)
9892 {
9893 free (strtab);
0429c154 9894 free (symbols);
a6e9f9df
AM		 9895 break;
9896 }
252b5132 9897
3f5e193b 9898 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 9899
9900 for (cnt = total; cnt --;)
b34976b6
AM		 9901 data[cnt] = byte_get (edata + cnt * sizeof (short),
9902 sizeof (short));
252b5132
RH		 9903
9904 free (edata);
9905
9906 for (cnt = 0; cnt < total; cnt += 4)
9907 {
9908 int j, nn;
ab273396
AM		 9909 char *name;
9910 char *invalid = _("*invalid*");
252b5132
RH		 9911
9912 printf (" %03x:", cnt);
9913
9914 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 9915 switch (data[cnt + j])
252b5132
RH		 9916 {
9917 case 0:
9918 fputs (_(" 0 (*local*) "), stdout);
9919 break;
9920
9921 case 1:
9922 fputs (_(" 1 (*global*) "), stdout);
9923 break;
9924
9925 default:
c244d050
NC		 9926 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9927 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 9928
dd24e3da 9929 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 9930 array, break to avoid an out-of-bounds read. */
9931 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 9932 {
9933 warn (_("invalid index into symbol array\n"));
9934 break;
9935 }
9936
ab273396
AM		 9937 name = NULL;
9938 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 9939 {
b34976b6
AM		 9940 Elf_Internal_Verneed ivn;
9941 unsigned long offset;
252b5132 9942
d93f0186
NC		 9943 offset = offset_from_vma
9944 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9945 sizeof (Elf_External_Verneed));
252b5132 9946
b34976b6 9947 do
252b5132 9948 {
b34976b6
AM		 9949 Elf_Internal_Vernaux ivna;
9950 Elf_External_Verneed evn;
9951 Elf_External_Vernaux evna;
9952 unsigned long a_off;
252b5132 9953
59245841
NC		 9954 if (get_data (&evn, file, offset, sizeof (evn), 1,
9955 _("version need")) == NULL)
9956 break;
0b4362b0 9957
252b5132
RH		 9958 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9959 ivn.vn_next = BYTE_GET (evn.vn_next);
9960
9961 a_off = offset + ivn.vn_aux;
9962
9963 do
9964 {
59245841
NC		 9965 if (get_data (&evna, file, a_off, sizeof (evna),
9966 1, _("version need aux (2)")) == NULL)
9967 {
9968 ivna.vna_next = 0;
9969 ivna.vna_other = 0;
9970 }
9971 else
9972 {
9973 ivna.vna_next = BYTE_GET (evna.vna_next);
9974 ivna.vna_other = BYTE_GET (evna.vna_other);
9975 }
252b5132
RH		 9976
9977 a_off += ivna.vna_next;
9978 }
b34976b6 9979 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 9980 && ivna.vna_next != 0);
9981
b34976b6 9982 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 9983 {
9984 ivna.vna_name = BYTE_GET (evna.vna_name);
9985
54806181 9986 if (ivna.vna_name >= string_sec->sh_size)
ab273396 9987 name = invalid;
54806181
AM		 9988 else
9989 name = strtab + ivna.vna_name;
252b5132
RH		 9990 break;
9991 }
9992
9993 offset += ivn.vn_next;
9994 }
9995 while (ivn.vn_next);
9996 }
00d93f34 9997
ab273396 9998 if (data[cnt + j] != 0x8001
b34976b6 9999 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 10000 {
b34976b6
AM		 10001 Elf_Internal_Verdef ivd;
10002 Elf_External_Verdef evd;
10003 unsigned long offset;
252b5132 10004
d93f0186
NC		 10005 offset = offset_from_vma
10006 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10007 sizeof evd);
252b5132
RH		 10008
10009 do
10010 {
59245841
NC		 10011 if (get_data (&evd, file, offset, sizeof (evd), 1,
10012 _("version def")) == NULL)
10013 {
10014 ivd.vd_next = 0;
948f632f 10015 /* PR 17531: file: 046-1082287-0.004. */
3102e897
NC		 10016 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
10017 break;
59245841
NC		 10018 }
10019 else
10020 {
10021 ivd.vd_next = BYTE_GET (evd.vd_next);
10022 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10023 }
252b5132
RH		 10024
10025 offset += ivd.vd_next;
10026 }
c244d050 10027 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 10028 && ivd.vd_next != 0);
10029
c244d050 10030 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 10031 {
b34976b6
AM		 10032 Elf_External_Verdaux evda;
10033 Elf_Internal_Verdaux ivda;
252b5132
RH		 10034
10035 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10036
59245841
NC		 10037 if (get_data (&evda, file,
10038 offset - ivd.vd_next + ivd.vd_aux,
10039 sizeof (evda), 1,
10040 _("version def aux")) == NULL)
10041 break;
252b5132
RH		 10042
10043 ivda.vda_name = BYTE_GET (evda.vda_name);
10044
54806181 10045 if (ivda.vda_name >= string_sec->sh_size)
ab273396
AM		 10046 name = invalid;
10047 else if (name != NULL && name != invalid)
10048 name = _("*both*");
54806181
AM		 10049 else
10050 name = strtab + ivda.vda_name;
252b5132
RH		 10051 }
10052 }
ab273396
AM		 10053 if (name != NULL)
10054 nn += printf ("(%s%-*s",
10055 name,
10056 12 - (int) strlen (name),
10057 ")");
252b5132
RH		 10058
10059 if (nn < 18)
10060 printf ("%*c", 18 - nn, ' ');
10061 }
10062
10063 putchar ('\n');
10064 }
10065
10066 free (data);
10067 free (strtab);
10068 free (symbols);
10069 }
10070 break;
103f02d3 10071
252b5132
RH		 10072 default:
10073 break;
10074 }
10075 }
10076
10077 if (! found)
10078 printf (_("\nNo version information found in this file.\n"));
10079
10080 return 1;
10081}
10082
d1133906 10083static const char *
d3ba0551 10084get_symbol_binding (unsigned int binding)
252b5132 10085{
b34976b6 10086 static char buff[32];
252b5132
RH		 10087
10088 switch (binding)
10089 {
b34976b6
AM		 10090 case STB_LOCAL: return "LOCAL";
10091 case STB_GLOBAL: return "GLOBAL";
10092 case STB_WEAK: return "WEAK";
252b5132
RH		 10093 default:
10094 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 10095 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10096 binding);
252b5132 10097 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 10098 {
10099 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 10100 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10101 /* GNU is still using the default value 0. */
3e7a7d11
NC		 10102 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10103 return "UNIQUE";
10104 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10105 }
252b5132 10106 else
e9e44622 10107 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 10108 return buff;
10109 }
10110}
10111
d1133906 10112static const char *
d3ba0551 10113get_symbol_type (unsigned int type)
252b5132 10114{
b34976b6 10115 static char buff[32];
252b5132
RH		 10116
10117 switch (type)
10118 {
b34976b6
AM		 10119 case STT_NOTYPE: return "NOTYPE";
10120 case STT_OBJECT: return "OBJECT";
10121 case STT_FUNC: return "FUNC";
10122 case STT_SECTION: return "SECTION";
10123 case STT_FILE: return "FILE";
10124 case STT_COMMON: return "COMMON";
10125 case STT_TLS: return "TLS";
15ab5209
DB		 10126 case STT_RELC: return "RELC";
10127 case STT_SRELC: return "SRELC";
252b5132
RH		 10128 default:
10129 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 10130 {
3510a7b8
NC		 10131 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10132 return "THUMB_FUNC";
103f02d3 10133
351b4b40 10134 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 10135 return "REGISTER";
10136
10137 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10138 return "PARISC_MILLI";
10139
e9e44622 10140 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 10141 }
252b5132 10142 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 10143 {
10144 if (elf_header.e_machine == EM_PARISC)
10145 {
10146 if (type == STT_HP_OPAQUE)
10147 return "HP_OPAQUE";
10148 if (type == STT_HP_STUB)
10149 return "HP_STUB";
10150 }
10151
d8045f23 10152 if (type == STT_GNU_IFUNC
9c55345c 10153 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 10154 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 10155 /* GNU is still using the default value 0. */
d8045f23
NC		 10156 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10157 return "IFUNC";
10158
e9e44622 10159 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 10160 }
252b5132 10161 else
e9e44622 10162 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 10163 return buff;
10164 }
10165}
10166
d1133906 10167static const char *
d3ba0551 10168get_symbol_visibility (unsigned int visibility)
d1133906
NC		 10169{
10170 switch (visibility)
10171 {
b34976b6
AM		 10172 case STV_DEFAULT: return "DEFAULT";
10173 case STV_INTERNAL: return "INTERNAL";
10174 case STV_HIDDEN: return "HIDDEN";
d1133906 10175 case STV_PROTECTED: return "PROTECTED";
bee0ee85
NC		 10176 default:
10177 error (_("Unrecognized visibility value: %u"), visibility);
10178 return _("<unknown>");
d1133906
NC		 10179 }
10180}
10181
5e2b0d47
NC		 10182static const char *
10183get_mips_symbol_other (unsigned int other)
10184{
10185 switch (other)
10186 {
df58fc94
RS		 10187 case STO_OPTIONAL:
10188 return "OPTIONAL";
10189 case STO_MIPS_PLT:
10190 return "MIPS PLT";
10191 case STO_MIPS_PIC:
10192 return "MIPS PIC";
10193 case STO_MICROMIPS:
10194 return "MICROMIPS";
10195 case STO_MICROMIPS | STO_MIPS_PIC:
10196 return "MICROMIPS, MIPS PIC";
10197 case STO_MIPS16:
10198 return "MIPS16";
10199 default:
10200 return NULL;
5e2b0d47
NC		 10201 }
10202}
10203
28f997cf
TG		 10204static const char *
10205get_ia64_symbol_other (unsigned int other)
10206{
10207 if (is_ia64_vms ())
10208 {
10209 static char res[32];
10210
10211 res[0] = 0;
10212
10213 /* Function types is for images and .STB files only. */
10214 switch (elf_header.e_type)
10215 {
10216 case ET_DYN:
10217 case ET_EXEC:
10218 switch (VMS_ST_FUNC_TYPE (other))
10219 {
10220 case VMS_SFT_CODE_ADDR:
10221 strcat (res, " CA");
10222 break;
10223 case VMS_SFT_SYMV_IDX:
10224 strcat (res, " VEC");
10225 break;
10226 case VMS_SFT_FD:
10227 strcat (res, " FD");
10228 break;
10229 case VMS_SFT_RESERVE:
10230 strcat (res, " RSV");
10231 break;
10232 default:
bee0ee85
NC		 10233 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10234 VMS_ST_FUNC_TYPE (other));
10235 strcat (res, " <unknown>");
10236 break;
28f997cf
TG		 10237 }
10238 break;
10239 default:
10240 break;
10241 }
10242 switch (VMS_ST_LINKAGE (other))
10243 {
10244 case VMS_STL_IGNORE:
10245 strcat (res, " IGN");
10246 break;
10247 case VMS_STL_RESERVE:
10248 strcat (res, " RSV");
10249 break;
10250 case VMS_STL_STD:
10251 strcat (res, " STD");
10252 break;
10253 case VMS_STL_LNK:
10254 strcat (res, " LNK");
10255 break;
10256 default:
bee0ee85
NC		 10257 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10258 VMS_ST_LINKAGE (other));
10259 strcat (res, " <unknown>");
10260 break;
28f997cf
TG		 10261 }
10262
10263 if (res[0] != 0)
10264 return res + 1;
10265 else
10266 return res;
10267 }
10268 return NULL;
10269}
10270
6911b7dc
AM		 10271static const char *
10272get_ppc64_symbol_other (unsigned int other)
10273{
10274 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10275 {
10276 static char buf[32];
10277 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10278 PPC64_LOCAL_ENTRY_OFFSET (other));
10279 return buf;
10280 }
10281 return NULL;
10282}
10283
5e2b0d47
NC		 10284static const char *
10285get_symbol_other (unsigned int other)
10286{
10287 const char * result = NULL;
10288 static char buff [32];
10289
10290 if (other == 0)
10291 return "";
10292
10293 switch (elf_header.e_machine)
10294 {
10295 case EM_MIPS:
10296 result = get_mips_symbol_other (other);
28f997cf
TG		 10297 break;
10298 case EM_IA_64:
10299 result = get_ia64_symbol_other (other);
10300 break;
6911b7dc
AM		 10301 case EM_PPC64:
10302 result = get_ppc64_symbol_other (other);
10303 break;
5e2b0d47
NC		 10304 default:
10305 break;
10306 }
10307
10308 if (result)
10309 return result;
10310
10311 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10312 return buff;
10313}
10314
d1133906 10315static const char *
d3ba0551 10316get_symbol_index_type (unsigned int type)
252b5132 10317{
b34976b6 10318 static char buff[32];
5cf1065c 10319
252b5132
RH		 10320 switch (type)
10321 {
b34976b6
AM		 10322 case SHN_UNDEF: return "UND";
10323 case SHN_ABS: return "ABS";
10324 case SHN_COMMON: return "COM";
252b5132 10325 default:
9ce701e2
L		 10326 if (type == SHN_IA_64_ANSI_COMMON
10327 && elf_header.e_machine == EM_IA_64
10328 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10329 return "ANSI_COM";
8a9036a4 10330 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 10331 || elf_header.e_machine == EM_L1OM
10332 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 10333 && type == SHN_X86_64_LCOMMON)
10334 return "LARGE_COM";
ac145307
BS		 10335 else if ((type == SHN_MIPS_SCOMMON
10336 && elf_header.e_machine == EM_MIPS)
10337 || (type == SHN_TIC6X_SCOMMON
10338 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 10339 return "SCOM";
10340 else if (type == SHN_MIPS_SUNDEFINED
10341 && elf_header.e_machine == EM_MIPS)
10342 return "SUND";
9ce701e2 10343 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 10344 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 10345 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 10346 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10347 else if (type >= SHN_LORESERVE)
10348 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4 10349 else if (type >= elf_header.e_shnum)
e0a31db1 10350 sprintf (buff, _("bad section index[%3d]"), type);
252b5132 10351 else
232e7cb8 10352 sprintf (buff, "%3d", type);
5cf1065c 10353 break;
252b5132 10354 }
5cf1065c
NC		 10355
10356 return buff;
252b5132
RH		 10357}
10358
66543521 10359static bfd_vma *
57028622 10360get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
252b5132 10361{
2cf0635d
NC		 10362 unsigned char * e_data;
10363 bfd_vma * i_data;
252b5132 10364
57028622
NC		 10365 /* If the size_t type is smaller than the bfd_size_type, eg because
10366 you are building a 32-bit tool on a 64-bit host, then make sure
10367 that when (number) is cast to (size_t) no information is lost. */
10368 if (sizeof (size_t) < sizeof (bfd_size_type)
10369 && (bfd_size_type) ((size_t) number) != number)
10370 {
10371 error (_("Size truncation prevents reading %llu elements of size %u\n"),
10372 (unsigned long long) number, ent_size);
10373 return NULL;
10374 }
948f632f 10375
3102e897
NC		 10376 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10377 attempting to allocate memory when the read is bound to fail. */
10378 if (ent_size * number > current_file_size)
10379 {
57028622
NC		 10380 error (_("Invalid number of dynamic entries: %llu\n"),
10381 (unsigned long long) number);
3102e897
NC		 10382 return NULL;
10383 }
10384
57028622 10385 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
252b5132
RH		 10386 if (e_data == NULL)
10387 {
57028622
NC		 10388 error (_("Out of memory reading %llu dynamic entries\n"),
10389 (unsigned long long) number);
252b5132
RH		 10390 return NULL;
10391 }
10392
57028622 10393 if (fread (e_data, ent_size, (size_t) number, file) != number)
252b5132 10394 {
57028622
NC		 10395 error (_("Unable to read in %llu bytes of dynamic data\n"),
10396 (unsigned long long) (number * ent_size));
3102e897 10397 free (e_data);
252b5132
RH		 10398 return NULL;
10399 }
10400
57028622 10401 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
252b5132
RH		 10402 if (i_data == NULL)
10403 {
57028622
NC		 10404 error (_("Out of memory allocating space for %llu dynamic entries\n"),
10405 (unsigned long long) number);
252b5132
RH		 10406 free (e_data);
10407 return NULL;
10408 }
10409
10410 while (number--)
66543521 10411 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 10412
10413 free (e_data);
10414
10415 return i_data;
10416}
10417
6bd1a22c
L		 10418static void
10419print_dynamic_symbol (bfd_vma si, unsigned long hn)
10420{
2cf0635d 10421 Elf_Internal_Sym * psym;
6bd1a22c
L		 10422 int n;
10423
6bd1a22c
L		 10424 n = print_vma (si, DEC_5);
10425 if (n < 5)
0b4362b0 10426 fputs (&" "[n], stdout);
6bd1a22c 10427 printf (" %3lu: ", hn);
e0a31db1
NC		 10428
10429 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10430 {
3102e897
NC		 10431 printf (_("<No info available for dynamic symbol number %lu>\n"),
10432 (unsigned long) si);
e0a31db1
NC		 10433 return;
10434 }
10435
10436 psym = dynamic_symbols + si;
6bd1a22c
L		 10437 print_vma (psym->st_value, LONG_HEX);
10438 putchar (' ');
10439 print_vma (psym->st_size, DEC_5);
10440
f4be36b3
AM		 10441 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10442 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10443 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 10444 /* Check to see if any other bits in the st_other field are set.
10445 Note - displaying this information disrupts the layout of the
10446 table being generated, but for the moment this case is very
10447 rare. */
10448 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10449 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10450 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10451 if (VALID_DYNAMIC_NAME (psym->st_name))
10452 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10453 else
2b692964 10454 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 10455 putchar ('\n');
10456}
10457
bb4d2ac2
L		 10458static const char *
10459get_symbol_version_string (FILE *file, int is_dynsym,
10460 const char *strtab,
10461 unsigned long int strtab_size,
10462 unsigned int si, Elf_Internal_Sym *psym,
10463 enum versioned_symbol_info *sym_info,
10464 unsigned short *vna_other)
10465{
ab273396
AM		 10466 unsigned char data[2];
10467 unsigned short vers_data;
10468 unsigned long offset;
bb4d2ac2 10469
ab273396
AM		 10470 if (!is_dynsym
10471 || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
10472 return NULL;
bb4d2ac2 10473
ab273396
AM		 10474 offset = offset_from_vma (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10475 sizeof data + si * sizeof (vers_data));
bb4d2ac2 10476
ab273396
AM		 10477 if (get_data (&data, file, offset + si * sizeof (vers_data),
10478 sizeof (data), 1, _("version data")) == NULL)
10479 return NULL;
10480
10481 vers_data = byte_get (data, 2);
bb4d2ac2 10482
ab273396
AM		 10483 if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
10484 return NULL;
bb4d2ac2 10485
ab273396
AM		 10486 /* Usually we'd only see verdef for defined symbols, and verneed for
10487 undefined symbols. However, symbols defined by the linker in
10488 .dynbss for variables copied from a shared library in order to
10489 avoid text relocations are defined yet have verneed. We could
10490 use a heuristic to detect the special case, for example, check
10491 for verneed first on symbols defined in SHT_NOBITS sections, but
10492 it is simpler and more reliable to just look for both verdef and
10493 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
bb4d2ac2 10494
ab273396
AM		 10495 if (psym->st_shndx != SHN_UNDEF
10496 && vers_data != 0x8001
10497 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10498 {
10499 Elf_Internal_Verdef ivd;
10500 Elf_Internal_Verdaux ivda;
10501 Elf_External_Verdaux evda;
10502 unsigned long off;
bb4d2ac2 10503
ab273396
AM		 10504 off = offset_from_vma (file,
10505 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10506 sizeof (Elf_External_Verdef));
10507
10508 do
bb4d2ac2 10509 {
ab273396
AM		 10510 Elf_External_Verdef evd;
10511
10512 if (get_data (&evd, file, off, sizeof (evd), 1,
10513 _("version def")) == NULL)
10514 {
10515 ivd.vd_ndx = 0;
10516 ivd.vd_aux = 0;
10517 ivd.vd_next = 0;
10518 }
10519 else
bb4d2ac2 10520 {
ab273396
AM		 10521 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10522 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10523 ivd.vd_next = BYTE_GET (evd.vd_next);
10524 }
bb4d2ac2 10525
ab273396
AM		 10526 off += ivd.vd_next;
10527 }
10528 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
bb4d2ac2 10529
ab273396
AM		 10530 if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
10531 {
10532 off -= ivd.vd_next;
10533 off += ivd.vd_aux;
bb4d2ac2 10534
ab273396
AM		 10535 if (get_data (&evda, file, off, sizeof (evda), 1,
10536 _("version def aux")) != NULL)
10537 {
10538 ivda.vda_name = BYTE_GET (evda.vda_name);
bb4d2ac2 10539
ab273396
AM		 10540 if (psym->st_name != ivda.vda_name)
10541 {
10542 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10543 ? symbol_hidden : symbol_public);
10544 return (ivda.vda_name < strtab_size
10545 ? strtab + ivda.vda_name : _("<corrupt>"));
10546 }
10547 }
10548 }
10549 }
bb4d2ac2 10550
ab273396
AM		 10551 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10552 {
10553 Elf_External_Verneed evn;
10554 Elf_Internal_Verneed ivn;
10555 Elf_Internal_Vernaux ivna;
bb4d2ac2 10556
ab273396
AM		 10557 offset = offset_from_vma (file,
10558 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10559 sizeof evn);
10560 do
10561 {
10562 unsigned long vna_off;
bb4d2ac2 10563
ab273396
AM		 10564 if (get_data (&evn, file, offset, sizeof (evn), 1,
10565 _("version need")) == NULL)
10566 {
10567 ivna.vna_next = 0;
10568 ivna.vna_other = 0;
10569 ivna.vna_name = 0;
10570 break;
10571 }
bb4d2ac2 10572
ab273396
AM		 10573 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10574 ivn.vn_next = BYTE_GET (evn.vn_next);
bb4d2ac2 10575
ab273396 10576 vna_off = offset + ivn.vn_aux;
bb4d2ac2 10577
ab273396
AM		 10578 do
10579 {
10580 Elf_External_Vernaux evna;
bb4d2ac2 10581
ab273396
AM		 10582 if (get_data (&evna, file, vna_off, sizeof (evna), 1,
10583 _("version need aux (3)")) == NULL)
bb4d2ac2 10584 {
ab273396
AM		 10585 ivna.vna_next = 0;
10586 ivna.vna_other = 0;
10587 ivna.vna_name = 0;
bb4d2ac2 10588 }
bb4d2ac2 10589 else
bb4d2ac2 10590 {
ab273396
AM		 10591 ivna.vna_other = BYTE_GET (evna.vna_other);
10592 ivna.vna_next = BYTE_GET (evna.vna_next);
10593 ivna.vna_name = BYTE_GET (evna.vna_name);
10594 }
bb4d2ac2 10595
ab273396
AM		 10596 vna_off += ivna.vna_next;
10597 }
10598 while (ivna.vna_other != vers_data && ivna.vna_next != 0);
bb4d2ac2 10599
ab273396
AM		 10600 if (ivna.vna_other == vers_data)
10601 break;
bb4d2ac2 10602
ab273396
AM		 10603 offset += ivn.vn_next;
10604 }
10605 while (ivn.vn_next != 0);
bb4d2ac2 10606
ab273396
AM		 10607 if (ivna.vna_other == vers_data)
10608 {
10609 *sym_info = symbol_undefined;
10610 *vna_other = ivna.vna_other;
10611 return (ivna.vna_name < strtab_size
10612 ? strtab + ivna.vna_name : _("<corrupt>"));
bb4d2ac2
L		 10613 }
10614 }
ab273396 10615 return NULL;
bb4d2ac2
L		 10616}
10617
e3c8793a 10618/* Dump the symbol table. */
252b5132 10619static int
2cf0635d 10620process_symbol_table (FILE * file)
252b5132 10621{
2cf0635d 10622 Elf_Internal_Shdr * section;
8b73c356
NC		 10623 bfd_size_type nbuckets = 0;
10624 bfd_size_type nchains = 0;
2cf0635d
NC		 10625 bfd_vma * buckets = NULL;
10626 bfd_vma * chains = NULL;
fdc90cb4 10627 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 10628 bfd_vma * gnubuckets = NULL;
10629 bfd_vma * gnuchains = NULL;
6bd1a22c 10630 bfd_vma gnusymidx = 0;
071436c6 10631 bfd_size_type ngnuchains = 0;
252b5132 10632
2c610e4b 10633 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 10634 return 1;
10635
6bd1a22c
L		 10636 if (dynamic_info[DT_HASH]
10637 && (do_histogram
2c610e4b
L		 10638 || (do_using_dynamic
10639 && !do_dyn_syms
10640 && dynamic_strings != NULL)))
252b5132 10641 {
66543521
AM		 10642 unsigned char nb[8];
10643 unsigned char nc[8];
8b73c356 10644 unsigned int hash_ent_size = 4;
66543521
AM		 10645
10646 if ((elf_header.e_machine == EM_ALPHA
10647 || elf_header.e_machine == EM_S390
10648 || elf_header.e_machine == EM_S390_OLD)
10649 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10650 hash_ent_size = 8;
10651
fb52b2f4
NC		 10652 if (fseek (file,
10653 (archive_file_offset
10654 + offset_from_vma (file, dynamic_info[DT_HASH],
10655 sizeof nb + sizeof nc)),
d93f0186 10656 SEEK_SET))
252b5132 10657 {
591a748a 10658 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10659 goto no_hash;
252b5132
RH		 10660 }
10661
66543521 10662 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 10663 {
10664 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10665 goto no_hash;
252b5132
RH		 10666 }
10667
66543521 10668 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 10669 {
10670 error (_("Failed to read in number of chains\n"));
d3a44ec6 10671 goto no_hash;
252b5132
RH		 10672 }
10673
66543521
AM		 10674 nbuckets = byte_get (nb, hash_ent_size);
10675 nchains = byte_get (nc, hash_ent_size);
252b5132 10676
66543521
AM		 10677 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10678 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 10679
d3a44ec6 10680 no_hash:
252b5132 10681 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 10682 {
10683 if (do_using_dynamic)
10684 return 0;
10685 free (buckets);
10686 free (chains);
10687 buckets = NULL;
10688 chains = NULL;
10689 nbuckets = 0;
10690 nchains = 0;
10691 }
252b5132
RH		 10692 }
10693
6bd1a22c
L		 10694 if (dynamic_info_DT_GNU_HASH
10695 && (do_histogram
2c610e4b
L		 10696 || (do_using_dynamic
10697 && !do_dyn_syms
10698 && dynamic_strings != NULL)))
252b5132 10699 {
6bd1a22c
L		 10700 unsigned char nb[16];
10701 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10702 bfd_vma buckets_vma;
10703
10704 if (fseek (file,
10705 (archive_file_offset
10706 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10707 sizeof nb)),
10708 SEEK_SET))
10709 {
10710 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10711 goto no_gnu_hash;
6bd1a22c 10712 }
252b5132 10713
6bd1a22c
L		 10714 if (fread (nb, 16, 1, file) != 1)
10715 {
10716 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10717 goto no_gnu_hash;
6bd1a22c
L		 10718 }
10719
10720 ngnubuckets = byte_get (nb, 4);
10721 gnusymidx = byte_get (nb + 4, 4);
10722 bitmaskwords = byte_get (nb + 8, 4);
10723 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 10724 if (is_32bit_elf)
6bd1a22c 10725 buckets_vma += bitmaskwords * 4;
f7a99963 10726 else
6bd1a22c 10727 buckets_vma += bitmaskwords * 8;
252b5132 10728
6bd1a22c
L		 10729 if (fseek (file,
10730 (archive_file_offset
10731 + offset_from_vma (file, buckets_vma, 4)),
10732 SEEK_SET))
252b5132 10733 {
6bd1a22c 10734 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10735 goto no_gnu_hash;
6bd1a22c
L		 10736 }
10737
10738 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 10739
6bd1a22c 10740 if (gnubuckets == NULL)
d3a44ec6 10741 goto no_gnu_hash;
6bd1a22c
L		 10742
10743 for (i = 0; i < ngnubuckets; i++)
10744 if (gnubuckets[i] != 0)
10745 {
10746 if (gnubuckets[i] < gnusymidx)
10747 return 0;
10748
10749 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10750 maxchain = gnubuckets[i];
10751 }
10752
10753 if (maxchain == 0xffffffff)
d3a44ec6 10754 goto no_gnu_hash;
6bd1a22c
L		 10755
10756 maxchain -= gnusymidx;
10757
10758 if (fseek (file,
10759 (archive_file_offset
10760 + offset_from_vma (file, buckets_vma
10761 + 4 * (ngnubuckets + maxchain), 4)),
10762 SEEK_SET))
10763 {
10764 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10765 goto no_gnu_hash;
6bd1a22c
L		 10766 }
10767
10768 do
10769 {
10770 if (fread (nb, 4, 1, file) != 1)
252b5132 10771 {
6bd1a22c 10772 error (_("Failed to determine last chain length\n"));
d3a44ec6 10773 goto no_gnu_hash;
6bd1a22c 10774 }
252b5132 10775
6bd1a22c 10776 if (maxchain + 1 == 0)
d3a44ec6 10777 goto no_gnu_hash;
252b5132 10778
6bd1a22c
L		 10779 ++maxchain;
10780 }
10781 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 10782
6bd1a22c
L		 10783 if (fseek (file,
10784 (archive_file_offset
10785 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10786 SEEK_SET))
10787 {
10788 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10789 goto no_gnu_hash;
6bd1a22c
L		 10790 }
10791
10792 gnuchains = get_dynamic_data (file, maxchain, 4);
071436c6 10793 ngnuchains = maxchain;
6bd1a22c 10794
d3a44ec6 10795 no_gnu_hash:
6bd1a22c 10796 if (gnuchains == NULL)
d3a44ec6
JJ		 10797 {
10798 free (gnubuckets);
d3a44ec6
JJ		 10799 gnubuckets = NULL;
10800 ngnubuckets = 0;
f64fddf1
NC		 10801 if (do_using_dynamic)
10802 return 0;
d3a44ec6 10803 }
6bd1a22c
L		 10804 }
10805
10806 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10807 && do_syms
10808 && do_using_dynamic
3102e897
NC		 10809 && dynamic_strings != NULL
10810 && dynamic_symbols != NULL)
6bd1a22c
L		 10811 {
10812 unsigned long hn;
10813
10814 if (dynamic_info[DT_HASH])
10815 {
10816 bfd_vma si;
10817
10818 printf (_("\nSymbol table for image:\n"));
10819 if (is_32bit_elf)
10820 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10821 else
10822 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10823
10824 for (hn = 0; hn < nbuckets; hn++)
10825 {
10826 if (! buckets[hn])
10827 continue;
10828
10829 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10830 print_dynamic_symbol (si, hn);
252b5132
RH		 10831 }
10832 }
6bd1a22c
L		 10833
10834 if (dynamic_info_DT_GNU_HASH)
10835 {
10836 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10837 if (is_32bit_elf)
10838 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10839 else
10840 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10841
10842 for (hn = 0; hn < ngnubuckets; ++hn)
10843 if (gnubuckets[hn] != 0)
10844 {
10845 bfd_vma si = gnubuckets[hn];
10846 bfd_vma off = si - gnusymidx;
10847
10848 do
10849 {
10850 print_dynamic_symbol (si, hn);
10851 si++;
10852 }
071436c6 10853 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
6bd1a22c
L		 10854 }
10855 }
252b5132 10856 }
8b73c356
NC		 10857 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10858 && section_headers != NULL)
252b5132 10859 {
b34976b6 10860 unsigned int i;
252b5132
RH		 10861
10862 for (i = 0, section = section_headers;
10863 i < elf_header.e_shnum;
10864 i++, section++)
10865 {
b34976b6 10866 unsigned int si;
2cf0635d 10867 char * strtab = NULL;
c256ffe7 10868 unsigned long int strtab_size = 0;
2cf0635d
NC		 10869 Elf_Internal_Sym * symtab;
10870 Elf_Internal_Sym * psym;
ba5cdace 10871 unsigned long num_syms;
252b5132 10872
2c610e4b
L		 10873 if ((section->sh_type != SHT_SYMTAB
10874 && section->sh_type != SHT_DYNSYM)
10875 || (!do_syms
10876 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 10877 continue;
10878
dd24e3da
NC		 10879 if (section->sh_entsize == 0)
10880 {
10881 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
74e1a04b 10882 printable_section_name (section));
dd24e3da
NC		 10883 continue;
10884 }
10885
252b5132 10886 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
74e1a04b 10887 printable_section_name (section),
252b5132 10888 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 10889
f7a99963 10890 if (is_32bit_elf)
ca47b30c 10891 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 10892 else
ca47b30c 10893 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 10894
ba5cdace 10895 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 10896 if (symtab == NULL)
10897 continue;
10898
10899 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 10900 {
10901 strtab = string_table;
10902 strtab_size = string_table_length;
10903 }
4fbb74a6 10904 else if (section->sh_link < elf_header.e_shnum)
252b5132 10905 {
2cf0635d 10906 Elf_Internal_Shdr * string_sec;
252b5132 10907
4fbb74a6 10908 string_sec = section_headers + section->sh_link;
252b5132 10909
3f5e193b
NC		 10910 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10911 1, string_sec->sh_size,
10912 _("string table"));
c256ffe7 10913 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 10914 }
10915
ba5cdace 10916 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 10917 {
bb4d2ac2
L		 10918 const char *version_string;
10919 enum versioned_symbol_info sym_info;
10920 unsigned short vna_other;
10921
5e220199 10922 printf ("%6d: ", si);
f7a99963
NC		 10923 print_vma (psym->st_value, LONG_HEX);
10924 putchar (' ');
10925 print_vma (psym->st_size, DEC_5);
d1133906
NC		 10926 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10927 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 10928 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 10929 /* Check to see if any other bits in the st_other field are set.
10930 Note - displaying this information disrupts the layout of the
10931 table being generated, but for the moment this case is very rare. */
10932 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10933 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 10934 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 10935 print_symbol (25, psym->st_name < strtab_size
2b692964 10936 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 10937
bb4d2ac2
L		 10938 version_string
10939 = get_symbol_version_string (file,
10940 section->sh_type == SHT_DYNSYM,
10941 strtab, strtab_size, si,
10942 psym, &sym_info, &vna_other);
10943 if (version_string)
252b5132 10944 {
bb4d2ac2
L		 10945 if (sym_info == symbol_undefined)
10946 printf ("@%s (%d)", version_string, vna_other);
10947 else
10948 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10949 version_string);
252b5132
RH		 10950 }
10951
10952 putchar ('\n');
10953 }
10954
10955 free (symtab);
10956 if (strtab != string_table)
10957 free (strtab);
10958 }
10959 }
10960 else if (do_syms)
10961 printf
10962 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10963
10964 if (do_histogram && buckets != NULL)
10965 {
2cf0635d
NC		 10966 unsigned long * lengths;
10967 unsigned long * counts;
66543521
AM		 10968 unsigned long hn;
10969 bfd_vma si;
10970 unsigned long maxlength = 0;
10971 unsigned long nzero_counts = 0;
10972 unsigned long nsyms = 0;
94d15024 10973 unsigned long chained;
252b5132 10974
66543521
AM		 10975 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10976 (unsigned long) nbuckets);
252b5132 10977
3f5e193b 10978 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 10979 if (lengths == NULL)
10980 {
8b73c356 10981 error (_("Out of memory allocating space for histogram buckets\n"));
252b5132
RH		 10982 return 0;
10983 }
8b73c356
NC		 10984
10985 printf (_(" Length Number %% of total Coverage\n"));
252b5132
RH		 10986 for (hn = 0; hn < nbuckets; ++hn)
10987 {
94d15024
MF		 10988 for (si = buckets[hn], chained = 0;
10989 si > 0 && si < nchains && si < nbuckets && chained <= nchains;
10990 si = chains[si], ++chained)
252b5132 10991 {
b34976b6 10992 ++nsyms;
252b5132 10993 if (maxlength < ++lengths[hn])
b34976b6 10994 ++maxlength;
252b5132 10995 }
94d15024
MF		 10996
10997 /* PR binutils/17531: A corrupt binary could contain broken
10998 histogram data. Do not go into an infinite loop trying
10999 to process it. */
11000 if (chained > nchains)
11001 {
11002 error (_("histogram chain is corrupt\n"));
11003 break;
11004 }
252b5132
RH		 11005 }
11006
3f5e193b 11007 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 11008 if (counts == NULL)
11009 {
b2e951ec 11010 free (lengths);
8b73c356 11011 error (_("Out of memory allocating space for histogram counts\n"));
252b5132
RH		 11012 return 0;
11013 }
11014
11015 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 11016 ++counts[lengths[hn]];
252b5132 11017
103f02d3 11018 if (nbuckets > 0)
252b5132 11019 {
66543521
AM		 11020 unsigned long i;
11021 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 11022 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 11023 for (i = 1; i <= maxlength; ++i)
103f02d3 11024 {
66543521
AM		 11025 nzero_counts += counts[i] * i;
11026 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11027 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 11028 (nzero_counts * 100.0) / nsyms);
11029 }
252b5132
RH		 11030 }
11031
11032 free (counts);
11033 free (lengths);
11034 }
11035
11036 if (buckets != NULL)
11037 {
11038 free (buckets);
11039 free (chains);
11040 }
11041
d3a44ec6 11042 if (do_histogram && gnubuckets != NULL)
fdc90cb4 11043 {
2cf0635d
NC		 11044 unsigned long * lengths;
11045 unsigned long * counts;
fdc90cb4
JJ		 11046 unsigned long hn;
11047 unsigned long maxlength = 0;
11048 unsigned long nzero_counts = 0;
11049 unsigned long nsyms = 0;
fdc90cb4 11050
8b73c356
NC		 11051 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11052 (unsigned long) ngnubuckets);
11053
3f5e193b 11054 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 11055 if (lengths == NULL)
11056 {
8b73c356 11057 error (_("Out of memory allocating space for gnu histogram buckets\n"));
fdc90cb4
JJ		 11058 return 0;
11059 }
11060
fdc90cb4
JJ		 11061 printf (_(" Length Number %% of total Coverage\n"));
11062
11063 for (hn = 0; hn < ngnubuckets; ++hn)
11064 if (gnubuckets[hn] != 0)
11065 {
11066 bfd_vma off, length = 1;
11067
6bd1a22c 11068 for (off = gnubuckets[hn] - gnusymidx;
071436c6
NC		 11069 /* PR 17531 file: 010-77222-0.004. */
11070 off < ngnuchains && (gnuchains[off] & 1) == 0;
11071 ++off)
fdc90cb4
JJ		 11072 ++length;
11073 lengths[hn] = length;
11074 if (length > maxlength)
11075 maxlength = length;
11076 nsyms += length;
11077 }
11078
3f5e193b 11079 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 11080 if (counts == NULL)
11081 {
b2e951ec 11082 free (lengths);
8b73c356 11083 error (_("Out of memory allocating space for gnu histogram counts\n"));
fdc90cb4
JJ		 11084 return 0;
11085 }
11086
11087 for (hn = 0; hn < ngnubuckets; ++hn)
11088 ++counts[lengths[hn]];
11089
11090 if (ngnubuckets > 0)
11091 {
11092 unsigned long j;
11093 printf (" 0 %-10lu (%5.1f%%)\n",
11094 counts[0], (counts[0] * 100.0) / ngnubuckets);
11095 for (j = 1; j <= maxlength; ++j)
11096 {
11097 nzero_counts += counts[j] * j;
11098 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11099 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11100 (nzero_counts * 100.0) / nsyms);
11101 }
11102 }
11103
11104 free (counts);
11105 free (lengths);
11106 free (gnubuckets);
11107 free (gnuchains);
11108 }
11109
252b5132
RH		 11110 return 1;
11111}
11112
11113static int
2cf0635d 11114process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 11115{
b4c96d0d 11116 unsigned int i;
252b5132
RH		 11117
11118 if (dynamic_syminfo == NULL
11119 || !do_dynamic)
11120 /* No syminfo, this is ok. */
11121 return 1;
11122
11123 /* There better should be a dynamic symbol section. */
11124 if (dynamic_symbols == NULL || dynamic_strings == NULL)
11125 return 0;
11126
11127 if (dynamic_addr)
11128 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11129 dynamic_syminfo_offset, dynamic_syminfo_nent);
11130
11131 printf (_(" Num: Name BoundTo Flags\n"));
11132 for (i = 0; i < dynamic_syminfo_nent; ++i)
11133 {
11134 unsigned short int flags = dynamic_syminfo[i].si_flags;
11135
31104126 11136 printf ("%4d: ", i);
4082ef84
NC		 11137 if (i >= num_dynamic_syms)
11138 printf (_("<corrupt index>"));
11139 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
d79b3d50
NC		 11140 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11141 else
2b692964 11142 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 11143 putchar (' ');
252b5132
RH		 11144
11145 switch (dynamic_syminfo[i].si_boundto)
11146 {
11147 case SYMINFO_BT_SELF:
11148 fputs ("SELF ", stdout);
11149 break;
11150 case SYMINFO_BT_PARENT:
11151 fputs ("PARENT ", stdout);
11152 break;
11153 default:
11154 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 11155 && dynamic_syminfo[i].si_boundto < dynamic_nent
11156 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 11157 {
d79b3d50 11158 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 11159 putchar (' ' );
11160 }
252b5132
RH		 11161 else
11162 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11163 break;
11164 }
11165
11166 if (flags & SYMINFO_FLG_DIRECT)
11167 printf (" DIRECT");
11168 if (flags & SYMINFO_FLG_PASSTHRU)
11169 printf (" PASSTHRU");
11170 if (flags & SYMINFO_FLG_COPY)
11171 printf (" COPY");
11172 if (flags & SYMINFO_FLG_LAZYLOAD)
11173 printf (" LAZYLOAD");
11174
11175 puts ("");
11176 }
11177
11178 return 1;
11179}
11180
cf13d699
NC		 11181/* Check to see if the given reloc needs to be handled in a target specific
11182 manner. If so then process the reloc and return TRUE otherwise return
11183 FALSE. */
09c11c86 11184
cf13d699
NC		 11185static bfd_boolean
11186target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11187 unsigned char * start,
11188 Elf_Internal_Sym * symtab)
252b5132 11189{
cf13d699 11190 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 11191
cf13d699 11192 switch (elf_header.e_machine)
252b5132 11193 {
13761a11
NC		 11194 case EM_MSP430:
11195 case EM_MSP430_OLD:
11196 {
11197 static Elf_Internal_Sym * saved_sym = NULL;
11198
11199 switch (reloc_type)
11200 {
11201 case 10: /* R_MSP430_SYM_DIFF */
11202 if (uses_msp430x_relocs ())
11203 break;
11204 case 21: /* R_MSP430X_SYM_DIFF */
11205 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11206 return TRUE;
11207
11208 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11209 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11210 goto handle_sym_diff;
0b4362b0 11211
13761a11
NC		 11212 case 5: /* R_MSP430_16_BYTE */
11213 case 9: /* R_MSP430_8 */
11214 if (uses_msp430x_relocs ())
11215 break;
11216 goto handle_sym_diff;
11217
11218 case 2: /* R_MSP430_ABS16 */
11219 case 15: /* R_MSP430X_ABS16 */
11220 if (! uses_msp430x_relocs ())
11221 break;
11222 goto handle_sym_diff;
0b4362b0 11223
13761a11
NC		 11224 handle_sym_diff:
11225 if (saved_sym != NULL)
11226 {
11227 bfd_vma value;
11228
11229 value = reloc->r_addend
11230 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11231 - saved_sym->st_value);
11232
11233 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11234
11235 saved_sym = NULL;
11236 return TRUE;
11237 }
11238 break;
11239
11240 default:
11241 if (saved_sym != NULL)
071436c6 11242 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13761a11
NC		 11243 break;
11244 }
11245 break;
11246 }
11247
cf13d699
NC		 11248 case EM_MN10300:
11249 case EM_CYGNUS_MN10300:
11250 {
11251 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 11252
cf13d699
NC		 11253 switch (reloc_type)
11254 {
11255 case 34: /* R_MN10300_ALIGN */
11256 return TRUE;
11257 case 33: /* R_MN10300_SYM_DIFF */
11258 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11259 return TRUE;
11260 case 1: /* R_MN10300_32 */
11261 case 2: /* R_MN10300_16 */
11262 if (saved_sym != NULL)
11263 {
11264 bfd_vma value;
252b5132 11265
cf13d699
NC		 11266 value = reloc->r_addend
11267 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11268 - saved_sym->st_value);
252b5132 11269
cf13d699 11270 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 11271
cf13d699
NC		 11272 saved_sym = NULL;
11273 return TRUE;
11274 }
11275 break;
11276 default:
11277 if (saved_sym != NULL)
071436c6 11278 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
cf13d699
NC		 11279 break;
11280 }
11281 break;
11282 }
6ff71e76
NC		 11283
11284 case EM_RL78:
11285 {
11286 static bfd_vma saved_sym1 = 0;
11287 static bfd_vma saved_sym2 = 0;
11288 static bfd_vma value;
11289
11290 switch (reloc_type)
11291 {
11292 case 0x80: /* R_RL78_SYM. */
11293 saved_sym1 = saved_sym2;
11294 saved_sym2 = symtab[get_reloc_symindex (reloc->r_info)].st_value;
11295 saved_sym2 += reloc->r_addend;
11296 return TRUE;
11297
11298 case 0x83: /* R_RL78_OPsub. */
11299 value = saved_sym1 - saved_sym2;
11300 saved_sym2 = saved_sym1 = 0;
11301 return TRUE;
11302 break;
11303
11304 case 0x41: /* R_RL78_ABS32. */
11305 byte_put (start + reloc->r_offset, value, 4);
11306 value = 0;
11307 return TRUE;
11308
11309 case 0x43: /* R_RL78_ABS16. */
11310 byte_put (start + reloc->r_offset, value, 2);
11311 value = 0;
11312 return TRUE;
11313
11314 default:
11315 break;
11316 }
11317 break;
11318 }
252b5132
RH		 11319 }
11320
cf13d699 11321 return FALSE;
252b5132
RH		 11322}
11323
aca88567
NC		 11324/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11325 DWARF debug sections. This is a target specific test. Note - we do not
11326 go through the whole including-target-headers-multiple-times route, (as
11327 we have already done with <elf/h8.h>) because this would become very
11328 messy and even then this function would have to contain target specific
11329 information (the names of the relocs instead of their numeric values).
11330 FIXME: This is not the correct way to solve this problem. The proper way
11331 is to have target specific reloc sizing and typing functions created by
11332 the reloc-macros.h header, in the same way that it already creates the
11333 reloc naming functions. */
11334
11335static bfd_boolean
11336is_32bit_abs_reloc (unsigned int reloc_type)
11337{
11338 switch (elf_header.e_machine)
11339 {
41e92641 11340 case EM_386:
22abe556 11341 case EM_IAMCU:
41e92641 11342 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 11343 case EM_68K:
11344 return reloc_type == 1; /* R_68K_32. */
11345 case EM_860:
11346 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 11347 case EM_960:
11348 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 11349 case EM_AARCH64:
11350 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 11351 case EM_ALPHA:
137b6b5f 11352 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 11353 case EM_ARC:
11354 return reloc_type == 1; /* R_ARC_32. */
886a2506
NC		 11355 case EM_ARC_COMPACT:
11356 case EM_ARC_COMPACT2:
11357 return reloc_type == 4; /* R_ARC_32. */
41e92641
NC		 11358 case EM_ARM:
11359 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 11360 case EM_AVR_OLD:
aca88567
NC		 11361 case EM_AVR:
11362 return reloc_type == 1;
cfb8c092
NC		 11363 case EM_ADAPTEVA_EPIPHANY:
11364 return reloc_type == 3;
aca88567
NC		 11365 case EM_BLACKFIN:
11366 return reloc_type == 0x12; /* R_byte4_data. */
11367 case EM_CRIS:
11368 return reloc_type == 3; /* R_CRIS_32. */
11369 case EM_CR16:
11370 return reloc_type == 3; /* R_CR16_NUM32. */
11371 case EM_CRX:
11372 return reloc_type == 15; /* R_CRX_NUM32. */
11373 case EM_CYGNUS_FRV:
11374 return reloc_type == 1;
41e92641
NC		 11375 case EM_CYGNUS_D10V:
11376 case EM_D10V:
11377 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 11378 case EM_CYGNUS_D30V:
11379 case EM_D30V:
11380 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 11381 case EM_DLX:
11382 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 11383 case EM_CYGNUS_FR30:
11384 case EM_FR30:
11385 return reloc_type == 3; /* R_FR30_32. */
3f8107ab
AM		 11386 case EM_FT32:
11387 return reloc_type == 1; /* R_FT32_32. */
aca88567
NC		 11388 case EM_H8S:
11389 case EM_H8_300:
11390 case EM_H8_300H:
11391 return reloc_type == 1; /* R_H8_DIR32. */
3730236a 11392 case EM_IA_64:
d1c4b12b
NC		 11393 return reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
11394 || reloc_type == 0x25; /* R_IA64_DIR32LSB. */
aca88567
NC		 11395 case EM_IP2K_OLD:
11396 case EM_IP2K:
11397 return reloc_type == 2; /* R_IP2K_32. */
11398 case EM_IQ2000:
11399 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 11400 case EM_LATTICEMICO32:
11401 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 11402 case EM_M32C_OLD:
aca88567
NC		 11403 case EM_M32C:
11404 return reloc_type == 3; /* R_M32C_32. */
11405 case EM_M32R:
11406 return reloc_type == 34; /* R_M32R_32_RELA. */
adec12c1
AM		 11407 case EM_68HC11:
11408 case EM_68HC12:
11409 return reloc_type == 6; /* R_M68HC11_32. */
aca88567
NC		 11410 case EM_MCORE:
11411 return reloc_type == 1; /* R_MCORE_ADDR32. */
11412 case EM_CYGNUS_MEP:
11413 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 11414 case EM_METAG:
11415 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 11416 case EM_MICROBLAZE:
11417 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 11418 case EM_MIPS:
11419 return reloc_type == 2; /* R_MIPS_32. */
11420 case EM_MMIX:
11421 return reloc_type == 4; /* R_MMIX_32. */
11422 case EM_CYGNUS_MN10200:
11423 case EM_MN10200:
11424 return reloc_type == 1; /* R_MN10200_32. */
11425 case EM_CYGNUS_MN10300:
11426 case EM_MN10300:
11427 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 11428 case EM_MOXIE:
11429 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 11430 case EM_MSP430_OLD:
11431 case EM_MSP430:
13761a11 11432 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 11433 case EM_MT:
11434 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 11435 case EM_NDS32:
11436 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 11437 case EM_ALTERA_NIOS2:
36591ba1 11438 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 11439 case EM_NIOS32:
11440 return reloc_type == 1; /* R_NIOS_32. */
73589c9d
CS		 11441 case EM_OR1K:
11442 return reloc_type == 1; /* R_OR1K_32. */
aca88567 11443 case EM_PARISC:
5fda8eca
NC		 11444 return (reloc_type == 1 /* R_PARISC_DIR32. */
11445 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 11446 case EM_PJ:
11447 case EM_PJ_OLD:
11448 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
11449 case EM_PPC64:
11450 return reloc_type == 1; /* R_PPC64_ADDR32. */
11451 case EM_PPC:
11452 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 11453 case EM_RL78:
11454 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 11455 case EM_RX:
11456 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 11457 case EM_S370:
11458 return reloc_type == 1; /* R_I370_ADDR31. */
11459 case EM_S390_OLD:
11460 case EM_S390:
11461 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 11462 case EM_SCORE:
11463 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 11464 case EM_SH:
11465 return reloc_type == 1; /* R_SH_DIR32. */
11466 case EM_SPARC32PLUS:
11467 case EM_SPARCV9:
11468 case EM_SPARC:
11469 return reloc_type == 3 /* R_SPARC_32. */
11470 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 11471 case EM_SPU:
11472 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 11473 case EM_TI_C6000:
11474 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 11475 case EM_TILEGX:
11476 return reloc_type == 2; /* R_TILEGX_32. */
11477 case EM_TILEPRO:
11478 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 11479 case EM_CYGNUS_V850:
11480 case EM_V850:
11481 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 11482 case EM_V800:
11483 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 11484 case EM_VAX:
11485 return reloc_type == 1; /* R_VAX_32. */
619ed720
EB		 11486 case EM_VISIUM:
11487 return reloc_type == 3; /* R_VISIUM_32. */
aca88567 11488 case EM_X86_64:
8a9036a4 11489 case EM_L1OM:
7a9068fe 11490 case EM_K1OM:
aca88567 11491 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 11492 case EM_XC16X:
11493 case EM_C166:
11494 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 11495 case EM_XGATE:
11496 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 11497 case EM_XSTORMY16:
11498 return reloc_type == 1; /* R_XSTROMY16_32. */
11499 case EM_XTENSA_OLD:
11500 case EM_XTENSA:
11501 return reloc_type == 1; /* R_XTENSA_32. */
aca88567 11502 default:
bee0ee85
NC		 11503 {
11504 static unsigned int prev_warn = 0;
11505
11506 /* Avoid repeating the same warning multiple times. */
11507 if (prev_warn != elf_header.e_machine)
11508 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11509 elf_header.e_machine);
11510 prev_warn = elf_header.e_machine;
11511 return FALSE;
11512 }
aca88567
NC		 11513 }
11514}
11515
11516/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11517 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11518
11519static bfd_boolean
11520is_32bit_pcrel_reloc (unsigned int reloc_type)
11521{
11522 switch (elf_header.e_machine)
11523 {
41e92641 11524 case EM_386:
22abe556 11525 case EM_IAMCU:
3e0873ac 11526 return reloc_type == 2; /* R_386_PC32. */
aca88567 11527 case EM_68K:
3e0873ac 11528 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 11529 case EM_AARCH64:
11530 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 11531 case EM_ADAPTEVA_EPIPHANY:
11532 return reloc_type == 6;
aca88567
NC		 11533 case EM_ALPHA:
11534 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 11535 case EM_ARM:
3e0873ac 11536 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 11537 case EM_MICROBLAZE:
11538 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
73589c9d
CS		 11539 case EM_OR1K:
11540 return reloc_type == 9; /* R_OR1K_32_PCREL. */
aca88567 11541 case EM_PARISC:
85acf597 11542 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 11543 case EM_PPC:
11544 return reloc_type == 26; /* R_PPC_REL32. */
11545 case EM_PPC64:
3e0873ac 11546 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 11547 case EM_S390_OLD:
11548 case EM_S390:
3e0873ac 11549 return reloc_type == 5; /* R_390_PC32. */
aca88567 11550 case EM_SH:
3e0873ac 11551 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 11552 case EM_SPARC32PLUS:
11553 case EM_SPARCV9:
11554 case EM_SPARC:
3e0873ac 11555 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 11556 case EM_SPU:
11557 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 11558 case EM_TILEGX:
11559 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
11560 case EM_TILEPRO:
11561 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
619ed720
EB		 11562 case EM_VISIUM:
11563 return reloc_type == 6; /* R_VISIUM_32_PCREL */
aca88567 11564 case EM_X86_64:
8a9036a4 11565 case EM_L1OM:
7a9068fe 11566 case EM_K1OM:
3e0873ac 11567 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 11568 case EM_XTENSA_OLD:
11569 case EM_XTENSA:
11570 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 11571 default:
11572 /* Do not abort or issue an error message here. Not all targets use
11573 pc-relative 32-bit relocs in their DWARF debug information and we
11574 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 11575 more helpful warning message will be generated by apply_relocations
11576 anyway, so just return. */
aca88567
NC		 11577 return FALSE;
11578 }
11579}
11580
11581/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11582 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11583
11584static bfd_boolean
11585is_64bit_abs_reloc (unsigned int reloc_type)
11586{
11587 switch (elf_header.e_machine)
11588 {
a06ea964
NC		 11589 case EM_AARCH64:
11590 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 11591 case EM_ALPHA:
11592 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 11593 case EM_IA_64:
11594 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 11595 case EM_PARISC:
11596 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 11597 case EM_PPC64:
11598 return reloc_type == 38; /* R_PPC64_ADDR64. */
11599 case EM_SPARC32PLUS:
11600 case EM_SPARCV9:
11601 case EM_SPARC:
11602 return reloc_type == 54; /* R_SPARC_UA64. */
11603 case EM_X86_64:
8a9036a4 11604 case EM_L1OM:
7a9068fe 11605 case EM_K1OM:
aca88567 11606 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 11607 case EM_S390_OLD:
11608 case EM_S390:
aa137e4d
NC		 11609 return reloc_type == 22; /* R_S390_64. */
11610 case EM_TILEGX:
11611 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 11612 case EM_MIPS:
aa137e4d 11613 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 11614 default:
11615 return FALSE;
11616 }
11617}
11618
85acf597
RH		 11619/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11620 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11621
11622static bfd_boolean
11623is_64bit_pcrel_reloc (unsigned int reloc_type)
11624{
11625 switch (elf_header.e_machine)
11626 {
a06ea964
NC		 11627 case EM_AARCH64:
11628 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 11629 case EM_ALPHA:
aa137e4d 11630 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 11631 case EM_IA_64:
aa137e4d 11632 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 11633 case EM_PARISC:
aa137e4d 11634 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 11635 case EM_PPC64:
aa137e4d 11636 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 11637 case EM_SPARC32PLUS:
11638 case EM_SPARCV9:
11639 case EM_SPARC:
aa137e4d 11640 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 11641 case EM_X86_64:
8a9036a4 11642 case EM_L1OM:
7a9068fe 11643 case EM_K1OM:
aa137e4d 11644 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 11645 case EM_S390_OLD:
11646 case EM_S390:
aa137e4d
NC		 11647 return reloc_type == 23; /* R_S390_PC64. */
11648 case EM_TILEGX:
11649 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 11650 default:
11651 return FALSE;
11652 }
11653}
11654
4dc3c23d
AM		 11655/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11656 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11657
11658static bfd_boolean
11659is_24bit_abs_reloc (unsigned int reloc_type)
11660{
11661 switch (elf_header.e_machine)
11662 {
11663 case EM_CYGNUS_MN10200:
11664 case EM_MN10200:
11665 return reloc_type == 4; /* R_MN10200_24. */
11666 default:
11667 return FALSE;
11668 }
11669}
11670
aca88567
NC		 11671/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11672 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11673
11674static bfd_boolean
11675is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 11676{
11677 switch (elf_header.e_machine)
11678 {
886a2506
NC		 11679 case EM_ARC:
11680 case EM_ARC_COMPACT:
11681 case EM_ARC_COMPACT2:
11682 return reloc_type == 2; /* R_ARC_16. */
aca88567
NC		 11683 case EM_AVR_OLD:
11684 case EM_AVR:
11685 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 11686 case EM_ADAPTEVA_EPIPHANY:
11687 return reloc_type == 5;
41e92641
NC		 11688 case EM_CYGNUS_D10V:
11689 case EM_D10V:
11690 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 11691 case EM_H8S:
11692 case EM_H8_300:
11693 case EM_H8_300H:
aca88567
NC		 11694 return reloc_type == R_H8_DIR16;
11695 case EM_IP2K_OLD:
11696 case EM_IP2K:
11697 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 11698 case EM_M32C_OLD:
f4236fe4
DD		 11699 case EM_M32C:
11700 return reloc_type == 1; /* R_M32C_16 */
aca88567 11701 case EM_MSP430:
13761a11
NC		 11702 if (uses_msp430x_relocs ())
11703 return reloc_type == 2; /* R_MSP430_ABS16. */
78c8d46c 11704 case EM_MSP430_OLD:
aca88567 11705 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 11706 case EM_NDS32:
11707 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 11708 case EM_ALTERA_NIOS2:
36591ba1 11709 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 11710 case EM_NIOS32:
11711 return reloc_type == 9; /* R_NIOS_16. */
73589c9d
CS		 11712 case EM_OR1K:
11713 return reloc_type == 2; /* R_OR1K_16. */
40b36596
JM		 11714 case EM_TI_C6000:
11715 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 11716 case EM_XC16X:
11717 case EM_C166:
11718 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 11719 case EM_CYGNUS_MN10200:
11720 case EM_MN10200:
11721 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 11722 case EM_CYGNUS_MN10300:
11723 case EM_MN10300:
11724 return reloc_type == 2; /* R_MN10300_16. */
619ed720
EB		 11725 case EM_VISIUM:
11726 return reloc_type == 2; /* R_VISIUM_16. */
f6c1a2d5
NC		 11727 case EM_XGATE:
11728 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 11729 default:
aca88567 11730 return FALSE;
4b78141a
NC		 11731 }
11732}
11733
2a7b2e88
JK		 11734/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11735 relocation entries (possibly formerly used for SHT_GROUP sections). */
11736
11737static bfd_boolean
11738is_none_reloc (unsigned int reloc_type)
11739{
11740 switch (elf_header.e_machine)
11741 {
cb8f3167
NC		 11742 case EM_68K: /* R_68K_NONE. */
11743 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 11744 case EM_SPARC32PLUS:
11745 case EM_SPARCV9:
cb8f3167
NC		 11746 case EM_SPARC: /* R_SPARC_NONE. */
11747 case EM_MIPS: /* R_MIPS_NONE. */
11748 case EM_PARISC: /* R_PARISC_NONE. */
11749 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 11750 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 11751 case EM_PPC: /* R_PPC_NONE. */
11752 case EM_PPC64: /* R_PPC64_NONE. */
886a2506
NC		 11753 case EM_ARC: /* R_ARC_NONE. */
11754 case EM_ARC_COMPACT: /* R_ARC_NONE. */
11755 case EM_ARC_COMPACT2: /* R_ARC_NONE. */
cb8f3167
NC		 11756 case EM_ARM: /* R_ARM_NONE. */
11757 case EM_IA_64: /* R_IA64_NONE. */
11758 case EM_SH: /* R_SH_NONE. */
2a7b2e88 11759 case EM_S390_OLD:
cb8f3167
NC		 11760 case EM_S390: /* R_390_NONE. */
11761 case EM_CRIS: /* R_CRIS_NONE. */
11762 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 11763 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 11764 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 11765 case EM_MN10300: /* R_MN10300_NONE. */
3f8107ab 11766 case EM_FT32: /* R_FT32_NONE. */
5506d11a 11767 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 11768 case EM_M32R: /* R_M32R_NONE. */
40b36596 11769 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 11770 case EM_TILEGX: /* R_TILEGX_NONE. */
11771 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 11772 case EM_XC16X:
11773 case EM_C166: /* R_XC16X_NONE. */
36591ba1
SL		 11774 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
11775 case EM_NIOS32: /* R_NIOS_NONE. */
73589c9d 11776 case EM_OR1K: /* R_OR1K_NONE. */
cb8f3167 11777 return reloc_type == 0;
a06ea964
NC		 11778 case EM_AARCH64:
11779 return reloc_type == 0 || reloc_type == 256;
35c08157
KLC		 11780 case EM_NDS32:
11781 return (reloc_type == 0 /* R_XTENSA_NONE. */
11782 || reloc_type == 204 /* R_NDS32_DIFF8. */
11783 || reloc_type == 205 /* R_NDS32_DIFF16. */
11784 || reloc_type == 206 /* R_NDS32_DIFF32. */
11785 || reloc_type == 207 /* R_NDS32_ULEB128. */);
58332dda
JK		 11786 case EM_XTENSA_OLD:
11787 case EM_XTENSA:
4dc3c23d
AM		 11788 return (reloc_type == 0 /* R_XTENSA_NONE. */
11789 || reloc_type == 17 /* R_XTENSA_DIFF8. */
11790 || reloc_type == 18 /* R_XTENSA_DIFF16. */
11791 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
a3c62988
NC		 11792 case EM_METAG:
11793 return reloc_type == 3; /* R_METAG_NONE. */
2a7b2e88
JK		 11794 }
11795 return FALSE;
11796}
11797
d1c4b12b
NC		 11798/* Returns TRUE if there is a relocation against
11799 section NAME at OFFSET bytes. */
11800
11801bfd_boolean
11802reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
11803{
11804 Elf_Internal_Rela * relocs;
11805 Elf_Internal_Rela * rp;
11806
11807 if (dsec == NULL || dsec->reloc_info == NULL)
11808 return FALSE;
11809
11810 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
11811
11812 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
11813 if (rp->r_offset == offset)
11814 return TRUE;
11815
11816 return FALSE;
11817}
11818
cf13d699
NC		 11819/* Apply relocations to a section.
11820 Note: So far support has been added only for those relocations
11821 which can be found in debug sections.
d1c4b12b
NC		 11822 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
11823 loaded relocs. It is then the caller's responsibility to free them.
cf13d699 11824 FIXME: Add support for more relocations ? */
1b315056 11825
cf13d699 11826static void
d1c4b12b
NC		 11827apply_relocations (void * file,
11828 const Elf_Internal_Shdr * section,
11829 unsigned char * start,
11830 bfd_size_type size,
11831 void ** relocs_return,
11832 unsigned long * num_relocs_return)
1b315056 11833{
cf13d699 11834 Elf_Internal_Shdr * relsec;
0d2a7a93 11835 unsigned char * end = start + size;
cb8f3167 11836
d1c4b12b
NC		 11837 if (relocs_return != NULL)
11838 {
11839 * (Elf_Internal_Rela **) relocs_return = NULL;
11840 * num_relocs_return = 0;
11841 }
11842
cf13d699
NC		 11843 if (elf_header.e_type != ET_REL)
11844 return;
1b315056 11845
cf13d699 11846 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 11847 for (relsec = section_headers;
11848 relsec < section_headers + elf_header.e_shnum;
11849 ++relsec)
252b5132 11850 {
41e92641
NC		 11851 bfd_boolean is_rela;
11852 unsigned long num_relocs;
2cf0635d
NC		 11853 Elf_Internal_Rela * relocs;
11854 Elf_Internal_Rela * rp;
11855 Elf_Internal_Shdr * symsec;
11856 Elf_Internal_Sym * symtab;
ba5cdace 11857 unsigned long num_syms;
2cf0635d 11858 Elf_Internal_Sym * sym;
252b5132 11859
41e92641 11860 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 11861 || relsec->sh_info >= elf_header.e_shnum
11862 || section_headers + relsec->sh_info != section
c256ffe7 11863 || relsec->sh_size == 0
4fbb74a6 11864 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 11865 continue;
428409d5 11866
41e92641
NC		 11867 is_rela = relsec->sh_type == SHT_RELA;
11868
11869 if (is_rela)
11870 {
3f5e193b
NC		 11871 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11872 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11873 return;
11874 }
11875 else
11876 {
3f5e193b
NC		 11877 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11878 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11879 return;
11880 }
11881
11882 /* SH uses RELA but uses in place value instead of the addend field. */
11883 if (elf_header.e_machine == EM_SH)
11884 is_rela = FALSE;
428409d5 11885
4fbb74a6 11886 symsec = section_headers + relsec->sh_link;
ba5cdace 11887 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 11888
41e92641 11889 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 11890 {
41e92641
NC		 11891 bfd_vma addend;
11892 unsigned int reloc_type;
11893 unsigned int reloc_size;
91d6fa6a 11894 unsigned char * rloc;
ba5cdace 11895 unsigned long sym_index;
4b78141a 11896
aca88567 11897 reloc_type = get_reloc_type (rp->r_info);
41e92641 11898
98fb390a 11899 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 11900 continue;
98fb390a
NC		 11901 else if (is_none_reloc (reloc_type))
11902 continue;
11903 else if (is_32bit_abs_reloc (reloc_type)
11904 || is_32bit_pcrel_reloc (reloc_type))
aca88567 11905 reloc_size = 4;
85acf597
RH		 11906 else if (is_64bit_abs_reloc (reloc_type)
11907 || is_64bit_pcrel_reloc (reloc_type))
aca88567 11908 reloc_size = 8;
4dc3c23d
AM		 11909 else if (is_24bit_abs_reloc (reloc_type))
11910 reloc_size = 3;
aca88567
NC		 11911 else if (is_16bit_abs_reloc (reloc_type))
11912 reloc_size = 2;
11913 else
4b78141a 11914 {
bee0ee85
NC		 11915 static unsigned int prev_reloc = 0;
11916 if (reloc_type != prev_reloc)
11917 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11918 reloc_type, printable_section_name (section));
11919 prev_reloc = reloc_type;
4b78141a
NC		 11920 continue;
11921 }
103f02d3 11922
91d6fa6a 11923 rloc = start + rp->r_offset;
c8da6823 11924 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 11925 {
11926 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11927 (unsigned long) rp->r_offset,
74e1a04b 11928 printable_section_name (section));
700dd8b7
L		 11929 continue;
11930 }
103f02d3 11931
ba5cdace
NC		 11932 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11933 if (sym_index >= num_syms)
11934 {
11935 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
74e1a04b 11936 sym_index, printable_section_name (section));
ba5cdace
NC		 11937 continue;
11938 }
11939 sym = symtab + sym_index;
41e92641
NC		 11940
11941 /* If the reloc has a symbol associated with it,
55f25fc3
L		 11942 make sure that it is of an appropriate type.
11943
11944 Relocations against symbols without type can happen.
11945 Gcc -feliminate-dwarf2-dups may generate symbols
11946 without type for debug info.
11947
11948 Icc generates relocations against function symbols
11949 instead of local labels.
11950
11951 Relocations against object symbols can happen, eg when
11952 referencing a global array. For an example of this see
11953 the _clz.o binary in libgcc.a. */
aca88567 11954 if (sym != symtab
55f25fc3 11955 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 11956 {
41e92641 11957 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 11958 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 11959 (long int)(rp - relocs),
74e1a04b 11960 printable_section_name (relsec));
aca88567 11961 continue;
5b18a4bc 11962 }
252b5132 11963
4dc3c23d
AM		 11964 addend = 0;
11965 if (is_rela)
11966 addend += rp->r_addend;
c47320c3
AM		 11967 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11968 partial_inplace. */
4dc3c23d
AM		 11969 if (!is_rela
11970 || (elf_header.e_machine == EM_XTENSA
11971 && reloc_type == 1)
11972 || ((elf_header.e_machine == EM_PJ
11973 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 11974 && reloc_type == 1)
11975 || ((elf_header.e_machine == EM_D30V
11976 || elf_header.e_machine == EM_CYGNUS_D30V)
11977 && reloc_type == 12))
91d6fa6a 11978 addend += byte_get (rloc, reloc_size);
cb8f3167 11979
85acf597
RH		 11980 if (is_32bit_pcrel_reloc (reloc_type)
11981 || is_64bit_pcrel_reloc (reloc_type))
11982 {
11983 /* On HPPA, all pc-relative relocations are biased by 8. */
11984 if (elf_header.e_machine == EM_PARISC)
11985 addend -= 8;
91d6fa6a 11986 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 11987 reloc_size);
11988 }
41e92641 11989 else
91d6fa6a 11990 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 11991 }
252b5132 11992
5b18a4bc 11993 free (symtab);
d1c4b12b
NC		 11994
11995 if (relocs_return)
11996 {
11997 * (Elf_Internal_Rela **) relocs_return = relocs;
11998 * num_relocs_return = num_relocs;
11999 }
12000 else
12001 free (relocs);
12002
5b18a4bc
NC		 12003 break;
12004 }
5b18a4bc 12005}
103f02d3 12006
cf13d699
NC		 12007#ifdef SUPPORT_DISASSEMBLY
12008static int
12009disassemble_section (Elf_Internal_Shdr * section, FILE * file)
12010{
74e1a04b 12011 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
cf13d699 12012
74e1a04b 12013 /* FIXME: XXX -- to be done --- XXX */
cf13d699
NC		 12014
12015 return 1;
12016}
12017#endif
12018
12019/* Reads in the contents of SECTION from FILE, returning a pointer
12020 to a malloc'ed buffer or NULL if something went wrong. */
12021
12022static char *
12023get_section_contents (Elf_Internal_Shdr * section, FILE * file)
12024{
12025 bfd_size_type num_bytes;
12026
12027 num_bytes = section->sh_size;
12028
12029 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
12030 {
12031 printf (_("\nSection '%s' has no data to dump.\n"),
74e1a04b 12032 printable_section_name (section));
cf13d699
NC		 12033 return NULL;
12034 }
12035
3f5e193b
NC		 12036 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
12037 _("section contents"));
cf13d699
NC		 12038}
12039
0e602686
NC		 12040/* Uncompresses a section that was compressed using zlib, in place. */
12041
12042static bfd_boolean
12043uncompress_section_contents (unsigned char **buffer,
12044 dwarf_size_type uncompressed_size,
12045 dwarf_size_type *size)
12046{
12047 dwarf_size_type compressed_size = *size;
12048 unsigned char * compressed_buffer = *buffer;
12049 unsigned char * uncompressed_buffer;
12050 z_stream strm;
12051 int rc;
12052
12053 /* It is possible the section consists of several compressed
12054 buffers concatenated together, so we uncompress in a loop. */
12055 /* PR 18313: The state field in the z_stream structure is supposed
12056 to be invisible to the user (ie us), but some compilers will
12057 still complain about it being used without initialisation. So
12058 we first zero the entire z_stream structure and then set the fields
12059 that we need. */
12060 memset (& strm, 0, sizeof strm);
12061 strm.avail_in = compressed_size;
12062 strm.next_in = (Bytef *) compressed_buffer;
12063 strm.avail_out = uncompressed_size;
12064 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12065
12066 rc = inflateInit (& strm);
12067 while (strm.avail_in > 0)
12068 {
12069 if (rc != Z_OK)
12070 goto fail;
12071 strm.next_out = ((Bytef *) uncompressed_buffer
12072 + (uncompressed_size - strm.avail_out));
12073 rc = inflate (&strm, Z_FINISH);
12074 if (rc != Z_STREAM_END)
12075 goto fail;
12076 rc = inflateReset (& strm);
12077 }
12078 rc = inflateEnd (& strm);
12079 if (rc != Z_OK
12080 || strm.avail_out != 0)
12081 goto fail;
12082
12083 *buffer = uncompressed_buffer;
12084 *size = uncompressed_size;
12085 return TRUE;
12086
12087 fail:
12088 free (uncompressed_buffer);
12089 /* Indicate decompression failure. */
12090 *buffer = NULL;
12091 return FALSE;
12092}
dd24e3da 12093
cf13d699
NC		 12094static void
12095dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12096{
0e602686
NC		 12097 Elf_Internal_Shdr * relsec;
12098 bfd_size_type num_bytes;
fd8008d8
L		 12099 unsigned char * data;
12100 unsigned char * end;
12101 unsigned char * real_start;
12102 unsigned char * start;
0e602686 12103 bfd_boolean some_strings_shown;
cf13d699 12104
fd8008d8
L		 12105 real_start = start = (unsigned char *) get_section_contents (section,
12106 file);
cf13d699
NC		 12107 if (start == NULL)
12108 return;
0e602686 12109 num_bytes = section->sh_size;
cf13d699 12110
74e1a04b 12111 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
cf13d699 12112
0e602686
NC		 12113 if (decompress_dumps)
12114 {
12115 dwarf_size_type new_size = num_bytes;
12116 dwarf_size_type uncompressed_size = 0;
12117
12118 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12119 {
12120 Elf_Internal_Chdr chdr;
12121 unsigned int compression_header_size
12122 = get_compression_header (& chdr, (unsigned char *) start);
12123
813dabb9 12124 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12125 {
813dabb9
L		 12126 warn (_("section '%s' has unsupported compress type: %d\n"),
12127 printable_section_name (section), chdr.ch_type);
12128 return;
12129 }
12130 else if (chdr.ch_addralign != section->sh_addralign)
12131 {
12132 warn (_("compressed section '%s' is corrupted\n"),
12133 printable_section_name (section));
12134 return;
0e602686 12135 }
813dabb9
L		 12136 uncompressed_size = chdr.ch_size;
12137 start += compression_header_size;
12138 new_size -= compression_header_size;
0e602686
NC		 12139 }
12140 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12141 {
12142 /* Read the zlib header. In this case, it should be "ZLIB"
12143 followed by the uncompressed section size, 8 bytes in
12144 big-endian order. */
12145 uncompressed_size = start[4]; uncompressed_size <<= 8;
12146 uncompressed_size += start[5]; uncompressed_size <<= 8;
12147 uncompressed_size += start[6]; uncompressed_size <<= 8;
12148 uncompressed_size += start[7]; uncompressed_size <<= 8;
12149 uncompressed_size += start[8]; uncompressed_size <<= 8;
12150 uncompressed_size += start[9]; uncompressed_size <<= 8;
12151 uncompressed_size += start[10]; uncompressed_size <<= 8;
12152 uncompressed_size += start[11];
12153 start += 12;
12154 new_size -= 12;
12155 }
12156
12157 if (uncompressed_size
fd8008d8 12158 && uncompress_section_contents (& start,
0e602686
NC		 12159 uncompressed_size, & new_size))
12160 num_bytes = new_size;
12161 }
fd8008d8 12162
cf13d699
NC		 12163 /* If the section being dumped has relocations against it the user might
12164 be expecting these relocations to have been applied. Check for this
12165 case and issue a warning message in order to avoid confusion.
12166 FIXME: Maybe we ought to have an option that dumps a section with
12167 relocs applied ? */
12168 for (relsec = section_headers;
12169 relsec < section_headers + elf_header.e_shnum;
12170 ++relsec)
12171 {
12172 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12173 || relsec->sh_info >= elf_header.e_shnum
12174 || section_headers + relsec->sh_info != section
12175 || relsec->sh_size == 0
12176 || relsec->sh_link >= elf_header.e_shnum)
12177 continue;
12178
12179 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12180 break;
12181 }
12182
cf13d699
NC		 12183 data = start;
12184 end = start + num_bytes;
12185 some_strings_shown = FALSE;
12186
12187 while (data < end)
12188 {
12189 while (!ISPRINT (* data))
12190 if (++ data >= end)
12191 break;
12192
12193 if (data < end)
12194 {
071436c6
NC		 12195 size_t maxlen = end - data;
12196
cf13d699 12197#ifndef __MSVCRT__
c975cc98
NC		 12198 /* PR 11128: Use two separate invocations in order to work
12199 around bugs in the Solaris 8 implementation of printf. */
12200 printf (" [%6tx] ", data - start);
cf13d699 12201#else
071436c6 12202 printf (" [%6Ix] ", (size_t) (data - start));
cf13d699 12203#endif
4082ef84
NC		 12204 if (maxlen > 0)
12205 {
fd8008d8 12206 print_symbol ((int) maxlen, (const char *) data);
4082ef84 12207 putchar ('\n');
fd8008d8 12208 data += strnlen ((const char *) data, maxlen);
4082ef84
NC		 12209 }
12210 else
12211 {
12212 printf (_("<corrupt>\n"));
12213 data = end;
12214 }
cf13d699
NC		 12215 some_strings_shown = TRUE;
12216 }
12217 }
12218
12219 if (! some_strings_shown)
12220 printf (_(" No strings found in this section."));
12221
0e602686 12222 free (real_start);
cf13d699
NC		 12223
12224 putchar ('\n');
12225}
12226
12227static void
12228dump_section_as_bytes (Elf_Internal_Shdr * section,
12229 FILE * file,
12230 bfd_boolean relocate)
12231{
12232 Elf_Internal_Shdr * relsec;
0e602686
NC		 12233 bfd_size_type bytes;
12234 bfd_size_type section_size;
12235 bfd_vma addr;
12236 unsigned char * data;
12237 unsigned char * real_start;
12238 unsigned char * start;
12239
12240 real_start = start = (unsigned char *) get_section_contents (section, file);
cf13d699
NC		 12241 if (start == NULL)
12242 return;
0e602686 12243 section_size = section->sh_size;
cf13d699 12244
74e1a04b 12245 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
cf13d699 12246
0e602686
NC		 12247 if (decompress_dumps)
12248 {
12249 dwarf_size_type new_size = section_size;
12250 dwarf_size_type uncompressed_size = 0;
12251
12252 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12253 {
12254 Elf_Internal_Chdr chdr;
12255 unsigned int compression_header_size
12256 = get_compression_header (& chdr, start);
12257
813dabb9 12258 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12259 {
813dabb9
L		 12260 warn (_("section '%s' has unsupported compress type: %d\n"),
12261 printable_section_name (section), chdr.ch_type);
12262 return;
0e602686 12263 }
813dabb9
L		 12264 else if (chdr.ch_addralign != section->sh_addralign)
12265 {
12266 warn (_("compressed section '%s' is corrupted\n"),
12267 printable_section_name (section));
12268 return;
12269 }
12270 uncompressed_size = chdr.ch_size;
12271 start += compression_header_size;
12272 new_size -= compression_header_size;
0e602686
NC		 12273 }
12274 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12275 {
12276 /* Read the zlib header. In this case, it should be "ZLIB"
12277 followed by the uncompressed section size, 8 bytes in
12278 big-endian order. */
12279 uncompressed_size = start[4]; uncompressed_size <<= 8;
12280 uncompressed_size += start[5]; uncompressed_size <<= 8;
12281 uncompressed_size += start[6]; uncompressed_size <<= 8;
12282 uncompressed_size += start[7]; uncompressed_size <<= 8;
12283 uncompressed_size += start[8]; uncompressed_size <<= 8;
12284 uncompressed_size += start[9]; uncompressed_size <<= 8;
12285 uncompressed_size += start[10]; uncompressed_size <<= 8;
12286 uncompressed_size += start[11];
12287 start += 12;
12288 new_size -= 12;
12289 }
12290
12291 if (uncompressed_size
12292 && uncompress_section_contents (& start, uncompressed_size,
12293 & new_size))
12294 section_size = new_size;
12295 }
14ae95f2 12296
cf13d699
NC		 12297 if (relocate)
12298 {
0e602686 12299 apply_relocations (file, section, start, section_size, NULL, NULL);
cf13d699
NC		 12300 }
12301 else
12302 {
12303 /* If the section being dumped has relocations against it the user might
12304 be expecting these relocations to have been applied. Check for this
12305 case and issue a warning message in order to avoid confusion.
12306 FIXME: Maybe we ought to have an option that dumps a section with
12307 relocs applied ? */
12308 for (relsec = section_headers;
12309 relsec < section_headers + elf_header.e_shnum;
12310 ++relsec)
12311 {
12312 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12313 || relsec->sh_info >= elf_header.e_shnum
12314 || section_headers + relsec->sh_info != section
12315 || relsec->sh_size == 0
12316 || relsec->sh_link >= elf_header.e_shnum)
12317 continue;
12318
12319 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12320 break;
12321 }
12322 }
12323
12324 addr = section->sh_addr;
0e602686 12325 bytes = section_size;
cf13d699
NC		 12326 data = start;
12327
12328 while (bytes)
12329 {
12330 int j;
12331 int k;
12332 int lbytes;
12333
12334 lbytes = (bytes > 16 ? 16 : bytes);
12335
12336 printf (" 0x%8.8lx ", (unsigned long) addr);
12337
12338 for (j = 0; j < 16; j++)
12339 {
12340 if (j < lbytes)
12341 printf ("%2.2x", data[j]);
12342 else
12343 printf (" ");
12344
12345 if ((j & 3) == 3)
12346 printf (" ");
12347 }
12348
12349 for (j = 0; j < lbytes; j++)
12350 {
12351 k = data[j];
12352 if (k >= ' ' && k < 0x7f)
12353 printf ("%c", k);
12354 else
12355 printf (".");
12356 }
12357
12358 putchar ('\n');
12359
12360 data += lbytes;
12361 addr += lbytes;
12362 bytes -= lbytes;
12363 }
12364
0e602686 12365 free (real_start);
cf13d699
NC		 12366
12367 putchar ('\n');
12368}
12369
d966045b
DJ		 12370static int
12371load_specific_debug_section (enum dwarf_section_display_enum debug,
0d2a7a93 12372 const Elf_Internal_Shdr * sec, void * file)
1007acb3 12373{
2cf0635d 12374 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 12375 char buf [64];
1007acb3 12376
19e6b90e
L		 12377 /* If it is already loaded, do nothing. */
12378 if (section->start != NULL)
12379 return 1;
1007acb3 12380
19e6b90e
L		 12381 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12382 section->address = sec->sh_addr;
06614111 12383 section->user_data = NULL;
3f5e193b
NC		 12384 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12385 sec->sh_offset, 1,
12386 sec->sh_size, buf);
59245841
NC		 12387 if (section->start == NULL)
12388 section->size = 0;
12389 else
12390 {
77115a4a
L		 12391 unsigned char *start = section->start;
12392 dwarf_size_type size = sec->sh_size;
dab394de 12393 dwarf_size_type uncompressed_size = 0;
77115a4a
L		 12394
12395 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12396 {
12397 Elf_Internal_Chdr chdr;
12398 unsigned int compression_header_size
12399 = get_compression_header (&chdr, start);
813dabb9
L		 12400 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12401 {
12402 warn (_("section '%s' has unsupported compress type: %d\n"),
12403 section->name, chdr.ch_type);
12404 return 0;
12405 }
12406 else if (chdr.ch_addralign != sec->sh_addralign)
12407 {
12408 warn (_("compressed section '%s' is corrupted\n"),
12409 section->name);
12410 return 0;
12411 }
dab394de 12412 uncompressed_size = chdr.ch_size;
77115a4a
L		 12413 start += compression_header_size;
12414 size -= compression_header_size;
12415 }
dab394de
L		 12416 else if (size > 12 && streq ((char *) start, "ZLIB"))
12417 {
12418 /* Read the zlib header. In this case, it should be "ZLIB"
12419 followed by the uncompressed section size, 8 bytes in
12420 big-endian order. */
12421 uncompressed_size = start[4]; uncompressed_size <<= 8;
12422 uncompressed_size += start[5]; uncompressed_size <<= 8;
12423 uncompressed_size += start[6]; uncompressed_size <<= 8;
12424 uncompressed_size += start[7]; uncompressed_size <<= 8;
12425 uncompressed_size += start[8]; uncompressed_size <<= 8;
12426 uncompressed_size += start[9]; uncompressed_size <<= 8;
12427 uncompressed_size += start[10]; uncompressed_size <<= 8;
12428 uncompressed_size += start[11];
12429 start += 12;
12430 size -= 12;
12431 }
12432
12433 if (uncompressed_size
12434 && uncompress_section_contents (&start, uncompressed_size,
12435 &size))
77115a4a
L		 12436 {
12437 /* Free the compressed buffer, update the section buffer
12438 and the section size if uncompress is successful. */
12439 free (section->start);
12440 section->start = start;
77115a4a
L		 12441 }
12442 section->size = size;
59245841 12443 }
4a114e3e 12444
1b315056
CS		 12445 if (section->start == NULL)
12446 return 0;
12447
19e6b90e 12448 if (debug_displays [debug].relocate)
d1c4b12b
NC		 12449 apply_relocations ((FILE *) file, sec, section->start, section->size,
12450 & section->reloc_info, & section->num_relocs);
12451 else
12452 {
12453 section->reloc_info = NULL;
12454 section->num_relocs = 0;
12455 }
1007acb3 12456
1b315056 12457 return 1;
1007acb3
L		 12458}
12459
657d0d47
CC		 12460/* If this is not NULL, load_debug_section will only look for sections
12461 within the list of sections given here. */
12462unsigned int *section_subset = NULL;
12463
d966045b 12464int
2cf0635d 12465load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 12466{
2cf0635d
NC		 12467 struct dwarf_section * section = &debug_displays [debug].section;
12468 Elf_Internal_Shdr * sec;
d966045b
DJ		 12469
12470 /* Locate the debug section. */
657d0d47 12471 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 12472 if (sec != NULL)
12473 section->name = section->uncompressed_name;
12474 else
12475 {
657d0d47 12476 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 12477 if (sec != NULL)
12478 section->name = section->compressed_name;
12479 }
12480 if (sec == NULL)
12481 return 0;
12482
657d0d47
CC		 12483 /* If we're loading from a subset of sections, and we've loaded
12484 a section matching this name before, it's likely that it's a
12485 different one. */
12486 if (section_subset != NULL)
12487 free_debug_section (debug);
12488
3f5e193b 12489 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 12490}
12491
19e6b90e
L		 12492void
12493free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 12494{
2cf0635d 12495 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 12496
19e6b90e
L		 12497 if (section->start == NULL)
12498 return;
1007acb3 12499
19e6b90e
L		 12500 free ((char *) section->start);
12501 section->start = NULL;
12502 section->address = 0;
12503 section->size = 0;
1007acb3
L		 12504}
12505
1007acb3 12506static int
657d0d47 12507display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 12508{
2cf0635d 12509 char * name = SECTION_NAME (section);
74e1a04b 12510 const char * print_name = printable_section_name (section);
19e6b90e
L		 12511 bfd_size_type length;
12512 int result = 1;
3f5e193b 12513 int i;
1007acb3 12514
19e6b90e
L		 12515 length = section->sh_size;
12516 if (length == 0)
1007acb3 12517 {
74e1a04b 12518 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
19e6b90e 12519 return 0;
1007acb3 12520 }
5dff79d8
NC		 12521 if (section->sh_type == SHT_NOBITS)
12522 {
12523 /* There is no point in dumping the contents of a debugging section
12524 which has the NOBITS type - the bits in the file will be random.
12525 This can happen when a file containing a .eh_frame section is
12526 stripped with the --only-keep-debug command line option. */
74e1a04b
NC		 12527 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12528 print_name);
5dff79d8
NC		 12529 return 0;
12530 }
1007acb3 12531
0112cd26 12532 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 12533 name = ".debug_info";
1007acb3 12534
19e6b90e
L		 12535 /* See if we know how to display the contents of this section. */
12536 for (i = 0; i < max; i++)
1b315056 12537 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 12538 || (i == line && const_strneq (name, ".debug_line."))
1b315056 12539 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 12540 {
2cf0635d 12541 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 12542 int secondary = (section != find_section (name));
12543
12544 if (secondary)
3f5e193b 12545 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 12546
b40bf0a2
NC		 12547 if (i == line && const_strneq (name, ".debug_line."))
12548 sec->name = name;
12549 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 12550 sec->name = sec->uncompressed_name;
12551 else
12552 sec->name = sec->compressed_name;
3f5e193b
NC		 12553 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12554 section, file))
19e6b90e 12555 {
657d0d47
CC		 12556 /* If this debug section is part of a CU/TU set in a .dwp file,
12557 restrict load_debug_section to the sections in that set. */
12558 section_subset = find_cu_tu_set (file, shndx);
12559
19e6b90e 12560 result &= debug_displays[i].display (sec, file);
1007acb3 12561
657d0d47
CC		 12562 section_subset = NULL;
12563
d966045b 12564 if (secondary || (i != info && i != abbrev))
3f5e193b 12565 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 12566 }
1007acb3 12567
19e6b90e
L		 12568 break;
12569 }
1007acb3 12570
19e6b90e 12571 if (i == max)
1007acb3 12572 {
74e1a04b 12573 printf (_("Unrecognized debug section: %s\n"), print_name);
19e6b90e 12574 result = 0;
1007acb3
L		 12575 }
12576
19e6b90e 12577 return result;
5b18a4bc 12578}
103f02d3 12579
aef1f6d0
DJ		 12580/* Set DUMP_SECTS for all sections where dumps were requested
12581 based on section name. */
12582
12583static void
12584initialise_dumps_byname (void)
12585{
2cf0635d 12586 struct dump_list_entry * cur;
aef1f6d0
DJ		 12587
12588 for (cur = dump_sects_byname; cur; cur = cur->next)
12589 {
12590 unsigned int i;
12591 int any;
12592
12593 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12594 if (streq (SECTION_NAME (section_headers + i), cur->name))
12595 {
09c11c86 12596 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 12597 any = 1;
12598 }
12599
12600 if (!any)
12601 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12602 cur->name);
12603 }
12604}
12605
5b18a4bc 12606static void
2cf0635d 12607process_section_contents (FILE * file)
5b18a4bc 12608{
2cf0635d 12609 Elf_Internal_Shdr * section;
19e6b90e 12610 unsigned int i;
103f02d3 12611
19e6b90e
L		 12612 if (! do_dump)
12613 return;
103f02d3 12614
aef1f6d0
DJ		 12615 initialise_dumps_byname ();
12616
19e6b90e
L		 12617 for (i = 0, section = section_headers;
12618 i < elf_header.e_shnum && i < num_dump_sects;
12619 i++, section++)
12620 {
12621#ifdef SUPPORT_DISASSEMBLY
12622 if (dump_sects[i] & DISASS_DUMP)
12623 disassemble_section (section, file);
12624#endif
12625 if (dump_sects[i] & HEX_DUMP)
cf13d699 12626 dump_section_as_bytes (section, file, FALSE);
103f02d3 12627
cf13d699
NC		 12628 if (dump_sects[i] & RELOC_DUMP)
12629 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 12630
12631 if (dump_sects[i] & STRING_DUMP)
12632 dump_section_as_strings (section, file);
cf13d699
NC		 12633
12634 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 12635 display_debug_section (i, section, file);
5b18a4bc 12636 }
103f02d3 12637
19e6b90e
L		 12638 /* Check to see if the user requested a
12639 dump of a section that does not exist. */
12640 while (i++ < num_dump_sects)
12641 if (dump_sects[i])
12642 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 12643}
103f02d3 12644
5b18a4bc 12645static void
19e6b90e 12646process_mips_fpe_exception (int mask)
5b18a4bc 12647{
19e6b90e
L		 12648 if (mask)
12649 {
12650 int first = 1;
12651 if (mask & OEX_FPU_INEX)
12652 fputs ("INEX", stdout), first = 0;
12653 if (mask & OEX_FPU_UFLO)
12654 printf ("%sUFLO", first ? "" : "|"), first = 0;
12655 if (mask & OEX_FPU_OFLO)
12656 printf ("%sOFLO", first ? "" : "|"), first = 0;
12657 if (mask & OEX_FPU_DIV0)
12658 printf ("%sDIV0", first ? "" : "|"), first = 0;
12659 if (mask & OEX_FPU_INVAL)
12660 printf ("%sINVAL", first ? "" : "|");
12661 }
5b18a4bc 12662 else
19e6b90e 12663 fputs ("0", stdout);
5b18a4bc 12664}
103f02d3 12665
f6f0e17b
NC		 12666/* Display's the value of TAG at location P. If TAG is
12667 greater than 0 it is assumed to be an unknown tag, and
12668 a message is printed to this effect. Otherwise it is
12669 assumed that a message has already been printed.
12670
12671 If the bottom bit of TAG is set it assumed to have a
12672 string value, otherwise it is assumed to have an integer
12673 value.
12674
12675 Returns an updated P pointing to the first unread byte
12676 beyond the end of TAG's value.
12677
12678 Reads at or beyond END will not be made. */
12679
12680static unsigned char *
12681display_tag_value (int tag,
12682 unsigned char * p,
12683 const unsigned char * const end)
12684{
12685 unsigned long val;
12686
12687 if (tag > 0)
12688 printf (" Tag_unknown_%d: ", tag);
12689
12690 if (p >= end)
12691 {
4082ef84 12692 warn (_("<corrupt tag>\n"));
f6f0e17b
NC		 12693 }
12694 else if (tag & 1)
12695 {
071436c6
NC		 12696 /* PR 17531 file: 027-19978-0.004. */
12697 size_t maxlen = (end - p) - 1;
12698
12699 putchar ('"');
4082ef84
NC		 12700 if (maxlen > 0)
12701 {
12702 print_symbol ((int) maxlen, (const char *) p);
12703 p += strnlen ((char *) p, maxlen) + 1;
12704 }
12705 else
12706 {
12707 printf (_("<corrupt string tag>"));
12708 p = (unsigned char *) end;
12709 }
071436c6 12710 printf ("\"\n");
f6f0e17b
NC		 12711 }
12712 else
12713 {
12714 unsigned int len;
12715
12716 val = read_uleb128 (p, &len, end);
12717 p += len;
12718 printf ("%ld (0x%lx)\n", val, val);
12719 }
12720
4082ef84 12721 assert (p <= end);
f6f0e17b
NC		 12722 return p;
12723}
12724
11c1ff18
PB		 12725/* ARM EABI attributes section. */
12726typedef struct
12727{
70e99720 12728 unsigned int tag;
2cf0635d 12729 const char * name;
11c1ff18 12730 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 12731 unsigned int type;
2cf0635d 12732 const char ** table;
11c1ff18
PB		 12733} arm_attr_public_tag;
12734
2cf0635d 12735static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 12736 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
ff8646ee
TP		 12737 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
12738 "v8-M.mainline"};
2cf0635d
NC		 12739static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12740static const char * arm_attr_tag_THUMB_ISA_use[] =
4ed7ed8d 12741 {"No", "Thumb-1", "Thumb-2", "Yes"};
75375b3e 12742static const char * arm_attr_tag_FP_arch[] =
bca38921 12743 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
a715796b 12744 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
2cf0635d 12745static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 12746static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 12747 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 12748static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 12749 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12750 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 12751static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 12752 {"V6", "SB", "TLS", "Unused"};
2cf0635d 12753static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 12754 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 12755static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 12756 {"Absolute", "PC-relative", "None"};
2cf0635d 12757static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 12758 {"None", "direct", "GOT-indirect"};
2cf0635d 12759static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 12760 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 12761static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12762static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 12763 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 12764static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12765static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12766static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 12767 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 12768static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 12769 {"Unused", "small", "int", "forced to int"};
2cf0635d 12770static const char * arm_attr_tag_ABI_HardFP_use[] =
99654aaf 12771 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
2cf0635d 12772static const char * arm_attr_tag_ABI_VFP_args[] =
5c294fee 12773 {"AAPCS", "VFP registers", "custom", "compatible"};
2cf0635d 12774static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 12775 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 12776static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 12777 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12778 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 12779static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 12780 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12781 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 12782static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 12783static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 12784 {"Not Allowed", "Allowed"};
2cf0635d 12785static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 12786 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 12787static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 12788 {"Not Allowed", "Allowed"};
12789static const char * arm_attr_tag_DIV_use[] =
dd24e3da 12790 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 12791 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 12792static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12793static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 12794 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 12795 "TrustZone and Virtualization Extensions"};
dd24e3da 12796static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 12797 {"Not Allowed", "Allowed"};
11c1ff18
PB		 12798
12799#define LOOKUP(id, name) \
12800 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 12801static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 12802{
12803 {4, "CPU_raw_name", 1, NULL},
12804 {5, "CPU_name", 1, NULL},
12805 LOOKUP(6, CPU_arch),
12806 {7, "CPU_arch_profile", 0, NULL},
12807 LOOKUP(8, ARM_ISA_use),
12808 LOOKUP(9, THUMB_ISA_use),
75375b3e 12809 LOOKUP(10, FP_arch),
11c1ff18 12810 LOOKUP(11, WMMX_arch),
f5f53991
AS		 12811 LOOKUP(12, Advanced_SIMD_arch),
12812 LOOKUP(13, PCS_config),
11c1ff18
PB		 12813 LOOKUP(14, ABI_PCS_R9_use),
12814 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 12815 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 12816 LOOKUP(17, ABI_PCS_GOT_use),
12817 LOOKUP(18, ABI_PCS_wchar_t),
12818 LOOKUP(19, ABI_FP_rounding),
12819 LOOKUP(20, ABI_FP_denormal),
12820 LOOKUP(21, ABI_FP_exceptions),
12821 LOOKUP(22, ABI_FP_user_exceptions),
12822 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 12823 {24, "ABI_align_needed", 0, NULL},
12824 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 12825 LOOKUP(26, ABI_enum_size),
12826 LOOKUP(27, ABI_HardFP_use),
12827 LOOKUP(28, ABI_VFP_args),
12828 LOOKUP(29, ABI_WMMX_args),
12829 LOOKUP(30, ABI_optimization_goals),
12830 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 12831 {32, "compatibility", 0, NULL},
f5f53991 12832 LOOKUP(34, CPU_unaligned_access),
75375b3e 12833 LOOKUP(36, FP_HP_extension),
8e79c3df 12834 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 12835 LOOKUP(42, MPextension_use),
12836 LOOKUP(44, DIV_use),
f5f53991
AS		 12837 {64, "nodefaults", 0, NULL},
12838 {65, "also_compatible_with", 0, NULL},
12839 LOOKUP(66, T2EE_use),
12840 {67, "conformance", 1, NULL},
12841 LOOKUP(68, Virtualization_use),
cd21e546 12842 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 12843};
12844#undef LOOKUP
12845
11c1ff18 12846static unsigned char *
f6f0e17b
NC		 12847display_arm_attribute (unsigned char * p,
12848 const unsigned char * const end)
11c1ff18 12849{
70e99720 12850 unsigned int tag;
11c1ff18 12851 unsigned int len;
70e99720 12852 unsigned int val;
2cf0635d 12853 arm_attr_public_tag * attr;
11c1ff18 12854 unsigned i;
70e99720 12855 unsigned int type;
11c1ff18 12856
f6f0e17b 12857 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 12858 p += len;
12859 attr = NULL;
2cf0635d 12860 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 12861 {
12862 if (arm_attr_public_tags[i].tag == tag)
12863 {
12864 attr = &arm_attr_public_tags[i];
12865 break;
12866 }
12867 }
12868
12869 if (attr)
12870 {
12871 printf (" Tag_%s: ", attr->name);
12872 switch (attr->type)
12873 {
12874 case 0:
12875 switch (tag)
12876 {
12877 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 12878 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12879 p += len;
12880 switch (val)
12881 {
2b692964
NC		 12882 case 0: printf (_("None\n")); break;
12883 case 'A': printf (_("Application\n")); break;
12884 case 'R': printf (_("Realtime\n")); break;
12885 case 'M': printf (_("Microcontroller\n")); break;
12886 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 12887 default: printf ("??? (%d)\n", val); break;
12888 }
12889 break;
12890
75375b3e 12891 case 24: /* Tag_align_needed. */
f6f0e17b 12892 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12893 p += len;
12894 switch (val)
12895 {
2b692964
NC		 12896 case 0: printf (_("None\n")); break;
12897 case 1: printf (_("8-byte\n")); break;
12898 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 12899 case 3: printf ("??? 3\n"); break;
12900 default:
12901 if (val <= 12)
dd24e3da 12902 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12903 1 << val);
12904 else
12905 printf ("??? (%d)\n", val);
12906 break;
12907 }
12908 break;
12909
12910 case 25: /* Tag_align_preserved. */
f6f0e17b 12911 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12912 p += len;
12913 switch (val)
12914 {
2b692964
NC		 12915 case 0: printf (_("None\n")); break;
12916 case 1: printf (_("8-byte, except leaf SP\n")); break;
12917 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 12918 case 3: printf ("??? 3\n"); break;
12919 default:
12920 if (val <= 12)
dd24e3da 12921 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12922 1 << val);
12923 else
12924 printf ("??? (%d)\n", val);
12925 break;
12926 }
12927 break;
12928
11c1ff18 12929 case 32: /* Tag_compatibility. */
071436c6 12930 {
071436c6
NC		 12931 val = read_uleb128 (p, &len, end);
12932 p += len;
071436c6 12933 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 12934 if (p < end - 1)
12935 {
12936 size_t maxlen = (end - p) - 1;
12937
12938 print_symbol ((int) maxlen, (const char *) p);
12939 p += strnlen ((char *) p, maxlen) + 1;
12940 }
12941 else
12942 {
12943 printf (_("<corrupt>"));
12944 p = (unsigned char *) end;
12945 }
071436c6 12946 putchar ('\n');
071436c6 12947 }
11c1ff18
PB		 12948 break;
12949
f5f53991 12950 case 64: /* Tag_nodefaults. */
541a3cbd
NC		 12951 /* PR 17531: file: 001-505008-0.01. */
12952 if (p < end)
12953 p++;
2b692964 12954 printf (_("True\n"));
f5f53991
AS		 12955 break;
12956
12957 case 65: /* Tag_also_compatible_with. */
f6f0e17b 12958 val = read_uleb128 (p, &len, end);
f5f53991
AS		 12959 p += len;
12960 if (val == 6 /* Tag_CPU_arch. */)
12961 {
f6f0e17b 12962 val = read_uleb128 (p, &len, end);
f5f53991 12963 p += len;
071436c6 12964 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 12965 printf ("??? (%d)\n", val);
12966 else
12967 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12968 }
12969 else
12970 printf ("???\n");
071436c6
NC		 12971 while (p < end && *(p++) != '\0' /* NUL terminator. */)
12972 ;
f5f53991
AS		 12973 break;
12974
11c1ff18 12975 default:
bee0ee85
NC		 12976 printf (_("<unknown: %d>\n"), tag);
12977 break;
11c1ff18
PB		 12978 }
12979 return p;
12980
12981 case 1:
f6f0e17b 12982 return display_tag_value (-1, p, end);
11c1ff18 12983 case 2:
f6f0e17b 12984 return display_tag_value (0, p, end);
11c1ff18
PB		 12985
12986 default:
12987 assert (attr->type & 0x80);
f6f0e17b 12988 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12989 p += len;
12990 type = attr->type & 0x7f;
12991 if (val >= type)
12992 printf ("??? (%d)\n", val);
12993 else
12994 printf ("%s\n", attr->table[val]);
12995 return p;
12996 }
12997 }
11c1ff18 12998
f6f0e17b 12999 return display_tag_value (tag, p, end);
11c1ff18
PB		 13000}
13001
104d59d1 13002static unsigned char *
60bca95a 13003display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 13004 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
13005 const unsigned char * const end)
104d59d1
JM		 13006{
13007 int tag;
13008 unsigned int len;
13009 int val;
104d59d1 13010
f6f0e17b 13011 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 13012 p += len;
13013
13014 /* Tag_compatibility is the only generic GNU attribute defined at
13015 present. */
13016 if (tag == 32)
13017 {
f6f0e17b 13018 val = read_uleb128 (p, &len, end);
104d59d1 13019 p += len;
071436c6
NC		 13020
13021 printf (_("flag = %d, vendor = "), val);
f6f0e17b
NC		 13022 if (p == end)
13023 {
071436c6 13024 printf (_("<corrupt>\n"));
f6f0e17b
NC		 13025 warn (_("corrupt vendor attribute\n"));
13026 }
13027 else
13028 {
4082ef84
NC		 13029 if (p < end - 1)
13030 {
13031 size_t maxlen = (end - p) - 1;
071436c6 13032
4082ef84
NC		 13033 print_symbol ((int) maxlen, (const char *) p);
13034 p += strnlen ((char *) p, maxlen) + 1;
13035 }
13036 else
13037 {
13038 printf (_("<corrupt>"));
13039 p = (unsigned char *) end;
13040 }
071436c6 13041 putchar ('\n');
f6f0e17b 13042 }
104d59d1
JM		 13043 return p;
13044 }
13045
13046 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 13047 return display_proc_gnu_attribute (p, tag, end);
104d59d1 13048
f6f0e17b 13049 return display_tag_value (tag, p, end);
104d59d1
JM		 13050}
13051
34c8bcba 13052static unsigned char *
f6f0e17b
NC		 13053display_power_gnu_attribute (unsigned char * p,
13054 int tag,
13055 const unsigned char * const end)
34c8bcba 13056{
34c8bcba
JM		 13057 unsigned int len;
13058 int val;
13059
13060 if (tag == Tag_GNU_Power_ABI_FP)
13061 {
f6f0e17b 13062 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 13063 p += len;
13064 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 13065
34c8bcba
JM		 13066 switch (val)
13067 {
13068 case 0:
2b692964 13069 printf (_("Hard or soft float\n"));
34c8bcba
JM		 13070 break;
13071 case 1:
2b692964 13072 printf (_("Hard float\n"));
34c8bcba
JM		 13073 break;
13074 case 2:
2b692964 13075 printf (_("Soft float\n"));
34c8bcba 13076 break;
3c7b9897 13077 case 3:
2b692964 13078 printf (_("Single-precision hard float\n"));
3c7b9897 13079 break;
34c8bcba
JM		 13080 default:
13081 printf ("??? (%d)\n", val);
13082 break;
13083 }
13084 return p;
13085 }
13086
c6e65352
DJ		 13087 if (tag == Tag_GNU_Power_ABI_Vector)
13088 {
f6f0e17b 13089 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 13090 p += len;
13091 printf (" Tag_GNU_Power_ABI_Vector: ");
13092 switch (val)
13093 {
13094 case 0:
2b692964 13095 printf (_("Any\n"));
c6e65352
DJ		 13096 break;
13097 case 1:
2b692964 13098 printf (_("Generic\n"));
c6e65352
DJ		 13099 break;
13100 case 2:
13101 printf ("AltiVec\n");
13102 break;
13103 case 3:
13104 printf ("SPE\n");
13105 break;
13106 default:
13107 printf ("??? (%d)\n", val);
13108 break;
13109 }
13110 return p;
13111 }
13112
f82e0623
NF		 13113 if (tag == Tag_GNU_Power_ABI_Struct_Return)
13114 {
f6f0e17b
NC		 13115 if (p == end)
13116 {
071436c6 13117 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
f6f0e17b
NC		 13118 return p;
13119 }
0b4362b0 13120
f6f0e17b 13121 val = read_uleb128 (p, &len, end);
f82e0623
NF		 13122 p += len;
13123 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13124 switch (val)
13125 {
13126 case 0:
2b692964 13127 printf (_("Any\n"));
f82e0623
NF		 13128 break;
13129 case 1:
13130 printf ("r3/r4\n");
13131 break;
13132 case 2:
2b692964 13133 printf (_("Memory\n"));
f82e0623
NF		 13134 break;
13135 default:
13136 printf ("??? (%d)\n", val);
13137 break;
13138 }
13139 return p;
13140 }
13141
f6f0e17b 13142 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 13143}
13144
643f7afb
AK		 13145static unsigned char *
13146display_s390_gnu_attribute (unsigned char * p,
13147 int tag,
13148 const unsigned char * const end)
13149{
13150 unsigned int len;
13151 int val;
13152
13153 if (tag == Tag_GNU_S390_ABI_Vector)
13154 {
13155 val = read_uleb128 (p, &len, end);
13156 p += len;
13157 printf (" Tag_GNU_S390_ABI_Vector: ");
13158
13159 switch (val)
13160 {
13161 case 0:
13162 printf (_("any\n"));
13163 break;
13164 case 1:
13165 printf (_("software\n"));
13166 break;
13167 case 2:
13168 printf (_("hardware\n"));
13169 break;
13170 default:
13171 printf ("??? (%d)\n", val);
13172 break;
13173 }
13174 return p;
13175 }
13176
13177 return display_tag_value (tag & 1, p, end);
13178}
13179
9e8c70f9
DM		 13180static void
13181display_sparc_hwcaps (int mask)
13182{
13183 if (mask)
13184 {
13185 int first = 1;
071436c6 13186
9e8c70f9
DM		 13187 if (mask & ELF_SPARC_HWCAP_MUL32)
13188 fputs ("mul32", stdout), first = 0;
13189 if (mask & ELF_SPARC_HWCAP_DIV32)
13190 printf ("%sdiv32", first ? "" : "|"), first = 0;
13191 if (mask & ELF_SPARC_HWCAP_FSMULD)
13192 printf ("%sfsmuld", first ? "" : "|"), first = 0;
13193 if (mask & ELF_SPARC_HWCAP_V8PLUS)
13194 printf ("%sv8plus", first ? "" : "|"), first = 0;
13195 if (mask & ELF_SPARC_HWCAP_POPC)
13196 printf ("%spopc", first ? "" : "|"), first = 0;
13197 if (mask & ELF_SPARC_HWCAP_VIS)
13198 printf ("%svis", first ? "" : "|"), first = 0;
13199 if (mask & ELF_SPARC_HWCAP_VIS2)
13200 printf ("%svis2", first ? "" : "|"), first = 0;
13201 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
13202 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
13203 if (mask & ELF_SPARC_HWCAP_FMAF)
13204 printf ("%sfmaf", first ? "" : "|"), first = 0;
13205 if (mask & ELF_SPARC_HWCAP_VIS3)
13206 printf ("%svis3", first ? "" : "|"), first = 0;
13207 if (mask & ELF_SPARC_HWCAP_HPC)
13208 printf ("%shpc", first ? "" : "|"), first = 0;
13209 if (mask & ELF_SPARC_HWCAP_RANDOM)
13210 printf ("%srandom", first ? "" : "|"), first = 0;
13211 if (mask & ELF_SPARC_HWCAP_TRANS)
13212 printf ("%strans", first ? "" : "|"), first = 0;
13213 if (mask & ELF_SPARC_HWCAP_FJFMAU)
13214 printf ("%sfjfmau", first ? "" : "|"), first = 0;
13215 if (mask & ELF_SPARC_HWCAP_IMA)
13216 printf ("%sima", first ? "" : "|"), first = 0;
13217 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
13218 printf ("%scspare", first ? "" : "|"), first = 0;
13219 }
13220 else
071436c6
NC		 13221 fputc ('0', stdout);
13222 fputc ('\n', stdout);
9e8c70f9
DM		 13223}
13224
3d68f91c
JM		 13225static void
13226display_sparc_hwcaps2 (int mask)
13227{
13228 if (mask)
13229 {
13230 int first = 1;
071436c6 13231
3d68f91c
JM		 13232 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
13233 fputs ("fjathplus", stdout), first = 0;
13234 if (mask & ELF_SPARC_HWCAP2_VIS3B)
13235 printf ("%svis3b", first ? "" : "|"), first = 0;
13236 if (mask & ELF_SPARC_HWCAP2_ADP)
13237 printf ("%sadp", first ? "" : "|"), first = 0;
13238 if (mask & ELF_SPARC_HWCAP2_SPARC5)
13239 printf ("%ssparc5", first ? "" : "|"), first = 0;
13240 if (mask & ELF_SPARC_HWCAP2_MWAIT)
13241 printf ("%smwait", first ? "" : "|"), first = 0;
13242 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
13243 printf ("%sxmpmul", first ? "" : "|"), first = 0;
13244 if (mask & ELF_SPARC_HWCAP2_XMONT)
13245 printf ("%sxmont2", first ? "" : "|"), first = 0;
13246 if (mask & ELF_SPARC_HWCAP2_NSEC)
13247 printf ("%snsec", first ? "" : "|"), first = 0;
13248 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
13249 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
13250 if (mask & ELF_SPARC_HWCAP2_FJDES)
13251 printf ("%sfjdes", first ? "" : "|"), first = 0;
13252 if (mask & ELF_SPARC_HWCAP2_FJAES)
13253 printf ("%sfjaes", first ? "" : "|"), first = 0;
13254 }
13255 else
071436c6
NC		 13256 fputc ('0', stdout);
13257 fputc ('\n', stdout);
3d68f91c
JM		 13258}
13259
9e8c70f9 13260static unsigned char *
f6f0e17b
NC		 13261display_sparc_gnu_attribute (unsigned char * p,
13262 int tag,
13263 const unsigned char * const end)
9e8c70f9 13264{
3d68f91c
JM		 13265 unsigned int len;
13266 int val;
13267
9e8c70f9
DM		 13268 if (tag == Tag_GNU_Sparc_HWCAPS)
13269 {
f6f0e17b 13270 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 13271 p += len;
13272 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 13273 display_sparc_hwcaps (val);
13274 return p;
3d68f91c
JM		 13275 }
13276 if (tag == Tag_GNU_Sparc_HWCAPS2)
13277 {
13278 val = read_uleb128 (p, &len, end);
13279 p += len;
13280 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13281 display_sparc_hwcaps2 (val);
13282 return p;
13283 }
9e8c70f9 13284
f6f0e17b 13285 return display_tag_value (tag, p, end);
9e8c70f9
DM		 13286}
13287
351cdf24
MF		 13288static void
13289print_mips_fp_abi_value (int val)
13290{
13291 switch (val)
13292 {
13293 case Val_GNU_MIPS_ABI_FP_ANY:
13294 printf (_("Hard or soft float\n"));
13295 break;
13296 case Val_GNU_MIPS_ABI_FP_DOUBLE:
13297 printf (_("Hard float (double precision)\n"));
13298 break;
13299 case Val_GNU_MIPS_ABI_FP_SINGLE:
13300 printf (_("Hard float (single precision)\n"));
13301 break;
13302 case Val_GNU_MIPS_ABI_FP_SOFT:
13303 printf (_("Soft float\n"));
13304 break;
13305 case Val_GNU_MIPS_ABI_FP_OLD_64:
13306 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13307 break;
13308 case Val_GNU_MIPS_ABI_FP_XX:
13309 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13310 break;
13311 case Val_GNU_MIPS_ABI_FP_64:
13312 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13313 break;
13314 case Val_GNU_MIPS_ABI_FP_64A:
13315 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13316 break;
3350cc01
CM		 13317 case Val_GNU_MIPS_ABI_FP_NAN2008:
13318 printf (_("NaN 2008 compatibility\n"));
13319 break;
351cdf24
MF		 13320 default:
13321 printf ("??? (%d)\n", val);
13322 break;
13323 }
13324}
13325
2cf19d5c 13326static unsigned char *
f6f0e17b
NC		 13327display_mips_gnu_attribute (unsigned char * p,
13328 int tag,
13329 const unsigned char * const end)
2cf19d5c 13330{
2cf19d5c
JM		 13331 if (tag == Tag_GNU_MIPS_ABI_FP)
13332 {
f6f0e17b
NC		 13333 unsigned int len;
13334 int val;
13335
13336 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 13337 p += len;
13338 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 13339
351cdf24
MF		 13340 print_mips_fp_abi_value (val);
13341
2cf19d5c
JM		 13342 return p;
13343 }
13344
a9f58168
CF		 13345 if (tag == Tag_GNU_MIPS_ABI_MSA)
13346 {
13347 unsigned int len;
13348 int val;
13349
13350 val = read_uleb128 (p, &len, end);
13351 p += len;
13352 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13353
13354 switch (val)
13355 {
13356 case Val_GNU_MIPS_ABI_MSA_ANY:
13357 printf (_("Any MSA or not\n"));
13358 break;
13359 case Val_GNU_MIPS_ABI_MSA_128:
13360 printf (_("128-bit MSA\n"));
13361 break;
13362 default:
13363 printf ("??? (%d)\n", val);
13364 break;
13365 }
13366 return p;
13367 }
13368
f6f0e17b 13369 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 13370}
13371
59e6276b 13372static unsigned char *
f6f0e17b
NC		 13373display_tic6x_attribute (unsigned char * p,
13374 const unsigned char * const end)
59e6276b
JM		 13375{
13376 int tag;
13377 unsigned int len;
13378 int val;
13379
f6f0e17b 13380 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 13381 p += len;
13382
13383 switch (tag)
13384 {
75fa6dc1 13385 case Tag_ISA:
f6f0e17b 13386 val = read_uleb128 (p, &len, end);
59e6276b 13387 p += len;
75fa6dc1 13388 printf (" Tag_ISA: ");
59e6276b
JM		 13389
13390 switch (val)
13391 {
75fa6dc1 13392 case C6XABI_Tag_ISA_none:
59e6276b
JM		 13393 printf (_("None\n"));
13394 break;
75fa6dc1 13395 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 13396 printf ("C62x\n");
13397 break;
75fa6dc1 13398 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 13399 printf ("C67x\n");
13400 break;
75fa6dc1 13401 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 13402 printf ("C67x+\n");
13403 break;
75fa6dc1 13404 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 13405 printf ("C64x\n");
13406 break;
75fa6dc1 13407 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 13408 printf ("C64x+\n");
13409 break;
75fa6dc1 13410 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 13411 printf ("C674x\n");
13412 break;
13413 default:
13414 printf ("??? (%d)\n", val);
13415 break;
13416 }
13417 return p;
13418
87779176 13419 case Tag_ABI_wchar_t:
f6f0e17b 13420 val = read_uleb128 (p, &len, end);
87779176
JM		 13421 p += len;
13422 printf (" Tag_ABI_wchar_t: ");
13423 switch (val)
13424 {
13425 case 0:
13426 printf (_("Not used\n"));
13427 break;
13428 case 1:
13429 printf (_("2 bytes\n"));
13430 break;
13431 case 2:
13432 printf (_("4 bytes\n"));
13433 break;
13434 default:
13435 printf ("??? (%d)\n", val);
13436 break;
13437 }
13438 return p;
13439
13440 case Tag_ABI_stack_align_needed:
f6f0e17b 13441 val = read_uleb128 (p, &len, end);
87779176
JM		 13442 p += len;
13443 printf (" Tag_ABI_stack_align_needed: ");
13444 switch (val)
13445 {
13446 case 0:
13447 printf (_("8-byte\n"));
13448 break;
13449 case 1:
13450 printf (_("16-byte\n"));
13451 break;
13452 default:
13453 printf ("??? (%d)\n", val);
13454 break;
13455 }
13456 return p;
13457
13458 case Tag_ABI_stack_align_preserved:
f6f0e17b 13459 val = read_uleb128 (p, &len, end);
87779176
JM		 13460 p += len;
13461 printf (" Tag_ABI_stack_align_preserved: ");
13462 switch (val)
13463 {
13464 case 0:
13465 printf (_("8-byte\n"));
13466 break;
13467 case 1:
13468 printf (_("16-byte\n"));
13469 break;
13470 default:
13471 printf ("??? (%d)\n", val);
13472 break;
13473 }
13474 return p;
13475
b5593623 13476 case Tag_ABI_DSBT:
f6f0e17b 13477 val = read_uleb128 (p, &len, end);
b5593623
JM		 13478 p += len;
13479 printf (" Tag_ABI_DSBT: ");
13480 switch (val)
13481 {
13482 case 0:
13483 printf (_("DSBT addressing not used\n"));
13484 break;
13485 case 1:
13486 printf (_("DSBT addressing used\n"));
13487 break;
13488 default:
13489 printf ("??? (%d)\n", val);
13490 break;
13491 }
13492 return p;
13493
87779176 13494 case Tag_ABI_PID:
f6f0e17b 13495 val = read_uleb128 (p, &len, end);
87779176
JM		 13496 p += len;
13497 printf (" Tag_ABI_PID: ");
13498 switch (val)
13499 {
13500 case 0:
13501 printf (_("Data addressing position-dependent\n"));
13502 break;
13503 case 1:
13504 printf (_("Data addressing position-independent, GOT near DP\n"));
13505 break;
13506 case 2:
13507 printf (_("Data addressing position-independent, GOT far from DP\n"));
13508 break;
13509 default:
13510 printf ("??? (%d)\n", val);
13511 break;
13512 }
13513 return p;
13514
13515 case Tag_ABI_PIC:
f6f0e17b 13516 val = read_uleb128 (p, &len, end);
87779176
JM		 13517 p += len;
13518 printf (" Tag_ABI_PIC: ");
13519 switch (val)
13520 {
13521 case 0:
13522 printf (_("Code addressing position-dependent\n"));
13523 break;
13524 case 1:
13525 printf (_("Code addressing position-independent\n"));
13526 break;
13527 default:
13528 printf ("??? (%d)\n", val);
13529 break;
13530 }
13531 return p;
13532
13533 case Tag_ABI_array_object_alignment:
f6f0e17b 13534 val = read_uleb128 (p, &len, end);
87779176
JM		 13535 p += len;
13536 printf (" Tag_ABI_array_object_alignment: ");
13537 switch (val)
13538 {
13539 case 0:
13540 printf (_("8-byte\n"));
13541 break;
13542 case 1:
13543 printf (_("4-byte\n"));
13544 break;
13545 case 2:
13546 printf (_("16-byte\n"));
13547 break;
13548 default:
13549 printf ("??? (%d)\n", val);
13550 break;
13551 }
13552 return p;
13553
13554 case Tag_ABI_array_object_align_expected:
f6f0e17b 13555 val = read_uleb128 (p, &len, end);
87779176
JM		 13556 p += len;
13557 printf (" Tag_ABI_array_object_align_expected: ");
13558 switch (val)
13559 {
13560 case 0:
13561 printf (_("8-byte\n"));
13562 break;
13563 case 1:
13564 printf (_("4-byte\n"));
13565 break;
13566 case 2:
13567 printf (_("16-byte\n"));
13568 break;
13569 default:
13570 printf ("??? (%d)\n", val);
13571 break;
13572 }
13573 return p;
13574
3cbd1c06 13575 case Tag_ABI_compatibility:
071436c6 13576 {
071436c6
NC		 13577 val = read_uleb128 (p, &len, end);
13578 p += len;
13579 printf (" Tag_ABI_compatibility: ");
071436c6 13580 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13581 if (p < end - 1)
13582 {
13583 size_t maxlen = (end - p) - 1;
13584
13585 print_symbol ((int) maxlen, (const char *) p);
13586 p += strnlen ((char *) p, maxlen) + 1;
13587 }
13588 else
13589 {
13590 printf (_("<corrupt>"));
13591 p = (unsigned char *) end;
13592 }
071436c6 13593 putchar ('\n');
071436c6
NC		 13594 return p;
13595 }
87779176
JM		 13596
13597 case Tag_ABI_conformance:
071436c6 13598 {
4082ef84
NC		 13599 printf (" Tag_ABI_conformance: \"");
13600 if (p < end - 1)
13601 {
13602 size_t maxlen = (end - p) - 1;
071436c6 13603
4082ef84
NC		 13604 print_symbol ((int) maxlen, (const char *) p);
13605 p += strnlen ((char *) p, maxlen) + 1;
13606 }
13607 else
13608 {
13609 printf (_("<corrupt>"));
13610 p = (unsigned char *) end;
13611 }
071436c6 13612 printf ("\"\n");
071436c6
NC		 13613 return p;
13614 }
59e6276b
JM		 13615 }
13616
f6f0e17b
NC		 13617 return display_tag_value (tag, p, end);
13618}
59e6276b 13619
f6f0e17b
NC		 13620static void
13621display_raw_attribute (unsigned char * p, unsigned char * end)
13622{
13623 unsigned long addr = 0;
13624 size_t bytes = end - p;
13625
e0a31db1 13626 assert (end > p);
f6f0e17b 13627 while (bytes)
87779176 13628 {
f6f0e17b
NC		 13629 int j;
13630 int k;
13631 int lbytes = (bytes > 16 ? 16 : bytes);
13632
13633 printf (" 0x%8.8lx ", addr);
13634
13635 for (j = 0; j < 16; j++)
13636 {
13637 if (j < lbytes)
13638 printf ("%2.2x", p[j]);
13639 else
13640 printf (" ");
13641
13642 if ((j & 3) == 3)
13643 printf (" ");
13644 }
13645
13646 for (j = 0; j < lbytes; j++)
13647 {
13648 k = p[j];
13649 if (k >= ' ' && k < 0x7f)
13650 printf ("%c", k);
13651 else
13652 printf (".");
13653 }
13654
13655 putchar ('\n');
13656
13657 p += lbytes;
13658 bytes -= lbytes;
13659 addr += lbytes;
87779176 13660 }
59e6276b 13661
f6f0e17b 13662 putchar ('\n');
59e6276b
JM		 13663}
13664
13761a11
NC		 13665static unsigned char *
13666display_msp430x_attribute (unsigned char * p,
13667 const unsigned char * const end)
13668{
13669 unsigned int len;
13670 int val;
13671 int tag;
13672
13673 tag = read_uleb128 (p, & len, end);
13674 p += len;
0b4362b0 13675
13761a11
NC		 13676 switch (tag)
13677 {
13678 case OFBA_MSPABI_Tag_ISA:
13679 val = read_uleb128 (p, &len, end);
13680 p += len;
13681 printf (" Tag_ISA: ");
13682 switch (val)
13683 {
13684 case 0: printf (_("None\n")); break;
13685 case 1: printf (_("MSP430\n")); break;
13686 case 2: printf (_("MSP430X\n")); break;
13687 default: printf ("??? (%d)\n", val); break;
13688 }
13689 break;
13690
13691 case OFBA_MSPABI_Tag_Code_Model:
13692 val = read_uleb128 (p, &len, end);
13693 p += len;
13694 printf (" Tag_Code_Model: ");
13695 switch (val)
13696 {
13697 case 0: printf (_("None\n")); break;
13698 case 1: printf (_("Small\n")); break;
13699 case 2: printf (_("Large\n")); break;
13700 default: printf ("??? (%d)\n", val); break;
13701 }
13702 break;
13703
13704 case OFBA_MSPABI_Tag_Data_Model:
13705 val = read_uleb128 (p, &len, end);
13706 p += len;
13707 printf (" Tag_Data_Model: ");
13708 switch (val)
13709 {
13710 case 0: printf (_("None\n")); break;
13711 case 1: printf (_("Small\n")); break;
13712 case 2: printf (_("Large\n")); break;
13713 case 3: printf (_("Restricted Large\n")); break;
13714 default: printf ("??? (%d)\n", val); break;
13715 }
13716 break;
13717
13718 default:
13719 printf (_(" <unknown tag %d>: "), tag);
13720
13721 if (tag & 1)
13722 {
071436c6 13723 putchar ('"');
4082ef84
NC		 13724 if (p < end - 1)
13725 {
13726 size_t maxlen = (end - p) - 1;
13727
13728 print_symbol ((int) maxlen, (const char *) p);
13729 p += strnlen ((char *) p, maxlen) + 1;
13730 }
13731 else
13732 {
13733 printf (_("<corrupt>"));
13734 p = (unsigned char *) end;
13735 }
071436c6 13736 printf ("\"\n");
13761a11
NC		 13737 }
13738 else
13739 {
13740 val = read_uleb128 (p, &len, end);
13741 p += len;
13742 printf ("%d (0x%x)\n", val, val);
13743 }
13744 break;
13745 }
13746
4082ef84 13747 assert (p <= end);
13761a11
NC		 13748 return p;
13749}
13750
11c1ff18 13751static int
60bca95a
NC		 13752process_attributes (FILE * file,
13753 const char * public_name,
104d59d1 13754 unsigned int proc_type,
f6f0e17b
NC		 13755 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13756 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 13757{
2cf0635d 13758 Elf_Internal_Shdr * sect;
11c1ff18
PB		 13759 unsigned i;
13760
13761 /* Find the section header so that we get the size. */
13762 for (i = 0, sect = section_headers;
13763 i < elf_header.e_shnum;
13764 i++, sect++)
13765 {
071436c6
NC		 13766 unsigned char * contents;
13767 unsigned char * p;
13768
104d59d1 13769 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 13770 continue;
13771
3f5e193b
NC		 13772 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13773 sect->sh_size, _("attributes"));
60bca95a 13774 if (contents == NULL)
11c1ff18 13775 continue;
60bca95a 13776
11c1ff18
PB		 13777 p = contents;
13778 if (*p == 'A')
13779 {
071436c6
NC		 13780 bfd_vma section_len;
13781
13782 section_len = sect->sh_size - 1;
11c1ff18 13783 p++;
60bca95a 13784
071436c6 13785 while (section_len > 0)
11c1ff18 13786 {
071436c6 13787 bfd_vma attr_len;
e9847026 13788 unsigned int namelen;
11c1ff18 13789 bfd_boolean public_section;
104d59d1 13790 bfd_boolean gnu_section;
11c1ff18 13791
071436c6 13792 if (section_len <= 4)
e0a31db1
NC		 13793 {
13794 error (_("Tag section ends prematurely\n"));
13795 break;
13796 }
071436c6 13797 attr_len = byte_get (p, 4);
11c1ff18 13798 p += 4;
60bca95a 13799
071436c6 13800 if (attr_len > section_len)
11c1ff18 13801 {
071436c6
NC		 13802 error (_("Bad attribute length (%u > %u)\n"),
13803 (unsigned) attr_len, (unsigned) section_len);
13804 attr_len = section_len;
11c1ff18 13805 }
74e1a04b 13806 /* PR 17531: file: 001-101425-0.004 */
071436c6 13807 else if (attr_len < 5)
74e1a04b 13808 {
071436c6 13809 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
74e1a04b
NC		 13810 break;
13811 }
e9847026 13812
071436c6
NC		 13813 section_len -= attr_len;
13814 attr_len -= 4;
13815
13816 namelen = strnlen ((char *) p, attr_len) + 1;
13817 if (namelen == 0 || namelen >= attr_len)
e9847026
NC		 13818 {
13819 error (_("Corrupt attribute section name\n"));
13820 break;
13821 }
13822
071436c6
NC		 13823 printf (_("Attribute Section: "));
13824 print_symbol (INT_MAX, (const char *) p);
13825 putchar ('\n');
60bca95a
NC		 13826
13827 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 13828 public_section = TRUE;
13829 else
13830 public_section = FALSE;
60bca95a
NC		 13831
13832 if (streq ((char *) p, "gnu"))
104d59d1
JM		 13833 gnu_section = TRUE;
13834 else
13835 gnu_section = FALSE;
60bca95a 13836
11c1ff18 13837 p += namelen;
071436c6 13838 attr_len -= namelen;
e0a31db1 13839
071436c6 13840 while (attr_len > 0 && p < contents + sect->sh_size)
11c1ff18 13841 {
e0a31db1 13842 int tag;
11c1ff18
PB		 13843 int val;
13844 bfd_vma size;
071436c6 13845 unsigned char * end;
60bca95a 13846
e0a31db1 13847 /* PR binutils/17531: Safe handling of corrupt files. */
071436c6 13848 if (attr_len < 6)
e0a31db1
NC		 13849 {
13850 error (_("Unused bytes at end of section\n"));
13851 section_len = 0;
13852 break;
13853 }
13854
13855 tag = *(p++);
11c1ff18 13856 size = byte_get (p, 4);
071436c6 13857 if (size > attr_len)
11c1ff18 13858 {
e9847026 13859 error (_("Bad subsection length (%u > %u)\n"),
071436c6
NC		 13860 (unsigned) size, (unsigned) attr_len);
13861 size = attr_len;
11c1ff18 13862 }
e0a31db1
NC		 13863 /* PR binutils/17531: Safe handling of corrupt files. */
13864 if (size < 6)
13865 {
13866 error (_("Bad subsection length (%u < 6)\n"),
13867 (unsigned) size);
13868 section_len = 0;
13869 break;
13870 }
60bca95a 13871
071436c6 13872 attr_len -= size;
11c1ff18 13873 end = p + size - 1;
071436c6 13874 assert (end <= contents + sect->sh_size);
11c1ff18 13875 p += 4;
60bca95a 13876
11c1ff18
PB		 13877 switch (tag)
13878 {
13879 case 1:
2b692964 13880 printf (_("File Attributes\n"));
11c1ff18
PB		 13881 break;
13882 case 2:
2b692964 13883 printf (_("Section Attributes:"));
11c1ff18
PB		 13884 goto do_numlist;
13885 case 3:
2b692964 13886 printf (_("Symbol Attributes:"));
11c1ff18
PB		 13887 do_numlist:
13888 for (;;)
13889 {
91d6fa6a 13890 unsigned int j;
60bca95a 13891
f6f0e17b 13892 val = read_uleb128 (p, &j, end);
91d6fa6a 13893 p += j;
11c1ff18
PB		 13894 if (val == 0)
13895 break;
13896 printf (" %d", val);
13897 }
13898 printf ("\n");
13899 break;
13900 default:
2b692964 13901 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 13902 public_section = FALSE;
13903 break;
13904 }
60bca95a 13905
071436c6 13906 if (public_section && display_pub_attribute != NULL)
11c1ff18
PB		 13907 {
13908 while (p < end)
f6f0e17b 13909 p = display_pub_attribute (p, end);
071436c6 13910 assert (p <= end);
104d59d1 13911 }
071436c6 13912 else if (gnu_section && display_proc_gnu_attribute != NULL)
104d59d1
JM		 13913 {
13914 while (p < end)
13915 p = display_gnu_attribute (p,
f6f0e17b
NC		 13916 display_proc_gnu_attribute,
13917 end);
071436c6 13918 assert (p <= end);
11c1ff18 13919 }
071436c6 13920 else if (p < end)
11c1ff18 13921 {
071436c6 13922 printf (_(" Unknown attribute:\n"));
f6f0e17b 13923 display_raw_attribute (p, end);
11c1ff18
PB		 13924 p = end;
13925 }
071436c6
NC		 13926 else
13927 attr_len = 0;
11c1ff18
PB		 13928 }
13929 }
13930 }
13931 else
e9847026 13932 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
d70c5fc7 13933
60bca95a 13934 free (contents);
11c1ff18
PB		 13935 }
13936 return 1;
13937}
13938
104d59d1 13939static int
2cf0635d 13940process_arm_specific (FILE * file)
104d59d1
JM		 13941{
13942 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13943 display_arm_attribute, NULL);
13944}
13945
34c8bcba 13946static int
2cf0635d 13947process_power_specific (FILE * file)
34c8bcba
JM		 13948{
13949 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13950 display_power_gnu_attribute);
13951}
13952
643f7afb
AK		 13953static int
13954process_s390_specific (FILE * file)
13955{
13956 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13957 display_s390_gnu_attribute);
13958}
13959
9e8c70f9
DM		 13960static int
13961process_sparc_specific (FILE * file)
13962{
13963 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13964 display_sparc_gnu_attribute);
13965}
13966
59e6276b
JM		 13967static int
13968process_tic6x_specific (FILE * file)
13969{
13970 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13971 display_tic6x_attribute, NULL);
13972}
13973
13761a11
NC		 13974static int
13975process_msp430x_specific (FILE * file)
13976{
13977 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13978 display_msp430x_attribute, NULL);
13979}
13980
ccb4c951
RS		 13981/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13982 Print the Address, Access and Initial fields of an entry at VMA ADDR
82b1b41b
NC		 13983 and return the VMA of the next entry, or -1 if there was a problem.
13984 Does not read from DATA_END or beyond. */
ccb4c951
RS		 13985
13986static bfd_vma
82b1b41b
NC		 13987print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
13988 unsigned char * data_end)
ccb4c951
RS		 13989{
13990 printf (" ");
13991 print_vma (addr, LONG_HEX);
13992 printf (" ");
13993 if (addr < pltgot + 0xfff0)
13994 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13995 else
13996 printf ("%10s", "");
13997 printf (" ");
13998 if (data == NULL)
2b692964 13999 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 14000 else
14001 {
14002 bfd_vma entry;
82b1b41b 14003 unsigned char * from = data + addr - pltgot;
ccb4c951 14004
82b1b41b
NC		 14005 if (from + (is_32bit_elf ? 4 : 8) > data_end)
14006 {
14007 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14008 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
14009 return (bfd_vma) -1;
14010 }
14011 else
14012 {
14013 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14014 print_vma (entry, LONG_HEX);
14015 }
ccb4c951
RS		 14016 }
14017 return addr + (is_32bit_elf ? 4 : 8);
14018}
14019
861fb55a
DJ		 14020/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14021 PLTGOT. Print the Address and Initial fields of an entry at VMA
14022 ADDR and return the VMA of the next entry. */
14023
14024static bfd_vma
2cf0635d 14025print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 14026{
14027 printf (" ");
14028 print_vma (addr, LONG_HEX);
14029 printf (" ");
14030 if (data == NULL)
2b692964 14031 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 14032 else
14033 {
14034 bfd_vma entry;
14035
14036 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14037 print_vma (entry, LONG_HEX);
14038 }
14039 return addr + (is_32bit_elf ? 4 : 8);
14040}
14041
351cdf24
MF		 14042static void
14043print_mips_ases (unsigned int mask)
14044{
14045 if (mask & AFL_ASE_DSP)
14046 fputs ("\n\tDSP ASE", stdout);
14047 if (mask & AFL_ASE_DSPR2)
14048 fputs ("\n\tDSP R2 ASE", stdout);
14049 if (mask & AFL_ASE_EVA)
14050 fputs ("\n\tEnhanced VA Scheme", stdout);
14051 if (mask & AFL_ASE_MCU)
14052 fputs ("\n\tMCU (MicroController) ASE", stdout);
14053 if (mask & AFL_ASE_MDMX)
14054 fputs ("\n\tMDMX ASE", stdout);
14055 if (mask & AFL_ASE_MIPS3D)
14056 fputs ("\n\tMIPS-3D ASE", stdout);
14057 if (mask & AFL_ASE_MT)
14058 fputs ("\n\tMT ASE", stdout);
14059 if (mask & AFL_ASE_SMARTMIPS)
14060 fputs ("\n\tSmartMIPS ASE", stdout);
14061 if (mask & AFL_ASE_VIRT)
14062 fputs ("\n\tVZ ASE", stdout);
14063 if (mask & AFL_ASE_MSA)
14064 fputs ("\n\tMSA ASE", stdout);
14065 if (mask & AFL_ASE_MIPS16)
14066 fputs ("\n\tMIPS16 ASE", stdout);
14067 if (mask & AFL_ASE_MICROMIPS)
14068 fputs ("\n\tMICROMIPS ASE", stdout);
14069 if (mask & AFL_ASE_XPA)
14070 fputs ("\n\tXPA ASE", stdout);
14071 if (mask == 0)
14072 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 14073 else if ((mask & ~AFL_ASE_MASK) != 0)
14074 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 14075}
14076
14077static void
14078print_mips_isa_ext (unsigned int isa_ext)
14079{
14080 switch (isa_ext)
14081 {
14082 case 0:
14083 fputs (_("None"), stdout);
14084 break;
14085 case AFL_EXT_XLR:
14086 fputs ("RMI XLR", stdout);
14087 break;
2c629856
N		 14088 case AFL_EXT_OCTEON3:
14089 fputs ("Cavium Networks Octeon3", stdout);
14090 break;
351cdf24
MF		 14091 case AFL_EXT_OCTEON2:
14092 fputs ("Cavium Networks Octeon2", stdout);
14093 break;
14094 case AFL_EXT_OCTEONP:
14095 fputs ("Cavium Networks OcteonP", stdout);
14096 break;
14097 case AFL_EXT_LOONGSON_3A:
14098 fputs ("Loongson 3A", stdout);
14099 break;
14100 case AFL_EXT_OCTEON:
14101 fputs ("Cavium Networks Octeon", stdout);
14102 break;
14103 case AFL_EXT_5900:
14104 fputs ("Toshiba R5900", stdout);
14105 break;
14106 case AFL_EXT_4650:
14107 fputs ("MIPS R4650", stdout);
14108 break;
14109 case AFL_EXT_4010:
14110 fputs ("LSI R4010", stdout);
14111 break;
14112 case AFL_EXT_4100:
14113 fputs ("NEC VR4100", stdout);
14114 break;
14115 case AFL_EXT_3900:
14116 fputs ("Toshiba R3900", stdout);
14117 break;
14118 case AFL_EXT_10000:
14119 fputs ("MIPS R10000", stdout);
14120 break;
14121 case AFL_EXT_SB1:
14122 fputs ("Broadcom SB-1", stdout);
14123 break;
14124 case AFL_EXT_4111:
14125 fputs ("NEC VR4111/VR4181", stdout);
14126 break;
14127 case AFL_EXT_4120:
14128 fputs ("NEC VR4120", stdout);
14129 break;
14130 case AFL_EXT_5400:
14131 fputs ("NEC VR5400", stdout);
14132 break;
14133 case AFL_EXT_5500:
14134 fputs ("NEC VR5500", stdout);
14135 break;
14136 case AFL_EXT_LOONGSON_2E:
14137 fputs ("ST Microelectronics Loongson 2E", stdout);
14138 break;
14139 case AFL_EXT_LOONGSON_2F:
14140 fputs ("ST Microelectronics Loongson 2F", stdout);
14141 break;
14142 default:
00ac7aa0 14143 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 14144 }
14145}
14146
14147static int
14148get_mips_reg_size (int reg_size)
14149{
14150 return (reg_size == AFL_REG_NONE) ? 0
14151 : (reg_size == AFL_REG_32) ? 32
14152 : (reg_size == AFL_REG_64) ? 64
14153 : (reg_size == AFL_REG_128) ? 128
14154 : -1;
14155}
14156
19e6b90e 14157static int
2cf0635d 14158process_mips_specific (FILE * file)
5b18a4bc 14159{
2cf0635d 14160 Elf_Internal_Dyn * entry;
351cdf24 14161 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 14162 size_t liblist_offset = 0;
14163 size_t liblistno = 0;
14164 size_t conflictsno = 0;
14165 size_t options_offset = 0;
14166 size_t conflicts_offset = 0;
861fb55a
DJ		 14167 size_t pltrelsz = 0;
14168 size_t pltrel = 0;
ccb4c951 14169 bfd_vma pltgot = 0;
861fb55a
DJ		 14170 bfd_vma mips_pltgot = 0;
14171 bfd_vma jmprel = 0;
ccb4c951
RS		 14172 bfd_vma local_gotno = 0;
14173 bfd_vma gotsym = 0;
14174 bfd_vma symtabno = 0;
103f02d3 14175
2cf19d5c
JM		 14176 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14177 display_mips_gnu_attribute);
14178
351cdf24
MF		 14179 sect = find_section (".MIPS.abiflags");
14180
14181 if (sect != NULL)
14182 {
14183 Elf_External_ABIFlags_v0 *abiflags_ext;
14184 Elf_Internal_ABIFlags_v0 abiflags_in;
14185
14186 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
14187 fputs ("\nCorrupt ABI Flags section.\n", stdout);
14188 else
14189 {
14190 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
14191 sect->sh_size, _("MIPS ABI Flags section"));
14192 if (abiflags_ext)
14193 {
14194 abiflags_in.version = BYTE_GET (abiflags_ext->version);
14195 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
14196 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
14197 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
14198 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
14199 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
14200 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
14201 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
14202 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
14203 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
14204 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
14205
14206 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
14207 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
14208 if (abiflags_in.isa_rev > 1)
14209 printf ("r%d", abiflags_in.isa_rev);
14210 printf ("\nGPR size: %d",
14211 get_mips_reg_size (abiflags_in.gpr_size));
14212 printf ("\nCPR1 size: %d",
14213 get_mips_reg_size (abiflags_in.cpr1_size));
14214 printf ("\nCPR2 size: %d",
14215 get_mips_reg_size (abiflags_in.cpr2_size));
14216 fputs ("\nFP ABI: ", stdout);
14217 print_mips_fp_abi_value (abiflags_in.fp_abi);
14218 fputs ("ISA Extension: ", stdout);
14219 print_mips_isa_ext (abiflags_in.isa_ext);
14220 fputs ("\nASEs:", stdout);
14221 print_mips_ases (abiflags_in.ases);
14222 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
14223 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
14224 fputc ('\n', stdout);
14225 free (abiflags_ext);
14226 }
14227 }
14228 }
14229
19e6b90e
L		 14230 /* We have a lot of special sections. Thanks SGI! */
14231 if (dynamic_section == NULL)
14232 /* No information available. */
14233 return 0;
252b5132 14234
071436c6
NC		 14235 for (entry = dynamic_section;
14236 /* PR 17531 file: 012-50589-0.004. */
14237 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
14238 ++entry)
252b5132
RH		 14239 switch (entry->d_tag)
14240 {
14241 case DT_MIPS_LIBLIST:
d93f0186
NC		 14242 liblist_offset
14243 = offset_from_vma (file, entry->d_un.d_val,
14244 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 14245 break;
14246 case DT_MIPS_LIBLISTNO:
14247 liblistno = entry->d_un.d_val;
14248 break;
14249 case DT_MIPS_OPTIONS:
d93f0186 14250 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 14251 break;
14252 case DT_MIPS_CONFLICT:
d93f0186
NC		 14253 conflicts_offset
14254 = offset_from_vma (file, entry->d_un.d_val,
14255 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 14256 break;
14257 case DT_MIPS_CONFLICTNO:
14258 conflictsno = entry->d_un.d_val;
14259 break;
ccb4c951 14260 case DT_PLTGOT:
861fb55a
DJ		 14261 pltgot = entry->d_un.d_ptr;
14262 break;
ccb4c951
RS		 14263 case DT_MIPS_LOCAL_GOTNO:
14264 local_gotno = entry->d_un.d_val;
14265 break;
14266 case DT_MIPS_GOTSYM:
14267 gotsym = entry->d_un.d_val;
14268 break;
14269 case DT_MIPS_SYMTABNO:
14270 symtabno = entry->d_un.d_val;
14271 break;
861fb55a
DJ		 14272 case DT_MIPS_PLTGOT:
14273 mips_pltgot = entry->d_un.d_ptr;
14274 break;
14275 case DT_PLTREL:
14276 pltrel = entry->d_un.d_val;
14277 break;
14278 case DT_PLTRELSZ:
14279 pltrelsz = entry->d_un.d_val;
14280 break;
14281 case DT_JMPREL:
14282 jmprel = entry->d_un.d_ptr;
14283 break;
252b5132
RH		 14284 default:
14285 break;
14286 }
14287
14288 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
14289 {
2cf0635d 14290 Elf32_External_Lib * elib;
252b5132
RH		 14291 size_t cnt;
14292
3f5e193b
NC		 14293 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
14294 liblistno,
14295 sizeof (Elf32_External_Lib),
9cf03b7e 14296 _("liblist section data"));
a6e9f9df 14297 if (elib)
252b5132 14298 {
2b692964 14299 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 14300 (unsigned long) liblistno);
2b692964 14301 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 14302 stdout);
14303
14304 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 14305 {
a6e9f9df 14306 Elf32_Lib liblist;
91d6fa6a 14307 time_t atime;
a6e9f9df 14308 char timebuf[20];
2cf0635d 14309 struct tm * tmp;
a6e9f9df
AM		 14310
14311 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14312 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 14313 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14314 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14315 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14316
91d6fa6a 14317 tmp = gmtime (&atime);
e9e44622
JJ		 14318 snprintf (timebuf, sizeof (timebuf),
14319 "%04u-%02u-%02uT%02u:%02u:%02u",
14320 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14321 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 14322
31104126 14323 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 14324 if (VALID_DYNAMIC_NAME (liblist.l_name))
14325 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
14326 else
2b692964 14327 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 14328 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
14329 liblist.l_version);
a6e9f9df
AM		 14330
14331 if (liblist.l_flags == 0)
2b692964 14332 puts (_(" NONE"));
a6e9f9df
AM		 14333 else
14334 {
14335 static const struct
252b5132 14336 {
2cf0635d 14337 const char * name;
a6e9f9df 14338 int bit;
252b5132 14339 }
a6e9f9df
AM		 14340 l_flags_vals[] =
14341 {
14342 { " EXACT_MATCH", LL_EXACT_MATCH },
14343 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
14344 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
14345 { " EXPORTS", LL_EXPORTS },
14346 { " DELAY_LOAD", LL_DELAY_LOAD },
14347 { " DELTA", LL_DELTA }
14348 };
14349 int flags = liblist.l_flags;
14350 size_t fcnt;
14351
60bca95a 14352 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 14353 if ((flags & l_flags_vals[fcnt].bit) != 0)
14354 {
14355 fputs (l_flags_vals[fcnt].name, stdout);
14356 flags ^= l_flags_vals[fcnt].bit;
14357 }
14358 if (flags != 0)
14359 printf (" %#x", (unsigned int) flags);
252b5132 14360
a6e9f9df
AM		 14361 puts ("");
14362 }
252b5132 14363 }
252b5132 14364
a6e9f9df
AM		 14365 free (elib);
14366 }
252b5132
RH		 14367 }
14368
14369 if (options_offset != 0)
14370 {
2cf0635d 14371 Elf_External_Options * eopt;
2cf0635d
NC		 14372 Elf_Internal_Options * iopt;
14373 Elf_Internal_Options * option;
252b5132
RH		 14374 size_t offset;
14375 int cnt;
351cdf24 14376 sect = section_headers;
252b5132
RH		 14377
14378 /* Find the section header so that we get the size. */
071436c6 14379 sect = find_section_by_type (SHT_MIPS_OPTIONS);
948f632f 14380 /* PR 17533 file: 012-277276-0.004. */
071436c6
NC		 14381 if (sect == NULL)
14382 {
14383 error (_("No MIPS_OPTIONS header found\n"));
14384 return 0;
14385 }
252b5132 14386
3f5e193b
NC		 14387 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14388 sect->sh_size, _("options"));
a6e9f9df 14389 if (eopt)
252b5132 14390 {
3f5e193b
NC		 14391 iopt = (Elf_Internal_Options *)
14392 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 14393 if (iopt == NULL)
14394 {
8b73c356 14395 error (_("Out of memory allocatinf space for MIPS options\n"));
a6e9f9df
AM		 14396 return 0;
14397 }
76da6bbe 14398
a6e9f9df
AM		 14399 offset = cnt = 0;
14400 option = iopt;
252b5132 14401
82b1b41b 14402 while (offset <= sect->sh_size - sizeof (* eopt))
a6e9f9df 14403 {
2cf0635d 14404 Elf_External_Options * eoption;
252b5132 14405
a6e9f9df 14406 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 14407
a6e9f9df
AM		 14408 option->kind = BYTE_GET (eoption->kind);
14409 option->size = BYTE_GET (eoption->size);
14410 option->section = BYTE_GET (eoption->section);
14411 option->info = BYTE_GET (eoption->info);
76da6bbe 14412
82b1b41b
NC		 14413 /* PR 17531: file: ffa0fa3b. */
14414 if (option->size < sizeof (* eopt)
14415 || offset + option->size > sect->sh_size)
14416 {
55325047
NC		 14417 error (_("Invalid size (%u) for MIPS option\n"), option->size);
14418 return 0;
82b1b41b 14419 }
a6e9f9df 14420 offset += option->size;
14ae95f2 14421
a6e9f9df
AM		 14422 ++option;
14423 ++cnt;
14424 }
252b5132 14425
a6e9f9df 14426 printf (_("\nSection '%s' contains %d entries:\n"),
74e1a04b 14427 printable_section_name (sect), cnt);
76da6bbe 14428
a6e9f9df 14429 option = iopt;
82b1b41b 14430 offset = 0;
252b5132 14431
a6e9f9df 14432 while (cnt-- > 0)
252b5132 14433 {
a6e9f9df
AM		 14434 size_t len;
14435
14436 switch (option->kind)
252b5132 14437 {
a6e9f9df
AM		 14438 case ODK_NULL:
14439 /* This shouldn't happen. */
14440 printf (" NULL %d %lx", option->section, option->info);
14441 break;
14442 case ODK_REGINFO:
14443 printf (" REGINFO ");
14444 if (elf_header.e_machine == EM_MIPS)
14445 {
14446 /* 32bit form. */
2cf0635d 14447 Elf32_External_RegInfo * ereg;
b34976b6 14448 Elf32_RegInfo reginfo;
a6e9f9df
AM		 14449
14450 ereg = (Elf32_External_RegInfo *) (option + 1);
14451 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14452 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14453 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14454 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14455 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14456 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14457
14458 printf ("GPR %08lx GP 0x%lx\n",
14459 reginfo.ri_gprmask,
14460 (unsigned long) reginfo.ri_gp_value);
14461 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14462 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14463 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14464 }
14465 else
14466 {
14467 /* 64 bit form. */
2cf0635d 14468 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 14469 Elf64_Internal_RegInfo reginfo;
14470
14471 ereg = (Elf64_External_RegInfo *) (option + 1);
14472 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14473 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14474 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14475 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14476 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 14477 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 14478
14479 printf ("GPR %08lx GP 0x",
14480 reginfo.ri_gprmask);
14481 printf_vma (reginfo.ri_gp_value);
14482 printf ("\n");
14483
14484 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14485 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14486 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14487 }
14488 ++option;
14489 continue;
14490 case ODK_EXCEPTIONS:
14491 fputs (" EXCEPTIONS fpe_min(", stdout);
14492 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14493 fputs (") fpe_max(", stdout);
14494 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14495 fputs (")", stdout);
14496
14497 if (option->info & OEX_PAGE0)
14498 fputs (" PAGE0", stdout);
14499 if (option->info & OEX_SMM)
14500 fputs (" SMM", stdout);
14501 if (option->info & OEX_FPDBUG)
14502 fputs (" FPDBUG", stdout);
14503 if (option->info & OEX_DISMISS)
14504 fputs (" DISMISS", stdout);
14505 break;
14506 case ODK_PAD:
14507 fputs (" PAD ", stdout);
14508 if (option->info & OPAD_PREFIX)
14509 fputs (" PREFIX", stdout);
14510 if (option->info & OPAD_POSTFIX)
14511 fputs (" POSTFIX", stdout);
14512 if (option->info & OPAD_SYMBOL)
14513 fputs (" SYMBOL", stdout);
14514 break;
14515 case ODK_HWPATCH:
14516 fputs (" HWPATCH ", stdout);
14517 if (option->info & OHW_R4KEOP)
14518 fputs (" R4KEOP", stdout);
14519 if (option->info & OHW_R8KPFETCH)
14520 fputs (" R8KPFETCH", stdout);
14521 if (option->info & OHW_R5KEOP)
14522 fputs (" R5KEOP", stdout);
14523 if (option->info & OHW_R5KCVTL)
14524 fputs (" R5KCVTL", stdout);
14525 break;
14526 case ODK_FILL:
14527 fputs (" FILL ", stdout);
14528 /* XXX Print content of info word? */
14529 break;
14530 case ODK_TAGS:
14531 fputs (" TAGS ", stdout);
14532 /* XXX Print content of info word? */
14533 break;
14534 case ODK_HWAND:
14535 fputs (" HWAND ", stdout);
14536 if (option->info & OHWA0_R4KEOP_CHECKED)
14537 fputs (" R4KEOP_CHECKED", stdout);
14538 if (option->info & OHWA0_R4KEOP_CLEAN)
14539 fputs (" R4KEOP_CLEAN", stdout);
14540 break;
14541 case ODK_HWOR:
14542 fputs (" HWOR ", stdout);
14543 if (option->info & OHWA0_R4KEOP_CHECKED)
14544 fputs (" R4KEOP_CHECKED", stdout);
14545 if (option->info & OHWA0_R4KEOP_CLEAN)
14546 fputs (" R4KEOP_CLEAN", stdout);
14547 break;
14548 case ODK_GP_GROUP:
14549 printf (" GP_GROUP %#06lx self-contained %#06lx",
14550 option->info & OGP_GROUP,
14551 (option->info & OGP_SELF) >> 16);
14552 break;
14553 case ODK_IDENT:
14554 printf (" IDENT %#06lx self-contained %#06lx",
14555 option->info & OGP_GROUP,
14556 (option->info & OGP_SELF) >> 16);
14557 break;
14558 default:
14559 /* This shouldn't happen. */
14560 printf (" %3d ??? %d %lx",
14561 option->kind, option->section, option->info);
14562 break;
252b5132 14563 }
a6e9f9df 14564
2cf0635d 14565 len = sizeof (* eopt);
a6e9f9df 14566 while (len < option->size)
82b1b41b 14567 {
7e27a9d5 14568 unsigned char datum = * ((unsigned char *) eopt + offset + len);
a6e9f9df 14569
82b1b41b
NC		 14570 if (ISPRINT (datum))
14571 printf ("%c", datum);
14572 else
14573 printf ("\\%03o", datum);
14574 len ++;
14575 }
a6e9f9df 14576 fputs ("\n", stdout);
82b1b41b
NC		 14577
14578 offset += option->size;
252b5132 14579 ++option;
252b5132
RH		 14580 }
14581
a6e9f9df 14582 free (eopt);
252b5132 14583 }
252b5132
RH		 14584 }
14585
14586 if (conflicts_offset != 0 && conflictsno != 0)
14587 {
2cf0635d 14588 Elf32_Conflict * iconf;
252b5132
RH		 14589 size_t cnt;
14590
14591 if (dynamic_symbols == NULL)
14592 {
591a748a 14593 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 14594 return 0;
14595 }
14596
3f5e193b 14597 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 14598 if (iconf == NULL)
14599 {
8b73c356 14600 error (_("Out of memory allocating space for dynamic conflicts\n"));
252b5132
RH		 14601 return 0;
14602 }
14603
9ea033b2 14604 if (is_32bit_elf)
252b5132 14605 {
2cf0635d 14606 Elf32_External_Conflict * econf32;
a6e9f9df 14607
3f5e193b
NC		 14608 econf32 = (Elf32_External_Conflict *)
14609 get_data (NULL, file, conflicts_offset, conflictsno,
14610 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 14611 if (!econf32)
14612 return 0;
252b5132
RH		 14613
14614 for (cnt = 0; cnt < conflictsno; ++cnt)
14615 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 14616
14617 free (econf32);
252b5132
RH		 14618 }
14619 else
14620 {
2cf0635d 14621 Elf64_External_Conflict * econf64;
a6e9f9df 14622
3f5e193b
NC		 14623 econf64 = (Elf64_External_Conflict *)
14624 get_data (NULL, file, conflicts_offset, conflictsno,
14625 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 14626 if (!econf64)
14627 return 0;
252b5132
RH		 14628
14629 for (cnt = 0; cnt < conflictsno; ++cnt)
14630 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 14631
14632 free (econf64);
252b5132
RH		 14633 }
14634
c7e7ca54
NC		 14635 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14636 (unsigned long) conflictsno);
252b5132
RH		 14637 puts (_(" Num: Index Value Name"));
14638
14639 for (cnt = 0; cnt < conflictsno; ++cnt)
14640 {
b34976b6 14641 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 14642
14643 if (iconf[cnt] >= num_dynamic_syms)
14644 printf (_("<corrupt symbol index>"));
d79b3d50 14645 else
e0a31db1
NC		 14646 {
14647 Elf_Internal_Sym * psym;
14648
14649 psym = & dynamic_symbols[iconf[cnt]];
14650 print_vma (psym->st_value, FULL_HEX);
14651 putchar (' ');
14652 if (VALID_DYNAMIC_NAME (psym->st_name))
14653 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14654 else
14655 printf (_("<corrupt: %14ld>"), psym->st_name);
14656 }
31104126 14657 putchar ('\n');
252b5132
RH		 14658 }
14659
252b5132
RH		 14660 free (iconf);
14661 }
14662
ccb4c951
RS		 14663 if (pltgot != 0 && local_gotno != 0)
14664 {
91d6fa6a 14665 bfd_vma ent, local_end, global_end;
bbeee7ea 14666 size_t i, offset;
2cf0635d 14667 unsigned char * data;
82b1b41b 14668 unsigned char * data_end;
bbeee7ea 14669 int addr_size;
ccb4c951 14670
91d6fa6a 14671 ent = pltgot;
ccb4c951
RS		 14672 addr_size = (is_32bit_elf ? 4 : 8);
14673 local_end = pltgot + local_gotno * addr_size;
ccb4c951 14674
74e1a04b
NC		 14675 /* PR binutils/17533 file: 012-111227-0.004 */
14676 if (symtabno < gotsym)
14677 {
14678 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
82b1b41b 14679 (unsigned long) gotsym, (unsigned long) symtabno);
74e1a04b
NC		 14680 return 0;
14681 }
82b1b41b 14682
74e1a04b 14683 global_end = local_end + (symtabno - gotsym) * addr_size;
82b1b41b
NC		 14684 /* PR 17531: file: 54c91a34. */
14685 if (global_end < local_end)
14686 {
14687 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14688 return 0;
14689 }
948f632f 14690
ccb4c951 14691 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 14692 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 14693 global_end - pltgot, 1,
14694 _("Global Offset Table data"));
59245841
NC		 14695 if (data == NULL)
14696 return 0;
82b1b41b 14697 data_end = data + (global_end - pltgot);
59245841 14698
ccb4c951
RS		 14699 printf (_("\nPrimary GOT:\n"));
14700 printf (_(" Canonical gp value: "));
14701 print_vma (pltgot + 0x7ff0, LONG_HEX);
14702 printf ("\n\n");
14703
14704 printf (_(" Reserved entries:\n"));
14705 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 14706 addr_size * 2, _("Address"), _("Access"),
14707 addr_size * 2, _("Initial"));
82b1b41b 14708 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14709 printf (_(" Lazy resolver\n"));
82b1b41b
NC		 14710 if (ent == (bfd_vma) -1)
14711 goto got_print_fail;
ccb4c951 14712 if (data
91d6fa6a 14713 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 14714 >> (addr_size * 8 - 1)) != 0)
14715 {
82b1b41b 14716 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14717 printf (_(" Module pointer (GNU extension)\n"));
82b1b41b
NC		 14718 if (ent == (bfd_vma) -1)
14719 goto got_print_fail;
ccb4c951
RS		 14720 }
14721 printf ("\n");
14722
91d6fa6a 14723 if (ent < local_end)
ccb4c951
RS		 14724 {
14725 printf (_(" Local entries:\n"));
cc5914eb 14726 printf (" %*s %10s %*s\n",
2b692964
NC		 14727 addr_size * 2, _("Address"), _("Access"),
14728 addr_size * 2, _("Initial"));
91d6fa6a 14729 while (ent < local_end)
ccb4c951 14730 {
82b1b41b 14731 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14732 printf ("\n");
82b1b41b
NC		 14733 if (ent == (bfd_vma) -1)
14734 goto got_print_fail;
ccb4c951
RS		 14735 }
14736 printf ("\n");
14737 }
14738
14739 if (gotsym < symtabno)
14740 {
14741 int sym_width;
14742
14743 printf (_(" Global entries:\n"));
cc5914eb 14744 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 14745 addr_size * 2, _("Address"),
14746 _("Access"),
2b692964 14747 addr_size * 2, _("Initial"),
9cf03b7e
NC		 14748 addr_size * 2, _("Sym.Val."),
14749 _("Type"),
14750 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14751 _("Ndx"), _("Name"));
0b4362b0 14752
ccb4c951 14753 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 14754
ccb4c951
RS		 14755 for (i = gotsym; i < symtabno; i++)
14756 {
82b1b41b 14757 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14758 printf (" ");
e0a31db1
NC		 14759
14760 if (dynamic_symbols == NULL)
14761 printf (_("<no dynamic symbols>"));
14762 else if (i < num_dynamic_syms)
14763 {
14764 Elf_Internal_Sym * psym = dynamic_symbols + i;
14765
14766 print_vma (psym->st_value, LONG_HEX);
14767 printf (" %-7s %3s ",
14768 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14769 get_symbol_index_type (psym->st_shndx));
14770
14771 if (VALID_DYNAMIC_NAME (psym->st_name))
14772 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14773 else
14774 printf (_("<corrupt: %14ld>"), psym->st_name);
14775 }
ccb4c951 14776 else
7fc5ac57
JBG		 14777 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14778 (unsigned long) i);
e0a31db1 14779
ccb4c951 14780 printf ("\n");
82b1b41b
NC		 14781 if (ent == (bfd_vma) -1)
14782 break;
ccb4c951
RS		 14783 }
14784 printf ("\n");
14785 }
14786
82b1b41b 14787 got_print_fail:
ccb4c951
RS		 14788 if (data)
14789 free (data);
14790 }
14791
861fb55a
DJ		 14792 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14793 {
91d6fa6a 14794 bfd_vma ent, end;
861fb55a
DJ		 14795 size_t offset, rel_offset;
14796 unsigned long count, i;
2cf0635d 14797 unsigned char * data;
861fb55a 14798 int addr_size, sym_width;
2cf0635d 14799 Elf_Internal_Rela * rels;
861fb55a
DJ		 14800
14801 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14802 if (pltrel == DT_RELA)
14803 {
14804 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14805 return 0;
14806 }
14807 else
14808 {
14809 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14810 return 0;
14811 }
14812
91d6fa6a 14813 ent = mips_pltgot;
861fb55a
DJ		 14814 addr_size = (is_32bit_elf ? 4 : 8);
14815 end = mips_pltgot + (2 + count) * addr_size;
14816
14817 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 14818 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 14819 1, _("Procedure Linkage Table data"));
59245841
NC		 14820 if (data == NULL)
14821 return 0;
14822
9cf03b7e 14823 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 14824 printf (_(" Reserved entries:\n"));
14825 printf (_(" %*s %*s Purpose\n"),
2b692964 14826 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 14827 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14828 printf (_(" PLT lazy resolver\n"));
91d6fa6a 14829 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14830 printf (_(" Module pointer\n"));
861fb55a
DJ		 14831 printf ("\n");
14832
14833 printf (_(" Entries:\n"));
cc5914eb 14834 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 14835 addr_size * 2, _("Address"),
14836 addr_size * 2, _("Initial"),
14837 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 14838 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14839 for (i = 0; i < count; i++)
14840 {
df97ab2a 14841 unsigned long idx = get_reloc_symindex (rels[i].r_info);
861fb55a 14842
91d6fa6a 14843 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 14844 printf (" ");
e0a31db1 14845
df97ab2a
MF		 14846 if (idx >= num_dynamic_syms)
14847 printf (_("<corrupt symbol index: %lu>"), idx);
861fb55a 14848 else
e0a31db1 14849 {
df97ab2a 14850 Elf_Internal_Sym * psym = dynamic_symbols + idx;
e0a31db1
NC		 14851
14852 print_vma (psym->st_value, LONG_HEX);
14853 printf (" %-7s %3s ",
14854 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14855 get_symbol_index_type (psym->st_shndx));
14856 if (VALID_DYNAMIC_NAME (psym->st_name))
14857 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14858 else
14859 printf (_("<corrupt: %14ld>"), psym->st_name);
14860 }
861fb55a
DJ		 14861 printf ("\n");
14862 }
14863 printf ("\n");
14864
14865 if (data)
14866 free (data);
14867 free (rels);
14868 }
14869
252b5132
RH		 14870 return 1;
14871}
14872
35c08157
KLC		 14873static int
14874process_nds32_specific (FILE * file)
14875{
14876 Elf_Internal_Shdr *sect = NULL;
14877
14878 sect = find_section (".nds32_e_flags");
14879 if (sect != NULL)
14880 {
14881 unsigned int *flag;
14882
14883 printf ("\nNDS32 elf flags section:\n");
14884 flag = get_data (NULL, file, sect->sh_offset, 1,
14885 sect->sh_size, _("NDS32 elf flags section"));
14886
14887 switch ((*flag) & 0x3)
14888 {
14889 case 0:
14890 printf ("(VEC_SIZE):\tNo entry.\n");
14891 break;
14892 case 1:
14893 printf ("(VEC_SIZE):\t4 bytes\n");
14894 break;
14895 case 2:
14896 printf ("(VEC_SIZE):\t16 bytes\n");
14897 break;
14898 case 3:
14899 printf ("(VEC_SIZE):\treserved\n");
14900 break;
14901 }
14902 }
14903
14904 return TRUE;
14905}
14906
047b2264 14907static int
2cf0635d 14908process_gnu_liblist (FILE * file)
047b2264 14909{
2cf0635d
NC		 14910 Elf_Internal_Shdr * section;
14911 Elf_Internal_Shdr * string_sec;
14912 Elf32_External_Lib * elib;
14913 char * strtab;
c256ffe7 14914 size_t strtab_size;
047b2264
JJ		 14915 size_t cnt;
14916 unsigned i;
14917
14918 if (! do_arch)
14919 return 0;
14920
14921 for (i = 0, section = section_headers;
14922 i < elf_header.e_shnum;
b34976b6 14923 i++, section++)
047b2264
JJ		 14924 {
14925 switch (section->sh_type)
14926 {
14927 case SHT_GNU_LIBLIST:
4fbb74a6 14928 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 14929 break;
14930
3f5e193b
NC		 14931 elib = (Elf32_External_Lib *)
14932 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 14933 _("liblist section data"));
047b2264
JJ		 14934
14935 if (elib == NULL)
14936 break;
4fbb74a6 14937 string_sec = section_headers + section->sh_link;
047b2264 14938
3f5e193b
NC		 14939 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14940 string_sec->sh_size,
14941 _("liblist string table"));
047b2264
JJ		 14942 if (strtab == NULL
14943 || section->sh_entsize != sizeof (Elf32_External_Lib))
14944 {
14945 free (elib);
2842702f 14946 free (strtab);
047b2264
JJ		 14947 break;
14948 }
59245841 14949 strtab_size = string_sec->sh_size;
047b2264
JJ		 14950
14951 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
74e1a04b 14952 printable_section_name (section),
0af1713e 14953 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 14954
2b692964 14955 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 14956
14957 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14958 ++cnt)
14959 {
14960 Elf32_Lib liblist;
91d6fa6a 14961 time_t atime;
047b2264 14962 char timebuf[20];
2cf0635d 14963 struct tm * tmp;
047b2264
JJ		 14964
14965 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14966 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 14967 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14968 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14969 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14970
91d6fa6a 14971 tmp = gmtime (&atime);
e9e44622
JJ		 14972 snprintf (timebuf, sizeof (timebuf),
14973 "%04u-%02u-%02uT%02u:%02u:%02u",
14974 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14975 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 14976
14977 printf ("%3lu: ", (unsigned long) cnt);
14978 if (do_wide)
c256ffe7 14979 printf ("%-20s", liblist.l_name < strtab_size
2b692964 14980 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 14981 else
c256ffe7 14982 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 14983 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 14984 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14985 liblist.l_version, liblist.l_flags);
14986 }
14987
14988 free (elib);
2842702f 14989 free (strtab);
047b2264
JJ		 14990 }
14991 }
14992
14993 return 1;
14994}
14995
9437c45b 14996static const char *
d3ba0551 14997get_note_type (unsigned e_type)
779fe533
NC		 14998{
14999 static char buff[64];
103f02d3 15000
1ec5cd37
NC		 15001 if (elf_header.e_type == ET_CORE)
15002 switch (e_type)
15003 {
57346661 15004 case NT_AUXV:
1ec5cd37 15005 return _("NT_AUXV (auxiliary vector)");
57346661 15006 case NT_PRSTATUS:
1ec5cd37 15007 return _("NT_PRSTATUS (prstatus structure)");
57346661 15008 case NT_FPREGSET:
1ec5cd37 15009 return _("NT_FPREGSET (floating point registers)");
57346661 15010 case NT_PRPSINFO:
1ec5cd37 15011 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 15012 case NT_TASKSTRUCT:
1ec5cd37 15013 return _("NT_TASKSTRUCT (task structure)");
57346661 15014 case NT_PRXFPREG:
1ec5cd37 15015 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 15016 case NT_PPC_VMX:
15017 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 15018 case NT_PPC_VSX:
15019 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 15020 case NT_386_TLS:
15021 return _("NT_386_TLS (x86 TLS information)");
15022 case NT_386_IOPERM:
15023 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 15024 case NT_X86_XSTATE:
15025 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 15026 case NT_S390_HIGH_GPRS:
15027 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 15028 case NT_S390_TIMER:
15029 return _("NT_S390_TIMER (s390 timer register)");
15030 case NT_S390_TODCMP:
15031 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15032 case NT_S390_TODPREG:
15033 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15034 case NT_S390_CTRS:
15035 return _("NT_S390_CTRS (s390 control registers)");
15036 case NT_S390_PREFIX:
15037 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 15038 case NT_S390_LAST_BREAK:
15039 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15040 case NT_S390_SYSTEM_CALL:
15041 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 15042 case NT_S390_TDB:
15043 return _("NT_S390_TDB (s390 transaction diagnostic block)");
4ef9f41a
AA		 15044 case NT_S390_VXRS_LOW:
15045 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15046 case NT_S390_VXRS_HIGH:
15047 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
faa9a424
UW		 15048 case NT_ARM_VFP:
15049 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 15050 case NT_ARM_TLS:
15051 return _("NT_ARM_TLS (AArch TLS registers)");
15052 case NT_ARM_HW_BREAK:
15053 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15054 case NT_ARM_HW_WATCH:
15055 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 15056 case NT_PSTATUS:
1ec5cd37 15057 return _("NT_PSTATUS (pstatus structure)");
57346661 15058 case NT_FPREGS:
1ec5cd37 15059 return _("NT_FPREGS (floating point registers)");
57346661 15060 case NT_PSINFO:
1ec5cd37 15061 return _("NT_PSINFO (psinfo structure)");
57346661 15062 case NT_LWPSTATUS:
1ec5cd37 15063 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 15064 case NT_LWPSINFO:
1ec5cd37 15065 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 15066 case NT_WIN32PSTATUS:
1ec5cd37 15067 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 15068 case NT_SIGINFO:
15069 return _("NT_SIGINFO (siginfo_t data)");
15070 case NT_FILE:
15071 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 15072 default:
15073 break;
15074 }
15075 else
15076 switch (e_type)
15077 {
15078 case NT_VERSION:
15079 return _("NT_VERSION (version)");
15080 case NT_ARCH:
15081 return _("NT_ARCH (architecture)");
15082 default:
15083 break;
15084 }
15085
e9e44622 15086 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 15087 return buff;
779fe533
NC		 15088}
15089
9ece1fa9
TT		 15090static int
15091print_core_note (Elf_Internal_Note *pnote)
15092{
15093 unsigned int addr_size = is_32bit_elf ? 4 : 8;
15094 bfd_vma count, page_size;
15095 unsigned char *descdata, *filenames, *descend;
15096
15097 if (pnote->type != NT_FILE)
15098 return 1;
15099
15100#ifndef BFD64
15101 if (!is_32bit_elf)
15102 {
15103 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15104 /* Still "successful". */
15105 return 1;
15106 }
15107#endif
15108
15109 if (pnote->descsz < 2 * addr_size)
15110 {
15111 printf (_(" Malformed note - too short for header\n"));
15112 return 0;
15113 }
15114
15115 descdata = (unsigned char *) pnote->descdata;
15116 descend = descdata + pnote->descsz;
15117
15118 if (descdata[pnote->descsz - 1] != '\0')
15119 {
15120 printf (_(" Malformed note - does not end with \\0\n"));
15121 return 0;
15122 }
15123
15124 count = byte_get (descdata, addr_size);
15125 descdata += addr_size;
15126
15127 page_size = byte_get (descdata, addr_size);
15128 descdata += addr_size;
15129
15130 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
15131 {
15132 printf (_(" Malformed note - too short for supplied file count\n"));
15133 return 0;
15134 }
15135
15136 printf (_(" Page size: "));
15137 print_vma (page_size, DEC);
15138 printf ("\n");
15139
15140 printf (_(" %*s%*s%*s\n"),
15141 (int) (2 + 2 * addr_size), _("Start"),
15142 (int) (4 + 2 * addr_size), _("End"),
15143 (int) (4 + 2 * addr_size), _("Page Offset"));
15144 filenames = descdata + count * 3 * addr_size;
595712bb 15145 while (count-- > 0)
9ece1fa9
TT		 15146 {
15147 bfd_vma start, end, file_ofs;
15148
15149 if (filenames == descend)
15150 {
15151 printf (_(" Malformed note - filenames end too early\n"));
15152 return 0;
15153 }
15154
15155 start = byte_get (descdata, addr_size);
15156 descdata += addr_size;
15157 end = byte_get (descdata, addr_size);
15158 descdata += addr_size;
15159 file_ofs = byte_get (descdata, addr_size);
15160 descdata += addr_size;
15161
15162 printf (" ");
15163 print_vma (start, FULL_HEX);
15164 printf (" ");
15165 print_vma (end, FULL_HEX);
15166 printf (" ");
15167 print_vma (file_ofs, FULL_HEX);
15168 printf ("\n %s\n", filenames);
15169
15170 filenames += 1 + strlen ((char *) filenames);
15171 }
15172
15173 return 1;
15174}
15175
1118d252
RM		 15176static const char *
15177get_gnu_elf_note_type (unsigned e_type)
15178{
15179 static char buff[64];
15180
15181 switch (e_type)
15182 {
15183 case NT_GNU_ABI_TAG:
15184 return _("NT_GNU_ABI_TAG (ABI version tag)");
15185 case NT_GNU_HWCAP:
15186 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15187 case NT_GNU_BUILD_ID:
15188 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 15189 case NT_GNU_GOLD_VERSION:
15190 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 15191 default:
15192 break;
15193 }
15194
15195 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15196 return buff;
15197}
15198
664f90a3
TT		 15199static int
15200print_gnu_note (Elf_Internal_Note *pnote)
15201{
15202 switch (pnote->type)
15203 {
15204 case NT_GNU_BUILD_ID:
15205 {
15206 unsigned long i;
15207
15208 printf (_(" Build ID: "));
15209 for (i = 0; i < pnote->descsz; ++i)
15210 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 15211 printf ("\n");
664f90a3
TT		 15212 }
15213 break;
15214
15215 case NT_GNU_ABI_TAG:
15216 {
15217 unsigned long os, major, minor, subminor;
15218 const char *osname;
15219
3102e897
NC		 15220 /* PR 17531: file: 030-599401-0.004. */
15221 if (pnote->descsz < 16)
15222 {
15223 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15224 break;
15225 }
15226
664f90a3
TT		 15227 os = byte_get ((unsigned char *) pnote->descdata, 4);
15228 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15229 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
15230 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
15231
15232 switch (os)
15233 {
15234 case GNU_ABI_TAG_LINUX:
15235 osname = "Linux";
15236 break;
15237 case GNU_ABI_TAG_HURD:
15238 osname = "Hurd";
15239 break;
15240 case GNU_ABI_TAG_SOLARIS:
15241 osname = "Solaris";
15242 break;
15243 case GNU_ABI_TAG_FREEBSD:
15244 osname = "FreeBSD";
15245 break;
15246 case GNU_ABI_TAG_NETBSD:
15247 osname = "NetBSD";
15248 break;
14ae95f2
RM		 15249 case GNU_ABI_TAG_SYLLABLE:
15250 osname = "Syllable";
15251 break;
15252 case GNU_ABI_TAG_NACL:
15253 osname = "NaCl";
15254 break;
664f90a3
TT		 15255 default:
15256 osname = "Unknown";
15257 break;
15258 }
15259
15260 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
15261 major, minor, subminor);
15262 }
15263 break;
926c5385
CC		 15264
15265 case NT_GNU_GOLD_VERSION:
15266 {
15267 unsigned long i;
15268
15269 printf (_(" Version: "));
15270 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
15271 printf ("%c", pnote->descdata[i]);
15272 printf ("\n");
15273 }
15274 break;
664f90a3
TT		 15275 }
15276
15277 return 1;
15278}
15279
685080f2
NC		 15280static const char *
15281get_v850_elf_note_type (enum v850_notes n_type)
15282{
15283 static char buff[64];
15284
15285 switch (n_type)
15286 {
15287 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
15288 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
15289 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
15290 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
15291 case V850_NOTE_CACHE_INFO: return _("Use of cache");
15292 case V850_NOTE_MMU_INFO: return _("Use of MMU");
15293 default:
15294 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
15295 return buff;
15296 }
15297}
15298
15299static int
15300print_v850_note (Elf_Internal_Note * pnote)
15301{
15302 unsigned int val;
15303
15304 if (pnote->descsz != 4)
15305 return 0;
15306 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
15307
15308 if (val == 0)
15309 {
15310 printf (_("not set\n"));
15311 return 1;
15312 }
15313
15314 switch (pnote->type)
15315 {
15316 case V850_NOTE_ALIGNMENT:
15317 switch (val)
15318 {
15319 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
15320 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
15321 }
15322 break;
14ae95f2 15323
685080f2
NC		 15324 case V850_NOTE_DATA_SIZE:
15325 switch (val)
15326 {
15327 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
15328 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
15329 }
15330 break;
14ae95f2 15331
685080f2
NC		 15332 case V850_NOTE_FPU_INFO:
15333 switch (val)
15334 {
15335 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
15336 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
15337 }
15338 break;
14ae95f2 15339
685080f2
NC		 15340 case V850_NOTE_MMU_INFO:
15341 case V850_NOTE_CACHE_INFO:
15342 case V850_NOTE_SIMD_INFO:
15343 if (val == EF_RH850_SIMD)
15344 {
15345 printf (_("yes\n"));
15346 return 1;
15347 }
15348 break;
15349
15350 default:
15351 /* An 'unknown note type' message will already have been displayed. */
15352 break;
15353 }
15354
15355 printf (_("unknown value: %x\n"), val);
15356 return 0;
15357}
15358
c6056a74
SF		 15359static int
15360process_netbsd_elf_note (Elf_Internal_Note * pnote)
15361{
15362 unsigned int version;
15363
15364 switch (pnote->type)
15365 {
15366 case NT_NETBSD_IDENT:
15367 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
15368 if ((version / 10000) % 100)
15369 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
15370 version, version / 100000000, (version / 1000000) % 100,
15371 (version / 10000) % 100 > 26 ? "Z" : "",
15372 'A' + (version / 10000) % 26);
15373 else
15374 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
15375 version, version / 100000000, (version / 1000000) % 100,
15376 (version / 100) % 100);
15377 return 1;
15378
15379 case NT_NETBSD_MARCH:
15380 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
15381 pnote->descdata);
15382 return 1;
15383
15384 default:
15385 break;
15386 }
15387
15388 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
15389 pnote->type);
15390 return 1;
15391}
15392
9437c45b 15393static const char *
d3ba0551 15394get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 15395{
15396 static char buff[64];
15397
b4db1224 15398 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 15399 {
15400 /* NetBSD core "procinfo" structure. */
15401 return _("NetBSD procinfo structure");
15402 }
15403
15404 /* As of Jan 2002 there are no other machine-independent notes
15405 defined for NetBSD core files. If the note type is less
15406 than the start of the machine-dependent note types, we don't
15407 understand it. */
15408
b4db1224 15409 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 15410 {
e9e44622 15411 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 15412 return buff;
15413 }
15414
15415 switch (elf_header.e_machine)
15416 {
15417 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15418 and PT_GETFPREGS == mach+2. */
15419
15420 case EM_OLD_ALPHA:
15421 case EM_ALPHA:
15422 case EM_SPARC:
15423 case EM_SPARC32PLUS:
15424 case EM_SPARCV9:
15425 switch (e_type)
15426 {
2b692964 15427 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 15428 return _("PT_GETREGS (reg structure)");
2b692964 15429 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 15430 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15431 default:
15432 break;
15433 }
15434 break;
15435
15436 /* On all other arch's, PT_GETREGS == mach+1 and
15437 PT_GETFPREGS == mach+3. */
15438 default:
15439 switch (e_type)
15440 {
2b692964 15441 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 15442 return _("PT_GETREGS (reg structure)");
2b692964 15443 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 15444 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15445 default:
15446 break;
15447 }
15448 }
15449
9cf03b7e 15450 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 15451 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 15452 return buff;
15453}
15454
70616151
TT		 15455static const char *
15456get_stapsdt_note_type (unsigned e_type)
15457{
15458 static char buff[64];
15459
15460 switch (e_type)
15461 {
15462 case NT_STAPSDT:
15463 return _("NT_STAPSDT (SystemTap probe descriptors)");
15464
15465 default:
15466 break;
15467 }
15468
15469 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15470 return buff;
15471}
15472
c6a9fc58
TT		 15473static int
15474print_stapsdt_note (Elf_Internal_Note *pnote)
15475{
15476 int addr_size = is_32bit_elf ? 4 : 8;
15477 char *data = pnote->descdata;
15478 char *data_end = pnote->descdata + pnote->descsz;
15479 bfd_vma pc, base_addr, semaphore;
15480 char *provider, *probe, *arg_fmt;
15481
15482 pc = byte_get ((unsigned char *) data, addr_size);
15483 data += addr_size;
15484 base_addr = byte_get ((unsigned char *) data, addr_size);
15485 data += addr_size;
15486 semaphore = byte_get ((unsigned char *) data, addr_size);
15487 data += addr_size;
15488
15489 provider = data;
15490 data += strlen (data) + 1;
15491 probe = data;
15492 data += strlen (data) + 1;
15493 arg_fmt = data;
15494 data += strlen (data) + 1;
15495
15496 printf (_(" Provider: %s\n"), provider);
15497 printf (_(" Name: %s\n"), probe);
15498 printf (_(" Location: "));
15499 print_vma (pc, FULL_HEX);
15500 printf (_(", Base: "));
15501 print_vma (base_addr, FULL_HEX);
15502 printf (_(", Semaphore: "));
15503 print_vma (semaphore, FULL_HEX);
9cf03b7e 15504 printf ("\n");
c6a9fc58
TT		 15505 printf (_(" Arguments: %s\n"), arg_fmt);
15506
15507 return data == data_end;
15508}
15509
00e98fc7
TG		 15510static const char *
15511get_ia64_vms_note_type (unsigned e_type)
15512{
15513 static char buff[64];
15514
15515 switch (e_type)
15516 {
15517 case NT_VMS_MHD:
15518 return _("NT_VMS_MHD (module header)");
15519 case NT_VMS_LNM:
15520 return _("NT_VMS_LNM (language name)");
15521 case NT_VMS_SRC:
15522 return _("NT_VMS_SRC (source files)");
15523 case NT_VMS_TITLE:
9cf03b7e 15524 return "NT_VMS_TITLE";
00e98fc7
TG		 15525 case NT_VMS_EIDC:
15526 return _("NT_VMS_EIDC (consistency check)");
15527 case NT_VMS_FPMODE:
15528 return _("NT_VMS_FPMODE (FP mode)");
15529 case NT_VMS_LINKTIME:
9cf03b7e 15530 return "NT_VMS_LINKTIME";
00e98fc7
TG		 15531 case NT_VMS_IMGNAM:
15532 return _("NT_VMS_IMGNAM (image name)");
15533 case NT_VMS_IMGID:
15534 return _("NT_VMS_IMGID (image id)");
15535 case NT_VMS_LINKID:
15536 return _("NT_VMS_LINKID (link id)");
15537 case NT_VMS_IMGBID:
15538 return _("NT_VMS_IMGBID (build id)");
15539 case NT_VMS_GSTNAM:
15540 return _("NT_VMS_GSTNAM (sym table name)");
15541 case NT_VMS_ORIG_DYN:
9cf03b7e 15542 return "NT_VMS_ORIG_DYN";
00e98fc7 15543 case NT_VMS_PATCHTIME:
9cf03b7e 15544 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 15545 default:
15546 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15547 return buff;
15548 }
15549}
15550
15551static int
15552print_ia64_vms_note (Elf_Internal_Note * pnote)
15553{
15554 switch (pnote->type)
15555 {
15556 case NT_VMS_MHD:
15557 if (pnote->descsz > 36)
15558 {
15559 size_t l = strlen (pnote->descdata + 34);
15560 printf (_(" Creation date : %.17s\n"), pnote->descdata);
15561 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
15562 printf (_(" Module name : %s\n"), pnote->descdata + 34);
15563 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
15564 }
15565 else
15566 printf (_(" Invalid size\n"));
15567 break;
15568 case NT_VMS_LNM:
15569 printf (_(" Language: %s\n"), pnote->descdata);
15570 break;
15571#ifdef BFD64
15572 case NT_VMS_FPMODE:
9cf03b7e 15573 printf (_(" Floating Point mode: "));
4a5cb34f 15574 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15575 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
00e98fc7
TG		 15576 break;
15577 case NT_VMS_LINKTIME:
15578 printf (_(" Link time: "));
15579 print_vms_time
15580 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15581 printf ("\n");
15582 break;
15583 case NT_VMS_PATCHTIME:
15584 printf (_(" Patch time: "));
15585 print_vms_time
15586 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15587 printf ("\n");
15588 break;
15589 case NT_VMS_ORIG_DYN:
15590 printf (_(" Major id: %u, minor id: %u\n"),
15591 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15592 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 15593 printf (_(" Last modified : "));
00e98fc7
TG		 15594 print_vms_time
15595 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 15596 printf (_("\n Link flags : "));
4a5cb34f 15597 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15598 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
00e98fc7 15599 printf (_(" Header flags: 0x%08x\n"),
948f632f 15600 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
00e98fc7
TG		 15601 printf (_(" Image id : %s\n"), pnote->descdata + 32);
15602 break;
15603#endif
15604 case NT_VMS_IMGNAM:
15605 printf (_(" Image name: %s\n"), pnote->descdata);
15606 break;
15607 case NT_VMS_GSTNAM:
15608 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
15609 break;
15610 case NT_VMS_IMGID:
15611 printf (_(" Image id: %s\n"), pnote->descdata);
15612 break;
15613 case NT_VMS_LINKID:
15614 printf (_(" Linker id: %s\n"), pnote->descdata);
15615 break;
15616 default:
15617 break;
15618 }
15619 return 1;
15620}
15621
6d118b09
NC		 15622/* Note that by the ELF standard, the name field is already null byte
15623 terminated, and namesz includes the terminating null byte.
15624 I.E. the value of namesz for the name "FSF" is 4.
15625
e3c8793a 15626 If the value of namesz is zero, there is no name present. */
779fe533 15627static int
2cf0635d 15628process_note (Elf_Internal_Note * pnote)
779fe533 15629{
2cf0635d
NC		 15630 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15631 const char * nt;
9437c45b
JT		 15632
15633 if (pnote->namesz == 0)
1ec5cd37
NC		 15634 /* If there is no note name, then use the default set of
15635 note type strings. */
15636 nt = get_note_type (pnote->type);
15637
1118d252
RM		 15638 else if (const_strneq (pnote->namedata, "GNU"))
15639 /* GNU-specific object file notes. */
15640 nt = get_gnu_elf_note_type (pnote->type);
15641
0112cd26 15642 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 15643 /* NetBSD-specific core file notes. */
15644 nt = get_netbsd_elfcore_note_type (pnote->type);
15645
c6056a74
SF		 15646 else if (const_strneq (pnote->namedata, "NetBSD"))
15647 /* NetBSD-specific core file notes. */
15648 return process_netbsd_elf_note (pnote);
15649
b15fa79e
AM		 15650 else if (strneq (pnote->namedata, "SPU/", 4))
15651 {
15652 /* SPU-specific core file notes. */
15653 nt = pnote->namedata + 4;
15654 name = "SPU";
15655 }
15656
00e98fc7
TG		 15657 else if (const_strneq (pnote->namedata, "IPF/VMS"))
15658 /* VMS/ia64-specific file notes. */
15659 nt = get_ia64_vms_note_type (pnote->type);
15660
70616151
TT		 15661 else if (const_strneq (pnote->namedata, "stapsdt"))
15662 nt = get_stapsdt_note_type (pnote->type);
15663
9437c45b 15664 else
1ec5cd37
NC		 15665 /* Don't recognize this note name; just use the default set of
15666 note type strings. */
00e98fc7 15667 nt = get_note_type (pnote->type);
9437c45b 15668
2aee03ae 15669 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 15670
15671 if (const_strneq (pnote->namedata, "IPF/VMS"))
15672 return print_ia64_vms_note (pnote);
664f90a3
TT		 15673 else if (const_strneq (pnote->namedata, "GNU"))
15674 return print_gnu_note (pnote);
c6a9fc58
TT		 15675 else if (const_strneq (pnote->namedata, "stapsdt"))
15676 return print_stapsdt_note (pnote);
9ece1fa9
TT		 15677 else if (const_strneq (pnote->namedata, "CORE"))
15678 return print_core_note (pnote);
00e98fc7
TG		 15679 else
15680 return 1;
779fe533
NC		 15681}
15682
6d118b09 15683
779fe533 15684static int
2cf0635d 15685process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 15686{
2cf0635d
NC		 15687 Elf_External_Note * pnotes;
15688 Elf_External_Note * external;
c8071705 15689 char * end;
b34976b6 15690 int res = 1;
103f02d3 15691
779fe533
NC		 15692 if (length <= 0)
15693 return 0;
103f02d3 15694
3f5e193b 15695 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 15696 _("notes"));
dd24e3da 15697 if (pnotes == NULL)
a6e9f9df 15698 return 0;
779fe533 15699
103f02d3 15700 external = pnotes;
103f02d3 15701
9dd3a467 15702 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 15703 (unsigned long) offset, (unsigned long) length);
2aee03ae 15704 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 15705
c8071705
NC		 15706 end = (char *) pnotes + length;
15707 while ((char *) external < end)
779fe533 15708 {
b34976b6 15709 Elf_Internal_Note inote;
15b42fb0
AM		 15710 size_t min_notesz;
15711 char *next;
2cf0635d 15712 char * temp = NULL;
c8071705 15713 size_t data_remaining = end - (char *) external;
6d118b09 15714
00e98fc7 15715 if (!is_ia64_vms ())
15b42fb0 15716 {
9dd3a467
NC		 15717 /* PR binutils/15191
15718 Make sure that there is enough data to read. */
15b42fb0
AM		 15719 min_notesz = offsetof (Elf_External_Note, name);
15720 if (data_remaining < min_notesz)
9dd3a467
NC		 15721 {
15722 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15723 (int) data_remaining);
15724 break;
15725 }
15b42fb0
AM		 15726 inote.type = BYTE_GET (external->type);
15727 inote.namesz = BYTE_GET (external->namesz);
15728 inote.namedata = external->name;
15729 inote.descsz = BYTE_GET (external->descsz);
15730 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
834f871c 15731 /* PR 17531: file: 3443835e. */
c8071705 15732 if (inote.descdata < (char *) pnotes || inote.descdata > end)
834f871c
NC		 15733 {
15734 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15735 inote.descdata = inote.namedata;
15736 inote.namesz = 0;
15737 }
14ae95f2 15738
15b42fb0
AM		 15739 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15740 next = inote.descdata + align_power (inote.descsz, 2);
15741 }
00e98fc7 15742 else
15b42fb0
AM		 15743 {
15744 Elf64_External_VMS_Note *vms_external;
00e98fc7 15745
9dd3a467
NC		 15746 /* PR binutils/15191
15747 Make sure that there is enough data to read. */
15b42fb0
AM		 15748 min_notesz = offsetof (Elf64_External_VMS_Note, name);
15749 if (data_remaining < min_notesz)
9dd3a467
NC		 15750 {
15751 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15752 (int) data_remaining);
15753 break;
15754 }
3e55a963 15755
15b42fb0
AM		 15756 vms_external = (Elf64_External_VMS_Note *) external;
15757 inote.type = BYTE_GET (vms_external->type);
15758 inote.namesz = BYTE_GET (vms_external->namesz);
15759 inote.namedata = vms_external->name;
15760 inote.descsz = BYTE_GET (vms_external->descsz);
15761 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15762 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15763 next = inote.descdata + align_power (inote.descsz, 3);
15764 }
15765
15766 if (inote.descdata < (char *) external + min_notesz
15767 || next < (char *) external + min_notesz
5d921cbd
NC		 15768 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15769 || inote.namedata + inote.namesz < inote.namedata
15770 || inote.descdata + inote.descsz < inote.descdata
15b42fb0 15771 || data_remaining < (size_t)(next - (char *) external))
3e55a963 15772 {
15b42fb0 15773 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 15774 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 15775 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 15776 inote.type, inote.namesz, inote.descsz);
15777 break;
15778 }
15779
15b42fb0 15780 external = (Elf_External_Note *) next;
dd24e3da 15781
6d118b09
NC		 15782 /* Verify that name is null terminated. It appears that at least
15783 one version of Linux (RedHat 6.0) generates corefiles that don't
15784 comply with the ELF spec by failing to include the null byte in
15785 namesz. */
8b971f9f 15786 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 15787 {
3f5e193b 15788 temp = (char *) malloc (inote.namesz + 1);
6d118b09
NC		 15789 if (temp == NULL)
15790 {
8b73c356 15791 error (_("Out of memory allocating space for inote name\n"));
6d118b09
NC		 15792 res = 0;
15793 break;
15794 }
76da6bbe 15795
6d118b09
NC		 15796 strncpy (temp, inote.namedata, inote.namesz);
15797 temp[inote.namesz] = 0;
76da6bbe 15798
6d118b09
NC		 15799 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15800 inote.namedata = temp;
15801 }
15802
15803 res &= process_note (& inote);
103f02d3 15804
6d118b09
NC		 15805 if (temp != NULL)
15806 {
15807 free (temp);
15808 temp = NULL;
15809 }
779fe533
NC		 15810 }
15811
15812 free (pnotes);
103f02d3 15813
779fe533
NC		 15814 return res;
15815}
15816
15817static int
2cf0635d 15818process_corefile_note_segments (FILE * file)
779fe533 15819{
2cf0635d 15820 Elf_Internal_Phdr * segment;
b34976b6
AM		 15821 unsigned int i;
15822 int res = 1;
103f02d3 15823
d93f0186 15824 if (! get_program_headers (file))
779fe533 15825 return 0;
103f02d3 15826
779fe533
NC		 15827 for (i = 0, segment = program_headers;
15828 i < elf_header.e_phnum;
b34976b6 15829 i++, segment++)
779fe533
NC		 15830 {
15831 if (segment->p_type == PT_NOTE)
103f02d3 15832 res &= process_corefile_note_segment (file,
30800947
NC		 15833 (bfd_vma) segment->p_offset,
15834 (bfd_vma) segment->p_filesz);
779fe533 15835 }
103f02d3 15836
779fe533
NC		 15837 return res;
15838}
15839
685080f2
NC		 15840static int
15841process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
15842{
15843 Elf_External_Note * pnotes;
15844 Elf_External_Note * external;
c8071705 15845 char * end;
685080f2
NC		 15846 int res = 1;
15847
15848 if (length <= 0)
15849 return 0;
15850
15851 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15852 _("v850 notes"));
15853 if (pnotes == NULL)
15854 return 0;
15855
15856 external = pnotes;
c8071705 15857 end = (char*) pnotes + length;
685080f2
NC		 15858
15859 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15860 (unsigned long) offset, (unsigned long) length);
15861
c8071705 15862 while ((char *) external + sizeof (Elf_External_Note) < end)
685080f2
NC		 15863 {
15864 Elf_External_Note * next;
15865 Elf_Internal_Note inote;
15866
15867 inote.type = BYTE_GET (external->type);
15868 inote.namesz = BYTE_GET (external->namesz);
15869 inote.namedata = external->name;
15870 inote.descsz = BYTE_GET (external->descsz);
15871 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15872 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15873
c8071705
NC		 15874 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
15875 {
15876 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15877 inote.descdata = inote.namedata;
15878 inote.namesz = 0;
15879 }
15880
685080f2
NC		 15881 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
15882
c8071705 15883 if ( ((char *) next > end)
685080f2
NC		 15884 || ((char *) next < (char *) pnotes))
15885 {
15886 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15887 (unsigned long) ((char *) external - (char *) pnotes));
15888 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15889 inote.type, inote.namesz, inote.descsz);
15890 break;
15891 }
15892
15893 external = next;
15894
15895 /* Prevent out-of-bounds indexing. */
c8071705 15896 if ( inote.namedata + inote.namesz > end
685080f2
NC		 15897 || inote.namedata + inote.namesz < inote.namedata)
15898 {
15899 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15900 (unsigned long) ((char *) external - (char *) pnotes));
15901 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15902 inote.type, inote.namesz, inote.descsz);
15903 break;
15904 }
15905
15906 printf (" %s: ", get_v850_elf_note_type (inote.type));
15907
15908 if (! print_v850_note (& inote))
15909 {
15910 res = 0;
15911 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15912 inote.namesz, inote.descsz);
15913 }
15914 }
15915
15916 free (pnotes);
15917
15918 return res;
15919}
15920
779fe533 15921static int
2cf0635d 15922process_note_sections (FILE * file)
1ec5cd37 15923{
2cf0635d 15924 Elf_Internal_Shdr * section;
1ec5cd37 15925 unsigned long i;
df565f32 15926 int n = 0;
1ec5cd37
NC		 15927 int res = 1;
15928
15929 for (i = 0, section = section_headers;
fa1908fd 15930 i < elf_header.e_shnum && section != NULL;
1ec5cd37 15931 i++, section++)
685080f2
NC		 15932 {
15933 if (section->sh_type == SHT_NOTE)
15934 {
15935 res &= process_corefile_note_segment (file,
15936 (bfd_vma) section->sh_offset,
15937 (bfd_vma) section->sh_size);
15938 n++;
15939 }
15940
15941 if (( elf_header.e_machine == EM_V800
15942 || elf_header.e_machine == EM_V850
15943 || elf_header.e_machine == EM_CYGNUS_V850)
15944 && section->sh_type == SHT_RENESAS_INFO)
15945 {
15946 res &= process_v850_notes (file,
15947 (bfd_vma) section->sh_offset,
15948 (bfd_vma) section->sh_size);
15949 n++;
15950 }
15951 }
df565f32
NC		 15952
15953 if (n == 0)
15954 /* Try processing NOTE segments instead. */
15955 return process_corefile_note_segments (file);
1ec5cd37
NC		 15956
15957 return res;
15958}
15959
15960static int
2cf0635d 15961process_notes (FILE * file)
779fe533
NC		 15962{
15963 /* If we have not been asked to display the notes then do nothing. */
15964 if (! do_notes)
15965 return 1;
103f02d3 15966
779fe533 15967 if (elf_header.e_type != ET_CORE)
1ec5cd37 15968 return process_note_sections (file);
103f02d3 15969
779fe533 15970 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 15971 if (elf_header.e_phnum > 0)
15972 return process_corefile_note_segments (file);
779fe533 15973
1ec5cd37
NC		 15974 printf (_("No note segments present in the core file.\n"));
15975 return 1;
779fe533
NC		 15976}
15977
252b5132 15978static int
2cf0635d 15979process_arch_specific (FILE * file)
252b5132 15980{
a952a375
NC		 15981 if (! do_arch)
15982 return 1;
15983
252b5132
RH		 15984 switch (elf_header.e_machine)
15985 {
11c1ff18
PB		 15986 case EM_ARM:
15987 return process_arm_specific (file);
252b5132 15988 case EM_MIPS:
4fe85591 15989 case EM_MIPS_RS3_LE:
252b5132
RH		 15990 return process_mips_specific (file);
15991 break;
35c08157
KLC		 15992 case EM_NDS32:
15993 return process_nds32_specific (file);
15994 break;
34c8bcba
JM		 15995 case EM_PPC:
15996 return process_power_specific (file);
15997 break;
643f7afb
AK		 15998 case EM_S390:
15999 case EM_S390_OLD:
16000 return process_s390_specific (file);
16001 break;
9e8c70f9
DM		 16002 case EM_SPARC:
16003 case EM_SPARC32PLUS:
16004 case EM_SPARCV9:
16005 return process_sparc_specific (file);
16006 break;
59e6276b
JM		 16007 case EM_TI_C6000:
16008 return process_tic6x_specific (file);
16009 break;
13761a11
NC		 16010 case EM_MSP430:
16011 return process_msp430x_specific (file);
252b5132
RH		 16012 default:
16013 break;
16014 }
16015 return 1;
16016}
16017
16018static int
2cf0635d 16019get_file_header (FILE * file)
252b5132 16020{
9ea033b2
NC		 16021 /* Read in the identity array. */
16022 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 16023 return 0;
16024
9ea033b2 16025 /* Determine how to read the rest of the header. */
b34976b6 16026 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 16027 {
16028 default: /* fall through */
16029 case ELFDATANONE: /* fall through */
adab8cdc
AO		 16030 case ELFDATA2LSB:
16031 byte_get = byte_get_little_endian;
16032 byte_put = byte_put_little_endian;
16033 break;
16034 case ELFDATA2MSB:
16035 byte_get = byte_get_big_endian;
16036 byte_put = byte_put_big_endian;
16037 break;
9ea033b2
NC		 16038 }
16039
16040 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 16041 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 16042
16043 /* Read in the rest of the header. */
16044 if (is_32bit_elf)
16045 {
16046 Elf32_External_Ehdr ehdr32;
252b5132 16047
9ea033b2
NC		 16048 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
16049 return 0;
103f02d3 16050
9ea033b2
NC		 16051 elf_header.e_type = BYTE_GET (ehdr32.e_type);
16052 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
16053 elf_header.e_version = BYTE_GET (ehdr32.e_version);
16054 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
16055 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
16056 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
16057 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
16058 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
16059 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
16060 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
16061 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
16062 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
16063 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
16064 }
252b5132 16065 else
9ea033b2
NC		 16066 {
16067 Elf64_External_Ehdr ehdr64;
a952a375
NC		 16068
16069 /* If we have been compiled with sizeof (bfd_vma) == 4, then
16070 we will not be able to cope with the 64bit data found in
16071 64 ELF files. Detect this now and abort before we start
50c2245b 16072 overwriting things. */
a952a375
NC		 16073 if (sizeof (bfd_vma) < 8)
16074 {
e3c8793a
NC		 16075 error (_("This instance of readelf has been built without support for a\n\
1607664 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 16077 return 0;
16078 }
103f02d3 16079
9ea033b2
NC		 16080 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
16081 return 0;
103f02d3 16082
9ea033b2
NC		 16083 elf_header.e_type = BYTE_GET (ehdr64.e_type);
16084 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
16085 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 16086 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
16087 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
16088 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 16089 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
16090 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
16091 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
16092 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
16093 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
16094 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
16095 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
16096 }
252b5132 16097
7ece0d85
JJ		 16098 if (elf_header.e_shoff)
16099 {
16100 /* There may be some extensions in the first section header. Don't
16101 bomb if we can't read it. */
16102 if (is_32bit_elf)
049b0c3a 16103 get_32bit_section_headers (file, TRUE);
7ece0d85 16104 else
049b0c3a 16105 get_64bit_section_headers (file, TRUE);
7ece0d85 16106 }
560f3c1c 16107
252b5132
RH		 16108 return 1;
16109}
16110
fb52b2f4
NC		 16111/* Process one ELF object file according to the command line options.
16112 This file may actually be stored in an archive. The file is
16113 positioned at the start of the ELF object. */
16114
ff78d6d6 16115static int
2cf0635d 16116process_object (char * file_name, FILE * file)
252b5132 16117{
252b5132
RH		 16118 unsigned int i;
16119
252b5132
RH		 16120 if (! get_file_header (file))
16121 {
16122 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 16123 return 1;
252b5132
RH		 16124 }
16125
16126 /* Initialise per file variables. */
60bca95a 16127 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 16128 version_info[i] = 0;
16129
60bca95a 16130 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 16131 dynamic_info[i] = 0;
5115b233 16132 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 16133
16134 /* Process the file. */
16135 if (show_name)
16136 printf (_("\nFile: %s\n"), file_name);
16137
18bd398b
NC		 16138 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16139 Note we do this even if cmdline_dump_sects is empty because we
16140 must make sure that the dump_sets array is zeroed out before each
16141 object file is processed. */
16142 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 16143 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 16144
16145 if (num_cmdline_dump_sects > 0)
16146 {
16147 if (num_dump_sects == 0)
16148 /* A sneaky way of allocating the dump_sects array. */
09c11c86 16149 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 16150
16151 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 16152 memcpy (dump_sects, cmdline_dump_sects,
16153 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 16154 }
d70c5fc7 16155
252b5132 16156 if (! process_file_header ())
fb52b2f4 16157 return 1;
252b5132 16158
d1f5c6e3 16159 if (! process_section_headers (file))
2f62977e 16160 {
d1f5c6e3
L		 16161 /* Without loaded section headers we cannot process lots of
16162 things. */
2f62977e 16163 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 16164
2f62977e 16165 if (! do_using_dynamic)
2c610e4b 16166 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 16167 }
252b5132 16168
d1f5c6e3
L		 16169 if (! process_section_groups (file))
16170 {
16171 /* Without loaded section groups we cannot process unwind. */
16172 do_unwind = 0;
16173 }
16174
2f62977e 16175 if (process_program_headers (file))
b2d38a17 16176 process_dynamic_section (file);
252b5132
RH		 16177
16178 process_relocs (file);
16179
4d6ed7c8
NC		 16180 process_unwind (file);
16181
252b5132
RH		 16182 process_symbol_table (file);
16183
16184 process_syminfo (file);
16185
16186 process_version_sections (file);
16187
16188 process_section_contents (file);
f5842774 16189
1ec5cd37 16190 process_notes (file);
103f02d3 16191
047b2264
JJ		 16192 process_gnu_liblist (file);
16193
252b5132
RH		 16194 process_arch_specific (file);
16195
d93f0186
NC		 16196 if (program_headers)
16197 {
16198 free (program_headers);
16199 program_headers = NULL;
16200 }
16201
252b5132
RH		 16202 if (section_headers)
16203 {
16204 free (section_headers);
16205 section_headers = NULL;
16206 }
16207
16208 if (string_table)
16209 {
16210 free (string_table);
16211 string_table = NULL;
d40ac9bd 16212 string_table_length = 0;
252b5132
RH		 16213 }
16214
16215 if (dynamic_strings)
16216 {
16217 free (dynamic_strings);
16218 dynamic_strings = NULL;
d79b3d50 16219 dynamic_strings_length = 0;
252b5132
RH		 16220 }
16221
16222 if (dynamic_symbols)
16223 {
16224 free (dynamic_symbols);
16225 dynamic_symbols = NULL;
19936277 16226 num_dynamic_syms = 0;
252b5132
RH		 16227 }
16228
16229 if (dynamic_syminfo)
16230 {
16231 free (dynamic_syminfo);
16232 dynamic_syminfo = NULL;
16233 }
ff78d6d6 16234
293c573e
MR		 16235 if (dynamic_section)
16236 {
16237 free (dynamic_section);
16238 dynamic_section = NULL;
16239 }
16240
e4b17d5c
L		 16241 if (section_headers_groups)
16242 {
16243 free (section_headers_groups);
16244 section_headers_groups = NULL;
16245 }
16246
16247 if (section_groups)
16248 {
2cf0635d
NC		 16249 struct group_list * g;
16250 struct group_list * next;
e4b17d5c
L		 16251
16252 for (i = 0; i < group_count; i++)
16253 {
16254 for (g = section_groups [i].root; g != NULL; g = next)
16255 {
16256 next = g->next;
16257 free (g);
16258 }
16259 }
16260
16261 free (section_groups);
16262 section_groups = NULL;
16263 }
16264
19e6b90e 16265 free_debug_memory ();
18bd398b 16266
ff78d6d6 16267 return 0;
252b5132
RH		 16268}
16269
2cf0635d
NC		 16270/* Process an ELF archive.
16271 On entry the file is positioned just after the ARMAG string. */
16272
16273static int
16274process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
16275{
16276 struct archive_info arch;
16277 struct archive_info nested_arch;
16278 size_t got;
2cf0635d
NC		 16279 int ret;
16280
16281 show_name = 1;
16282
16283 /* The ARCH structure is used to hold information about this archive. */
16284 arch.file_name = NULL;
16285 arch.file = NULL;
16286 arch.index_array = NULL;
16287 arch.sym_table = NULL;
16288 arch.longnames = NULL;
16289
16290 /* The NESTED_ARCH structure is used as a single-item cache of information
16291 about a nested archive (when members of a thin archive reside within
16292 another regular archive file). */
16293 nested_arch.file_name = NULL;
16294 nested_arch.file = NULL;
16295 nested_arch.index_array = NULL;
16296 nested_arch.sym_table = NULL;
16297 nested_arch.longnames = NULL;
16298
16299 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
16300 {
16301 ret = 1;
16302 goto out;
4145f1d5 16303 }
fb52b2f4 16304
4145f1d5
NC		 16305 if (do_archive_index)
16306 {
2cf0635d 16307 if (arch.sym_table == NULL)
4145f1d5
NC		 16308 error (_("%s: unable to dump the index as none was found\n"), file_name);
16309 else
16310 {
591f7597 16311 unsigned long i, l;
4145f1d5
NC		 16312 unsigned long current_pos;
16313
591f7597
NC		 16314 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16315 file_name, (unsigned long) arch.index_num, arch.sym_size);
4145f1d5
NC		 16316 current_pos = ftell (file);
16317
2cf0635d 16318 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 16319 {
2cf0635d
NC		 16320 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
16321 {
16322 char * member_name;
4145f1d5 16323
2cf0635d
NC		 16324 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
16325
16326 if (member_name != NULL)
16327 {
16328 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
16329
16330 if (qualified_name != NULL)
16331 {
c2a7d3f5
NC		 16332 printf (_("Contents of binary %s at offset "), qualified_name);
16333 (void) print_vma (arch.index_array[i], PREFIX_HEX);
16334 putchar ('\n');
2cf0635d
NC		 16335 free (qualified_name);
16336 }
4145f1d5
NC		 16337 }
16338 }
2cf0635d
NC		 16339
16340 if (l >= arch.sym_size)
4145f1d5
NC		 16341 {
16342 error (_("%s: end of the symbol table reached before the end of the index\n"),
16343 file_name);
cb8f3167 16344 break;
4145f1d5 16345 }
591f7597
NC		 16346 /* PR 17531: file: 0b6630b2. */
16347 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
16348 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
4145f1d5
NC		 16349 }
16350
c2a7d3f5
NC		 16351 if (arch.uses_64bit_indicies)
16352 l = (l + 7) & ~ 7;
16353 else
16354 l += l & 1;
16355
2cf0635d 16356 if (l < arch.sym_size)
c2a7d3f5
NC		 16357 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16358 file_name, arch.sym_size - l);
4145f1d5 16359
4145f1d5
NC		 16360 if (fseek (file, current_pos, SEEK_SET) != 0)
16361 {
16362 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 16363 ret = 1;
16364 goto out;
4145f1d5 16365 }
fb52b2f4 16366 }
4145f1d5
NC		 16367
16368 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
16369 && !do_segments && !do_header && !do_dump && !do_version
16370 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 16371 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 16372 {
16373 ret = 0; /* Archive index only. */
16374 goto out;
16375 }
fb52b2f4
NC		 16376 }
16377
d989285c 16378 ret = 0;
fb52b2f4
NC		 16379
16380 while (1)
16381 {
2cf0635d
NC		 16382 char * name;
16383 size_t namelen;
16384 char * qualified_name;
16385
16386 /* Read the next archive header. */
16387 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
16388 {
16389 error (_("%s: failed to seek to next archive header\n"), file_name);
16390 return 1;
16391 }
16392 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
16393 if (got != sizeof arch.arhdr)
16394 {
16395 if (got == 0)
16396 break;
16397 error (_("%s: failed to read archive header\n"), file_name);
16398 ret = 1;
16399 break;
16400 }
16401 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
16402 {
16403 error (_("%s: did not find a valid archive header\n"), arch.file_name);
16404 ret = 1;
16405 break;
16406 }
16407
16408 arch.next_arhdr_offset += sizeof arch.arhdr;
16409
16410 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
16411 if (archive_file_size & 01)
16412 ++archive_file_size;
16413
16414 name = get_archive_member_name (&arch, &nested_arch);
16415 if (name == NULL)
fb52b2f4 16416 {
0fd3a477 16417 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16418 ret = 1;
16419 break;
fb52b2f4 16420 }
2cf0635d 16421 namelen = strlen (name);
fb52b2f4 16422
2cf0635d
NC		 16423 qualified_name = make_qualified_name (&arch, &nested_arch, name);
16424 if (qualified_name == NULL)
fb52b2f4 16425 {
2cf0635d 16426 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16427 ret = 1;
16428 break;
fb52b2f4
NC		 16429 }
16430
2cf0635d
NC		 16431 if (is_thin_archive && arch.nested_member_origin == 0)
16432 {
16433 /* This is a proxy for an external member of a thin archive. */
16434 FILE * member_file;
16435 char * member_file_name = adjust_relative_path (file_name, name, namelen);
16436 if (member_file_name == NULL)
16437 {
16438 ret = 1;
16439 break;
16440 }
16441
16442 member_file = fopen (member_file_name, "rb");
16443 if (member_file == NULL)
16444 {
16445 error (_("Input file '%s' is not readable.\n"), member_file_name);
16446 free (member_file_name);
16447 ret = 1;
16448 break;
16449 }
16450
16451 archive_file_offset = arch.nested_member_origin;
16452
16453 ret |= process_object (qualified_name, member_file);
16454
16455 fclose (member_file);
16456 free (member_file_name);
16457 }
16458 else if (is_thin_archive)
16459 {
a043396b
NC		 16460 /* PR 15140: Allow for corrupt thin archives. */
16461 if (nested_arch.file == NULL)
16462 {
16463 error (_("%s: contains corrupt thin archive: %s\n"),
16464 file_name, name);
16465 ret = 1;
16466 break;
16467 }
16468
2cf0635d
NC		 16469 /* This is a proxy for a member of a nested archive. */
16470 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
16471
16472 /* The nested archive file will have been opened and setup by
16473 get_archive_member_name. */
16474 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
16475 {
16476 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
16477 ret = 1;
16478 break;
16479 }
16480
16481 ret |= process_object (qualified_name, nested_arch.file);
16482 }
16483 else
16484 {
16485 archive_file_offset = arch.next_arhdr_offset;
16486 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 16487
2cf0635d
NC		 16488 ret |= process_object (qualified_name, file);
16489 }
fb52b2f4 16490
2b52916e
L		 16491 if (dump_sects != NULL)
16492 {
16493 free (dump_sects);
16494 dump_sects = NULL;
16495 num_dump_sects = 0;
16496 }
16497
2cf0635d 16498 free (qualified_name);
fb52b2f4
NC		 16499 }
16500
4145f1d5 16501 out:
2cf0635d
NC		 16502 if (nested_arch.file != NULL)
16503 fclose (nested_arch.file);
16504 release_archive (&nested_arch);
16505 release_archive (&arch);
fb52b2f4 16506
d989285c 16507 return ret;
fb52b2f4
NC		 16508}
16509
16510static int
2cf0635d 16511process_file (char * file_name)
fb52b2f4 16512{
2cf0635d 16513 FILE * file;
fb52b2f4
NC		 16514 struct stat statbuf;
16515 char armag[SARMAG];
16516 int ret;
16517
16518 if (stat (file_name, &statbuf) < 0)
16519 {
f24ddbdd
NC		 16520 if (errno == ENOENT)
16521 error (_("'%s': No such file\n"), file_name);
16522 else
16523 error (_("Could not locate '%s'. System error message: %s\n"),
16524 file_name, strerror (errno));
16525 return 1;
16526 }
16527
16528 if (! S_ISREG (statbuf.st_mode))
16529 {
16530 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 16531 return 1;
16532 }
16533
16534 file = fopen (file_name, "rb");
16535 if (file == NULL)
16536 {
f24ddbdd 16537 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 16538 return 1;
16539 }
16540
16541 if (fread (armag, SARMAG, 1, file) != 1)
16542 {
4145f1d5 16543 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 16544 fclose (file);
16545 return 1;
16546 }
16547
f54498b4
NC		 16548 current_file_size = (bfd_size_type) statbuf.st_size;
16549
fb52b2f4 16550 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 16551 ret = process_archive (file_name, file, FALSE);
16552 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16553 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 16554 else
16555 {
4145f1d5
NC		 16556 if (do_archive_index)
16557 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16558 file_name);
16559
fb52b2f4
NC		 16560 rewind (file);
16561 archive_file_size = archive_file_offset = 0;
16562 ret = process_object (file_name, file);
16563 }
16564
16565 fclose (file);
16566
f54498b4 16567 current_file_size = 0;
fb52b2f4
NC		 16568 return ret;
16569}
16570
252b5132
RH		 16571#ifdef SUPPORT_DISASSEMBLY
16572/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 16573 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 16574 symbols. */
252b5132
RH		 16575
16576void
2cf0635d 16577print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 16578{
16579 fprintf (outfile,"0x%8.8x", addr);
16580}
16581
e3c8793a 16582/* Needed by the i386 disassembler. */
252b5132
RH		 16583void
16584db_task_printsym (unsigned int addr)
16585{
16586 print_address (addr, stderr);
16587}
16588#endif
16589
16590int
2cf0635d 16591main (int argc, char ** argv)
252b5132 16592{
ff78d6d6
L		 16593 int err;
16594
252b5132
RH		 16595#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16596 setlocale (LC_MESSAGES, "");
3882b010
L		 16597#endif
16598#if defined (HAVE_SETLOCALE)
16599 setlocale (LC_CTYPE, "");
252b5132
RH		 16600#endif
16601 bindtextdomain (PACKAGE, LOCALEDIR);
16602 textdomain (PACKAGE);
16603
869b9d07
MM		 16604 expandargv (&argc, &argv);
16605
252b5132
RH		 16606 parse_args (argc, argv);
16607
18bd398b 16608 if (num_dump_sects > 0)
59f14fc0 16609 {
18bd398b 16610 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 16611 cmdline_dump_sects = (dump_type *)
16612 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 16613 if (cmdline_dump_sects == NULL)
591a748a 16614 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 16615 else
16616 {
09c11c86
NC		 16617 memcpy (cmdline_dump_sects, dump_sects,
16618 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 16619 num_cmdline_dump_sects = num_dump_sects;
16620 }
16621 }
16622
18bd398b
NC		 16623 if (optind < (argc - 1))
16624 show_name = 1;
5656ba2c
L		 16625 else if (optind >= argc)
16626 {
16627 warn (_("Nothing to do.\n"));
16628 usage (stderr);
16629 }
18bd398b 16630
ff78d6d6 16631 err = 0;
252b5132 16632 while (optind < argc)
18bd398b 16633 err |= process_file (argv[optind++]);
252b5132
RH		 16634
16635 if (dump_sects != NULL)
16636 free (dump_sects);
59f14fc0
AS		 16637 if (cmdline_dump_sects != NULL)
16638 free (cmdline_dump_sects);
252b5132 16639
ff78d6d6 16640 return err;
252b5132 16641}
GDB Binutils - Deliverables
This page took 2.433085 seconds and 4 git commands to generate.