]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - binutils/readelf.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Consolidate Thumb-1/Thumb-2 ISA detection
[thirdparty/binutils-gdb.git] / binutils / readelf.c
CommitLineData
252b5132 1/* readelf.c -- display contents of an ELF format file
b90efa5b 2 Copyright (C) 1998-2015 Free Software Foundation, Inc.
252b5132
RH		 3
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
12ab83a9 5 Modifications by Nick Clifton <nickc@redhat.com>
252b5132
RH		 6
7 This file is part of GNU Binutils.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
32866df7 11 the Free Software Foundation; either version 3 of the License, or
252b5132
RH		 12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
b43b5d5f
NC		 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 02110-1301, USA. */
252b5132 23\f
9eb20dd8 24/* The difference between readelf and objdump:
252b5132 25
74013231 26 Both programs are capable of displaying the contents of ELF format files,
9eb20dd8 27 so why does the binutils project have two file dumpers ?
0de14b54 28
9eb20dd8
NC		 29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
35
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
38
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
42\f
3db64b00 43#include "sysdep.h"
252b5132 44#include <assert.h>
252b5132 45#include <time.h>
1b315056 46#include <zlib.h>
3bfcb652 47#ifdef HAVE_WCHAR_H
7bfd842d 48#include <wchar.h>
3bfcb652 49#endif
252b5132 50
a952a375 51#if __GNUC__ >= 2
19936277 52/* Define BFD64 here, even if our default architecture is 32 bit ELF
a952a375 53 as this will allow us to read in and parse 64bit and 32bit ELF files.
b34976b6 54 Only do this if we believe that the compiler can support a 64 bit
a952a375 55 data type. For now we only rely on GCC being able to do this. */
19936277 56#define BFD64
a952a375
NC		 57#endif
58
3db64b00
AM		 59#include "bfd.h"
60#include "bucomm.h"
3284fe0c 61#include "elfcomm.h"
19e6b90e 62#include "dwarf.h"
252b5132
RH		 63
64#include "elf/common.h"
65#include "elf/external.h"
66#include "elf/internal.h"
252b5132 67
4b78141a
NC		 68
69/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
73
74#include "elf/h8.h"
75#undef _ELF_H8_H
76
77/* Undo the effects of #including reloc-macros.h. */
78
79#undef START_RELOC_NUMBERS
80#undef RELOC_NUMBER
81#undef FAKE_RELOC
82#undef EMPTY_RELOC
83#undef END_RELOC_NUMBERS
84#undef _RELOC_MACROS_H
85
252b5132
RH		 86/* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
89
90#define RELOC_MACROS_GEN_FUNC
91
a06ea964 92#include "elf/aarch64.h"
252b5132 93#include "elf/alpha.h"
3b16e843 94#include "elf/arc.h"
252b5132 95#include "elf/arm.h"
3b16e843 96#include "elf/avr.h"
1d65ded4 97#include "elf/bfin.h"
60bca95a 98#include "elf/cr16.h"
3b16e843 99#include "elf/cris.h"
1c0d3aa6 100#include "elf/crx.h"
252b5132
RH		 101#include "elf/d10v.h"
102#include "elf/d30v.h"
d172d4ba 103#include "elf/dlx.h"
cfb8c092 104#include "elf/epiphany.h"
252b5132 105#include "elf/fr30.h"
5c70f934 106#include "elf/frv.h"
3f8107ab 107#include "elf/ft32.h"
3b16e843
NC		 108#include "elf/h8.h"
109#include "elf/hppa.h"
110#include "elf/i386.h"
35b1837e 111#include "elf/i370.h"
3b16e843
NC		 112#include "elf/i860.h"
113#include "elf/i960.h"
114#include "elf/ia64.h"
1e4cf259 115#include "elf/ip2k.h"
84e94c90 116#include "elf/lm32.h"
1c0d3aa6 117#include "elf/iq2000.h"
49f58d10 118#include "elf/m32c.h"
3b16e843
NC		 119#include "elf/m32r.h"
120#include "elf/m68k.h"
75751cd9 121#include "elf/m68hc11.h"
252b5132 122#include "elf/mcore.h"
15ab5209 123#include "elf/mep.h"
a3c62988 124#include "elf/metag.h"
7ba29e2a 125#include "elf/microblaze.h"
3b16e843 126#include "elf/mips.h"
3c3bdf30 127#include "elf/mmix.h"
3b16e843
NC		 128#include "elf/mn10200.h"
129#include "elf/mn10300.h"
5506d11a 130#include "elf/moxie.h"
4970f871 131#include "elf/mt.h"
2469cfa2 132#include "elf/msp430.h"
35c08157 133#include "elf/nds32.h"
13761a11 134#include "elf/nios2.h"
73589c9d 135#include "elf/or1k.h"
7d466069 136#include "elf/pj.h"
3b16e843 137#include "elf/ppc.h"
c833c019 138#include "elf/ppc64.h"
99c513f6 139#include "elf/rl78.h"
c7927a3c 140#include "elf/rx.h"
a85d7ed0 141#include "elf/s390.h"
1c0d3aa6 142#include "elf/score.h"
3b16e843
NC		 143#include "elf/sh.h"
144#include "elf/sparc.h"
e9f53129 145#include "elf/spu.h"
40b36596 146#include "elf/tic6x.h"
aa137e4d
NC		 147#include "elf/tilegx.h"
148#include "elf/tilepro.h"
3b16e843 149#include "elf/v850.h"
179d3252 150#include "elf/vax.h"
619ed720 151#include "elf/visium.h"
3b16e843 152#include "elf/x86-64.h"
c29aca4a 153#include "elf/xc16x.h"
f6c1a2d5 154#include "elf/xgate.h"
93fbbb04 155#include "elf/xstormy16.h"
88da6820 156#include "elf/xtensa.h"
252b5132 157
252b5132 158#include "getopt.h"
566b0d53 159#include "libiberty.h"
09c11c86 160#include "safe-ctype.h"
2cf0635d 161#include "filenames.h"
252b5132 162
15b42fb0
AM		 163#ifndef offsetof
164#define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
165#endif
166
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. */
11407 case EM_MCORE:
11408 return reloc_type == 1; /* R_MCORE_ADDR32. */
11409 case EM_CYGNUS_MEP:
11410 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 11411 case EM_METAG:
11412 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 11413 case EM_MICROBLAZE:
11414 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 11415 case EM_MIPS:
11416 return reloc_type == 2; /* R_MIPS_32. */
11417 case EM_MMIX:
11418 return reloc_type == 4; /* R_MMIX_32. */
11419 case EM_CYGNUS_MN10200:
11420 case EM_MN10200:
11421 return reloc_type == 1; /* R_MN10200_32. */
11422 case EM_CYGNUS_MN10300:
11423 case EM_MN10300:
11424 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 11425 case EM_MOXIE:
11426 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 11427 case EM_MSP430_OLD:
11428 case EM_MSP430:
13761a11 11429 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 11430 case EM_MT:
11431 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 11432 case EM_NDS32:
11433 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 11434 case EM_ALTERA_NIOS2:
36591ba1 11435 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 11436 case EM_NIOS32:
11437 return reloc_type == 1; /* R_NIOS_32. */
73589c9d
CS		 11438 case EM_OR1K:
11439 return reloc_type == 1; /* R_OR1K_32. */
aca88567 11440 case EM_PARISC:
5fda8eca
NC		 11441 return (reloc_type == 1 /* R_PARISC_DIR32. */
11442 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 11443 case EM_PJ:
11444 case EM_PJ_OLD:
11445 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
11446 case EM_PPC64:
11447 return reloc_type == 1; /* R_PPC64_ADDR32. */
11448 case EM_PPC:
11449 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 11450 case EM_RL78:
11451 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 11452 case EM_RX:
11453 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 11454 case EM_S370:
11455 return reloc_type == 1; /* R_I370_ADDR31. */
11456 case EM_S390_OLD:
11457 case EM_S390:
11458 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 11459 case EM_SCORE:
11460 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 11461 case EM_SH:
11462 return reloc_type == 1; /* R_SH_DIR32. */
11463 case EM_SPARC32PLUS:
11464 case EM_SPARCV9:
11465 case EM_SPARC:
11466 return reloc_type == 3 /* R_SPARC_32. */
11467 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 11468 case EM_SPU:
11469 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 11470 case EM_TI_C6000:
11471 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 11472 case EM_TILEGX:
11473 return reloc_type == 2; /* R_TILEGX_32. */
11474 case EM_TILEPRO:
11475 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 11476 case EM_CYGNUS_V850:
11477 case EM_V850:
11478 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 11479 case EM_V800:
11480 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 11481 case EM_VAX:
11482 return reloc_type == 1; /* R_VAX_32. */
619ed720
EB		 11483 case EM_VISIUM:
11484 return reloc_type == 3; /* R_VISIUM_32. */
aca88567 11485 case EM_X86_64:
8a9036a4 11486 case EM_L1OM:
7a9068fe 11487 case EM_K1OM:
aca88567 11488 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 11489 case EM_XC16X:
11490 case EM_C166:
11491 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 11492 case EM_XGATE:
11493 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 11494 case EM_XSTORMY16:
11495 return reloc_type == 1; /* R_XSTROMY16_32. */
11496 case EM_XTENSA_OLD:
11497 case EM_XTENSA:
11498 return reloc_type == 1; /* R_XTENSA_32. */
aca88567 11499 default:
bee0ee85
NC		 11500 {
11501 static unsigned int prev_warn = 0;
11502
11503 /* Avoid repeating the same warning multiple times. */
11504 if (prev_warn != elf_header.e_machine)
11505 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11506 elf_header.e_machine);
11507 prev_warn = elf_header.e_machine;
11508 return FALSE;
11509 }
aca88567
NC		 11510 }
11511}
11512
11513/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11514 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11515
11516static bfd_boolean
11517is_32bit_pcrel_reloc (unsigned int reloc_type)
11518{
11519 switch (elf_header.e_machine)
11520 {
41e92641 11521 case EM_386:
22abe556 11522 case EM_IAMCU:
3e0873ac 11523 return reloc_type == 2; /* R_386_PC32. */
aca88567 11524 case EM_68K:
3e0873ac 11525 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 11526 case EM_AARCH64:
11527 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 11528 case EM_ADAPTEVA_EPIPHANY:
11529 return reloc_type == 6;
aca88567
NC		 11530 case EM_ALPHA:
11531 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 11532 case EM_ARM:
3e0873ac 11533 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 11534 case EM_MICROBLAZE:
11535 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
73589c9d
CS		 11536 case EM_OR1K:
11537 return reloc_type == 9; /* R_OR1K_32_PCREL. */
aca88567 11538 case EM_PARISC:
85acf597 11539 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 11540 case EM_PPC:
11541 return reloc_type == 26; /* R_PPC_REL32. */
11542 case EM_PPC64:
3e0873ac 11543 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 11544 case EM_S390_OLD:
11545 case EM_S390:
3e0873ac 11546 return reloc_type == 5; /* R_390_PC32. */
aca88567 11547 case EM_SH:
3e0873ac 11548 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 11549 case EM_SPARC32PLUS:
11550 case EM_SPARCV9:
11551 case EM_SPARC:
3e0873ac 11552 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 11553 case EM_SPU:
11554 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 11555 case EM_TILEGX:
11556 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
11557 case EM_TILEPRO:
11558 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
619ed720
EB		 11559 case EM_VISIUM:
11560 return reloc_type == 6; /* R_VISIUM_32_PCREL */
aca88567 11561 case EM_X86_64:
8a9036a4 11562 case EM_L1OM:
7a9068fe 11563 case EM_K1OM:
3e0873ac 11564 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 11565 case EM_XTENSA_OLD:
11566 case EM_XTENSA:
11567 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 11568 default:
11569 /* Do not abort or issue an error message here. Not all targets use
11570 pc-relative 32-bit relocs in their DWARF debug information and we
11571 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 11572 more helpful warning message will be generated by apply_relocations
11573 anyway, so just return. */
aca88567
NC		 11574 return FALSE;
11575 }
11576}
11577
11578/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11579 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11580
11581static bfd_boolean
11582is_64bit_abs_reloc (unsigned int reloc_type)
11583{
11584 switch (elf_header.e_machine)
11585 {
a06ea964
NC		 11586 case EM_AARCH64:
11587 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 11588 case EM_ALPHA:
11589 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 11590 case EM_IA_64:
11591 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 11592 case EM_PARISC:
11593 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 11594 case EM_PPC64:
11595 return reloc_type == 38; /* R_PPC64_ADDR64. */
11596 case EM_SPARC32PLUS:
11597 case EM_SPARCV9:
11598 case EM_SPARC:
11599 return reloc_type == 54; /* R_SPARC_UA64. */
11600 case EM_X86_64:
8a9036a4 11601 case EM_L1OM:
7a9068fe 11602 case EM_K1OM:
aca88567 11603 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 11604 case EM_S390_OLD:
11605 case EM_S390:
aa137e4d
NC		 11606 return reloc_type == 22; /* R_S390_64. */
11607 case EM_TILEGX:
11608 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 11609 case EM_MIPS:
aa137e4d 11610 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 11611 default:
11612 return FALSE;
11613 }
11614}
11615
85acf597
RH		 11616/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11617 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11618
11619static bfd_boolean
11620is_64bit_pcrel_reloc (unsigned int reloc_type)
11621{
11622 switch (elf_header.e_machine)
11623 {
a06ea964
NC		 11624 case EM_AARCH64:
11625 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 11626 case EM_ALPHA:
aa137e4d 11627 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 11628 case EM_IA_64:
aa137e4d 11629 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 11630 case EM_PARISC:
aa137e4d 11631 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 11632 case EM_PPC64:
aa137e4d 11633 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 11634 case EM_SPARC32PLUS:
11635 case EM_SPARCV9:
11636 case EM_SPARC:
aa137e4d 11637 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 11638 case EM_X86_64:
8a9036a4 11639 case EM_L1OM:
7a9068fe 11640 case EM_K1OM:
aa137e4d 11641 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 11642 case EM_S390_OLD:
11643 case EM_S390:
aa137e4d
NC		 11644 return reloc_type == 23; /* R_S390_PC64. */
11645 case EM_TILEGX:
11646 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 11647 default:
11648 return FALSE;
11649 }
11650}
11651
4dc3c23d
AM		 11652/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11653 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11654
11655static bfd_boolean
11656is_24bit_abs_reloc (unsigned int reloc_type)
11657{
11658 switch (elf_header.e_machine)
11659 {
11660 case EM_CYGNUS_MN10200:
11661 case EM_MN10200:
11662 return reloc_type == 4; /* R_MN10200_24. */
11663 default:
11664 return FALSE;
11665 }
11666}
11667
aca88567
NC		 11668/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11669 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11670
11671static bfd_boolean
11672is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 11673{
11674 switch (elf_header.e_machine)
11675 {
886a2506
NC		 11676 case EM_ARC:
11677 case EM_ARC_COMPACT:
11678 case EM_ARC_COMPACT2:
11679 return reloc_type == 2; /* R_ARC_16. */
aca88567
NC		 11680 case EM_AVR_OLD:
11681 case EM_AVR:
11682 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 11683 case EM_ADAPTEVA_EPIPHANY:
11684 return reloc_type == 5;
41e92641
NC		 11685 case EM_CYGNUS_D10V:
11686 case EM_D10V:
11687 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 11688 case EM_H8S:
11689 case EM_H8_300:
11690 case EM_H8_300H:
aca88567
NC		 11691 return reloc_type == R_H8_DIR16;
11692 case EM_IP2K_OLD:
11693 case EM_IP2K:
11694 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 11695 case EM_M32C_OLD:
f4236fe4
DD		 11696 case EM_M32C:
11697 return reloc_type == 1; /* R_M32C_16 */
aca88567 11698 case EM_MSP430:
13761a11
NC		 11699 if (uses_msp430x_relocs ())
11700 return reloc_type == 2; /* R_MSP430_ABS16. */
78c8d46c 11701 case EM_MSP430_OLD:
aca88567 11702 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 11703 case EM_NDS32:
11704 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 11705 case EM_ALTERA_NIOS2:
36591ba1 11706 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 11707 case EM_NIOS32:
11708 return reloc_type == 9; /* R_NIOS_16. */
73589c9d
CS		 11709 case EM_OR1K:
11710 return reloc_type == 2; /* R_OR1K_16. */
40b36596
JM		 11711 case EM_TI_C6000:
11712 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 11713 case EM_XC16X:
11714 case EM_C166:
11715 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 11716 case EM_CYGNUS_MN10200:
11717 case EM_MN10200:
11718 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 11719 case EM_CYGNUS_MN10300:
11720 case EM_MN10300:
11721 return reloc_type == 2; /* R_MN10300_16. */
619ed720
EB		 11722 case EM_VISIUM:
11723 return reloc_type == 2; /* R_VISIUM_16. */
f6c1a2d5
NC		 11724 case EM_XGATE:
11725 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 11726 default:
aca88567 11727 return FALSE;
4b78141a
NC		 11728 }
11729}
11730
2a7b2e88
JK		 11731/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11732 relocation entries (possibly formerly used for SHT_GROUP sections). */
11733
11734static bfd_boolean
11735is_none_reloc (unsigned int reloc_type)
11736{
11737 switch (elf_header.e_machine)
11738 {
cb8f3167
NC		 11739 case EM_68K: /* R_68K_NONE. */
11740 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 11741 case EM_SPARC32PLUS:
11742 case EM_SPARCV9:
cb8f3167
NC		 11743 case EM_SPARC: /* R_SPARC_NONE. */
11744 case EM_MIPS: /* R_MIPS_NONE. */
11745 case EM_PARISC: /* R_PARISC_NONE. */
11746 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 11747 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 11748 case EM_PPC: /* R_PPC_NONE. */
11749 case EM_PPC64: /* R_PPC64_NONE. */
886a2506
NC		 11750 case EM_ARC: /* R_ARC_NONE. */
11751 case EM_ARC_COMPACT: /* R_ARC_NONE. */
11752 case EM_ARC_COMPACT2: /* R_ARC_NONE. */
cb8f3167
NC		 11753 case EM_ARM: /* R_ARM_NONE. */
11754 case EM_IA_64: /* R_IA64_NONE. */
11755 case EM_SH: /* R_SH_NONE. */
2a7b2e88 11756 case EM_S390_OLD:
cb8f3167
NC		 11757 case EM_S390: /* R_390_NONE. */
11758 case EM_CRIS: /* R_CRIS_NONE. */
11759 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 11760 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 11761 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 11762 case EM_MN10300: /* R_MN10300_NONE. */
3f8107ab 11763 case EM_FT32: /* R_FT32_NONE. */
5506d11a 11764 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 11765 case EM_M32R: /* R_M32R_NONE. */
40b36596 11766 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 11767 case EM_TILEGX: /* R_TILEGX_NONE. */
11768 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 11769 case EM_XC16X:
11770 case EM_C166: /* R_XC16X_NONE. */
36591ba1
SL		 11771 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
11772 case EM_NIOS32: /* R_NIOS_NONE. */
73589c9d 11773 case EM_OR1K: /* R_OR1K_NONE. */
cb8f3167 11774 return reloc_type == 0;
a06ea964
NC		 11775 case EM_AARCH64:
11776 return reloc_type == 0 || reloc_type == 256;
35c08157
KLC		 11777 case EM_NDS32:
11778 return (reloc_type == 0 /* R_XTENSA_NONE. */
11779 || reloc_type == 204 /* R_NDS32_DIFF8. */
11780 || reloc_type == 205 /* R_NDS32_DIFF16. */
11781 || reloc_type == 206 /* R_NDS32_DIFF32. */
11782 || reloc_type == 207 /* R_NDS32_ULEB128. */);
58332dda
JK		 11783 case EM_XTENSA_OLD:
11784 case EM_XTENSA:
4dc3c23d
AM		 11785 return (reloc_type == 0 /* R_XTENSA_NONE. */
11786 || reloc_type == 17 /* R_XTENSA_DIFF8. */
11787 || reloc_type == 18 /* R_XTENSA_DIFF16. */
11788 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
a3c62988
NC		 11789 case EM_METAG:
11790 return reloc_type == 3; /* R_METAG_NONE. */
2a7b2e88
JK		 11791 }
11792 return FALSE;
11793}
11794
d1c4b12b
NC		 11795/* Returns TRUE if there is a relocation against
11796 section NAME at OFFSET bytes. */
11797
11798bfd_boolean
11799reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
11800{
11801 Elf_Internal_Rela * relocs;
11802 Elf_Internal_Rela * rp;
11803
11804 if (dsec == NULL || dsec->reloc_info == NULL)
11805 return FALSE;
11806
11807 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
11808
11809 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
11810 if (rp->r_offset == offset)
11811 return TRUE;
11812
11813 return FALSE;
11814}
11815
cf13d699
NC		 11816/* Apply relocations to a section.
11817 Note: So far support has been added only for those relocations
11818 which can be found in debug sections.
d1c4b12b
NC		 11819 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
11820 loaded relocs. It is then the caller's responsibility to free them.
cf13d699 11821 FIXME: Add support for more relocations ? */
1b315056 11822
cf13d699 11823static void
d1c4b12b
NC		 11824apply_relocations (void * file,
11825 const Elf_Internal_Shdr * section,
11826 unsigned char * start,
11827 bfd_size_type size,
11828 void ** relocs_return,
11829 unsigned long * num_relocs_return)
1b315056 11830{
cf13d699 11831 Elf_Internal_Shdr * relsec;
0d2a7a93 11832 unsigned char * end = start + size;
cb8f3167 11833
d1c4b12b
NC		 11834 if (relocs_return != NULL)
11835 {
11836 * (Elf_Internal_Rela **) relocs_return = NULL;
11837 * num_relocs_return = 0;
11838 }
11839
cf13d699
NC		 11840 if (elf_header.e_type != ET_REL)
11841 return;
1b315056 11842
cf13d699 11843 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 11844 for (relsec = section_headers;
11845 relsec < section_headers + elf_header.e_shnum;
11846 ++relsec)
252b5132 11847 {
41e92641
NC		 11848 bfd_boolean is_rela;
11849 unsigned long num_relocs;
2cf0635d
NC		 11850 Elf_Internal_Rela * relocs;
11851 Elf_Internal_Rela * rp;
11852 Elf_Internal_Shdr * symsec;
11853 Elf_Internal_Sym * symtab;
ba5cdace 11854 unsigned long num_syms;
2cf0635d 11855 Elf_Internal_Sym * sym;
252b5132 11856
41e92641 11857 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 11858 || relsec->sh_info >= elf_header.e_shnum
11859 || section_headers + relsec->sh_info != section
c256ffe7 11860 || relsec->sh_size == 0
4fbb74a6 11861 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 11862 continue;
428409d5 11863
41e92641
NC		 11864 is_rela = relsec->sh_type == SHT_RELA;
11865
11866 if (is_rela)
11867 {
3f5e193b
NC		 11868 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11869 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11870 return;
11871 }
11872 else
11873 {
3f5e193b
NC		 11874 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11875 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11876 return;
11877 }
11878
11879 /* SH uses RELA but uses in place value instead of the addend field. */
11880 if (elf_header.e_machine == EM_SH)
11881 is_rela = FALSE;
428409d5 11882
4fbb74a6 11883 symsec = section_headers + relsec->sh_link;
ba5cdace 11884 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 11885
41e92641 11886 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 11887 {
41e92641
NC		 11888 bfd_vma addend;
11889 unsigned int reloc_type;
11890 unsigned int reloc_size;
91d6fa6a 11891 unsigned char * rloc;
ba5cdace 11892 unsigned long sym_index;
4b78141a 11893
aca88567 11894 reloc_type = get_reloc_type (rp->r_info);
41e92641 11895
98fb390a 11896 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 11897 continue;
98fb390a
NC		 11898 else if (is_none_reloc (reloc_type))
11899 continue;
11900 else if (is_32bit_abs_reloc (reloc_type)
11901 || is_32bit_pcrel_reloc (reloc_type))
aca88567 11902 reloc_size = 4;
85acf597
RH		 11903 else if (is_64bit_abs_reloc (reloc_type)
11904 || is_64bit_pcrel_reloc (reloc_type))
aca88567 11905 reloc_size = 8;
4dc3c23d
AM		 11906 else if (is_24bit_abs_reloc (reloc_type))
11907 reloc_size = 3;
aca88567
NC		 11908 else if (is_16bit_abs_reloc (reloc_type))
11909 reloc_size = 2;
11910 else
4b78141a 11911 {
bee0ee85
NC		 11912 static unsigned int prev_reloc = 0;
11913 if (reloc_type != prev_reloc)
11914 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11915 reloc_type, printable_section_name (section));
11916 prev_reloc = reloc_type;
4b78141a
NC		 11917 continue;
11918 }
103f02d3 11919
91d6fa6a 11920 rloc = start + rp->r_offset;
c8da6823 11921 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 11922 {
11923 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11924 (unsigned long) rp->r_offset,
74e1a04b 11925 printable_section_name (section));
700dd8b7
L		 11926 continue;
11927 }
103f02d3 11928
ba5cdace
NC		 11929 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11930 if (sym_index >= num_syms)
11931 {
11932 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
74e1a04b 11933 sym_index, printable_section_name (section));
ba5cdace
NC		 11934 continue;
11935 }
11936 sym = symtab + sym_index;
41e92641
NC		 11937
11938 /* If the reloc has a symbol associated with it,
55f25fc3
L		 11939 make sure that it is of an appropriate type.
11940
11941 Relocations against symbols without type can happen.
11942 Gcc -feliminate-dwarf2-dups may generate symbols
11943 without type for debug info.
11944
11945 Icc generates relocations against function symbols
11946 instead of local labels.
11947
11948 Relocations against object symbols can happen, eg when
11949 referencing a global array. For an example of this see
11950 the _clz.o binary in libgcc.a. */
aca88567 11951 if (sym != symtab
55f25fc3 11952 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 11953 {
41e92641 11954 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 11955 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 11956 (long int)(rp - relocs),
74e1a04b 11957 printable_section_name (relsec));
aca88567 11958 continue;
5b18a4bc 11959 }
252b5132 11960
4dc3c23d
AM		 11961 addend = 0;
11962 if (is_rela)
11963 addend += rp->r_addend;
c47320c3
AM		 11964 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11965 partial_inplace. */
4dc3c23d
AM		 11966 if (!is_rela
11967 || (elf_header.e_machine == EM_XTENSA
11968 && reloc_type == 1)
11969 || ((elf_header.e_machine == EM_PJ
11970 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 11971 && reloc_type == 1)
11972 || ((elf_header.e_machine == EM_D30V
11973 || elf_header.e_machine == EM_CYGNUS_D30V)
11974 && reloc_type == 12))
91d6fa6a 11975 addend += byte_get (rloc, reloc_size);
cb8f3167 11976
85acf597
RH		 11977 if (is_32bit_pcrel_reloc (reloc_type)
11978 || is_64bit_pcrel_reloc (reloc_type))
11979 {
11980 /* On HPPA, all pc-relative relocations are biased by 8. */
11981 if (elf_header.e_machine == EM_PARISC)
11982 addend -= 8;
91d6fa6a 11983 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 11984 reloc_size);
11985 }
41e92641 11986 else
91d6fa6a 11987 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 11988 }
252b5132 11989
5b18a4bc 11990 free (symtab);
d1c4b12b
NC		 11991
11992 if (relocs_return)
11993 {
11994 * (Elf_Internal_Rela **) relocs_return = relocs;
11995 * num_relocs_return = num_relocs;
11996 }
11997 else
11998 free (relocs);
11999
5b18a4bc
NC		 12000 break;
12001 }
5b18a4bc 12002}
103f02d3 12003
cf13d699
NC		 12004#ifdef SUPPORT_DISASSEMBLY
12005static int
12006disassemble_section (Elf_Internal_Shdr * section, FILE * file)
12007{
74e1a04b 12008 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
cf13d699 12009
74e1a04b 12010 /* FIXME: XXX -- to be done --- XXX */
cf13d699
NC		 12011
12012 return 1;
12013}
12014#endif
12015
12016/* Reads in the contents of SECTION from FILE, returning a pointer
12017 to a malloc'ed buffer or NULL if something went wrong. */
12018
12019static char *
12020get_section_contents (Elf_Internal_Shdr * section, FILE * file)
12021{
12022 bfd_size_type num_bytes;
12023
12024 num_bytes = section->sh_size;
12025
12026 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
12027 {
12028 printf (_("\nSection '%s' has no data to dump.\n"),
74e1a04b 12029 printable_section_name (section));
cf13d699
NC		 12030 return NULL;
12031 }
12032
3f5e193b
NC		 12033 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
12034 _("section contents"));
cf13d699
NC		 12035}
12036
0e602686
NC		 12037/* Uncompresses a section that was compressed using zlib, in place. */
12038
12039static bfd_boolean
12040uncompress_section_contents (unsigned char **buffer,
12041 dwarf_size_type uncompressed_size,
12042 dwarf_size_type *size)
12043{
12044 dwarf_size_type compressed_size = *size;
12045 unsigned char * compressed_buffer = *buffer;
12046 unsigned char * uncompressed_buffer;
12047 z_stream strm;
12048 int rc;
12049
12050 /* It is possible the section consists of several compressed
12051 buffers concatenated together, so we uncompress in a loop. */
12052 /* PR 18313: The state field in the z_stream structure is supposed
12053 to be invisible to the user (ie us), but some compilers will
12054 still complain about it being used without initialisation. So
12055 we first zero the entire z_stream structure and then set the fields
12056 that we need. */
12057 memset (& strm, 0, sizeof strm);
12058 strm.avail_in = compressed_size;
12059 strm.next_in = (Bytef *) compressed_buffer;
12060 strm.avail_out = uncompressed_size;
12061 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12062
12063 rc = inflateInit (& strm);
12064 while (strm.avail_in > 0)
12065 {
12066 if (rc != Z_OK)
12067 goto fail;
12068 strm.next_out = ((Bytef *) uncompressed_buffer
12069 + (uncompressed_size - strm.avail_out));
12070 rc = inflate (&strm, Z_FINISH);
12071 if (rc != Z_STREAM_END)
12072 goto fail;
12073 rc = inflateReset (& strm);
12074 }
12075 rc = inflateEnd (& strm);
12076 if (rc != Z_OK
12077 || strm.avail_out != 0)
12078 goto fail;
12079
12080 *buffer = uncompressed_buffer;
12081 *size = uncompressed_size;
12082 return TRUE;
12083
12084 fail:
12085 free (uncompressed_buffer);
12086 /* Indicate decompression failure. */
12087 *buffer = NULL;
12088 return FALSE;
12089}
dd24e3da 12090
cf13d699
NC		 12091static void
12092dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12093{
0e602686
NC		 12094 Elf_Internal_Shdr * relsec;
12095 bfd_size_type num_bytes;
fd8008d8
L		 12096 unsigned char * data;
12097 unsigned char * end;
12098 unsigned char * real_start;
12099 unsigned char * start;
0e602686 12100 bfd_boolean some_strings_shown;
cf13d699 12101
fd8008d8
L		 12102 real_start = start = (unsigned char *) get_section_contents (section,
12103 file);
cf13d699
NC		 12104 if (start == NULL)
12105 return;
0e602686 12106 num_bytes = section->sh_size;
cf13d699 12107
74e1a04b 12108 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
cf13d699 12109
0e602686
NC		 12110 if (decompress_dumps)
12111 {
12112 dwarf_size_type new_size = num_bytes;
12113 dwarf_size_type uncompressed_size = 0;
12114
12115 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12116 {
12117 Elf_Internal_Chdr chdr;
12118 unsigned int compression_header_size
12119 = get_compression_header (& chdr, (unsigned char *) start);
12120
813dabb9 12121 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12122 {
813dabb9
L		 12123 warn (_("section '%s' has unsupported compress type: %d\n"),
12124 printable_section_name (section), chdr.ch_type);
12125 return;
12126 }
12127 else if (chdr.ch_addralign != section->sh_addralign)
12128 {
12129 warn (_("compressed section '%s' is corrupted\n"),
12130 printable_section_name (section));
12131 return;
0e602686 12132 }
813dabb9
L		 12133 uncompressed_size = chdr.ch_size;
12134 start += compression_header_size;
12135 new_size -= compression_header_size;
0e602686
NC		 12136 }
12137 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12138 {
12139 /* Read the zlib header. In this case, it should be "ZLIB"
12140 followed by the uncompressed section size, 8 bytes in
12141 big-endian order. */
12142 uncompressed_size = start[4]; uncompressed_size <<= 8;
12143 uncompressed_size += start[5]; uncompressed_size <<= 8;
12144 uncompressed_size += start[6]; uncompressed_size <<= 8;
12145 uncompressed_size += start[7]; uncompressed_size <<= 8;
12146 uncompressed_size += start[8]; uncompressed_size <<= 8;
12147 uncompressed_size += start[9]; uncompressed_size <<= 8;
12148 uncompressed_size += start[10]; uncompressed_size <<= 8;
12149 uncompressed_size += start[11];
12150 start += 12;
12151 new_size -= 12;
12152 }
12153
12154 if (uncompressed_size
fd8008d8 12155 && uncompress_section_contents (& start,
0e602686
NC		 12156 uncompressed_size, & new_size))
12157 num_bytes = new_size;
12158 }
fd8008d8 12159
cf13d699
NC		 12160 /* If the section being dumped has relocations against it the user might
12161 be expecting these relocations to have been applied. Check for this
12162 case and issue a warning message in order to avoid confusion.
12163 FIXME: Maybe we ought to have an option that dumps a section with
12164 relocs applied ? */
12165 for (relsec = section_headers;
12166 relsec < section_headers + elf_header.e_shnum;
12167 ++relsec)
12168 {
12169 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12170 || relsec->sh_info >= elf_header.e_shnum
12171 || section_headers + relsec->sh_info != section
12172 || relsec->sh_size == 0
12173 || relsec->sh_link >= elf_header.e_shnum)
12174 continue;
12175
12176 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12177 break;
12178 }
12179
cf13d699
NC		 12180 data = start;
12181 end = start + num_bytes;
12182 some_strings_shown = FALSE;
12183
12184 while (data < end)
12185 {
12186 while (!ISPRINT (* data))
12187 if (++ data >= end)
12188 break;
12189
12190 if (data < end)
12191 {
071436c6
NC		 12192 size_t maxlen = end - data;
12193
cf13d699 12194#ifndef __MSVCRT__
c975cc98
NC		 12195 /* PR 11128: Use two separate invocations in order to work
12196 around bugs in the Solaris 8 implementation of printf. */
12197 printf (" [%6tx] ", data - start);
cf13d699 12198#else
071436c6 12199 printf (" [%6Ix] ", (size_t) (data - start));
cf13d699 12200#endif
4082ef84
NC		 12201 if (maxlen > 0)
12202 {
fd8008d8 12203 print_symbol ((int) maxlen, (const char *) data);
4082ef84 12204 putchar ('\n');
fd8008d8 12205 data += strnlen ((const char *) data, maxlen);
4082ef84
NC		 12206 }
12207 else
12208 {
12209 printf (_("<corrupt>\n"));
12210 data = end;
12211 }
cf13d699
NC		 12212 some_strings_shown = TRUE;
12213 }
12214 }
12215
12216 if (! some_strings_shown)
12217 printf (_(" No strings found in this section."));
12218
0e602686 12219 free (real_start);
cf13d699
NC		 12220
12221 putchar ('\n');
12222}
12223
12224static void
12225dump_section_as_bytes (Elf_Internal_Shdr * section,
12226 FILE * file,
12227 bfd_boolean relocate)
12228{
12229 Elf_Internal_Shdr * relsec;
0e602686
NC		 12230 bfd_size_type bytes;
12231 bfd_size_type section_size;
12232 bfd_vma addr;
12233 unsigned char * data;
12234 unsigned char * real_start;
12235 unsigned char * start;
12236
12237 real_start = start = (unsigned char *) get_section_contents (section, file);
cf13d699
NC		 12238 if (start == NULL)
12239 return;
0e602686 12240 section_size = section->sh_size;
cf13d699 12241
74e1a04b 12242 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
cf13d699 12243
0e602686
NC		 12244 if (decompress_dumps)
12245 {
12246 dwarf_size_type new_size = section_size;
12247 dwarf_size_type uncompressed_size = 0;
12248
12249 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12250 {
12251 Elf_Internal_Chdr chdr;
12252 unsigned int compression_header_size
12253 = get_compression_header (& chdr, start);
12254
813dabb9 12255 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12256 {
813dabb9
L		 12257 warn (_("section '%s' has unsupported compress type: %d\n"),
12258 printable_section_name (section), chdr.ch_type);
12259 return;
0e602686 12260 }
813dabb9
L		 12261 else if (chdr.ch_addralign != section->sh_addralign)
12262 {
12263 warn (_("compressed section '%s' is corrupted\n"),
12264 printable_section_name (section));
12265 return;
12266 }
12267 uncompressed_size = chdr.ch_size;
12268 start += compression_header_size;
12269 new_size -= compression_header_size;
0e602686
NC		 12270 }
12271 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12272 {
12273 /* Read the zlib header. In this case, it should be "ZLIB"
12274 followed by the uncompressed section size, 8 bytes in
12275 big-endian order. */
12276 uncompressed_size = start[4]; uncompressed_size <<= 8;
12277 uncompressed_size += start[5]; uncompressed_size <<= 8;
12278 uncompressed_size += start[6]; uncompressed_size <<= 8;
12279 uncompressed_size += start[7]; uncompressed_size <<= 8;
12280 uncompressed_size += start[8]; uncompressed_size <<= 8;
12281 uncompressed_size += start[9]; uncompressed_size <<= 8;
12282 uncompressed_size += start[10]; uncompressed_size <<= 8;
12283 uncompressed_size += start[11];
12284 start += 12;
12285 new_size -= 12;
12286 }
12287
12288 if (uncompressed_size
12289 && uncompress_section_contents (& start, uncompressed_size,
12290 & new_size))
12291 section_size = new_size;
12292 }
14ae95f2 12293
cf13d699
NC		 12294 if (relocate)
12295 {
0e602686 12296 apply_relocations (file, section, start, section_size, NULL, NULL);
cf13d699
NC		 12297 }
12298 else
12299 {
12300 /* If the section being dumped has relocations against it the user might
12301 be expecting these relocations to have been applied. Check for this
12302 case and issue a warning message in order to avoid confusion.
12303 FIXME: Maybe we ought to have an option that dumps a section with
12304 relocs applied ? */
12305 for (relsec = section_headers;
12306 relsec < section_headers + elf_header.e_shnum;
12307 ++relsec)
12308 {
12309 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12310 || relsec->sh_info >= elf_header.e_shnum
12311 || section_headers + relsec->sh_info != section
12312 || relsec->sh_size == 0
12313 || relsec->sh_link >= elf_header.e_shnum)
12314 continue;
12315
12316 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12317 break;
12318 }
12319 }
12320
12321 addr = section->sh_addr;
0e602686 12322 bytes = section_size;
cf13d699
NC		 12323 data = start;
12324
12325 while (bytes)
12326 {
12327 int j;
12328 int k;
12329 int lbytes;
12330
12331 lbytes = (bytes > 16 ? 16 : bytes);
12332
12333 printf (" 0x%8.8lx ", (unsigned long) addr);
12334
12335 for (j = 0; j < 16; j++)
12336 {
12337 if (j < lbytes)
12338 printf ("%2.2x", data[j]);
12339 else
12340 printf (" ");
12341
12342 if ((j & 3) == 3)
12343 printf (" ");
12344 }
12345
12346 for (j = 0; j < lbytes; j++)
12347 {
12348 k = data[j];
12349 if (k >= ' ' && k < 0x7f)
12350 printf ("%c", k);
12351 else
12352 printf (".");
12353 }
12354
12355 putchar ('\n');
12356
12357 data += lbytes;
12358 addr += lbytes;
12359 bytes -= lbytes;
12360 }
12361
0e602686 12362 free (real_start);
cf13d699
NC		 12363
12364 putchar ('\n');
12365}
12366
d966045b
DJ		 12367static int
12368load_specific_debug_section (enum dwarf_section_display_enum debug,
0d2a7a93 12369 const Elf_Internal_Shdr * sec, void * file)
1007acb3 12370{
2cf0635d 12371 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 12372 char buf [64];
1007acb3 12373
19e6b90e
L		 12374 /* If it is already loaded, do nothing. */
12375 if (section->start != NULL)
12376 return 1;
1007acb3 12377
19e6b90e
L		 12378 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12379 section->address = sec->sh_addr;
06614111 12380 section->user_data = NULL;
3f5e193b
NC		 12381 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12382 sec->sh_offset, 1,
12383 sec->sh_size, buf);
59245841
NC		 12384 if (section->start == NULL)
12385 section->size = 0;
12386 else
12387 {
77115a4a
L		 12388 unsigned char *start = section->start;
12389 dwarf_size_type size = sec->sh_size;
dab394de 12390 dwarf_size_type uncompressed_size = 0;
77115a4a
L		 12391
12392 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12393 {
12394 Elf_Internal_Chdr chdr;
12395 unsigned int compression_header_size
12396 = get_compression_header (&chdr, start);
813dabb9
L		 12397 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12398 {
12399 warn (_("section '%s' has unsupported compress type: %d\n"),
12400 section->name, chdr.ch_type);
12401 return 0;
12402 }
12403 else if (chdr.ch_addralign != sec->sh_addralign)
12404 {
12405 warn (_("compressed section '%s' is corrupted\n"),
12406 section->name);
12407 return 0;
12408 }
dab394de 12409 uncompressed_size = chdr.ch_size;
77115a4a
L		 12410 start += compression_header_size;
12411 size -= compression_header_size;
12412 }
dab394de
L		 12413 else if (size > 12 && streq ((char *) start, "ZLIB"))
12414 {
12415 /* Read the zlib header. In this case, it should be "ZLIB"
12416 followed by the uncompressed section size, 8 bytes in
12417 big-endian order. */
12418 uncompressed_size = start[4]; uncompressed_size <<= 8;
12419 uncompressed_size += start[5]; uncompressed_size <<= 8;
12420 uncompressed_size += start[6]; uncompressed_size <<= 8;
12421 uncompressed_size += start[7]; uncompressed_size <<= 8;
12422 uncompressed_size += start[8]; uncompressed_size <<= 8;
12423 uncompressed_size += start[9]; uncompressed_size <<= 8;
12424 uncompressed_size += start[10]; uncompressed_size <<= 8;
12425 uncompressed_size += start[11];
12426 start += 12;
12427 size -= 12;
12428 }
12429
12430 if (uncompressed_size
12431 && uncompress_section_contents (&start, uncompressed_size,
12432 &size))
77115a4a
L		 12433 {
12434 /* Free the compressed buffer, update the section buffer
12435 and the section size if uncompress is successful. */
12436 free (section->start);
12437 section->start = start;
77115a4a
L		 12438 }
12439 section->size = size;
59245841 12440 }
4a114e3e 12441
1b315056
CS		 12442 if (section->start == NULL)
12443 return 0;
12444
19e6b90e 12445 if (debug_displays [debug].relocate)
d1c4b12b
NC		 12446 apply_relocations ((FILE *) file, sec, section->start, section->size,
12447 & section->reloc_info, & section->num_relocs);
12448 else
12449 {
12450 section->reloc_info = NULL;
12451 section->num_relocs = 0;
12452 }
1007acb3 12453
1b315056 12454 return 1;
1007acb3
L		 12455}
12456
657d0d47
CC		 12457/* If this is not NULL, load_debug_section will only look for sections
12458 within the list of sections given here. */
12459unsigned int *section_subset = NULL;
12460
d966045b 12461int
2cf0635d 12462load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 12463{
2cf0635d
NC		 12464 struct dwarf_section * section = &debug_displays [debug].section;
12465 Elf_Internal_Shdr * sec;
d966045b
DJ		 12466
12467 /* Locate the debug section. */
657d0d47 12468 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 12469 if (sec != NULL)
12470 section->name = section->uncompressed_name;
12471 else
12472 {
657d0d47 12473 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 12474 if (sec != NULL)
12475 section->name = section->compressed_name;
12476 }
12477 if (sec == NULL)
12478 return 0;
12479
657d0d47
CC		 12480 /* If we're loading from a subset of sections, and we've loaded
12481 a section matching this name before, it's likely that it's a
12482 different one. */
12483 if (section_subset != NULL)
12484 free_debug_section (debug);
12485
3f5e193b 12486 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 12487}
12488
19e6b90e
L		 12489void
12490free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 12491{
2cf0635d 12492 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 12493
19e6b90e
L		 12494 if (section->start == NULL)
12495 return;
1007acb3 12496
19e6b90e
L		 12497 free ((char *) section->start);
12498 section->start = NULL;
12499 section->address = 0;
12500 section->size = 0;
1007acb3
L		 12501}
12502
1007acb3 12503static int
657d0d47 12504display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 12505{
2cf0635d 12506 char * name = SECTION_NAME (section);
74e1a04b 12507 const char * print_name = printable_section_name (section);
19e6b90e
L		 12508 bfd_size_type length;
12509 int result = 1;
3f5e193b 12510 int i;
1007acb3 12511
19e6b90e
L		 12512 length = section->sh_size;
12513 if (length == 0)
1007acb3 12514 {
74e1a04b 12515 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
19e6b90e 12516 return 0;
1007acb3 12517 }
5dff79d8
NC		 12518 if (section->sh_type == SHT_NOBITS)
12519 {
12520 /* There is no point in dumping the contents of a debugging section
12521 which has the NOBITS type - the bits in the file will be random.
12522 This can happen when a file containing a .eh_frame section is
12523 stripped with the --only-keep-debug command line option. */
74e1a04b
NC		 12524 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12525 print_name);
5dff79d8
NC		 12526 return 0;
12527 }
1007acb3 12528
0112cd26 12529 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 12530 name = ".debug_info";
1007acb3 12531
19e6b90e
L		 12532 /* See if we know how to display the contents of this section. */
12533 for (i = 0; i < max; i++)
1b315056 12534 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 12535 || (i == line && const_strneq (name, ".debug_line."))
1b315056 12536 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 12537 {
2cf0635d 12538 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 12539 int secondary = (section != find_section (name));
12540
12541 if (secondary)
3f5e193b 12542 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 12543
b40bf0a2
NC		 12544 if (i == line && const_strneq (name, ".debug_line."))
12545 sec->name = name;
12546 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 12547 sec->name = sec->uncompressed_name;
12548 else
12549 sec->name = sec->compressed_name;
3f5e193b
NC		 12550 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12551 section, file))
19e6b90e 12552 {
657d0d47
CC		 12553 /* If this debug section is part of a CU/TU set in a .dwp file,
12554 restrict load_debug_section to the sections in that set. */
12555 section_subset = find_cu_tu_set (file, shndx);
12556
19e6b90e 12557 result &= debug_displays[i].display (sec, file);
1007acb3 12558
657d0d47
CC		 12559 section_subset = NULL;
12560
d966045b 12561 if (secondary || (i != info && i != abbrev))
3f5e193b 12562 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 12563 }
1007acb3 12564
19e6b90e
L		 12565 break;
12566 }
1007acb3 12567
19e6b90e 12568 if (i == max)
1007acb3 12569 {
74e1a04b 12570 printf (_("Unrecognized debug section: %s\n"), print_name);
19e6b90e 12571 result = 0;
1007acb3
L		 12572 }
12573
19e6b90e 12574 return result;
5b18a4bc 12575}
103f02d3 12576
aef1f6d0
DJ		 12577/* Set DUMP_SECTS for all sections where dumps were requested
12578 based on section name. */
12579
12580static void
12581initialise_dumps_byname (void)
12582{
2cf0635d 12583 struct dump_list_entry * cur;
aef1f6d0
DJ		 12584
12585 for (cur = dump_sects_byname; cur; cur = cur->next)
12586 {
12587 unsigned int i;
12588 int any;
12589
12590 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12591 if (streq (SECTION_NAME (section_headers + i), cur->name))
12592 {
09c11c86 12593 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 12594 any = 1;
12595 }
12596
12597 if (!any)
12598 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12599 cur->name);
12600 }
12601}
12602
5b18a4bc 12603static void
2cf0635d 12604process_section_contents (FILE * file)
5b18a4bc 12605{
2cf0635d 12606 Elf_Internal_Shdr * section;
19e6b90e 12607 unsigned int i;
103f02d3 12608
19e6b90e
L		 12609 if (! do_dump)
12610 return;
103f02d3 12611
aef1f6d0
DJ		 12612 initialise_dumps_byname ();
12613
19e6b90e
L		 12614 for (i = 0, section = section_headers;
12615 i < elf_header.e_shnum && i < num_dump_sects;
12616 i++, section++)
12617 {
12618#ifdef SUPPORT_DISASSEMBLY
12619 if (dump_sects[i] & DISASS_DUMP)
12620 disassemble_section (section, file);
12621#endif
12622 if (dump_sects[i] & HEX_DUMP)
cf13d699 12623 dump_section_as_bytes (section, file, FALSE);
103f02d3 12624
cf13d699
NC		 12625 if (dump_sects[i] & RELOC_DUMP)
12626 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 12627
12628 if (dump_sects[i] & STRING_DUMP)
12629 dump_section_as_strings (section, file);
cf13d699
NC		 12630
12631 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 12632 display_debug_section (i, section, file);
5b18a4bc 12633 }
103f02d3 12634
19e6b90e
L		 12635 /* Check to see if the user requested a
12636 dump of a section that does not exist. */
12637 while (i++ < num_dump_sects)
12638 if (dump_sects[i])
12639 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 12640}
103f02d3 12641
5b18a4bc 12642static void
19e6b90e 12643process_mips_fpe_exception (int mask)
5b18a4bc 12644{
19e6b90e
L		 12645 if (mask)
12646 {
12647 int first = 1;
12648 if (mask & OEX_FPU_INEX)
12649 fputs ("INEX", stdout), first = 0;
12650 if (mask & OEX_FPU_UFLO)
12651 printf ("%sUFLO", first ? "" : "|"), first = 0;
12652 if (mask & OEX_FPU_OFLO)
12653 printf ("%sOFLO", first ? "" : "|"), first = 0;
12654 if (mask & OEX_FPU_DIV0)
12655 printf ("%sDIV0", first ? "" : "|"), first = 0;
12656 if (mask & OEX_FPU_INVAL)
12657 printf ("%sINVAL", first ? "" : "|");
12658 }
5b18a4bc 12659 else
19e6b90e 12660 fputs ("0", stdout);
5b18a4bc 12661}
103f02d3 12662
f6f0e17b
NC		 12663/* Display's the value of TAG at location P. If TAG is
12664 greater than 0 it is assumed to be an unknown tag, and
12665 a message is printed to this effect. Otherwise it is
12666 assumed that a message has already been printed.
12667
12668 If the bottom bit of TAG is set it assumed to have a
12669 string value, otherwise it is assumed to have an integer
12670 value.
12671
12672 Returns an updated P pointing to the first unread byte
12673 beyond the end of TAG's value.
12674
12675 Reads at or beyond END will not be made. */
12676
12677static unsigned char *
12678display_tag_value (int tag,
12679 unsigned char * p,
12680 const unsigned char * const end)
12681{
12682 unsigned long val;
12683
12684 if (tag > 0)
12685 printf (" Tag_unknown_%d: ", tag);
12686
12687 if (p >= end)
12688 {
4082ef84 12689 warn (_("<corrupt tag>\n"));
f6f0e17b
NC		 12690 }
12691 else if (tag & 1)
12692 {
071436c6
NC		 12693 /* PR 17531 file: 027-19978-0.004. */
12694 size_t maxlen = (end - p) - 1;
12695
12696 putchar ('"');
4082ef84
NC		 12697 if (maxlen > 0)
12698 {
12699 print_symbol ((int) maxlen, (const char *) p);
12700 p += strnlen ((char *) p, maxlen) + 1;
12701 }
12702 else
12703 {
12704 printf (_("<corrupt string tag>"));
12705 p = (unsigned char *) end;
12706 }
071436c6 12707 printf ("\"\n");
f6f0e17b
NC		 12708 }
12709 else
12710 {
12711 unsigned int len;
12712
12713 val = read_uleb128 (p, &len, end);
12714 p += len;
12715 printf ("%ld (0x%lx)\n", val, val);
12716 }
12717
4082ef84 12718 assert (p <= end);
f6f0e17b
NC		 12719 return p;
12720}
12721
11c1ff18
PB		 12722/* ARM EABI attributes section. */
12723typedef struct
12724{
70e99720 12725 unsigned int tag;
2cf0635d 12726 const char * name;
11c1ff18 12727 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 12728 unsigned int type;
2cf0635d 12729 const char ** table;
11c1ff18
PB		 12730} arm_attr_public_tag;
12731
2cf0635d 12732static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 12733 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 12734 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 12735static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12736static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 12737 {"No", "Thumb-1", "Thumb-2"};
75375b3e 12738static const char * arm_attr_tag_FP_arch[] =
bca38921 12739 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
a715796b 12740 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
2cf0635d 12741static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 12742static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 12743 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 12744static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 12745 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12746 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 12747static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 12748 {"V6", "SB", "TLS", "Unused"};
2cf0635d 12749static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 12750 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 12751static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 12752 {"Absolute", "PC-relative", "None"};
2cf0635d 12753static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 12754 {"None", "direct", "GOT-indirect"};
2cf0635d 12755static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 12756 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 12757static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12758static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 12759 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 12760static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12761static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12762static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 12763 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 12764static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 12765 {"Unused", "small", "int", "forced to int"};
2cf0635d 12766static const char * arm_attr_tag_ABI_HardFP_use[] =
99654aaf 12767 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
2cf0635d 12768static const char * arm_attr_tag_ABI_VFP_args[] =
5c294fee 12769 {"AAPCS", "VFP registers", "custom", "compatible"};
2cf0635d 12770static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 12771 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 12772static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 12773 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12774 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 12775static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 12776 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12777 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 12778static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 12779static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 12780 {"Not Allowed", "Allowed"};
2cf0635d 12781static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 12782 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 12783static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 12784 {"Not Allowed", "Allowed"};
12785static const char * arm_attr_tag_DIV_use[] =
dd24e3da 12786 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 12787 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 12788static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12789static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 12790 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 12791 "TrustZone and Virtualization Extensions"};
dd24e3da 12792static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 12793 {"Not Allowed", "Allowed"};
11c1ff18
PB		 12794
12795#define LOOKUP(id, name) \
12796 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 12797static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 12798{
12799 {4, "CPU_raw_name", 1, NULL},
12800 {5, "CPU_name", 1, NULL},
12801 LOOKUP(6, CPU_arch),
12802 {7, "CPU_arch_profile", 0, NULL},
12803 LOOKUP(8, ARM_ISA_use),
12804 LOOKUP(9, THUMB_ISA_use),
75375b3e 12805 LOOKUP(10, FP_arch),
11c1ff18 12806 LOOKUP(11, WMMX_arch),
f5f53991
AS		 12807 LOOKUP(12, Advanced_SIMD_arch),
12808 LOOKUP(13, PCS_config),
11c1ff18
PB		 12809 LOOKUP(14, ABI_PCS_R9_use),
12810 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 12811 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 12812 LOOKUP(17, ABI_PCS_GOT_use),
12813 LOOKUP(18, ABI_PCS_wchar_t),
12814 LOOKUP(19, ABI_FP_rounding),
12815 LOOKUP(20, ABI_FP_denormal),
12816 LOOKUP(21, ABI_FP_exceptions),
12817 LOOKUP(22, ABI_FP_user_exceptions),
12818 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 12819 {24, "ABI_align_needed", 0, NULL},
12820 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 12821 LOOKUP(26, ABI_enum_size),
12822 LOOKUP(27, ABI_HardFP_use),
12823 LOOKUP(28, ABI_VFP_args),
12824 LOOKUP(29, ABI_WMMX_args),
12825 LOOKUP(30, ABI_optimization_goals),
12826 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 12827 {32, "compatibility", 0, NULL},
f5f53991 12828 LOOKUP(34, CPU_unaligned_access),
75375b3e 12829 LOOKUP(36, FP_HP_extension),
8e79c3df 12830 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 12831 LOOKUP(42, MPextension_use),
12832 LOOKUP(44, DIV_use),
f5f53991
AS		 12833 {64, "nodefaults", 0, NULL},
12834 {65, "also_compatible_with", 0, NULL},
12835 LOOKUP(66, T2EE_use),
12836 {67, "conformance", 1, NULL},
12837 LOOKUP(68, Virtualization_use),
cd21e546 12838 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 12839};
12840#undef LOOKUP
12841
11c1ff18 12842static unsigned char *
f6f0e17b
NC		 12843display_arm_attribute (unsigned char * p,
12844 const unsigned char * const end)
11c1ff18 12845{
70e99720 12846 unsigned int tag;
11c1ff18 12847 unsigned int len;
70e99720 12848 unsigned int val;
2cf0635d 12849 arm_attr_public_tag * attr;
11c1ff18 12850 unsigned i;
70e99720 12851 unsigned int type;
11c1ff18 12852
f6f0e17b 12853 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 12854 p += len;
12855 attr = NULL;
2cf0635d 12856 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 12857 {
12858 if (arm_attr_public_tags[i].tag == tag)
12859 {
12860 attr = &arm_attr_public_tags[i];
12861 break;
12862 }
12863 }
12864
12865 if (attr)
12866 {
12867 printf (" Tag_%s: ", attr->name);
12868 switch (attr->type)
12869 {
12870 case 0:
12871 switch (tag)
12872 {
12873 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 12874 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12875 p += len;
12876 switch (val)
12877 {
2b692964
NC		 12878 case 0: printf (_("None\n")); break;
12879 case 'A': printf (_("Application\n")); break;
12880 case 'R': printf (_("Realtime\n")); break;
12881 case 'M': printf (_("Microcontroller\n")); break;
12882 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 12883 default: printf ("??? (%d)\n", val); break;
12884 }
12885 break;
12886
75375b3e 12887 case 24: /* Tag_align_needed. */
f6f0e17b 12888 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12889 p += len;
12890 switch (val)
12891 {
2b692964
NC		 12892 case 0: printf (_("None\n")); break;
12893 case 1: printf (_("8-byte\n")); break;
12894 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 12895 case 3: printf ("??? 3\n"); break;
12896 default:
12897 if (val <= 12)
dd24e3da 12898 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12899 1 << val);
12900 else
12901 printf ("??? (%d)\n", val);
12902 break;
12903 }
12904 break;
12905
12906 case 25: /* Tag_align_preserved. */
f6f0e17b 12907 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12908 p += len;
12909 switch (val)
12910 {
2b692964
NC		 12911 case 0: printf (_("None\n")); break;
12912 case 1: printf (_("8-byte, except leaf SP\n")); break;
12913 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 12914 case 3: printf ("??? 3\n"); break;
12915 default:
12916 if (val <= 12)
dd24e3da 12917 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12918 1 << val);
12919 else
12920 printf ("??? (%d)\n", val);
12921 break;
12922 }
12923 break;
12924
11c1ff18 12925 case 32: /* Tag_compatibility. */
071436c6 12926 {
071436c6
NC		 12927 val = read_uleb128 (p, &len, end);
12928 p += len;
071436c6 12929 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 12930 if (p < end - 1)
12931 {
12932 size_t maxlen = (end - p) - 1;
12933
12934 print_symbol ((int) maxlen, (const char *) p);
12935 p += strnlen ((char *) p, maxlen) + 1;
12936 }
12937 else
12938 {
12939 printf (_("<corrupt>"));
12940 p = (unsigned char *) end;
12941 }
071436c6 12942 putchar ('\n');
071436c6 12943 }
11c1ff18
PB		 12944 break;
12945
f5f53991 12946 case 64: /* Tag_nodefaults. */
541a3cbd
NC		 12947 /* PR 17531: file: 001-505008-0.01. */
12948 if (p < end)
12949 p++;
2b692964 12950 printf (_("True\n"));
f5f53991
AS		 12951 break;
12952
12953 case 65: /* Tag_also_compatible_with. */
f6f0e17b 12954 val = read_uleb128 (p, &len, end);
f5f53991
AS		 12955 p += len;
12956 if (val == 6 /* Tag_CPU_arch. */)
12957 {
f6f0e17b 12958 val = read_uleb128 (p, &len, end);
f5f53991 12959 p += len;
071436c6 12960 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 12961 printf ("??? (%d)\n", val);
12962 else
12963 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12964 }
12965 else
12966 printf ("???\n");
071436c6
NC		 12967 while (p < end && *(p++) != '\0' /* NUL terminator. */)
12968 ;
f5f53991
AS		 12969 break;
12970
11c1ff18 12971 default:
bee0ee85
NC		 12972 printf (_("<unknown: %d>\n"), tag);
12973 break;
11c1ff18
PB		 12974 }
12975 return p;
12976
12977 case 1:
f6f0e17b 12978 return display_tag_value (-1, p, end);
11c1ff18 12979 case 2:
f6f0e17b 12980 return display_tag_value (0, p, end);
11c1ff18
PB		 12981
12982 default:
12983 assert (attr->type & 0x80);
f6f0e17b 12984 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12985 p += len;
12986 type = attr->type & 0x7f;
12987 if (val >= type)
12988 printf ("??? (%d)\n", val);
12989 else
12990 printf ("%s\n", attr->table[val]);
12991 return p;
12992 }
12993 }
11c1ff18 12994
f6f0e17b 12995 return display_tag_value (tag, p, end);
11c1ff18
PB		 12996}
12997
104d59d1 12998static unsigned char *
60bca95a 12999display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 13000 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
13001 const unsigned char * const end)
104d59d1
JM		 13002{
13003 int tag;
13004 unsigned int len;
13005 int val;
104d59d1 13006
f6f0e17b 13007 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 13008 p += len;
13009
13010 /* Tag_compatibility is the only generic GNU attribute defined at
13011 present. */
13012 if (tag == 32)
13013 {
f6f0e17b 13014 val = read_uleb128 (p, &len, end);
104d59d1 13015 p += len;
071436c6
NC		 13016
13017 printf (_("flag = %d, vendor = "), val);
f6f0e17b
NC		 13018 if (p == end)
13019 {
071436c6 13020 printf (_("<corrupt>\n"));
f6f0e17b
NC		 13021 warn (_("corrupt vendor attribute\n"));
13022 }
13023 else
13024 {
4082ef84
NC		 13025 if (p < end - 1)
13026 {
13027 size_t maxlen = (end - p) - 1;
071436c6 13028
4082ef84
NC		 13029 print_symbol ((int) maxlen, (const char *) p);
13030 p += strnlen ((char *) p, maxlen) + 1;
13031 }
13032 else
13033 {
13034 printf (_("<corrupt>"));
13035 p = (unsigned char *) end;
13036 }
071436c6 13037 putchar ('\n');
f6f0e17b 13038 }
104d59d1
JM		 13039 return p;
13040 }
13041
13042 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 13043 return display_proc_gnu_attribute (p, tag, end);
104d59d1 13044
f6f0e17b 13045 return display_tag_value (tag, p, end);
104d59d1
JM		 13046}
13047
34c8bcba 13048static unsigned char *
f6f0e17b
NC		 13049display_power_gnu_attribute (unsigned char * p,
13050 int tag,
13051 const unsigned char * const end)
34c8bcba 13052{
34c8bcba
JM		 13053 unsigned int len;
13054 int val;
13055
13056 if (tag == Tag_GNU_Power_ABI_FP)
13057 {
f6f0e17b 13058 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 13059 p += len;
13060 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 13061
34c8bcba
JM		 13062 switch (val)
13063 {
13064 case 0:
2b692964 13065 printf (_("Hard or soft float\n"));
34c8bcba
JM		 13066 break;
13067 case 1:
2b692964 13068 printf (_("Hard float\n"));
34c8bcba
JM		 13069 break;
13070 case 2:
2b692964 13071 printf (_("Soft float\n"));
34c8bcba 13072 break;
3c7b9897 13073 case 3:
2b692964 13074 printf (_("Single-precision hard float\n"));
3c7b9897 13075 break;
34c8bcba
JM		 13076 default:
13077 printf ("??? (%d)\n", val);
13078 break;
13079 }
13080 return p;
13081 }
13082
c6e65352
DJ		 13083 if (tag == Tag_GNU_Power_ABI_Vector)
13084 {
f6f0e17b 13085 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 13086 p += len;
13087 printf (" Tag_GNU_Power_ABI_Vector: ");
13088 switch (val)
13089 {
13090 case 0:
2b692964 13091 printf (_("Any\n"));
c6e65352
DJ		 13092 break;
13093 case 1:
2b692964 13094 printf (_("Generic\n"));
c6e65352
DJ		 13095 break;
13096 case 2:
13097 printf ("AltiVec\n");
13098 break;
13099 case 3:
13100 printf ("SPE\n");
13101 break;
13102 default:
13103 printf ("??? (%d)\n", val);
13104 break;
13105 }
13106 return p;
13107 }
13108
f82e0623
NF		 13109 if (tag == Tag_GNU_Power_ABI_Struct_Return)
13110 {
f6f0e17b
NC		 13111 if (p == end)
13112 {
071436c6 13113 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
f6f0e17b
NC		 13114 return p;
13115 }
0b4362b0 13116
f6f0e17b 13117 val = read_uleb128 (p, &len, end);
f82e0623
NF		 13118 p += len;
13119 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13120 switch (val)
13121 {
13122 case 0:
2b692964 13123 printf (_("Any\n"));
f82e0623
NF		 13124 break;
13125 case 1:
13126 printf ("r3/r4\n");
13127 break;
13128 case 2:
2b692964 13129 printf (_("Memory\n"));
f82e0623
NF		 13130 break;
13131 default:
13132 printf ("??? (%d)\n", val);
13133 break;
13134 }
13135 return p;
13136 }
13137
f6f0e17b 13138 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 13139}
13140
643f7afb
AK		 13141static unsigned char *
13142display_s390_gnu_attribute (unsigned char * p,
13143 int tag,
13144 const unsigned char * const end)
13145{
13146 unsigned int len;
13147 int val;
13148
13149 if (tag == Tag_GNU_S390_ABI_Vector)
13150 {
13151 val = read_uleb128 (p, &len, end);
13152 p += len;
13153 printf (" Tag_GNU_S390_ABI_Vector: ");
13154
13155 switch (val)
13156 {
13157 case 0:
13158 printf (_("any\n"));
13159 break;
13160 case 1:
13161 printf (_("software\n"));
13162 break;
13163 case 2:
13164 printf (_("hardware\n"));
13165 break;
13166 default:
13167 printf ("??? (%d)\n", val);
13168 break;
13169 }
13170 return p;
13171 }
13172
13173 return display_tag_value (tag & 1, p, end);
13174}
13175
9e8c70f9
DM		 13176static void
13177display_sparc_hwcaps (int mask)
13178{
13179 if (mask)
13180 {
13181 int first = 1;
071436c6 13182
9e8c70f9
DM		 13183 if (mask & ELF_SPARC_HWCAP_MUL32)
13184 fputs ("mul32", stdout), first = 0;
13185 if (mask & ELF_SPARC_HWCAP_DIV32)
13186 printf ("%sdiv32", first ? "" : "|"), first = 0;
13187 if (mask & ELF_SPARC_HWCAP_FSMULD)
13188 printf ("%sfsmuld", first ? "" : "|"), first = 0;
13189 if (mask & ELF_SPARC_HWCAP_V8PLUS)
13190 printf ("%sv8plus", first ? "" : "|"), first = 0;
13191 if (mask & ELF_SPARC_HWCAP_POPC)
13192 printf ("%spopc", first ? "" : "|"), first = 0;
13193 if (mask & ELF_SPARC_HWCAP_VIS)
13194 printf ("%svis", first ? "" : "|"), first = 0;
13195 if (mask & ELF_SPARC_HWCAP_VIS2)
13196 printf ("%svis2", first ? "" : "|"), first = 0;
13197 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
13198 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
13199 if (mask & ELF_SPARC_HWCAP_FMAF)
13200 printf ("%sfmaf", first ? "" : "|"), first = 0;
13201 if (mask & ELF_SPARC_HWCAP_VIS3)
13202 printf ("%svis3", first ? "" : "|"), first = 0;
13203 if (mask & ELF_SPARC_HWCAP_HPC)
13204 printf ("%shpc", first ? "" : "|"), first = 0;
13205 if (mask & ELF_SPARC_HWCAP_RANDOM)
13206 printf ("%srandom", first ? "" : "|"), first = 0;
13207 if (mask & ELF_SPARC_HWCAP_TRANS)
13208 printf ("%strans", first ? "" : "|"), first = 0;
13209 if (mask & ELF_SPARC_HWCAP_FJFMAU)
13210 printf ("%sfjfmau", first ? "" : "|"), first = 0;
13211 if (mask & ELF_SPARC_HWCAP_IMA)
13212 printf ("%sima", first ? "" : "|"), first = 0;
13213 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
13214 printf ("%scspare", first ? "" : "|"), first = 0;
13215 }
13216 else
071436c6
NC		 13217 fputc ('0', stdout);
13218 fputc ('\n', stdout);
9e8c70f9
DM		 13219}
13220
3d68f91c
JM		 13221static void
13222display_sparc_hwcaps2 (int mask)
13223{
13224 if (mask)
13225 {
13226 int first = 1;
071436c6 13227
3d68f91c
JM		 13228 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
13229 fputs ("fjathplus", stdout), first = 0;
13230 if (mask & ELF_SPARC_HWCAP2_VIS3B)
13231 printf ("%svis3b", first ? "" : "|"), first = 0;
13232 if (mask & ELF_SPARC_HWCAP2_ADP)
13233 printf ("%sadp", first ? "" : "|"), first = 0;
13234 if (mask & ELF_SPARC_HWCAP2_SPARC5)
13235 printf ("%ssparc5", first ? "" : "|"), first = 0;
13236 if (mask & ELF_SPARC_HWCAP2_MWAIT)
13237 printf ("%smwait", first ? "" : "|"), first = 0;
13238 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
13239 printf ("%sxmpmul", first ? "" : "|"), first = 0;
13240 if (mask & ELF_SPARC_HWCAP2_XMONT)
13241 printf ("%sxmont2", first ? "" : "|"), first = 0;
13242 if (mask & ELF_SPARC_HWCAP2_NSEC)
13243 printf ("%snsec", first ? "" : "|"), first = 0;
13244 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
13245 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
13246 if (mask & ELF_SPARC_HWCAP2_FJDES)
13247 printf ("%sfjdes", first ? "" : "|"), first = 0;
13248 if (mask & ELF_SPARC_HWCAP2_FJAES)
13249 printf ("%sfjaes", first ? "" : "|"), first = 0;
13250 }
13251 else
071436c6
NC		 13252 fputc ('0', stdout);
13253 fputc ('\n', stdout);
3d68f91c
JM		 13254}
13255
9e8c70f9 13256static unsigned char *
f6f0e17b
NC		 13257display_sparc_gnu_attribute (unsigned char * p,
13258 int tag,
13259 const unsigned char * const end)
9e8c70f9 13260{
3d68f91c
JM		 13261 unsigned int len;
13262 int val;
13263
9e8c70f9
DM		 13264 if (tag == Tag_GNU_Sparc_HWCAPS)
13265 {
f6f0e17b 13266 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 13267 p += len;
13268 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 13269 display_sparc_hwcaps (val);
13270 return p;
3d68f91c
JM		 13271 }
13272 if (tag == Tag_GNU_Sparc_HWCAPS2)
13273 {
13274 val = read_uleb128 (p, &len, end);
13275 p += len;
13276 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13277 display_sparc_hwcaps2 (val);
13278 return p;
13279 }
9e8c70f9 13280
f6f0e17b 13281 return display_tag_value (tag, p, end);
9e8c70f9
DM		 13282}
13283
351cdf24
MF		 13284static void
13285print_mips_fp_abi_value (int val)
13286{
13287 switch (val)
13288 {
13289 case Val_GNU_MIPS_ABI_FP_ANY:
13290 printf (_("Hard or soft float\n"));
13291 break;
13292 case Val_GNU_MIPS_ABI_FP_DOUBLE:
13293 printf (_("Hard float (double precision)\n"));
13294 break;
13295 case Val_GNU_MIPS_ABI_FP_SINGLE:
13296 printf (_("Hard float (single precision)\n"));
13297 break;
13298 case Val_GNU_MIPS_ABI_FP_SOFT:
13299 printf (_("Soft float\n"));
13300 break;
13301 case Val_GNU_MIPS_ABI_FP_OLD_64:
13302 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13303 break;
13304 case Val_GNU_MIPS_ABI_FP_XX:
13305 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13306 break;
13307 case Val_GNU_MIPS_ABI_FP_64:
13308 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13309 break;
13310 case Val_GNU_MIPS_ABI_FP_64A:
13311 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13312 break;
3350cc01
CM		 13313 case Val_GNU_MIPS_ABI_FP_NAN2008:
13314 printf (_("NaN 2008 compatibility\n"));
13315 break;
351cdf24
MF		 13316 default:
13317 printf ("??? (%d)\n", val);
13318 break;
13319 }
13320}
13321
2cf19d5c 13322static unsigned char *
f6f0e17b
NC		 13323display_mips_gnu_attribute (unsigned char * p,
13324 int tag,
13325 const unsigned char * const end)
2cf19d5c 13326{
2cf19d5c
JM		 13327 if (tag == Tag_GNU_MIPS_ABI_FP)
13328 {
f6f0e17b
NC		 13329 unsigned int len;
13330 int val;
13331
13332 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 13333 p += len;
13334 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 13335
351cdf24
MF		 13336 print_mips_fp_abi_value (val);
13337
2cf19d5c
JM		 13338 return p;
13339 }
13340
a9f58168
CF		 13341 if (tag == Tag_GNU_MIPS_ABI_MSA)
13342 {
13343 unsigned int len;
13344 int val;
13345
13346 val = read_uleb128 (p, &len, end);
13347 p += len;
13348 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13349
13350 switch (val)
13351 {
13352 case Val_GNU_MIPS_ABI_MSA_ANY:
13353 printf (_("Any MSA or not\n"));
13354 break;
13355 case Val_GNU_MIPS_ABI_MSA_128:
13356 printf (_("128-bit MSA\n"));
13357 break;
13358 default:
13359 printf ("??? (%d)\n", val);
13360 break;
13361 }
13362 return p;
13363 }
13364
f6f0e17b 13365 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 13366}
13367
59e6276b 13368static unsigned char *
f6f0e17b
NC		 13369display_tic6x_attribute (unsigned char * p,
13370 const unsigned char * const end)
59e6276b
JM		 13371{
13372 int tag;
13373 unsigned int len;
13374 int val;
13375
f6f0e17b 13376 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 13377 p += len;
13378
13379 switch (tag)
13380 {
75fa6dc1 13381 case Tag_ISA:
f6f0e17b 13382 val = read_uleb128 (p, &len, end);
59e6276b 13383 p += len;
75fa6dc1 13384 printf (" Tag_ISA: ");
59e6276b
JM		 13385
13386 switch (val)
13387 {
75fa6dc1 13388 case C6XABI_Tag_ISA_none:
59e6276b
JM		 13389 printf (_("None\n"));
13390 break;
75fa6dc1 13391 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 13392 printf ("C62x\n");
13393 break;
75fa6dc1 13394 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 13395 printf ("C67x\n");
13396 break;
75fa6dc1 13397 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 13398 printf ("C67x+\n");
13399 break;
75fa6dc1 13400 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 13401 printf ("C64x\n");
13402 break;
75fa6dc1 13403 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 13404 printf ("C64x+\n");
13405 break;
75fa6dc1 13406 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 13407 printf ("C674x\n");
13408 break;
13409 default:
13410 printf ("??? (%d)\n", val);
13411 break;
13412 }
13413 return p;
13414
87779176 13415 case Tag_ABI_wchar_t:
f6f0e17b 13416 val = read_uleb128 (p, &len, end);
87779176
JM		 13417 p += len;
13418 printf (" Tag_ABI_wchar_t: ");
13419 switch (val)
13420 {
13421 case 0:
13422 printf (_("Not used\n"));
13423 break;
13424 case 1:
13425 printf (_("2 bytes\n"));
13426 break;
13427 case 2:
13428 printf (_("4 bytes\n"));
13429 break;
13430 default:
13431 printf ("??? (%d)\n", val);
13432 break;
13433 }
13434 return p;
13435
13436 case Tag_ABI_stack_align_needed:
f6f0e17b 13437 val = read_uleb128 (p, &len, end);
87779176
JM		 13438 p += len;
13439 printf (" Tag_ABI_stack_align_needed: ");
13440 switch (val)
13441 {
13442 case 0:
13443 printf (_("8-byte\n"));
13444 break;
13445 case 1:
13446 printf (_("16-byte\n"));
13447 break;
13448 default:
13449 printf ("??? (%d)\n", val);
13450 break;
13451 }
13452 return p;
13453
13454 case Tag_ABI_stack_align_preserved:
f6f0e17b 13455 val = read_uleb128 (p, &len, end);
87779176
JM		 13456 p += len;
13457 printf (" Tag_ABI_stack_align_preserved: ");
13458 switch (val)
13459 {
13460 case 0:
13461 printf (_("8-byte\n"));
13462 break;
13463 case 1:
13464 printf (_("16-byte\n"));
13465 break;
13466 default:
13467 printf ("??? (%d)\n", val);
13468 break;
13469 }
13470 return p;
13471
b5593623 13472 case Tag_ABI_DSBT:
f6f0e17b 13473 val = read_uleb128 (p, &len, end);
b5593623
JM		 13474 p += len;
13475 printf (" Tag_ABI_DSBT: ");
13476 switch (val)
13477 {
13478 case 0:
13479 printf (_("DSBT addressing not used\n"));
13480 break;
13481 case 1:
13482 printf (_("DSBT addressing used\n"));
13483 break;
13484 default:
13485 printf ("??? (%d)\n", val);
13486 break;
13487 }
13488 return p;
13489
87779176 13490 case Tag_ABI_PID:
f6f0e17b 13491 val = read_uleb128 (p, &len, end);
87779176
JM		 13492 p += len;
13493 printf (" Tag_ABI_PID: ");
13494 switch (val)
13495 {
13496 case 0:
13497 printf (_("Data addressing position-dependent\n"));
13498 break;
13499 case 1:
13500 printf (_("Data addressing position-independent, GOT near DP\n"));
13501 break;
13502 case 2:
13503 printf (_("Data addressing position-independent, GOT far from DP\n"));
13504 break;
13505 default:
13506 printf ("??? (%d)\n", val);
13507 break;
13508 }
13509 return p;
13510
13511 case Tag_ABI_PIC:
f6f0e17b 13512 val = read_uleb128 (p, &len, end);
87779176
JM		 13513 p += len;
13514 printf (" Tag_ABI_PIC: ");
13515 switch (val)
13516 {
13517 case 0:
13518 printf (_("Code addressing position-dependent\n"));
13519 break;
13520 case 1:
13521 printf (_("Code addressing position-independent\n"));
13522 break;
13523 default:
13524 printf ("??? (%d)\n", val);
13525 break;
13526 }
13527 return p;
13528
13529 case Tag_ABI_array_object_alignment:
f6f0e17b 13530 val = read_uleb128 (p, &len, end);
87779176
JM		 13531 p += len;
13532 printf (" Tag_ABI_array_object_alignment: ");
13533 switch (val)
13534 {
13535 case 0:
13536 printf (_("8-byte\n"));
13537 break;
13538 case 1:
13539 printf (_("4-byte\n"));
13540 break;
13541 case 2:
13542 printf (_("16-byte\n"));
13543 break;
13544 default:
13545 printf ("??? (%d)\n", val);
13546 break;
13547 }
13548 return p;
13549
13550 case Tag_ABI_array_object_align_expected:
f6f0e17b 13551 val = read_uleb128 (p, &len, end);
87779176
JM		 13552 p += len;
13553 printf (" Tag_ABI_array_object_align_expected: ");
13554 switch (val)
13555 {
13556 case 0:
13557 printf (_("8-byte\n"));
13558 break;
13559 case 1:
13560 printf (_("4-byte\n"));
13561 break;
13562 case 2:
13563 printf (_("16-byte\n"));
13564 break;
13565 default:
13566 printf ("??? (%d)\n", val);
13567 break;
13568 }
13569 return p;
13570
3cbd1c06 13571 case Tag_ABI_compatibility:
071436c6 13572 {
071436c6
NC		 13573 val = read_uleb128 (p, &len, end);
13574 p += len;
13575 printf (" Tag_ABI_compatibility: ");
071436c6 13576 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13577 if (p < end - 1)
13578 {
13579 size_t maxlen = (end - p) - 1;
13580
13581 print_symbol ((int) maxlen, (const char *) p);
13582 p += strnlen ((char *) p, maxlen) + 1;
13583 }
13584 else
13585 {
13586 printf (_("<corrupt>"));
13587 p = (unsigned char *) end;
13588 }
071436c6 13589 putchar ('\n');
071436c6
NC		 13590 return p;
13591 }
87779176
JM		 13592
13593 case Tag_ABI_conformance:
071436c6 13594 {
4082ef84
NC		 13595 printf (" Tag_ABI_conformance: \"");
13596 if (p < end - 1)
13597 {
13598 size_t maxlen = (end - p) - 1;
071436c6 13599
4082ef84
NC		 13600 print_symbol ((int) maxlen, (const char *) p);
13601 p += strnlen ((char *) p, maxlen) + 1;
13602 }
13603 else
13604 {
13605 printf (_("<corrupt>"));
13606 p = (unsigned char *) end;
13607 }
071436c6 13608 printf ("\"\n");
071436c6
NC		 13609 return p;
13610 }
59e6276b
JM		 13611 }
13612
f6f0e17b
NC		 13613 return display_tag_value (tag, p, end);
13614}
59e6276b 13615
f6f0e17b
NC		 13616static void
13617display_raw_attribute (unsigned char * p, unsigned char * end)
13618{
13619 unsigned long addr = 0;
13620 size_t bytes = end - p;
13621
e0a31db1 13622 assert (end > p);
f6f0e17b 13623 while (bytes)
87779176 13624 {
f6f0e17b
NC		 13625 int j;
13626 int k;
13627 int lbytes = (bytes > 16 ? 16 : bytes);
13628
13629 printf (" 0x%8.8lx ", addr);
13630
13631 for (j = 0; j < 16; j++)
13632 {
13633 if (j < lbytes)
13634 printf ("%2.2x", p[j]);
13635 else
13636 printf (" ");
13637
13638 if ((j & 3) == 3)
13639 printf (" ");
13640 }
13641
13642 for (j = 0; j < lbytes; j++)
13643 {
13644 k = p[j];
13645 if (k >= ' ' && k < 0x7f)
13646 printf ("%c", k);
13647 else
13648 printf (".");
13649 }
13650
13651 putchar ('\n');
13652
13653 p += lbytes;
13654 bytes -= lbytes;
13655 addr += lbytes;
87779176 13656 }
59e6276b 13657
f6f0e17b 13658 putchar ('\n');
59e6276b
JM		 13659}
13660
13761a11
NC		 13661static unsigned char *
13662display_msp430x_attribute (unsigned char * p,
13663 const unsigned char * const end)
13664{
13665 unsigned int len;
13666 int val;
13667 int tag;
13668
13669 tag = read_uleb128 (p, & len, end);
13670 p += len;
0b4362b0 13671
13761a11
NC		 13672 switch (tag)
13673 {
13674 case OFBA_MSPABI_Tag_ISA:
13675 val = read_uleb128 (p, &len, end);
13676 p += len;
13677 printf (" Tag_ISA: ");
13678 switch (val)
13679 {
13680 case 0: printf (_("None\n")); break;
13681 case 1: printf (_("MSP430\n")); break;
13682 case 2: printf (_("MSP430X\n")); break;
13683 default: printf ("??? (%d)\n", val); break;
13684 }
13685 break;
13686
13687 case OFBA_MSPABI_Tag_Code_Model:
13688 val = read_uleb128 (p, &len, end);
13689 p += len;
13690 printf (" Tag_Code_Model: ");
13691 switch (val)
13692 {
13693 case 0: printf (_("None\n")); break;
13694 case 1: printf (_("Small\n")); break;
13695 case 2: printf (_("Large\n")); break;
13696 default: printf ("??? (%d)\n", val); break;
13697 }
13698 break;
13699
13700 case OFBA_MSPABI_Tag_Data_Model:
13701 val = read_uleb128 (p, &len, end);
13702 p += len;
13703 printf (" Tag_Data_Model: ");
13704 switch (val)
13705 {
13706 case 0: printf (_("None\n")); break;
13707 case 1: printf (_("Small\n")); break;
13708 case 2: printf (_("Large\n")); break;
13709 case 3: printf (_("Restricted Large\n")); break;
13710 default: printf ("??? (%d)\n", val); break;
13711 }
13712 break;
13713
13714 default:
13715 printf (_(" <unknown tag %d>: "), tag);
13716
13717 if (tag & 1)
13718 {
071436c6 13719 putchar ('"');
4082ef84
NC		 13720 if (p < end - 1)
13721 {
13722 size_t maxlen = (end - p) - 1;
13723
13724 print_symbol ((int) maxlen, (const char *) p);
13725 p += strnlen ((char *) p, maxlen) + 1;
13726 }
13727 else
13728 {
13729 printf (_("<corrupt>"));
13730 p = (unsigned char *) end;
13731 }
071436c6 13732 printf ("\"\n");
13761a11
NC		 13733 }
13734 else
13735 {
13736 val = read_uleb128 (p, &len, end);
13737 p += len;
13738 printf ("%d (0x%x)\n", val, val);
13739 }
13740 break;
13741 }
13742
4082ef84 13743 assert (p <= end);
13761a11
NC		 13744 return p;
13745}
13746
11c1ff18 13747static int
60bca95a
NC		 13748process_attributes (FILE * file,
13749 const char * public_name,
104d59d1 13750 unsigned int proc_type,
f6f0e17b
NC		 13751 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13752 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 13753{
2cf0635d 13754 Elf_Internal_Shdr * sect;
11c1ff18
PB		 13755 unsigned i;
13756
13757 /* Find the section header so that we get the size. */
13758 for (i = 0, sect = section_headers;
13759 i < elf_header.e_shnum;
13760 i++, sect++)
13761 {
071436c6
NC		 13762 unsigned char * contents;
13763 unsigned char * p;
13764
104d59d1 13765 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 13766 continue;
13767
3f5e193b
NC		 13768 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13769 sect->sh_size, _("attributes"));
60bca95a 13770 if (contents == NULL)
11c1ff18 13771 continue;
60bca95a 13772
11c1ff18
PB		 13773 p = contents;
13774 if (*p == 'A')
13775 {
071436c6
NC		 13776 bfd_vma section_len;
13777
13778 section_len = sect->sh_size - 1;
11c1ff18 13779 p++;
60bca95a 13780
071436c6 13781 while (section_len > 0)
11c1ff18 13782 {
071436c6 13783 bfd_vma attr_len;
e9847026 13784 unsigned int namelen;
11c1ff18 13785 bfd_boolean public_section;
104d59d1 13786 bfd_boolean gnu_section;
11c1ff18 13787
071436c6 13788 if (section_len <= 4)
e0a31db1
NC		 13789 {
13790 error (_("Tag section ends prematurely\n"));
13791 break;
13792 }
071436c6 13793 attr_len = byte_get (p, 4);
11c1ff18 13794 p += 4;
60bca95a 13795
071436c6 13796 if (attr_len > section_len)
11c1ff18 13797 {
071436c6
NC		 13798 error (_("Bad attribute length (%u > %u)\n"),
13799 (unsigned) attr_len, (unsigned) section_len);
13800 attr_len = section_len;
11c1ff18 13801 }
74e1a04b 13802 /* PR 17531: file: 001-101425-0.004 */
071436c6 13803 else if (attr_len < 5)
74e1a04b 13804 {
071436c6 13805 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
74e1a04b
NC		 13806 break;
13807 }
e9847026 13808
071436c6
NC		 13809 section_len -= attr_len;
13810 attr_len -= 4;
13811
13812 namelen = strnlen ((char *) p, attr_len) + 1;
13813 if (namelen == 0 || namelen >= attr_len)
e9847026
NC		 13814 {
13815 error (_("Corrupt attribute section name\n"));
13816 break;
13817 }
13818
071436c6
NC		 13819 printf (_("Attribute Section: "));
13820 print_symbol (INT_MAX, (const char *) p);
13821 putchar ('\n');
60bca95a
NC		 13822
13823 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 13824 public_section = TRUE;
13825 else
13826 public_section = FALSE;
60bca95a
NC		 13827
13828 if (streq ((char *) p, "gnu"))
104d59d1
JM		 13829 gnu_section = TRUE;
13830 else
13831 gnu_section = FALSE;
60bca95a 13832
11c1ff18 13833 p += namelen;
071436c6 13834 attr_len -= namelen;
e0a31db1 13835
071436c6 13836 while (attr_len > 0 && p < contents + sect->sh_size)
11c1ff18 13837 {
e0a31db1 13838 int tag;
11c1ff18
PB		 13839 int val;
13840 bfd_vma size;
071436c6 13841 unsigned char * end;
60bca95a 13842
e0a31db1 13843 /* PR binutils/17531: Safe handling of corrupt files. */
071436c6 13844 if (attr_len < 6)
e0a31db1
NC		 13845 {
13846 error (_("Unused bytes at end of section\n"));
13847 section_len = 0;
13848 break;
13849 }
13850
13851 tag = *(p++);
11c1ff18 13852 size = byte_get (p, 4);
071436c6 13853 if (size > attr_len)
11c1ff18 13854 {
e9847026 13855 error (_("Bad subsection length (%u > %u)\n"),
071436c6
NC		 13856 (unsigned) size, (unsigned) attr_len);
13857 size = attr_len;
11c1ff18 13858 }
e0a31db1
NC		 13859 /* PR binutils/17531: Safe handling of corrupt files. */
13860 if (size < 6)
13861 {
13862 error (_("Bad subsection length (%u < 6)\n"),
13863 (unsigned) size);
13864 section_len = 0;
13865 break;
13866 }
60bca95a 13867
071436c6 13868 attr_len -= size;
11c1ff18 13869 end = p + size - 1;
071436c6 13870 assert (end <= contents + sect->sh_size);
11c1ff18 13871 p += 4;
60bca95a 13872
11c1ff18
PB		 13873 switch (tag)
13874 {
13875 case 1:
2b692964 13876 printf (_("File Attributes\n"));
11c1ff18
PB		 13877 break;
13878 case 2:
2b692964 13879 printf (_("Section Attributes:"));
11c1ff18
PB		 13880 goto do_numlist;
13881 case 3:
2b692964 13882 printf (_("Symbol Attributes:"));
11c1ff18
PB		 13883 do_numlist:
13884 for (;;)
13885 {
91d6fa6a 13886 unsigned int j;
60bca95a 13887
f6f0e17b 13888 val = read_uleb128 (p, &j, end);
91d6fa6a 13889 p += j;
11c1ff18
PB		 13890 if (val == 0)
13891 break;
13892 printf (" %d", val);
13893 }
13894 printf ("\n");
13895 break;
13896 default:
2b692964 13897 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 13898 public_section = FALSE;
13899 break;
13900 }
60bca95a 13901
071436c6 13902 if (public_section && display_pub_attribute != NULL)
11c1ff18
PB		 13903 {
13904 while (p < end)
f6f0e17b 13905 p = display_pub_attribute (p, end);
071436c6 13906 assert (p <= end);
104d59d1 13907 }
071436c6 13908 else if (gnu_section && display_proc_gnu_attribute != NULL)
104d59d1
JM		 13909 {
13910 while (p < end)
13911 p = display_gnu_attribute (p,
f6f0e17b
NC		 13912 display_proc_gnu_attribute,
13913 end);
071436c6 13914 assert (p <= end);
11c1ff18 13915 }
071436c6 13916 else if (p < end)
11c1ff18 13917 {
071436c6 13918 printf (_(" Unknown attribute:\n"));
f6f0e17b 13919 display_raw_attribute (p, end);
11c1ff18
PB		 13920 p = end;
13921 }
071436c6
NC		 13922 else
13923 attr_len = 0;
11c1ff18
PB		 13924 }
13925 }
13926 }
13927 else
e9847026 13928 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
d70c5fc7 13929
60bca95a 13930 free (contents);
11c1ff18
PB		 13931 }
13932 return 1;
13933}
13934
104d59d1 13935static int
2cf0635d 13936process_arm_specific (FILE * file)
104d59d1
JM		 13937{
13938 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13939 display_arm_attribute, NULL);
13940}
13941
34c8bcba 13942static int
2cf0635d 13943process_power_specific (FILE * file)
34c8bcba
JM		 13944{
13945 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13946 display_power_gnu_attribute);
13947}
13948
643f7afb
AK		 13949static int
13950process_s390_specific (FILE * file)
13951{
13952 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13953 display_s390_gnu_attribute);
13954}
13955
9e8c70f9
DM		 13956static int
13957process_sparc_specific (FILE * file)
13958{
13959 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13960 display_sparc_gnu_attribute);
13961}
13962
59e6276b
JM		 13963static int
13964process_tic6x_specific (FILE * file)
13965{
13966 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13967 display_tic6x_attribute, NULL);
13968}
13969
13761a11
NC		 13970static int
13971process_msp430x_specific (FILE * file)
13972{
13973 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13974 display_msp430x_attribute, NULL);
13975}
13976
ccb4c951
RS		 13977/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13978 Print the Address, Access and Initial fields of an entry at VMA ADDR
82b1b41b
NC		 13979 and return the VMA of the next entry, or -1 if there was a problem.
13980 Does not read from DATA_END or beyond. */
ccb4c951
RS		 13981
13982static bfd_vma
82b1b41b
NC		 13983print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
13984 unsigned char * data_end)
ccb4c951
RS		 13985{
13986 printf (" ");
13987 print_vma (addr, LONG_HEX);
13988 printf (" ");
13989 if (addr < pltgot + 0xfff0)
13990 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13991 else
13992 printf ("%10s", "");
13993 printf (" ");
13994 if (data == NULL)
2b692964 13995 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 13996 else
13997 {
13998 bfd_vma entry;
82b1b41b 13999 unsigned char * from = data + addr - pltgot;
ccb4c951 14000
82b1b41b
NC		 14001 if (from + (is_32bit_elf ? 4 : 8) > data_end)
14002 {
14003 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14004 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
14005 return (bfd_vma) -1;
14006 }
14007 else
14008 {
14009 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14010 print_vma (entry, LONG_HEX);
14011 }
ccb4c951
RS		 14012 }
14013 return addr + (is_32bit_elf ? 4 : 8);
14014}
14015
861fb55a
DJ		 14016/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14017 PLTGOT. Print the Address and Initial fields of an entry at VMA
14018 ADDR and return the VMA of the next entry. */
14019
14020static bfd_vma
2cf0635d 14021print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 14022{
14023 printf (" ");
14024 print_vma (addr, LONG_HEX);
14025 printf (" ");
14026 if (data == NULL)
2b692964 14027 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 14028 else
14029 {
14030 bfd_vma entry;
14031
14032 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14033 print_vma (entry, LONG_HEX);
14034 }
14035 return addr + (is_32bit_elf ? 4 : 8);
14036}
14037
351cdf24
MF		 14038static void
14039print_mips_ases (unsigned int mask)
14040{
14041 if (mask & AFL_ASE_DSP)
14042 fputs ("\n\tDSP ASE", stdout);
14043 if (mask & AFL_ASE_DSPR2)
14044 fputs ("\n\tDSP R2 ASE", stdout);
14045 if (mask & AFL_ASE_EVA)
14046 fputs ("\n\tEnhanced VA Scheme", stdout);
14047 if (mask & AFL_ASE_MCU)
14048 fputs ("\n\tMCU (MicroController) ASE", stdout);
14049 if (mask & AFL_ASE_MDMX)
14050 fputs ("\n\tMDMX ASE", stdout);
14051 if (mask & AFL_ASE_MIPS3D)
14052 fputs ("\n\tMIPS-3D ASE", stdout);
14053 if (mask & AFL_ASE_MT)
14054 fputs ("\n\tMT ASE", stdout);
14055 if (mask & AFL_ASE_SMARTMIPS)
14056 fputs ("\n\tSmartMIPS ASE", stdout);
14057 if (mask & AFL_ASE_VIRT)
14058 fputs ("\n\tVZ ASE", stdout);
14059 if (mask & AFL_ASE_MSA)
14060 fputs ("\n\tMSA ASE", stdout);
14061 if (mask & AFL_ASE_MIPS16)
14062 fputs ("\n\tMIPS16 ASE", stdout);
14063 if (mask & AFL_ASE_MICROMIPS)
14064 fputs ("\n\tMICROMIPS ASE", stdout);
14065 if (mask & AFL_ASE_XPA)
14066 fputs ("\n\tXPA ASE", stdout);
14067 if (mask == 0)
14068 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 14069 else if ((mask & ~AFL_ASE_MASK) != 0)
14070 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 14071}
14072
14073static void
14074print_mips_isa_ext (unsigned int isa_ext)
14075{
14076 switch (isa_ext)
14077 {
14078 case 0:
14079 fputs (_("None"), stdout);
14080 break;
14081 case AFL_EXT_XLR:
14082 fputs ("RMI XLR", stdout);
14083 break;
2c629856
N		 14084 case AFL_EXT_OCTEON3:
14085 fputs ("Cavium Networks Octeon3", stdout);
14086 break;
351cdf24
MF		 14087 case AFL_EXT_OCTEON2:
14088 fputs ("Cavium Networks Octeon2", stdout);
14089 break;
14090 case AFL_EXT_OCTEONP:
14091 fputs ("Cavium Networks OcteonP", stdout);
14092 break;
14093 case AFL_EXT_LOONGSON_3A:
14094 fputs ("Loongson 3A", stdout);
14095 break;
14096 case AFL_EXT_OCTEON:
14097 fputs ("Cavium Networks Octeon", stdout);
14098 break;
14099 case AFL_EXT_5900:
14100 fputs ("Toshiba R5900", stdout);
14101 break;
14102 case AFL_EXT_4650:
14103 fputs ("MIPS R4650", stdout);
14104 break;
14105 case AFL_EXT_4010:
14106 fputs ("LSI R4010", stdout);
14107 break;
14108 case AFL_EXT_4100:
14109 fputs ("NEC VR4100", stdout);
14110 break;
14111 case AFL_EXT_3900:
14112 fputs ("Toshiba R3900", stdout);
14113 break;
14114 case AFL_EXT_10000:
14115 fputs ("MIPS R10000", stdout);
14116 break;
14117 case AFL_EXT_SB1:
14118 fputs ("Broadcom SB-1", stdout);
14119 break;
14120 case AFL_EXT_4111:
14121 fputs ("NEC VR4111/VR4181", stdout);
14122 break;
14123 case AFL_EXT_4120:
14124 fputs ("NEC VR4120", stdout);
14125 break;
14126 case AFL_EXT_5400:
14127 fputs ("NEC VR5400", stdout);
14128 break;
14129 case AFL_EXT_5500:
14130 fputs ("NEC VR5500", stdout);
14131 break;
14132 case AFL_EXT_LOONGSON_2E:
14133 fputs ("ST Microelectronics Loongson 2E", stdout);
14134 break;
14135 case AFL_EXT_LOONGSON_2F:
14136 fputs ("ST Microelectronics Loongson 2F", stdout);
14137 break;
14138 default:
00ac7aa0 14139 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 14140 }
14141}
14142
14143static int
14144get_mips_reg_size (int reg_size)
14145{
14146 return (reg_size == AFL_REG_NONE) ? 0
14147 : (reg_size == AFL_REG_32) ? 32
14148 : (reg_size == AFL_REG_64) ? 64
14149 : (reg_size == AFL_REG_128) ? 128
14150 : -1;
14151}
14152
19e6b90e 14153static int
2cf0635d 14154process_mips_specific (FILE * file)
5b18a4bc 14155{
2cf0635d 14156 Elf_Internal_Dyn * entry;
351cdf24 14157 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 14158 size_t liblist_offset = 0;
14159 size_t liblistno = 0;
14160 size_t conflictsno = 0;
14161 size_t options_offset = 0;
14162 size_t conflicts_offset = 0;
861fb55a
DJ		 14163 size_t pltrelsz = 0;
14164 size_t pltrel = 0;
ccb4c951 14165 bfd_vma pltgot = 0;
861fb55a
DJ		 14166 bfd_vma mips_pltgot = 0;
14167 bfd_vma jmprel = 0;
ccb4c951
RS		 14168 bfd_vma local_gotno = 0;
14169 bfd_vma gotsym = 0;
14170 bfd_vma symtabno = 0;
103f02d3 14171
2cf19d5c
JM		 14172 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14173 display_mips_gnu_attribute);
14174
351cdf24
MF		 14175 sect = find_section (".MIPS.abiflags");
14176
14177 if (sect != NULL)
14178 {
14179 Elf_External_ABIFlags_v0 *abiflags_ext;
14180 Elf_Internal_ABIFlags_v0 abiflags_in;
14181
14182 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
14183 fputs ("\nCorrupt ABI Flags section.\n", stdout);
14184 else
14185 {
14186 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
14187 sect->sh_size, _("MIPS ABI Flags section"));
14188 if (abiflags_ext)
14189 {
14190 abiflags_in.version = BYTE_GET (abiflags_ext->version);
14191 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
14192 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
14193 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
14194 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
14195 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
14196 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
14197 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
14198 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
14199 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
14200 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
14201
14202 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
14203 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
14204 if (abiflags_in.isa_rev > 1)
14205 printf ("r%d", abiflags_in.isa_rev);
14206 printf ("\nGPR size: %d",
14207 get_mips_reg_size (abiflags_in.gpr_size));
14208 printf ("\nCPR1 size: %d",
14209 get_mips_reg_size (abiflags_in.cpr1_size));
14210 printf ("\nCPR2 size: %d",
14211 get_mips_reg_size (abiflags_in.cpr2_size));
14212 fputs ("\nFP ABI: ", stdout);
14213 print_mips_fp_abi_value (abiflags_in.fp_abi);
14214 fputs ("ISA Extension: ", stdout);
14215 print_mips_isa_ext (abiflags_in.isa_ext);
14216 fputs ("\nASEs:", stdout);
14217 print_mips_ases (abiflags_in.ases);
14218 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
14219 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
14220 fputc ('\n', stdout);
14221 free (abiflags_ext);
14222 }
14223 }
14224 }
14225
19e6b90e
L		 14226 /* We have a lot of special sections. Thanks SGI! */
14227 if (dynamic_section == NULL)
14228 /* No information available. */
14229 return 0;
252b5132 14230
071436c6
NC		 14231 for (entry = dynamic_section;
14232 /* PR 17531 file: 012-50589-0.004. */
14233 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
14234 ++entry)
252b5132
RH		 14235 switch (entry->d_tag)
14236 {
14237 case DT_MIPS_LIBLIST:
d93f0186
NC		 14238 liblist_offset
14239 = offset_from_vma (file, entry->d_un.d_val,
14240 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 14241 break;
14242 case DT_MIPS_LIBLISTNO:
14243 liblistno = entry->d_un.d_val;
14244 break;
14245 case DT_MIPS_OPTIONS:
d93f0186 14246 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 14247 break;
14248 case DT_MIPS_CONFLICT:
d93f0186
NC		 14249 conflicts_offset
14250 = offset_from_vma (file, entry->d_un.d_val,
14251 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 14252 break;
14253 case DT_MIPS_CONFLICTNO:
14254 conflictsno = entry->d_un.d_val;
14255 break;
ccb4c951 14256 case DT_PLTGOT:
861fb55a
DJ		 14257 pltgot = entry->d_un.d_ptr;
14258 break;
ccb4c951
RS		 14259 case DT_MIPS_LOCAL_GOTNO:
14260 local_gotno = entry->d_un.d_val;
14261 break;
14262 case DT_MIPS_GOTSYM:
14263 gotsym = entry->d_un.d_val;
14264 break;
14265 case DT_MIPS_SYMTABNO:
14266 symtabno = entry->d_un.d_val;
14267 break;
861fb55a
DJ		 14268 case DT_MIPS_PLTGOT:
14269 mips_pltgot = entry->d_un.d_ptr;
14270 break;
14271 case DT_PLTREL:
14272 pltrel = entry->d_un.d_val;
14273 break;
14274 case DT_PLTRELSZ:
14275 pltrelsz = entry->d_un.d_val;
14276 break;
14277 case DT_JMPREL:
14278 jmprel = entry->d_un.d_ptr;
14279 break;
252b5132
RH		 14280 default:
14281 break;
14282 }
14283
14284 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
14285 {
2cf0635d 14286 Elf32_External_Lib * elib;
252b5132
RH		 14287 size_t cnt;
14288
3f5e193b
NC		 14289 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
14290 liblistno,
14291 sizeof (Elf32_External_Lib),
9cf03b7e 14292 _("liblist section data"));
a6e9f9df 14293 if (elib)
252b5132 14294 {
2b692964 14295 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 14296 (unsigned long) liblistno);
2b692964 14297 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 14298 stdout);
14299
14300 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 14301 {
a6e9f9df 14302 Elf32_Lib liblist;
91d6fa6a 14303 time_t atime;
a6e9f9df 14304 char timebuf[20];
2cf0635d 14305 struct tm * tmp;
a6e9f9df
AM		 14306
14307 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14308 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 14309 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14310 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14311 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14312
91d6fa6a 14313 tmp = gmtime (&atime);
e9e44622
JJ		 14314 snprintf (timebuf, sizeof (timebuf),
14315 "%04u-%02u-%02uT%02u:%02u:%02u",
14316 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14317 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 14318
31104126 14319 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 14320 if (VALID_DYNAMIC_NAME (liblist.l_name))
14321 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
14322 else
2b692964 14323 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 14324 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
14325 liblist.l_version);
a6e9f9df
AM		 14326
14327 if (liblist.l_flags == 0)
2b692964 14328 puts (_(" NONE"));
a6e9f9df
AM		 14329 else
14330 {
14331 static const struct
252b5132 14332 {
2cf0635d 14333 const char * name;
a6e9f9df 14334 int bit;
252b5132 14335 }
a6e9f9df
AM		 14336 l_flags_vals[] =
14337 {
14338 { " EXACT_MATCH", LL_EXACT_MATCH },
14339 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
14340 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
14341 { " EXPORTS", LL_EXPORTS },
14342 { " DELAY_LOAD", LL_DELAY_LOAD },
14343 { " DELTA", LL_DELTA }
14344 };
14345 int flags = liblist.l_flags;
14346 size_t fcnt;
14347
60bca95a 14348 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 14349 if ((flags & l_flags_vals[fcnt].bit) != 0)
14350 {
14351 fputs (l_flags_vals[fcnt].name, stdout);
14352 flags ^= l_flags_vals[fcnt].bit;
14353 }
14354 if (flags != 0)
14355 printf (" %#x", (unsigned int) flags);
252b5132 14356
a6e9f9df
AM		 14357 puts ("");
14358 }
252b5132 14359 }
252b5132 14360
a6e9f9df
AM		 14361 free (elib);
14362 }
252b5132
RH		 14363 }
14364
14365 if (options_offset != 0)
14366 {
2cf0635d 14367 Elf_External_Options * eopt;
2cf0635d
NC		 14368 Elf_Internal_Options * iopt;
14369 Elf_Internal_Options * option;
252b5132
RH		 14370 size_t offset;
14371 int cnt;
351cdf24 14372 sect = section_headers;
252b5132
RH		 14373
14374 /* Find the section header so that we get the size. */
071436c6 14375 sect = find_section_by_type (SHT_MIPS_OPTIONS);
948f632f 14376 /* PR 17533 file: 012-277276-0.004. */
071436c6
NC		 14377 if (sect == NULL)
14378 {
14379 error (_("No MIPS_OPTIONS header found\n"));
14380 return 0;
14381 }
252b5132 14382
3f5e193b
NC		 14383 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14384 sect->sh_size, _("options"));
a6e9f9df 14385 if (eopt)
252b5132 14386 {
3f5e193b
NC		 14387 iopt = (Elf_Internal_Options *)
14388 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 14389 if (iopt == NULL)
14390 {
8b73c356 14391 error (_("Out of memory allocatinf space for MIPS options\n"));
a6e9f9df
AM		 14392 return 0;
14393 }
76da6bbe 14394
a6e9f9df
AM		 14395 offset = cnt = 0;
14396 option = iopt;
252b5132 14397
82b1b41b 14398 while (offset <= sect->sh_size - sizeof (* eopt))
a6e9f9df 14399 {
2cf0635d 14400 Elf_External_Options * eoption;
252b5132 14401
a6e9f9df 14402 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 14403
a6e9f9df
AM		 14404 option->kind = BYTE_GET (eoption->kind);
14405 option->size = BYTE_GET (eoption->size);
14406 option->section = BYTE_GET (eoption->section);
14407 option->info = BYTE_GET (eoption->info);
76da6bbe 14408
82b1b41b
NC		 14409 /* PR 17531: file: ffa0fa3b. */
14410 if (option->size < sizeof (* eopt)
14411 || offset + option->size > sect->sh_size)
14412 {
55325047
NC		 14413 error (_("Invalid size (%u) for MIPS option\n"), option->size);
14414 return 0;
82b1b41b 14415 }
a6e9f9df 14416 offset += option->size;
14ae95f2 14417
a6e9f9df
AM		 14418 ++option;
14419 ++cnt;
14420 }
252b5132 14421
a6e9f9df 14422 printf (_("\nSection '%s' contains %d entries:\n"),
74e1a04b 14423 printable_section_name (sect), cnt);
76da6bbe 14424
a6e9f9df 14425 option = iopt;
82b1b41b 14426 offset = 0;
252b5132 14427
a6e9f9df 14428 while (cnt-- > 0)
252b5132 14429 {
a6e9f9df
AM		 14430 size_t len;
14431
14432 switch (option->kind)
252b5132 14433 {
a6e9f9df
AM		 14434 case ODK_NULL:
14435 /* This shouldn't happen. */
14436 printf (" NULL %d %lx", option->section, option->info);
14437 break;
14438 case ODK_REGINFO:
14439 printf (" REGINFO ");
14440 if (elf_header.e_machine == EM_MIPS)
14441 {
14442 /* 32bit form. */
2cf0635d 14443 Elf32_External_RegInfo * ereg;
b34976b6 14444 Elf32_RegInfo reginfo;
a6e9f9df
AM		 14445
14446 ereg = (Elf32_External_RegInfo *) (option + 1);
14447 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14448 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14449 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14450 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14451 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14452 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14453
14454 printf ("GPR %08lx GP 0x%lx\n",
14455 reginfo.ri_gprmask,
14456 (unsigned long) reginfo.ri_gp_value);
14457 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14458 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14459 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14460 }
14461 else
14462 {
14463 /* 64 bit form. */
2cf0635d 14464 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 14465 Elf64_Internal_RegInfo reginfo;
14466
14467 ereg = (Elf64_External_RegInfo *) (option + 1);
14468 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14469 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14470 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14471 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14472 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 14473 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 14474
14475 printf ("GPR %08lx GP 0x",
14476 reginfo.ri_gprmask);
14477 printf_vma (reginfo.ri_gp_value);
14478 printf ("\n");
14479
14480 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14481 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14482 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14483 }
14484 ++option;
14485 continue;
14486 case ODK_EXCEPTIONS:
14487 fputs (" EXCEPTIONS fpe_min(", stdout);
14488 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14489 fputs (") fpe_max(", stdout);
14490 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14491 fputs (")", stdout);
14492
14493 if (option->info & OEX_PAGE0)
14494 fputs (" PAGE0", stdout);
14495 if (option->info & OEX_SMM)
14496 fputs (" SMM", stdout);
14497 if (option->info & OEX_FPDBUG)
14498 fputs (" FPDBUG", stdout);
14499 if (option->info & OEX_DISMISS)
14500 fputs (" DISMISS", stdout);
14501 break;
14502 case ODK_PAD:
14503 fputs (" PAD ", stdout);
14504 if (option->info & OPAD_PREFIX)
14505 fputs (" PREFIX", stdout);
14506 if (option->info & OPAD_POSTFIX)
14507 fputs (" POSTFIX", stdout);
14508 if (option->info & OPAD_SYMBOL)
14509 fputs (" SYMBOL", stdout);
14510 break;
14511 case ODK_HWPATCH:
14512 fputs (" HWPATCH ", stdout);
14513 if (option->info & OHW_R4KEOP)
14514 fputs (" R4KEOP", stdout);
14515 if (option->info & OHW_R8KPFETCH)
14516 fputs (" R8KPFETCH", stdout);
14517 if (option->info & OHW_R5KEOP)
14518 fputs (" R5KEOP", stdout);
14519 if (option->info & OHW_R5KCVTL)
14520 fputs (" R5KCVTL", stdout);
14521 break;
14522 case ODK_FILL:
14523 fputs (" FILL ", stdout);
14524 /* XXX Print content of info word? */
14525 break;
14526 case ODK_TAGS:
14527 fputs (" TAGS ", stdout);
14528 /* XXX Print content of info word? */
14529 break;
14530 case ODK_HWAND:
14531 fputs (" HWAND ", stdout);
14532 if (option->info & OHWA0_R4KEOP_CHECKED)
14533 fputs (" R4KEOP_CHECKED", stdout);
14534 if (option->info & OHWA0_R4KEOP_CLEAN)
14535 fputs (" R4KEOP_CLEAN", stdout);
14536 break;
14537 case ODK_HWOR:
14538 fputs (" HWOR ", stdout);
14539 if (option->info & OHWA0_R4KEOP_CHECKED)
14540 fputs (" R4KEOP_CHECKED", stdout);
14541 if (option->info & OHWA0_R4KEOP_CLEAN)
14542 fputs (" R4KEOP_CLEAN", stdout);
14543 break;
14544 case ODK_GP_GROUP:
14545 printf (" GP_GROUP %#06lx self-contained %#06lx",
14546 option->info & OGP_GROUP,
14547 (option->info & OGP_SELF) >> 16);
14548 break;
14549 case ODK_IDENT:
14550 printf (" IDENT %#06lx self-contained %#06lx",
14551 option->info & OGP_GROUP,
14552 (option->info & OGP_SELF) >> 16);
14553 break;
14554 default:
14555 /* This shouldn't happen. */
14556 printf (" %3d ??? %d %lx",
14557 option->kind, option->section, option->info);
14558 break;
252b5132 14559 }
a6e9f9df 14560
2cf0635d 14561 len = sizeof (* eopt);
a6e9f9df 14562 while (len < option->size)
82b1b41b 14563 {
7e27a9d5 14564 unsigned char datum = * ((unsigned char *) eopt + offset + len);
a6e9f9df 14565
82b1b41b
NC		 14566 if (ISPRINT (datum))
14567 printf ("%c", datum);
14568 else
14569 printf ("\\%03o", datum);
14570 len ++;
14571 }
a6e9f9df 14572 fputs ("\n", stdout);
82b1b41b
NC		 14573
14574 offset += option->size;
252b5132 14575 ++option;
252b5132
RH		 14576 }
14577
a6e9f9df 14578 free (eopt);
252b5132 14579 }
252b5132
RH		 14580 }
14581
14582 if (conflicts_offset != 0 && conflictsno != 0)
14583 {
2cf0635d 14584 Elf32_Conflict * iconf;
252b5132
RH		 14585 size_t cnt;
14586
14587 if (dynamic_symbols == NULL)
14588 {
591a748a 14589 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 14590 return 0;
14591 }
14592
3f5e193b 14593 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 14594 if (iconf == NULL)
14595 {
8b73c356 14596 error (_("Out of memory allocating space for dynamic conflicts\n"));
252b5132
RH		 14597 return 0;
14598 }
14599
9ea033b2 14600 if (is_32bit_elf)
252b5132 14601 {
2cf0635d 14602 Elf32_External_Conflict * econf32;
a6e9f9df 14603
3f5e193b
NC		 14604 econf32 = (Elf32_External_Conflict *)
14605 get_data (NULL, file, conflicts_offset, conflictsno,
14606 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 14607 if (!econf32)
14608 return 0;
252b5132
RH		 14609
14610 for (cnt = 0; cnt < conflictsno; ++cnt)
14611 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 14612
14613 free (econf32);
252b5132
RH		 14614 }
14615 else
14616 {
2cf0635d 14617 Elf64_External_Conflict * econf64;
a6e9f9df 14618
3f5e193b
NC		 14619 econf64 = (Elf64_External_Conflict *)
14620 get_data (NULL, file, conflicts_offset, conflictsno,
14621 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 14622 if (!econf64)
14623 return 0;
252b5132
RH		 14624
14625 for (cnt = 0; cnt < conflictsno; ++cnt)
14626 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 14627
14628 free (econf64);
252b5132
RH		 14629 }
14630
c7e7ca54
NC		 14631 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14632 (unsigned long) conflictsno);
252b5132
RH		 14633 puts (_(" Num: Index Value Name"));
14634
14635 for (cnt = 0; cnt < conflictsno; ++cnt)
14636 {
b34976b6 14637 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 14638
14639 if (iconf[cnt] >= num_dynamic_syms)
14640 printf (_("<corrupt symbol index>"));
d79b3d50 14641 else
e0a31db1
NC		 14642 {
14643 Elf_Internal_Sym * psym;
14644
14645 psym = & dynamic_symbols[iconf[cnt]];
14646 print_vma (psym->st_value, FULL_HEX);
14647 putchar (' ');
14648 if (VALID_DYNAMIC_NAME (psym->st_name))
14649 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14650 else
14651 printf (_("<corrupt: %14ld>"), psym->st_name);
14652 }
31104126 14653 putchar ('\n');
252b5132
RH		 14654 }
14655
252b5132
RH		 14656 free (iconf);
14657 }
14658
ccb4c951
RS		 14659 if (pltgot != 0 && local_gotno != 0)
14660 {
91d6fa6a 14661 bfd_vma ent, local_end, global_end;
bbeee7ea 14662 size_t i, offset;
2cf0635d 14663 unsigned char * data;
82b1b41b 14664 unsigned char * data_end;
bbeee7ea 14665 int addr_size;
ccb4c951 14666
91d6fa6a 14667 ent = pltgot;
ccb4c951
RS		 14668 addr_size = (is_32bit_elf ? 4 : 8);
14669 local_end = pltgot + local_gotno * addr_size;
ccb4c951 14670
74e1a04b
NC		 14671 /* PR binutils/17533 file: 012-111227-0.004 */
14672 if (symtabno < gotsym)
14673 {
14674 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
82b1b41b 14675 (unsigned long) gotsym, (unsigned long) symtabno);
74e1a04b
NC		 14676 return 0;
14677 }
82b1b41b 14678
74e1a04b 14679 global_end = local_end + (symtabno - gotsym) * addr_size;
82b1b41b
NC		 14680 /* PR 17531: file: 54c91a34. */
14681 if (global_end < local_end)
14682 {
14683 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14684 return 0;
14685 }
948f632f 14686
ccb4c951 14687 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 14688 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 14689 global_end - pltgot, 1,
14690 _("Global Offset Table data"));
59245841
NC		 14691 if (data == NULL)
14692 return 0;
82b1b41b 14693 data_end = data + (global_end - pltgot);
59245841 14694
ccb4c951
RS		 14695 printf (_("\nPrimary GOT:\n"));
14696 printf (_(" Canonical gp value: "));
14697 print_vma (pltgot + 0x7ff0, LONG_HEX);
14698 printf ("\n\n");
14699
14700 printf (_(" Reserved entries:\n"));
14701 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 14702 addr_size * 2, _("Address"), _("Access"),
14703 addr_size * 2, _("Initial"));
82b1b41b 14704 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14705 printf (_(" Lazy resolver\n"));
82b1b41b
NC		 14706 if (ent == (bfd_vma) -1)
14707 goto got_print_fail;
ccb4c951 14708 if (data
91d6fa6a 14709 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 14710 >> (addr_size * 8 - 1)) != 0)
14711 {
82b1b41b 14712 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14713 printf (_(" Module pointer (GNU extension)\n"));
82b1b41b
NC		 14714 if (ent == (bfd_vma) -1)
14715 goto got_print_fail;
ccb4c951
RS		 14716 }
14717 printf ("\n");
14718
91d6fa6a 14719 if (ent < local_end)
ccb4c951
RS		 14720 {
14721 printf (_(" Local entries:\n"));
cc5914eb 14722 printf (" %*s %10s %*s\n",
2b692964
NC		 14723 addr_size * 2, _("Address"), _("Access"),
14724 addr_size * 2, _("Initial"));
91d6fa6a 14725 while (ent < local_end)
ccb4c951 14726 {
82b1b41b 14727 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14728 printf ("\n");
82b1b41b
NC		 14729 if (ent == (bfd_vma) -1)
14730 goto got_print_fail;
ccb4c951
RS		 14731 }
14732 printf ("\n");
14733 }
14734
14735 if (gotsym < symtabno)
14736 {
14737 int sym_width;
14738
14739 printf (_(" Global entries:\n"));
cc5914eb 14740 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 14741 addr_size * 2, _("Address"),
14742 _("Access"),
2b692964 14743 addr_size * 2, _("Initial"),
9cf03b7e
NC		 14744 addr_size * 2, _("Sym.Val."),
14745 _("Type"),
14746 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14747 _("Ndx"), _("Name"));
0b4362b0 14748
ccb4c951 14749 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 14750
ccb4c951
RS		 14751 for (i = gotsym; i < symtabno; i++)
14752 {
82b1b41b 14753 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14754 printf (" ");
e0a31db1
NC		 14755
14756 if (dynamic_symbols == NULL)
14757 printf (_("<no dynamic symbols>"));
14758 else if (i < num_dynamic_syms)
14759 {
14760 Elf_Internal_Sym * psym = dynamic_symbols + i;
14761
14762 print_vma (psym->st_value, LONG_HEX);
14763 printf (" %-7s %3s ",
14764 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14765 get_symbol_index_type (psym->st_shndx));
14766
14767 if (VALID_DYNAMIC_NAME (psym->st_name))
14768 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14769 else
14770 printf (_("<corrupt: %14ld>"), psym->st_name);
14771 }
ccb4c951 14772 else
7fc5ac57
JBG		 14773 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14774 (unsigned long) i);
e0a31db1 14775
ccb4c951 14776 printf ("\n");
82b1b41b
NC		 14777 if (ent == (bfd_vma) -1)
14778 break;
ccb4c951
RS		 14779 }
14780 printf ("\n");
14781 }
14782
82b1b41b 14783 got_print_fail:
ccb4c951
RS		 14784 if (data)
14785 free (data);
14786 }
14787
861fb55a
DJ		 14788 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14789 {
91d6fa6a 14790 bfd_vma ent, end;
861fb55a
DJ		 14791 size_t offset, rel_offset;
14792 unsigned long count, i;
2cf0635d 14793 unsigned char * data;
861fb55a 14794 int addr_size, sym_width;
2cf0635d 14795 Elf_Internal_Rela * rels;
861fb55a
DJ		 14796
14797 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14798 if (pltrel == DT_RELA)
14799 {
14800 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14801 return 0;
14802 }
14803 else
14804 {
14805 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14806 return 0;
14807 }
14808
91d6fa6a 14809 ent = mips_pltgot;
861fb55a
DJ		 14810 addr_size = (is_32bit_elf ? 4 : 8);
14811 end = mips_pltgot + (2 + count) * addr_size;
14812
14813 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 14814 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 14815 1, _("Procedure Linkage Table data"));
59245841
NC		 14816 if (data == NULL)
14817 return 0;
14818
9cf03b7e 14819 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 14820 printf (_(" Reserved entries:\n"));
14821 printf (_(" %*s %*s Purpose\n"),
2b692964 14822 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 14823 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14824 printf (_(" PLT lazy resolver\n"));
91d6fa6a 14825 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14826 printf (_(" Module pointer\n"));
861fb55a
DJ		 14827 printf ("\n");
14828
14829 printf (_(" Entries:\n"));
cc5914eb 14830 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 14831 addr_size * 2, _("Address"),
14832 addr_size * 2, _("Initial"),
14833 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 14834 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14835 for (i = 0; i < count; i++)
14836 {
df97ab2a 14837 unsigned long idx = get_reloc_symindex (rels[i].r_info);
861fb55a 14838
91d6fa6a 14839 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 14840 printf (" ");
e0a31db1 14841
df97ab2a
MF		 14842 if (idx >= num_dynamic_syms)
14843 printf (_("<corrupt symbol index: %lu>"), idx);
861fb55a 14844 else
e0a31db1 14845 {
df97ab2a 14846 Elf_Internal_Sym * psym = dynamic_symbols + idx;
e0a31db1
NC		 14847
14848 print_vma (psym->st_value, LONG_HEX);
14849 printf (" %-7s %3s ",
14850 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14851 get_symbol_index_type (psym->st_shndx));
14852 if (VALID_DYNAMIC_NAME (psym->st_name))
14853 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14854 else
14855 printf (_("<corrupt: %14ld>"), psym->st_name);
14856 }
861fb55a
DJ		 14857 printf ("\n");
14858 }
14859 printf ("\n");
14860
14861 if (data)
14862 free (data);
14863 free (rels);
14864 }
14865
252b5132
RH		 14866 return 1;
14867}
14868
35c08157
KLC		 14869static int
14870process_nds32_specific (FILE * file)
14871{
14872 Elf_Internal_Shdr *sect = NULL;
14873
14874 sect = find_section (".nds32_e_flags");
14875 if (sect != NULL)
14876 {
14877 unsigned int *flag;
14878
14879 printf ("\nNDS32 elf flags section:\n");
14880 flag = get_data (NULL, file, sect->sh_offset, 1,
14881 sect->sh_size, _("NDS32 elf flags section"));
14882
14883 switch ((*flag) & 0x3)
14884 {
14885 case 0:
14886 printf ("(VEC_SIZE):\tNo entry.\n");
14887 break;
14888 case 1:
14889 printf ("(VEC_SIZE):\t4 bytes\n");
14890 break;
14891 case 2:
14892 printf ("(VEC_SIZE):\t16 bytes\n");
14893 break;
14894 case 3:
14895 printf ("(VEC_SIZE):\treserved\n");
14896 break;
14897 }
14898 }
14899
14900 return TRUE;
14901}
14902
047b2264 14903static int
2cf0635d 14904process_gnu_liblist (FILE * file)
047b2264 14905{
2cf0635d
NC		 14906 Elf_Internal_Shdr * section;
14907 Elf_Internal_Shdr * string_sec;
14908 Elf32_External_Lib * elib;
14909 char * strtab;
c256ffe7 14910 size_t strtab_size;
047b2264
JJ		 14911 size_t cnt;
14912 unsigned i;
14913
14914 if (! do_arch)
14915 return 0;
14916
14917 for (i = 0, section = section_headers;
14918 i < elf_header.e_shnum;
b34976b6 14919 i++, section++)
047b2264
JJ		 14920 {
14921 switch (section->sh_type)
14922 {
14923 case SHT_GNU_LIBLIST:
4fbb74a6 14924 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 14925 break;
14926
3f5e193b
NC		 14927 elib = (Elf32_External_Lib *)
14928 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 14929 _("liblist section data"));
047b2264
JJ		 14930
14931 if (elib == NULL)
14932 break;
4fbb74a6 14933 string_sec = section_headers + section->sh_link;
047b2264 14934
3f5e193b
NC		 14935 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14936 string_sec->sh_size,
14937 _("liblist string table"));
047b2264
JJ		 14938 if (strtab == NULL
14939 || section->sh_entsize != sizeof (Elf32_External_Lib))
14940 {
14941 free (elib);
2842702f 14942 free (strtab);
047b2264
JJ		 14943 break;
14944 }
59245841 14945 strtab_size = string_sec->sh_size;
047b2264
JJ		 14946
14947 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
74e1a04b 14948 printable_section_name (section),
0af1713e 14949 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 14950
2b692964 14951 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 14952
14953 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14954 ++cnt)
14955 {
14956 Elf32_Lib liblist;
91d6fa6a 14957 time_t atime;
047b2264 14958 char timebuf[20];
2cf0635d 14959 struct tm * tmp;
047b2264
JJ		 14960
14961 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14962 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 14963 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14964 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14965 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14966
91d6fa6a 14967 tmp = gmtime (&atime);
e9e44622
JJ		 14968 snprintf (timebuf, sizeof (timebuf),
14969 "%04u-%02u-%02uT%02u:%02u:%02u",
14970 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14971 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 14972
14973 printf ("%3lu: ", (unsigned long) cnt);
14974 if (do_wide)
c256ffe7 14975 printf ("%-20s", liblist.l_name < strtab_size
2b692964 14976 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 14977 else
c256ffe7 14978 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 14979 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 14980 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14981 liblist.l_version, liblist.l_flags);
14982 }
14983
14984 free (elib);
2842702f 14985 free (strtab);
047b2264
JJ		 14986 }
14987 }
14988
14989 return 1;
14990}
14991
9437c45b 14992static const char *
d3ba0551 14993get_note_type (unsigned e_type)
779fe533
NC		 14994{
14995 static char buff[64];
103f02d3 14996
1ec5cd37
NC		 14997 if (elf_header.e_type == ET_CORE)
14998 switch (e_type)
14999 {
57346661 15000 case NT_AUXV:
1ec5cd37 15001 return _("NT_AUXV (auxiliary vector)");
57346661 15002 case NT_PRSTATUS:
1ec5cd37 15003 return _("NT_PRSTATUS (prstatus structure)");
57346661 15004 case NT_FPREGSET:
1ec5cd37 15005 return _("NT_FPREGSET (floating point registers)");
57346661 15006 case NT_PRPSINFO:
1ec5cd37 15007 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 15008 case NT_TASKSTRUCT:
1ec5cd37 15009 return _("NT_TASKSTRUCT (task structure)");
57346661 15010 case NT_PRXFPREG:
1ec5cd37 15011 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 15012 case NT_PPC_VMX:
15013 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 15014 case NT_PPC_VSX:
15015 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 15016 case NT_386_TLS:
15017 return _("NT_386_TLS (x86 TLS information)");
15018 case NT_386_IOPERM:
15019 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 15020 case NT_X86_XSTATE:
15021 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 15022 case NT_S390_HIGH_GPRS:
15023 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 15024 case NT_S390_TIMER:
15025 return _("NT_S390_TIMER (s390 timer register)");
15026 case NT_S390_TODCMP:
15027 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15028 case NT_S390_TODPREG:
15029 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15030 case NT_S390_CTRS:
15031 return _("NT_S390_CTRS (s390 control registers)");
15032 case NT_S390_PREFIX:
15033 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 15034 case NT_S390_LAST_BREAK:
15035 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15036 case NT_S390_SYSTEM_CALL:
15037 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 15038 case NT_S390_TDB:
15039 return _("NT_S390_TDB (s390 transaction diagnostic block)");
4ef9f41a
AA		 15040 case NT_S390_VXRS_LOW:
15041 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15042 case NT_S390_VXRS_HIGH:
15043 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
faa9a424
UW		 15044 case NT_ARM_VFP:
15045 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 15046 case NT_ARM_TLS:
15047 return _("NT_ARM_TLS (AArch TLS registers)");
15048 case NT_ARM_HW_BREAK:
15049 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15050 case NT_ARM_HW_WATCH:
15051 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 15052 case NT_PSTATUS:
1ec5cd37 15053 return _("NT_PSTATUS (pstatus structure)");
57346661 15054 case NT_FPREGS:
1ec5cd37 15055 return _("NT_FPREGS (floating point registers)");
57346661 15056 case NT_PSINFO:
1ec5cd37 15057 return _("NT_PSINFO (psinfo structure)");
57346661 15058 case NT_LWPSTATUS:
1ec5cd37 15059 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 15060 case NT_LWPSINFO:
1ec5cd37 15061 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 15062 case NT_WIN32PSTATUS:
1ec5cd37 15063 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 15064 case NT_SIGINFO:
15065 return _("NT_SIGINFO (siginfo_t data)");
15066 case NT_FILE:
15067 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 15068 default:
15069 break;
15070 }
15071 else
15072 switch (e_type)
15073 {
15074 case NT_VERSION:
15075 return _("NT_VERSION (version)");
15076 case NT_ARCH:
15077 return _("NT_ARCH (architecture)");
15078 default:
15079 break;
15080 }
15081
e9e44622 15082 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 15083 return buff;
779fe533
NC		 15084}
15085
9ece1fa9
TT		 15086static int
15087print_core_note (Elf_Internal_Note *pnote)
15088{
15089 unsigned int addr_size = is_32bit_elf ? 4 : 8;
15090 bfd_vma count, page_size;
15091 unsigned char *descdata, *filenames, *descend;
15092
15093 if (pnote->type != NT_FILE)
15094 return 1;
15095
15096#ifndef BFD64
15097 if (!is_32bit_elf)
15098 {
15099 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15100 /* Still "successful". */
15101 return 1;
15102 }
15103#endif
15104
15105 if (pnote->descsz < 2 * addr_size)
15106 {
15107 printf (_(" Malformed note - too short for header\n"));
15108 return 0;
15109 }
15110
15111 descdata = (unsigned char *) pnote->descdata;
15112 descend = descdata + pnote->descsz;
15113
15114 if (descdata[pnote->descsz - 1] != '\0')
15115 {
15116 printf (_(" Malformed note - does not end with \\0\n"));
15117 return 0;
15118 }
15119
15120 count = byte_get (descdata, addr_size);
15121 descdata += addr_size;
15122
15123 page_size = byte_get (descdata, addr_size);
15124 descdata += addr_size;
15125
15126 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
15127 {
15128 printf (_(" Malformed note - too short for supplied file count\n"));
15129 return 0;
15130 }
15131
15132 printf (_(" Page size: "));
15133 print_vma (page_size, DEC);
15134 printf ("\n");
15135
15136 printf (_(" %*s%*s%*s\n"),
15137 (int) (2 + 2 * addr_size), _("Start"),
15138 (int) (4 + 2 * addr_size), _("End"),
15139 (int) (4 + 2 * addr_size), _("Page Offset"));
15140 filenames = descdata + count * 3 * addr_size;
595712bb 15141 while (count-- > 0)
9ece1fa9
TT		 15142 {
15143 bfd_vma start, end, file_ofs;
15144
15145 if (filenames == descend)
15146 {
15147 printf (_(" Malformed note - filenames end too early\n"));
15148 return 0;
15149 }
15150
15151 start = byte_get (descdata, addr_size);
15152 descdata += addr_size;
15153 end = byte_get (descdata, addr_size);
15154 descdata += addr_size;
15155 file_ofs = byte_get (descdata, addr_size);
15156 descdata += addr_size;
15157
15158 printf (" ");
15159 print_vma (start, FULL_HEX);
15160 printf (" ");
15161 print_vma (end, FULL_HEX);
15162 printf (" ");
15163 print_vma (file_ofs, FULL_HEX);
15164 printf ("\n %s\n", filenames);
15165
15166 filenames += 1 + strlen ((char *) filenames);
15167 }
15168
15169 return 1;
15170}
15171
1118d252
RM		 15172static const char *
15173get_gnu_elf_note_type (unsigned e_type)
15174{
15175 static char buff[64];
15176
15177 switch (e_type)
15178 {
15179 case NT_GNU_ABI_TAG:
15180 return _("NT_GNU_ABI_TAG (ABI version tag)");
15181 case NT_GNU_HWCAP:
15182 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15183 case NT_GNU_BUILD_ID:
15184 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 15185 case NT_GNU_GOLD_VERSION:
15186 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 15187 default:
15188 break;
15189 }
15190
15191 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15192 return buff;
15193}
15194
664f90a3
TT		 15195static int
15196print_gnu_note (Elf_Internal_Note *pnote)
15197{
15198 switch (pnote->type)
15199 {
15200 case NT_GNU_BUILD_ID:
15201 {
15202 unsigned long i;
15203
15204 printf (_(" Build ID: "));
15205 for (i = 0; i < pnote->descsz; ++i)
15206 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 15207 printf ("\n");
664f90a3
TT		 15208 }
15209 break;
15210
15211 case NT_GNU_ABI_TAG:
15212 {
15213 unsigned long os, major, minor, subminor;
15214 const char *osname;
15215
3102e897
NC		 15216 /* PR 17531: file: 030-599401-0.004. */
15217 if (pnote->descsz < 16)
15218 {
15219 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15220 break;
15221 }
15222
664f90a3
TT		 15223 os = byte_get ((unsigned char *) pnote->descdata, 4);
15224 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15225 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
15226 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
15227
15228 switch (os)
15229 {
15230 case GNU_ABI_TAG_LINUX:
15231 osname = "Linux";
15232 break;
15233 case GNU_ABI_TAG_HURD:
15234 osname = "Hurd";
15235 break;
15236 case GNU_ABI_TAG_SOLARIS:
15237 osname = "Solaris";
15238 break;
15239 case GNU_ABI_TAG_FREEBSD:
15240 osname = "FreeBSD";
15241 break;
15242 case GNU_ABI_TAG_NETBSD:
15243 osname = "NetBSD";
15244 break;
14ae95f2
RM		 15245 case GNU_ABI_TAG_SYLLABLE:
15246 osname = "Syllable";
15247 break;
15248 case GNU_ABI_TAG_NACL:
15249 osname = "NaCl";
15250 break;
664f90a3
TT		 15251 default:
15252 osname = "Unknown";
15253 break;
15254 }
15255
15256 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
15257 major, minor, subminor);
15258 }
15259 break;
926c5385
CC		 15260
15261 case NT_GNU_GOLD_VERSION:
15262 {
15263 unsigned long i;
15264
15265 printf (_(" Version: "));
15266 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
15267 printf ("%c", pnote->descdata[i]);
15268 printf ("\n");
15269 }
15270 break;
664f90a3
TT		 15271 }
15272
15273 return 1;
15274}
15275
685080f2
NC		 15276static const char *
15277get_v850_elf_note_type (enum v850_notes n_type)
15278{
15279 static char buff[64];
15280
15281 switch (n_type)
15282 {
15283 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
15284 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
15285 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
15286 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
15287 case V850_NOTE_CACHE_INFO: return _("Use of cache");
15288 case V850_NOTE_MMU_INFO: return _("Use of MMU");
15289 default:
15290 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
15291 return buff;
15292 }
15293}
15294
15295static int
15296print_v850_note (Elf_Internal_Note * pnote)
15297{
15298 unsigned int val;
15299
15300 if (pnote->descsz != 4)
15301 return 0;
15302 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
15303
15304 if (val == 0)
15305 {
15306 printf (_("not set\n"));
15307 return 1;
15308 }
15309
15310 switch (pnote->type)
15311 {
15312 case V850_NOTE_ALIGNMENT:
15313 switch (val)
15314 {
15315 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
15316 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
15317 }
15318 break;
14ae95f2 15319
685080f2
NC		 15320 case V850_NOTE_DATA_SIZE:
15321 switch (val)
15322 {
15323 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
15324 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
15325 }
15326 break;
14ae95f2 15327
685080f2
NC		 15328 case V850_NOTE_FPU_INFO:
15329 switch (val)
15330 {
15331 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
15332 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
15333 }
15334 break;
14ae95f2 15335
685080f2
NC		 15336 case V850_NOTE_MMU_INFO:
15337 case V850_NOTE_CACHE_INFO:
15338 case V850_NOTE_SIMD_INFO:
15339 if (val == EF_RH850_SIMD)
15340 {
15341 printf (_("yes\n"));
15342 return 1;
15343 }
15344 break;
15345
15346 default:
15347 /* An 'unknown note type' message will already have been displayed. */
15348 break;
15349 }
15350
15351 printf (_("unknown value: %x\n"), val);
15352 return 0;
15353}
15354
c6056a74
SF		 15355static int
15356process_netbsd_elf_note (Elf_Internal_Note * pnote)
15357{
15358 unsigned int version;
15359
15360 switch (pnote->type)
15361 {
15362 case NT_NETBSD_IDENT:
15363 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
15364 if ((version / 10000) % 100)
15365 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
15366 version, version / 100000000, (version / 1000000) % 100,
15367 (version / 10000) % 100 > 26 ? "Z" : "",
15368 'A' + (version / 10000) % 26);
15369 else
15370 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
15371 version, version / 100000000, (version / 1000000) % 100,
15372 (version / 100) % 100);
15373 return 1;
15374
15375 case NT_NETBSD_MARCH:
15376 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
15377 pnote->descdata);
15378 return 1;
15379
15380 default:
15381 break;
15382 }
15383
15384 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
15385 pnote->type);
15386 return 1;
15387}
15388
9437c45b 15389static const char *
d3ba0551 15390get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 15391{
15392 static char buff[64];
15393
b4db1224 15394 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 15395 {
15396 /* NetBSD core "procinfo" structure. */
15397 return _("NetBSD procinfo structure");
15398 }
15399
15400 /* As of Jan 2002 there are no other machine-independent notes
15401 defined for NetBSD core files. If the note type is less
15402 than the start of the machine-dependent note types, we don't
15403 understand it. */
15404
b4db1224 15405 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 15406 {
e9e44622 15407 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 15408 return buff;
15409 }
15410
15411 switch (elf_header.e_machine)
15412 {
15413 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15414 and PT_GETFPREGS == mach+2. */
15415
15416 case EM_OLD_ALPHA:
15417 case EM_ALPHA:
15418 case EM_SPARC:
15419 case EM_SPARC32PLUS:
15420 case EM_SPARCV9:
15421 switch (e_type)
15422 {
2b692964 15423 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 15424 return _("PT_GETREGS (reg structure)");
2b692964 15425 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 15426 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15427 default:
15428 break;
15429 }
15430 break;
15431
15432 /* On all other arch's, PT_GETREGS == mach+1 and
15433 PT_GETFPREGS == mach+3. */
15434 default:
15435 switch (e_type)
15436 {
2b692964 15437 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 15438 return _("PT_GETREGS (reg structure)");
2b692964 15439 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 15440 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15441 default:
15442 break;
15443 }
15444 }
15445
9cf03b7e 15446 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 15447 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 15448 return buff;
15449}
15450
70616151
TT		 15451static const char *
15452get_stapsdt_note_type (unsigned e_type)
15453{
15454 static char buff[64];
15455
15456 switch (e_type)
15457 {
15458 case NT_STAPSDT:
15459 return _("NT_STAPSDT (SystemTap probe descriptors)");
15460
15461 default:
15462 break;
15463 }
15464
15465 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15466 return buff;
15467}
15468
c6a9fc58
TT		 15469static int
15470print_stapsdt_note (Elf_Internal_Note *pnote)
15471{
15472 int addr_size = is_32bit_elf ? 4 : 8;
15473 char *data = pnote->descdata;
15474 char *data_end = pnote->descdata + pnote->descsz;
15475 bfd_vma pc, base_addr, semaphore;
15476 char *provider, *probe, *arg_fmt;
15477
15478 pc = byte_get ((unsigned char *) data, addr_size);
15479 data += addr_size;
15480 base_addr = byte_get ((unsigned char *) data, addr_size);
15481 data += addr_size;
15482 semaphore = byte_get ((unsigned char *) data, addr_size);
15483 data += addr_size;
15484
15485 provider = data;
15486 data += strlen (data) + 1;
15487 probe = data;
15488 data += strlen (data) + 1;
15489 arg_fmt = data;
15490 data += strlen (data) + 1;
15491
15492 printf (_(" Provider: %s\n"), provider);
15493 printf (_(" Name: %s\n"), probe);
15494 printf (_(" Location: "));
15495 print_vma (pc, FULL_HEX);
15496 printf (_(", Base: "));
15497 print_vma (base_addr, FULL_HEX);
15498 printf (_(", Semaphore: "));
15499 print_vma (semaphore, FULL_HEX);
9cf03b7e 15500 printf ("\n");
c6a9fc58
TT		 15501 printf (_(" Arguments: %s\n"), arg_fmt);
15502
15503 return data == data_end;
15504}
15505
00e98fc7
TG		 15506static const char *
15507get_ia64_vms_note_type (unsigned e_type)
15508{
15509 static char buff[64];
15510
15511 switch (e_type)
15512 {
15513 case NT_VMS_MHD:
15514 return _("NT_VMS_MHD (module header)");
15515 case NT_VMS_LNM:
15516 return _("NT_VMS_LNM (language name)");
15517 case NT_VMS_SRC:
15518 return _("NT_VMS_SRC (source files)");
15519 case NT_VMS_TITLE:
9cf03b7e 15520 return "NT_VMS_TITLE";
00e98fc7
TG		 15521 case NT_VMS_EIDC:
15522 return _("NT_VMS_EIDC (consistency check)");
15523 case NT_VMS_FPMODE:
15524 return _("NT_VMS_FPMODE (FP mode)");
15525 case NT_VMS_LINKTIME:
9cf03b7e 15526 return "NT_VMS_LINKTIME";
00e98fc7
TG		 15527 case NT_VMS_IMGNAM:
15528 return _("NT_VMS_IMGNAM (image name)");
15529 case NT_VMS_IMGID:
15530 return _("NT_VMS_IMGID (image id)");
15531 case NT_VMS_LINKID:
15532 return _("NT_VMS_LINKID (link id)");
15533 case NT_VMS_IMGBID:
15534 return _("NT_VMS_IMGBID (build id)");
15535 case NT_VMS_GSTNAM:
15536 return _("NT_VMS_GSTNAM (sym table name)");
15537 case NT_VMS_ORIG_DYN:
9cf03b7e 15538 return "NT_VMS_ORIG_DYN";
00e98fc7 15539 case NT_VMS_PATCHTIME:
9cf03b7e 15540 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 15541 default:
15542 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15543 return buff;
15544 }
15545}
15546
15547static int
15548print_ia64_vms_note (Elf_Internal_Note * pnote)
15549{
15550 switch (pnote->type)
15551 {
15552 case NT_VMS_MHD:
15553 if (pnote->descsz > 36)
15554 {
15555 size_t l = strlen (pnote->descdata + 34);
15556 printf (_(" Creation date : %.17s\n"), pnote->descdata);
15557 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
15558 printf (_(" Module name : %s\n"), pnote->descdata + 34);
15559 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
15560 }
15561 else
15562 printf (_(" Invalid size\n"));
15563 break;
15564 case NT_VMS_LNM:
15565 printf (_(" Language: %s\n"), pnote->descdata);
15566 break;
15567#ifdef BFD64
15568 case NT_VMS_FPMODE:
9cf03b7e 15569 printf (_(" Floating Point mode: "));
4a5cb34f 15570 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15571 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
00e98fc7
TG		 15572 break;
15573 case NT_VMS_LINKTIME:
15574 printf (_(" Link time: "));
15575 print_vms_time
15576 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15577 printf ("\n");
15578 break;
15579 case NT_VMS_PATCHTIME:
15580 printf (_(" Patch time: "));
15581 print_vms_time
15582 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15583 printf ("\n");
15584 break;
15585 case NT_VMS_ORIG_DYN:
15586 printf (_(" Major id: %u, minor id: %u\n"),
15587 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15588 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 15589 printf (_(" Last modified : "));
00e98fc7
TG		 15590 print_vms_time
15591 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 15592 printf (_("\n Link flags : "));
4a5cb34f 15593 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15594 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
00e98fc7 15595 printf (_(" Header flags: 0x%08x\n"),
948f632f 15596 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
00e98fc7
TG		 15597 printf (_(" Image id : %s\n"), pnote->descdata + 32);
15598 break;
15599#endif
15600 case NT_VMS_IMGNAM:
15601 printf (_(" Image name: %s\n"), pnote->descdata);
15602 break;
15603 case NT_VMS_GSTNAM:
15604 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
15605 break;
15606 case NT_VMS_IMGID:
15607 printf (_(" Image id: %s\n"), pnote->descdata);
15608 break;
15609 case NT_VMS_LINKID:
15610 printf (_(" Linker id: %s\n"), pnote->descdata);
15611 break;
15612 default:
15613 break;
15614 }
15615 return 1;
15616}
15617
6d118b09
NC		 15618/* Note that by the ELF standard, the name field is already null byte
15619 terminated, and namesz includes the terminating null byte.
15620 I.E. the value of namesz for the name "FSF" is 4.
15621
e3c8793a 15622 If the value of namesz is zero, there is no name present. */
779fe533 15623static int
2cf0635d 15624process_note (Elf_Internal_Note * pnote)
779fe533 15625{
2cf0635d
NC		 15626 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15627 const char * nt;
9437c45b
JT		 15628
15629 if (pnote->namesz == 0)
1ec5cd37
NC		 15630 /* If there is no note name, then use the default set of
15631 note type strings. */
15632 nt = get_note_type (pnote->type);
15633
1118d252
RM		 15634 else if (const_strneq (pnote->namedata, "GNU"))
15635 /* GNU-specific object file notes. */
15636 nt = get_gnu_elf_note_type (pnote->type);
15637
0112cd26 15638 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 15639 /* NetBSD-specific core file notes. */
15640 nt = get_netbsd_elfcore_note_type (pnote->type);
15641
c6056a74
SF		 15642 else if (const_strneq (pnote->namedata, "NetBSD"))
15643 /* NetBSD-specific core file notes. */
15644 return process_netbsd_elf_note (pnote);
15645
b15fa79e
AM		 15646 else if (strneq (pnote->namedata, "SPU/", 4))
15647 {
15648 /* SPU-specific core file notes. */
15649 nt = pnote->namedata + 4;
15650 name = "SPU";
15651 }
15652
00e98fc7
TG		 15653 else if (const_strneq (pnote->namedata, "IPF/VMS"))
15654 /* VMS/ia64-specific file notes. */
15655 nt = get_ia64_vms_note_type (pnote->type);
15656
70616151
TT		 15657 else if (const_strneq (pnote->namedata, "stapsdt"))
15658 nt = get_stapsdt_note_type (pnote->type);
15659
9437c45b 15660 else
1ec5cd37
NC		 15661 /* Don't recognize this note name; just use the default set of
15662 note type strings. */
00e98fc7 15663 nt = get_note_type (pnote->type);
9437c45b 15664
2aee03ae 15665 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 15666
15667 if (const_strneq (pnote->namedata, "IPF/VMS"))
15668 return print_ia64_vms_note (pnote);
664f90a3
TT		 15669 else if (const_strneq (pnote->namedata, "GNU"))
15670 return print_gnu_note (pnote);
c6a9fc58
TT		 15671 else if (const_strneq (pnote->namedata, "stapsdt"))
15672 return print_stapsdt_note (pnote);
9ece1fa9
TT		 15673 else if (const_strneq (pnote->namedata, "CORE"))
15674 return print_core_note (pnote);
00e98fc7
TG		 15675 else
15676 return 1;
779fe533
NC		 15677}
15678
6d118b09 15679
779fe533 15680static int
2cf0635d 15681process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 15682{
2cf0635d
NC		 15683 Elf_External_Note * pnotes;
15684 Elf_External_Note * external;
c8071705 15685 char * end;
b34976b6 15686 int res = 1;
103f02d3 15687
779fe533
NC		 15688 if (length <= 0)
15689 return 0;
103f02d3 15690
3f5e193b 15691 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 15692 _("notes"));
dd24e3da 15693 if (pnotes == NULL)
a6e9f9df 15694 return 0;
779fe533 15695
103f02d3 15696 external = pnotes;
103f02d3 15697
9dd3a467 15698 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 15699 (unsigned long) offset, (unsigned long) length);
2aee03ae 15700 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 15701
c8071705
NC		 15702 end = (char *) pnotes + length;
15703 while ((char *) external < end)
779fe533 15704 {
b34976b6 15705 Elf_Internal_Note inote;
15b42fb0
AM		 15706 size_t min_notesz;
15707 char *next;
2cf0635d 15708 char * temp = NULL;
c8071705 15709 size_t data_remaining = end - (char *) external;
6d118b09 15710
00e98fc7 15711 if (!is_ia64_vms ())
15b42fb0 15712 {
9dd3a467
NC		 15713 /* PR binutils/15191
15714 Make sure that there is enough data to read. */
15b42fb0
AM		 15715 min_notesz = offsetof (Elf_External_Note, name);
15716 if (data_remaining < min_notesz)
9dd3a467
NC		 15717 {
15718 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15719 (int) data_remaining);
15720 break;
15721 }
15b42fb0
AM		 15722 inote.type = BYTE_GET (external->type);
15723 inote.namesz = BYTE_GET (external->namesz);
15724 inote.namedata = external->name;
15725 inote.descsz = BYTE_GET (external->descsz);
15726 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
834f871c 15727 /* PR 17531: file: 3443835e. */
c8071705 15728 if (inote.descdata < (char *) pnotes || inote.descdata > end)
834f871c
NC		 15729 {
15730 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15731 inote.descdata = inote.namedata;
15732 inote.namesz = 0;
15733 }
14ae95f2 15734
15b42fb0
AM		 15735 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15736 next = inote.descdata + align_power (inote.descsz, 2);
15737 }
00e98fc7 15738 else
15b42fb0
AM		 15739 {
15740 Elf64_External_VMS_Note *vms_external;
00e98fc7 15741
9dd3a467
NC		 15742 /* PR binutils/15191
15743 Make sure that there is enough data to read. */
15b42fb0
AM		 15744 min_notesz = offsetof (Elf64_External_VMS_Note, name);
15745 if (data_remaining < min_notesz)
9dd3a467
NC		 15746 {
15747 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15748 (int) data_remaining);
15749 break;
15750 }
3e55a963 15751
15b42fb0
AM		 15752 vms_external = (Elf64_External_VMS_Note *) external;
15753 inote.type = BYTE_GET (vms_external->type);
15754 inote.namesz = BYTE_GET (vms_external->namesz);
15755 inote.namedata = vms_external->name;
15756 inote.descsz = BYTE_GET (vms_external->descsz);
15757 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15758 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15759 next = inote.descdata + align_power (inote.descsz, 3);
15760 }
15761
15762 if (inote.descdata < (char *) external + min_notesz
15763 || next < (char *) external + min_notesz
5d921cbd
NC		 15764 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15765 || inote.namedata + inote.namesz < inote.namedata
15766 || inote.descdata + inote.descsz < inote.descdata
15b42fb0 15767 || data_remaining < (size_t)(next - (char *) external))
3e55a963 15768 {
15b42fb0 15769 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 15770 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 15771 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 15772 inote.type, inote.namesz, inote.descsz);
15773 break;
15774 }
15775
15b42fb0 15776 external = (Elf_External_Note *) next;
dd24e3da 15777
6d118b09
NC		 15778 /* Verify that name is null terminated. It appears that at least
15779 one version of Linux (RedHat 6.0) generates corefiles that don't
15780 comply with the ELF spec by failing to include the null byte in
15781 namesz. */
8b971f9f 15782 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 15783 {
3f5e193b 15784 temp = (char *) malloc (inote.namesz + 1);
6d118b09
NC		 15785 if (temp == NULL)
15786 {
8b73c356 15787 error (_("Out of memory allocating space for inote name\n"));
6d118b09
NC		 15788 res = 0;
15789 break;
15790 }
76da6bbe 15791
6d118b09
NC		 15792 strncpy (temp, inote.namedata, inote.namesz);
15793 temp[inote.namesz] = 0;
76da6bbe 15794
6d118b09
NC		 15795 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15796 inote.namedata = temp;
15797 }
15798
15799 res &= process_note (& inote);
103f02d3 15800
6d118b09
NC		 15801 if (temp != NULL)
15802 {
15803 free (temp);
15804 temp = NULL;
15805 }
779fe533
NC		 15806 }
15807
15808 free (pnotes);
103f02d3 15809
779fe533
NC		 15810 return res;
15811}
15812
15813static int
2cf0635d 15814process_corefile_note_segments (FILE * file)
779fe533 15815{
2cf0635d 15816 Elf_Internal_Phdr * segment;
b34976b6
AM		 15817 unsigned int i;
15818 int res = 1;
103f02d3 15819
d93f0186 15820 if (! get_program_headers (file))
779fe533 15821 return 0;
103f02d3 15822
779fe533
NC		 15823 for (i = 0, segment = program_headers;
15824 i < elf_header.e_phnum;
b34976b6 15825 i++, segment++)
779fe533
NC		 15826 {
15827 if (segment->p_type == PT_NOTE)
103f02d3 15828 res &= process_corefile_note_segment (file,
30800947
NC		 15829 (bfd_vma) segment->p_offset,
15830 (bfd_vma) segment->p_filesz);
779fe533 15831 }
103f02d3 15832
779fe533
NC		 15833 return res;
15834}
15835
685080f2
NC		 15836static int
15837process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
15838{
15839 Elf_External_Note * pnotes;
15840 Elf_External_Note * external;
c8071705 15841 char * end;
685080f2
NC		 15842 int res = 1;
15843
15844 if (length <= 0)
15845 return 0;
15846
15847 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15848 _("v850 notes"));
15849 if (pnotes == NULL)
15850 return 0;
15851
15852 external = pnotes;
c8071705 15853 end = (char*) pnotes + length;
685080f2
NC		 15854
15855 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15856 (unsigned long) offset, (unsigned long) length);
15857
c8071705 15858 while ((char *) external + sizeof (Elf_External_Note) < end)
685080f2
NC		 15859 {
15860 Elf_External_Note * next;
15861 Elf_Internal_Note inote;
15862
15863 inote.type = BYTE_GET (external->type);
15864 inote.namesz = BYTE_GET (external->namesz);
15865 inote.namedata = external->name;
15866 inote.descsz = BYTE_GET (external->descsz);
15867 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15868 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15869
c8071705
NC		 15870 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
15871 {
15872 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15873 inote.descdata = inote.namedata;
15874 inote.namesz = 0;
15875 }
15876
685080f2
NC		 15877 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
15878
c8071705 15879 if ( ((char *) next > end)
685080f2
NC		 15880 || ((char *) next < (char *) pnotes))
15881 {
15882 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15883 (unsigned long) ((char *) external - (char *) pnotes));
15884 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15885 inote.type, inote.namesz, inote.descsz);
15886 break;
15887 }
15888
15889 external = next;
15890
15891 /* Prevent out-of-bounds indexing. */
c8071705 15892 if ( inote.namedata + inote.namesz > end
685080f2
NC		 15893 || inote.namedata + inote.namesz < inote.namedata)
15894 {
15895 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15896 (unsigned long) ((char *) external - (char *) pnotes));
15897 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15898 inote.type, inote.namesz, inote.descsz);
15899 break;
15900 }
15901
15902 printf (" %s: ", get_v850_elf_note_type (inote.type));
15903
15904 if (! print_v850_note (& inote))
15905 {
15906 res = 0;
15907 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15908 inote.namesz, inote.descsz);
15909 }
15910 }
15911
15912 free (pnotes);
15913
15914 return res;
15915}
15916
779fe533 15917static int
2cf0635d 15918process_note_sections (FILE * file)
1ec5cd37 15919{
2cf0635d 15920 Elf_Internal_Shdr * section;
1ec5cd37 15921 unsigned long i;
df565f32 15922 int n = 0;
1ec5cd37
NC		 15923 int res = 1;
15924
15925 for (i = 0, section = section_headers;
fa1908fd 15926 i < elf_header.e_shnum && section != NULL;
1ec5cd37 15927 i++, section++)
685080f2
NC		 15928 {
15929 if (section->sh_type == SHT_NOTE)
15930 {
15931 res &= process_corefile_note_segment (file,
15932 (bfd_vma) section->sh_offset,
15933 (bfd_vma) section->sh_size);
15934 n++;
15935 }
15936
15937 if (( elf_header.e_machine == EM_V800
15938 || elf_header.e_machine == EM_V850
15939 || elf_header.e_machine == EM_CYGNUS_V850)
15940 && section->sh_type == SHT_RENESAS_INFO)
15941 {
15942 res &= process_v850_notes (file,
15943 (bfd_vma) section->sh_offset,
15944 (bfd_vma) section->sh_size);
15945 n++;
15946 }
15947 }
df565f32
NC		 15948
15949 if (n == 0)
15950 /* Try processing NOTE segments instead. */
15951 return process_corefile_note_segments (file);
1ec5cd37
NC		 15952
15953 return res;
15954}
15955
15956static int
2cf0635d 15957process_notes (FILE * file)
779fe533
NC		 15958{
15959 /* If we have not been asked to display the notes then do nothing. */
15960 if (! do_notes)
15961 return 1;
103f02d3 15962
779fe533 15963 if (elf_header.e_type != ET_CORE)
1ec5cd37 15964 return process_note_sections (file);
103f02d3 15965
779fe533 15966 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 15967 if (elf_header.e_phnum > 0)
15968 return process_corefile_note_segments (file);
779fe533 15969
1ec5cd37
NC		 15970 printf (_("No note segments present in the core file.\n"));
15971 return 1;
779fe533
NC		 15972}
15973
252b5132 15974static int
2cf0635d 15975process_arch_specific (FILE * file)
252b5132 15976{
a952a375
NC		 15977 if (! do_arch)
15978 return 1;
15979
252b5132
RH		 15980 switch (elf_header.e_machine)
15981 {
11c1ff18
PB		 15982 case EM_ARM:
15983 return process_arm_specific (file);
252b5132 15984 case EM_MIPS:
4fe85591 15985 case EM_MIPS_RS3_LE:
252b5132
RH		 15986 return process_mips_specific (file);
15987 break;
35c08157
KLC		 15988 case EM_NDS32:
15989 return process_nds32_specific (file);
15990 break;
34c8bcba
JM		 15991 case EM_PPC:
15992 return process_power_specific (file);
15993 break;
643f7afb
AK		 15994 case EM_S390:
15995 case EM_S390_OLD:
15996 return process_s390_specific (file);
15997 break;
9e8c70f9
DM		 15998 case EM_SPARC:
15999 case EM_SPARC32PLUS:
16000 case EM_SPARCV9:
16001 return process_sparc_specific (file);
16002 break;
59e6276b
JM		 16003 case EM_TI_C6000:
16004 return process_tic6x_specific (file);
16005 break;
13761a11
NC		 16006 case EM_MSP430:
16007 return process_msp430x_specific (file);
252b5132
RH		 16008 default:
16009 break;
16010 }
16011 return 1;
16012}
16013
16014static int
2cf0635d 16015get_file_header (FILE * file)
252b5132 16016{
9ea033b2
NC		 16017 /* Read in the identity array. */
16018 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 16019 return 0;
16020
9ea033b2 16021 /* Determine how to read the rest of the header. */
b34976b6 16022 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 16023 {
16024 default: /* fall through */
16025 case ELFDATANONE: /* fall through */
adab8cdc
AO		 16026 case ELFDATA2LSB:
16027 byte_get = byte_get_little_endian;
16028 byte_put = byte_put_little_endian;
16029 break;
16030 case ELFDATA2MSB:
16031 byte_get = byte_get_big_endian;
16032 byte_put = byte_put_big_endian;
16033 break;
9ea033b2
NC		 16034 }
16035
16036 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 16037 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 16038
16039 /* Read in the rest of the header. */
16040 if (is_32bit_elf)
16041 {
16042 Elf32_External_Ehdr ehdr32;
252b5132 16043
9ea033b2
NC		 16044 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
16045 return 0;
103f02d3 16046
9ea033b2
NC		 16047 elf_header.e_type = BYTE_GET (ehdr32.e_type);
16048 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
16049 elf_header.e_version = BYTE_GET (ehdr32.e_version);
16050 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
16051 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
16052 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
16053 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
16054 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
16055 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
16056 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
16057 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
16058 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
16059 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
16060 }
252b5132 16061 else
9ea033b2
NC		 16062 {
16063 Elf64_External_Ehdr ehdr64;
a952a375
NC		 16064
16065 /* If we have been compiled with sizeof (bfd_vma) == 4, then
16066 we will not be able to cope with the 64bit data found in
16067 64 ELF files. Detect this now and abort before we start
50c2245b 16068 overwriting things. */
a952a375
NC		 16069 if (sizeof (bfd_vma) < 8)
16070 {
e3c8793a
NC		 16071 error (_("This instance of readelf has been built without support for a\n\
1607264 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 16073 return 0;
16074 }
103f02d3 16075
9ea033b2
NC		 16076 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
16077 return 0;
103f02d3 16078
9ea033b2
NC		 16079 elf_header.e_type = BYTE_GET (ehdr64.e_type);
16080 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
16081 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 16082 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
16083 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
16084 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 16085 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
16086 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
16087 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
16088 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
16089 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
16090 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
16091 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
16092 }
252b5132 16093
7ece0d85
JJ		 16094 if (elf_header.e_shoff)
16095 {
16096 /* There may be some extensions in the first section header. Don't
16097 bomb if we can't read it. */
16098 if (is_32bit_elf)
049b0c3a 16099 get_32bit_section_headers (file, TRUE);
7ece0d85 16100 else
049b0c3a 16101 get_64bit_section_headers (file, TRUE);
7ece0d85 16102 }
560f3c1c 16103
252b5132
RH		 16104 return 1;
16105}
16106
fb52b2f4
NC		 16107/* Process one ELF object file according to the command line options.
16108 This file may actually be stored in an archive. The file is
16109 positioned at the start of the ELF object. */
16110
ff78d6d6 16111static int
2cf0635d 16112process_object (char * file_name, FILE * file)
252b5132 16113{
252b5132
RH		 16114 unsigned int i;
16115
252b5132
RH		 16116 if (! get_file_header (file))
16117 {
16118 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 16119 return 1;
252b5132
RH		 16120 }
16121
16122 /* Initialise per file variables. */
60bca95a 16123 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 16124 version_info[i] = 0;
16125
60bca95a 16126 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 16127 dynamic_info[i] = 0;
5115b233 16128 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 16129
16130 /* Process the file. */
16131 if (show_name)
16132 printf (_("\nFile: %s\n"), file_name);
16133
18bd398b
NC		 16134 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16135 Note we do this even if cmdline_dump_sects is empty because we
16136 must make sure that the dump_sets array is zeroed out before each
16137 object file is processed. */
16138 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 16139 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 16140
16141 if (num_cmdline_dump_sects > 0)
16142 {
16143 if (num_dump_sects == 0)
16144 /* A sneaky way of allocating the dump_sects array. */
09c11c86 16145 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 16146
16147 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 16148 memcpy (dump_sects, cmdline_dump_sects,
16149 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 16150 }
d70c5fc7 16151
252b5132 16152 if (! process_file_header ())
fb52b2f4 16153 return 1;
252b5132 16154
d1f5c6e3 16155 if (! process_section_headers (file))
2f62977e 16156 {
d1f5c6e3
L		 16157 /* Without loaded section headers we cannot process lots of
16158 things. */
2f62977e 16159 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 16160
2f62977e 16161 if (! do_using_dynamic)
2c610e4b 16162 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 16163 }
252b5132 16164
d1f5c6e3
L		 16165 if (! process_section_groups (file))
16166 {
16167 /* Without loaded section groups we cannot process unwind. */
16168 do_unwind = 0;
16169 }
16170
2f62977e 16171 if (process_program_headers (file))
b2d38a17 16172 process_dynamic_section (file);
252b5132
RH		 16173
16174 process_relocs (file);
16175
4d6ed7c8
NC		 16176 process_unwind (file);
16177
252b5132
RH		 16178 process_symbol_table (file);
16179
16180 process_syminfo (file);
16181
16182 process_version_sections (file);
16183
16184 process_section_contents (file);
f5842774 16185
1ec5cd37 16186 process_notes (file);
103f02d3 16187
047b2264
JJ		 16188 process_gnu_liblist (file);
16189
252b5132
RH		 16190 process_arch_specific (file);
16191
d93f0186
NC		 16192 if (program_headers)
16193 {
16194 free (program_headers);
16195 program_headers = NULL;
16196 }
16197
252b5132
RH		 16198 if (section_headers)
16199 {
16200 free (section_headers);
16201 section_headers = NULL;
16202 }
16203
16204 if (string_table)
16205 {
16206 free (string_table);
16207 string_table = NULL;
d40ac9bd 16208 string_table_length = 0;
252b5132
RH		 16209 }
16210
16211 if (dynamic_strings)
16212 {
16213 free (dynamic_strings);
16214 dynamic_strings = NULL;
d79b3d50 16215 dynamic_strings_length = 0;
252b5132
RH		 16216 }
16217
16218 if (dynamic_symbols)
16219 {
16220 free (dynamic_symbols);
16221 dynamic_symbols = NULL;
19936277 16222 num_dynamic_syms = 0;
252b5132
RH		 16223 }
16224
16225 if (dynamic_syminfo)
16226 {
16227 free (dynamic_syminfo);
16228 dynamic_syminfo = NULL;
16229 }
ff78d6d6 16230
293c573e
MR		 16231 if (dynamic_section)
16232 {
16233 free (dynamic_section);
16234 dynamic_section = NULL;
16235 }
16236
e4b17d5c
L		 16237 if (section_headers_groups)
16238 {
16239 free (section_headers_groups);
16240 section_headers_groups = NULL;
16241 }
16242
16243 if (section_groups)
16244 {
2cf0635d
NC		 16245 struct group_list * g;
16246 struct group_list * next;
e4b17d5c
L		 16247
16248 for (i = 0; i < group_count; i++)
16249 {
16250 for (g = section_groups [i].root; g != NULL; g = next)
16251 {
16252 next = g->next;
16253 free (g);
16254 }
16255 }
16256
16257 free (section_groups);
16258 section_groups = NULL;
16259 }
16260
19e6b90e 16261 free_debug_memory ();
18bd398b 16262
ff78d6d6 16263 return 0;
252b5132
RH		 16264}
16265
2cf0635d
NC		 16266/* Process an ELF archive.
16267 On entry the file is positioned just after the ARMAG string. */
16268
16269static int
16270process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
16271{
16272 struct archive_info arch;
16273 struct archive_info nested_arch;
16274 size_t got;
2cf0635d
NC		 16275 int ret;
16276
16277 show_name = 1;
16278
16279 /* The ARCH structure is used to hold information about this archive. */
16280 arch.file_name = NULL;
16281 arch.file = NULL;
16282 arch.index_array = NULL;
16283 arch.sym_table = NULL;
16284 arch.longnames = NULL;
16285
16286 /* The NESTED_ARCH structure is used as a single-item cache of information
16287 about a nested archive (when members of a thin archive reside within
16288 another regular archive file). */
16289 nested_arch.file_name = NULL;
16290 nested_arch.file = NULL;
16291 nested_arch.index_array = NULL;
16292 nested_arch.sym_table = NULL;
16293 nested_arch.longnames = NULL;
16294
16295 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
16296 {
16297 ret = 1;
16298 goto out;
4145f1d5 16299 }
fb52b2f4 16300
4145f1d5
NC		 16301 if (do_archive_index)
16302 {
2cf0635d 16303 if (arch.sym_table == NULL)
4145f1d5
NC		 16304 error (_("%s: unable to dump the index as none was found\n"), file_name);
16305 else
16306 {
591f7597 16307 unsigned long i, l;
4145f1d5
NC		 16308 unsigned long current_pos;
16309
591f7597
NC		 16310 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16311 file_name, (unsigned long) arch.index_num, arch.sym_size);
4145f1d5
NC		 16312 current_pos = ftell (file);
16313
2cf0635d 16314 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 16315 {
2cf0635d
NC		 16316 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
16317 {
16318 char * member_name;
4145f1d5 16319
2cf0635d
NC		 16320 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
16321
16322 if (member_name != NULL)
16323 {
16324 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
16325
16326 if (qualified_name != NULL)
16327 {
c2a7d3f5
NC		 16328 printf (_("Contents of binary %s at offset "), qualified_name);
16329 (void) print_vma (arch.index_array[i], PREFIX_HEX);
16330 putchar ('\n');
2cf0635d
NC		 16331 free (qualified_name);
16332 }
4145f1d5
NC		 16333 }
16334 }
2cf0635d
NC		 16335
16336 if (l >= arch.sym_size)
4145f1d5
NC		 16337 {
16338 error (_("%s: end of the symbol table reached before the end of the index\n"),
16339 file_name);
cb8f3167 16340 break;
4145f1d5 16341 }
591f7597
NC		 16342 /* PR 17531: file: 0b6630b2. */
16343 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
16344 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
4145f1d5
NC		 16345 }
16346
c2a7d3f5
NC		 16347 if (arch.uses_64bit_indicies)
16348 l = (l + 7) & ~ 7;
16349 else
16350 l += l & 1;
16351
2cf0635d 16352 if (l < arch.sym_size)
c2a7d3f5
NC		 16353 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16354 file_name, arch.sym_size - l);
4145f1d5 16355
4145f1d5
NC		 16356 if (fseek (file, current_pos, SEEK_SET) != 0)
16357 {
16358 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 16359 ret = 1;
16360 goto out;
4145f1d5 16361 }
fb52b2f4 16362 }
4145f1d5
NC		 16363
16364 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
16365 && !do_segments && !do_header && !do_dump && !do_version
16366 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 16367 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 16368 {
16369 ret = 0; /* Archive index only. */
16370 goto out;
16371 }
fb52b2f4
NC		 16372 }
16373
d989285c 16374 ret = 0;
fb52b2f4
NC		 16375
16376 while (1)
16377 {
2cf0635d
NC		 16378 char * name;
16379 size_t namelen;
16380 char * qualified_name;
16381
16382 /* Read the next archive header. */
16383 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
16384 {
16385 error (_("%s: failed to seek to next archive header\n"), file_name);
16386 return 1;
16387 }
16388 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
16389 if (got != sizeof arch.arhdr)
16390 {
16391 if (got == 0)
16392 break;
16393 error (_("%s: failed to read archive header\n"), file_name);
16394 ret = 1;
16395 break;
16396 }
16397 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
16398 {
16399 error (_("%s: did not find a valid archive header\n"), arch.file_name);
16400 ret = 1;
16401 break;
16402 }
16403
16404 arch.next_arhdr_offset += sizeof arch.arhdr;
16405
16406 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
16407 if (archive_file_size & 01)
16408 ++archive_file_size;
16409
16410 name = get_archive_member_name (&arch, &nested_arch);
16411 if (name == NULL)
fb52b2f4 16412 {
0fd3a477 16413 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16414 ret = 1;
16415 break;
fb52b2f4 16416 }
2cf0635d 16417 namelen = strlen (name);
fb52b2f4 16418
2cf0635d
NC		 16419 qualified_name = make_qualified_name (&arch, &nested_arch, name);
16420 if (qualified_name == NULL)
fb52b2f4 16421 {
2cf0635d 16422 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16423 ret = 1;
16424 break;
fb52b2f4
NC		 16425 }
16426
2cf0635d
NC		 16427 if (is_thin_archive && arch.nested_member_origin == 0)
16428 {
16429 /* This is a proxy for an external member of a thin archive. */
16430 FILE * member_file;
16431 char * member_file_name = adjust_relative_path (file_name, name, namelen);
16432 if (member_file_name == NULL)
16433 {
16434 ret = 1;
16435 break;
16436 }
16437
16438 member_file = fopen (member_file_name, "rb");
16439 if (member_file == NULL)
16440 {
16441 error (_("Input file '%s' is not readable.\n"), member_file_name);
16442 free (member_file_name);
16443 ret = 1;
16444 break;
16445 }
16446
16447 archive_file_offset = arch.nested_member_origin;
16448
16449 ret |= process_object (qualified_name, member_file);
16450
16451 fclose (member_file);
16452 free (member_file_name);
16453 }
16454 else if (is_thin_archive)
16455 {
a043396b
NC		 16456 /* PR 15140: Allow for corrupt thin archives. */
16457 if (nested_arch.file == NULL)
16458 {
16459 error (_("%s: contains corrupt thin archive: %s\n"),
16460 file_name, name);
16461 ret = 1;
16462 break;
16463 }
16464
2cf0635d
NC		 16465 /* This is a proxy for a member of a nested archive. */
16466 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
16467
16468 /* The nested archive file will have been opened and setup by
16469 get_archive_member_name. */
16470 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
16471 {
16472 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
16473 ret = 1;
16474 break;
16475 }
16476
16477 ret |= process_object (qualified_name, nested_arch.file);
16478 }
16479 else
16480 {
16481 archive_file_offset = arch.next_arhdr_offset;
16482 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 16483
2cf0635d
NC		 16484 ret |= process_object (qualified_name, file);
16485 }
fb52b2f4 16486
2b52916e
L		 16487 if (dump_sects != NULL)
16488 {
16489 free (dump_sects);
16490 dump_sects = NULL;
16491 num_dump_sects = 0;
16492 }
16493
2cf0635d 16494 free (qualified_name);
fb52b2f4
NC		 16495 }
16496
4145f1d5 16497 out:
2cf0635d
NC		 16498 if (nested_arch.file != NULL)
16499 fclose (nested_arch.file);
16500 release_archive (&nested_arch);
16501 release_archive (&arch);
fb52b2f4 16502
d989285c 16503 return ret;
fb52b2f4
NC		 16504}
16505
16506static int
2cf0635d 16507process_file (char * file_name)
fb52b2f4 16508{
2cf0635d 16509 FILE * file;
fb52b2f4
NC		 16510 struct stat statbuf;
16511 char armag[SARMAG];
16512 int ret;
16513
16514 if (stat (file_name, &statbuf) < 0)
16515 {
f24ddbdd
NC		 16516 if (errno == ENOENT)
16517 error (_("'%s': No such file\n"), file_name);
16518 else
16519 error (_("Could not locate '%s'. System error message: %s\n"),
16520 file_name, strerror (errno));
16521 return 1;
16522 }
16523
16524 if (! S_ISREG (statbuf.st_mode))
16525 {
16526 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 16527 return 1;
16528 }
16529
16530 file = fopen (file_name, "rb");
16531 if (file == NULL)
16532 {
f24ddbdd 16533 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 16534 return 1;
16535 }
16536
16537 if (fread (armag, SARMAG, 1, file) != 1)
16538 {
4145f1d5 16539 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 16540 fclose (file);
16541 return 1;
16542 }
16543
f54498b4
NC		 16544 current_file_size = (bfd_size_type) statbuf.st_size;
16545
fb52b2f4 16546 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 16547 ret = process_archive (file_name, file, FALSE);
16548 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16549 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 16550 else
16551 {
4145f1d5
NC		 16552 if (do_archive_index)
16553 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16554 file_name);
16555
fb52b2f4
NC		 16556 rewind (file);
16557 archive_file_size = archive_file_offset = 0;
16558 ret = process_object (file_name, file);
16559 }
16560
16561 fclose (file);
16562
f54498b4 16563 current_file_size = 0;
fb52b2f4
NC		 16564 return ret;
16565}
16566
252b5132
RH		 16567#ifdef SUPPORT_DISASSEMBLY
16568/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 16569 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 16570 symbols. */
252b5132
RH		 16571
16572void
2cf0635d 16573print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 16574{
16575 fprintf (outfile,"0x%8.8x", addr);
16576}
16577
e3c8793a 16578/* Needed by the i386 disassembler. */
252b5132
RH		 16579void
16580db_task_printsym (unsigned int addr)
16581{
16582 print_address (addr, stderr);
16583}
16584#endif
16585
16586int
2cf0635d 16587main (int argc, char ** argv)
252b5132 16588{
ff78d6d6
L		 16589 int err;
16590
252b5132
RH		 16591#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16592 setlocale (LC_MESSAGES, "");
3882b010
L		 16593#endif
16594#if defined (HAVE_SETLOCALE)
16595 setlocale (LC_CTYPE, "");
252b5132
RH		 16596#endif
16597 bindtextdomain (PACKAGE, LOCALEDIR);
16598 textdomain (PACKAGE);
16599
869b9d07
MM		 16600 expandargv (&argc, &argv);
16601
252b5132
RH		 16602 parse_args (argc, argv);
16603
18bd398b 16604 if (num_dump_sects > 0)
59f14fc0 16605 {
18bd398b 16606 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 16607 cmdline_dump_sects = (dump_type *)
16608 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 16609 if (cmdline_dump_sects == NULL)
591a748a 16610 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 16611 else
16612 {
09c11c86
NC		 16613 memcpy (cmdline_dump_sects, dump_sects,
16614 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 16615 num_cmdline_dump_sects = num_dump_sects;
16616 }
16617 }
16618
18bd398b
NC		 16619 if (optind < (argc - 1))
16620 show_name = 1;
5656ba2c
L		 16621 else if (optind >= argc)
16622 {
16623 warn (_("Nothing to do.\n"));
16624 usage (stderr);
16625 }
18bd398b 16626
ff78d6d6 16627 err = 0;
252b5132 16628 while (optind < argc)
18bd398b 16629 err |= process_file (argv[optind++]);
252b5132
RH		 16630
16631 if (dump_sects != NULL)
16632 free (dump_sects);
59f14fc0
AS		 16633 if (cmdline_dump_sects != NULL)
16634 free (cmdline_dump_sects);
252b5132 16635
ff78d6d6 16636 return err;
252b5132 16637}
A mirror of the official binutils-gdb repository