projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
daily update
[deliverable/binutils-gdb.git] / binutils / readelf.c
CommitLineData
252b5132 1/* readelf.c -- display contents of an ELF format file
4b95cf5c 2 Copyright (C) 1998-2014 Free Software Foundation, Inc.
252b5132
RH		 3
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
12ab83a9 5 Modifications by Nick Clifton <nickc@redhat.com>
252b5132
RH		 6
7 This file is part of GNU Binutils.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
32866df7 11 the Free Software Foundation; either version 3 of the License, or
252b5132
RH		 12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
b43b5d5f
NC		 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 02110-1301, USA. */
252b5132 23\f
9eb20dd8 24/* The difference between readelf and objdump:
252b5132 25
74013231 26 Both programs are capable of displaying the contents of ELF format files,
9eb20dd8 27 so why does the binutils project have two file dumpers ?
0de14b54 28
9eb20dd8
NC		 29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
35
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
38
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
42\f
3db64b00 43#include "sysdep.h"
252b5132 44#include <assert.h>
252b5132 45#include <time.h>
1b315056
CS		 46#ifdef HAVE_ZLIB_H
47#include <zlib.h>
48#endif
3bfcb652 49#ifdef HAVE_WCHAR_H
7bfd842d 50#include <wchar.h>
3bfcb652 51#endif
252b5132 52
a952a375 53#if __GNUC__ >= 2
19936277 54/* Define BFD64 here, even if our default architecture is 32 bit ELF
a952a375 55 as this will allow us to read in and parse 64bit and 32bit ELF files.
b34976b6 56 Only do this if we believe that the compiler can support a 64 bit
a952a375 57 data type. For now we only rely on GCC being able to do this. */
19936277 58#define BFD64
a952a375
NC		 59#endif
60
3db64b00
AM		 61#include "bfd.h"
62#include "bucomm.h"
3284fe0c 63#include "elfcomm.h"
19e6b90e 64#include "dwarf.h"
252b5132
RH		 65
66#include "elf/common.h"
67#include "elf/external.h"
68#include "elf/internal.h"
252b5132 69
4b78141a
NC		 70
71/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
72 we can obtain the H8 reloc numbers. We need these for the
73 get_reloc_size() function. We include h8.h again after defining
74 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
75
76#include "elf/h8.h"
77#undef _ELF_H8_H
78
79/* Undo the effects of #including reloc-macros.h. */
80
81#undef START_RELOC_NUMBERS
82#undef RELOC_NUMBER
83#undef FAKE_RELOC
84#undef EMPTY_RELOC
85#undef END_RELOC_NUMBERS
86#undef _RELOC_MACROS_H
87
252b5132
RH		 88/* The following headers use the elf/reloc-macros.h file to
89 automatically generate relocation recognition functions
90 such as elf_mips_reloc_type() */
91
92#define RELOC_MACROS_GEN_FUNC
93
a06ea964 94#include "elf/aarch64.h"
252b5132 95#include "elf/alpha.h"
3b16e843 96#include "elf/arc.h"
252b5132 97#include "elf/arm.h"
3b16e843 98#include "elf/avr.h"
1d65ded4 99#include "elf/bfin.h"
60bca95a 100#include "elf/cr16.h"
3b16e843 101#include "elf/cris.h"
1c0d3aa6 102#include "elf/crx.h"
252b5132
RH		 103#include "elf/d10v.h"
104#include "elf/d30v.h"
d172d4ba 105#include "elf/dlx.h"
cfb8c092 106#include "elf/epiphany.h"
252b5132 107#include "elf/fr30.h"
5c70f934 108#include "elf/frv.h"
3b16e843
NC		 109#include "elf/h8.h"
110#include "elf/hppa.h"
111#include "elf/i386.h"
35b1837e 112#include "elf/i370.h"
3b16e843
NC		 113#include "elf/i860.h"
114#include "elf/i960.h"
115#include "elf/ia64.h"
1e4cf259 116#include "elf/ip2k.h"
84e94c90 117#include "elf/lm32.h"
1c0d3aa6 118#include "elf/iq2000.h"
49f58d10 119#include "elf/m32c.h"
3b16e843
NC		 120#include "elf/m32r.h"
121#include "elf/m68k.h"
75751cd9 122#include "elf/m68hc11.h"
252b5132 123#include "elf/mcore.h"
15ab5209 124#include "elf/mep.h"
a3c62988 125#include "elf/metag.h"
7ba29e2a 126#include "elf/microblaze.h"
3b16e843 127#include "elf/mips.h"
3c3bdf30 128#include "elf/mmix.h"
3b16e843
NC		 129#include "elf/mn10200.h"
130#include "elf/mn10300.h"
5506d11a 131#include "elf/moxie.h"
4970f871 132#include "elf/mt.h"
2469cfa2 133#include "elf/msp430.h"
35c08157 134#include "elf/nds32.h"
13761a11 135#include "elf/nios2.h"
73589c9d 136#include "elf/or1k.h"
7d466069 137#include "elf/pj.h"
3b16e843 138#include "elf/ppc.h"
c833c019 139#include "elf/ppc64.h"
99c513f6 140#include "elf/rl78.h"
c7927a3c 141#include "elf/rx.h"
a85d7ed0 142#include "elf/s390.h"
1c0d3aa6 143#include "elf/score.h"
3b16e843
NC		 144#include "elf/sh.h"
145#include "elf/sparc.h"
e9f53129 146#include "elf/spu.h"
40b36596 147#include "elf/tic6x.h"
aa137e4d
NC		 148#include "elf/tilegx.h"
149#include "elf/tilepro.h"
3b16e843 150#include "elf/v850.h"
179d3252 151#include "elf/vax.h"
3b16e843 152#include "elf/x86-64.h"
c29aca4a 153#include "elf/xc16x.h"
f6c1a2d5 154#include "elf/xgate.h"
93fbbb04 155#include "elf/xstormy16.h"
88da6820 156#include "elf/xtensa.h"
252b5132 157
252b5132 158#include "getopt.h"
566b0d53 159#include "libiberty.h"
09c11c86 160#include "safe-ctype.h"
2cf0635d 161#include "filenames.h"
252b5132 162
15b42fb0
AM		 163#ifndef offsetof
164#define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
165#endif
166
2cf0635d 167char * program_name = "readelf";
85b1c36d
BE		 168static long archive_file_offset;
169static unsigned long archive_file_size;
170static unsigned long dynamic_addr;
171static bfd_size_type dynamic_size;
172static unsigned int dynamic_nent;
2cf0635d 173static char * dynamic_strings;
85b1c36d 174static unsigned long dynamic_strings_length;
2cf0635d 175static char * string_table;
85b1c36d
BE		 176static unsigned long string_table_length;
177static unsigned long num_dynamic_syms;
2cf0635d
NC		 178static Elf_Internal_Sym * dynamic_symbols;
179static Elf_Internal_Syminfo * dynamic_syminfo;
85b1c36d
BE		 180static unsigned long dynamic_syminfo_offset;
181static unsigned int dynamic_syminfo_nent;
f8eae8b2 182static char program_interpreter[PATH_MAX];
bb8a0291 183static bfd_vma dynamic_info[DT_ENCODING];
fdc90cb4 184static bfd_vma dynamic_info_DT_GNU_HASH;
85b1c36d
BE		 185static bfd_vma version_info[16];
186static Elf_Internal_Ehdr elf_header;
2cf0635d
NC		 187static Elf_Internal_Shdr * section_headers;
188static Elf_Internal_Phdr * program_headers;
189static Elf_Internal_Dyn * dynamic_section;
190static Elf_Internal_Shdr * symtab_shndx_hdr;
85b1c36d
BE		 191static int show_name;
192static int do_dynamic;
193static int do_syms;
2c610e4b 194static int do_dyn_syms;
85b1c36d
BE		 195static int do_reloc;
196static int do_sections;
197static int do_section_groups;
5477e8a0 198static int do_section_details;
85b1c36d
BE		 199static int do_segments;
200static int do_unwind;
201static int do_using_dynamic;
202static int do_header;
203static int do_dump;
204static int do_version;
85b1c36d
BE		 205static int do_histogram;
206static int do_debugging;
85b1c36d
BE		 207static int do_arch;
208static int do_notes;
4145f1d5 209static int do_archive_index;
85b1c36d 210static int is_32bit_elf;
252b5132 211
e4b17d5c
L		 212struct group_list
213{
2cf0635d 214 struct group_list * next;
e4b17d5c
L		 215 unsigned int section_index;
216};
217
218struct group
219{
2cf0635d 220 struct group_list * root;
e4b17d5c
L		 221 unsigned int group_index;
222};
223
85b1c36d 224static size_t group_count;
2cf0635d
NC		 225static struct group * section_groups;
226static struct group ** section_headers_groups;
e4b17d5c 227
09c11c86
NC		 228
229/* Flag bits indicating particular types of dump. */
230#define HEX_DUMP (1 << 0) /* The -x command line switch. */
231#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
232#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
233#define STRING_DUMP (1 << 3) /* The -p command line switch. */
cf13d699 234#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
09c11c86
NC		 235
236typedef unsigned char dump_type;
237
238/* A linked list of the section names for which dumps were requested. */
aef1f6d0
DJ		 239struct dump_list_entry
240{
2cf0635d 241 char * name;
09c11c86 242 dump_type type;
2cf0635d 243 struct dump_list_entry * next;
aef1f6d0 244};
2cf0635d 245static struct dump_list_entry * dump_sects_byname;
aef1f6d0 246
09c11c86
NC		 247/* A dynamic array of flags indicating for which sections a dump
248 has been requested via command line switches. */
249static dump_type * cmdline_dump_sects = NULL;
250static unsigned int num_cmdline_dump_sects = 0;
18bd398b
NC		 251
252/* A dynamic array of flags indicating for which sections a dump of
253 some kind has been requested. It is reset on a per-object file
aef1f6d0
DJ		 254 basis and then initialised from the cmdline_dump_sects array,
255 the results of interpreting the -w switch, and the
256 dump_sects_byname list. */
09c11c86
NC		 257static dump_type * dump_sects = NULL;
258static unsigned int num_dump_sects = 0;
252b5132 259
252b5132 260
c256ffe7 261/* How to print a vma value. */
843dd992
NC		 262typedef enum print_mode
263{
264 HEX,
265 DEC,
266 DEC_5,
267 UNSIGNED,
268 PREFIX_HEX,
269 FULL_HEX,
270 LONG_HEX
271}
272print_mode;
273
9c19a809
NC		 274#define UNKNOWN -1
275
2b692964
NC		 276#define SECTION_NAME(X) \
277 ((X) == NULL ? _("<none>") \
278 : string_table == NULL ? _("<no-name>") \
279 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
0b49d371 280 : string_table + (X)->sh_name))
252b5132 281
ee42cf8c 282#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
252b5132 283
ba5cdace
NC		 284#define GET_ELF_SYMBOLS(file, section, sym_count) \
285 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
286 : get_64bit_elf_symbols (file, section, sym_count))
9ea033b2 287
d79b3d50
NC		 288#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
289/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
290 already been called and verified that the string exists. */
291#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
18bd398b 292
61865e30
NC		 293#define REMOVE_ARCH_BITS(ADDR) \
294 do \
295 { \
296 if (elf_header.e_machine == EM_ARM) \
297 (ADDR) &= ~1; \
298 } \
299 while (0)
d79b3d50 300\f
59245841
NC		 301/* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
302 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
303 using malloc and fill that. In either case return the pointer to the start of
304 the retrieved data or NULL if something went wrong. If something does go wrong
305 emit an error message using REASON as part of the context. */
306
c256ffe7 307static void *
2cf0635d
NC		 308get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
309 const char * reason)
a6e9f9df 310{
2cf0635d 311 void * mvar;
a6e9f9df 312
c256ffe7 313 if (size == 0 || nmemb == 0)
a6e9f9df
AM		 314 return NULL;
315
fb52b2f4 316 if (fseek (file, archive_file_offset + offset, SEEK_SET))
a6e9f9df 317 {
0fd3a477 318 error (_("Unable to seek to 0x%lx for %s\n"),
0af1713e 319 (unsigned long) archive_file_offset + offset, reason);
a6e9f9df
AM		 320 return NULL;
321 }
322
323 mvar = var;
324 if (mvar == NULL)
325 {
c256ffe7
JJ		 326 /* Check for overflow. */
327 if (nmemb < (~(size_t) 0 - 1) / size)
328 /* + 1 so that we can '\0' terminate invalid string table sections. */
329 mvar = malloc (size * nmemb + 1);
a6e9f9df
AM		 330
331 if (mvar == NULL)
332 {
0fd3a477
JW		 333 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
334 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM		 335 return NULL;
336 }
c256ffe7
JJ		 337
338 ((char *) mvar)[size * nmemb] = '\0';
a6e9f9df
AM		 339 }
340
c256ffe7 341 if (fread (mvar, size, nmemb, file) != nmemb)
a6e9f9df 342 {
0fd3a477
JW		 343 error (_("Unable to read in 0x%lx bytes of %s\n"),
344 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM		 345 if (mvar != var)
346 free (mvar);
347 return NULL;
348 }
349
350 return mvar;
351}
352
14a91970 353/* Print a VMA value. */
cb8f3167 354
66543521 355static int
14a91970 356print_vma (bfd_vma vma, print_mode mode)
66543521 357{
66543521
AM		 358 int nc = 0;
359
14a91970 360 switch (mode)
66543521 361 {
14a91970
AM		 362 case FULL_HEX:
363 nc = printf ("0x");
364 /* Drop through. */
66543521 365
14a91970 366 case LONG_HEX:
f7a99963 367#ifdef BFD64
14a91970 368 if (is_32bit_elf)
437c2fb7 369 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
f7a99963 370#endif
14a91970
AM		 371 printf_vma (vma);
372 return nc + 16;
b19aac67 373
14a91970
AM		 374 case DEC_5:
375 if (vma <= 99999)
376 return printf ("%5" BFD_VMA_FMT "d", vma);
377 /* Drop through. */
66543521 378
14a91970
AM		 379 case PREFIX_HEX:
380 nc = printf ("0x");
381 /* Drop through. */
66543521 382
14a91970
AM		 383 case HEX:
384 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 385
14a91970
AM		 386 case DEC:
387 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 388
14a91970
AM		 389 case UNSIGNED:
390 return printf ("%" BFD_VMA_FMT "u", vma);
f7a99963 391 }
66543521 392 return 0;
f7a99963
NC		 393}
394
7bfd842d 395/* Display a symbol on stdout. Handles the display of control characters and
3bfcb652 396 multibye characters (assuming the host environment supports them).
31104126 397
7bfd842d
NC		 398 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
399
400 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
401 padding as necessary.
171191ba
NC		 402
403 Returns the number of emitted characters. */
404
405static unsigned int
7a88bc9c 406print_symbol (int width, const char *symbol)
31104126 407{
171191ba 408 bfd_boolean extra_padding = FALSE;
7bfd842d 409 int num_printed = 0;
3bfcb652 410#ifdef HAVE_MBSTATE_T
7bfd842d 411 mbstate_t state;
3bfcb652 412#endif
7bfd842d 413 int width_remaining;
961c521f 414
7bfd842d 415 if (width < 0)
961c521f 416 {
961c521f
NC		 417 /* Keep the width positive. This also helps. */
418 width = - width;
171191ba 419 extra_padding = TRUE;
0b4362b0 420 }
961c521f 421
7bfd842d
NC		 422 if (do_wide)
423 /* Set the remaining width to a very large value.
424 This simplifies the code below. */
425 width_remaining = INT_MAX;
426 else
427 width_remaining = width;
cb8f3167 428
3bfcb652 429#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 430 /* Initialise the multibyte conversion state. */
431 memset (& state, 0, sizeof (state));
3bfcb652 432#endif
961c521f 433
7bfd842d
NC		 434 while (width_remaining)
435 {
436 size_t n;
7bfd842d 437 const char c = *symbol++;
961c521f 438
7bfd842d 439 if (c == 0)
961c521f
NC		 440 break;
441
7bfd842d
NC		 442 /* Do not print control characters directly as they can affect terminal
443 settings. Such characters usually appear in the names generated
444 by the assembler for local labels. */
445 if (ISCNTRL (c))
961c521f 446 {
7bfd842d 447 if (width_remaining < 2)
961c521f
NC		 448 break;
449
7bfd842d
NC		 450 printf ("^%c", c + 0x40);
451 width_remaining -= 2;
171191ba 452 num_printed += 2;
961c521f 453 }
7bfd842d
NC		 454 else if (ISPRINT (c))
455 {
456 putchar (c);
457 width_remaining --;
458 num_printed ++;
459 }
961c521f
NC		 460 else
461 {
3bfcb652
NC		 462#ifdef HAVE_MBSTATE_T
463 wchar_t w;
464#endif
7bfd842d
NC		 465 /* Let printf do the hard work of displaying multibyte characters. */
466 printf ("%.1s", symbol - 1);
467 width_remaining --;
468 num_printed ++;
469
3bfcb652 470#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 471 /* Try to find out how many bytes made up the character that was
472 just printed. Advance the symbol pointer past the bytes that
473 were displayed. */
474 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
3bfcb652
NC		 475#else
476 n = 1;
477#endif
7bfd842d
NC		 478 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
479 symbol += (n - 1);
961c521f 480 }
961c521f 481 }
171191ba 482
7bfd842d 483 if (extra_padding && num_printed < width)
171191ba
NC		 484 {
485 /* Fill in the remaining spaces. */
7bfd842d
NC		 486 printf ("%-*s", width - num_printed, " ");
487 num_printed = width;
171191ba
NC		 488 }
489
490 return num_printed;
31104126
NC		 491}
492
89fac5e3
RS		 493/* Return a pointer to section NAME, or NULL if no such section exists. */
494
495static Elf_Internal_Shdr *
2cf0635d 496find_section (const char * name)
89fac5e3
RS		 497{
498 unsigned int i;
499
500 for (i = 0; i < elf_header.e_shnum; i++)
501 if (streq (SECTION_NAME (section_headers + i), name))
502 return section_headers + i;
503
504 return NULL;
505}
506
0b6ae522
DJ		 507/* Return a pointer to a section containing ADDR, or NULL if no such
508 section exists. */
509
510static Elf_Internal_Shdr *
511find_section_by_address (bfd_vma addr)
512{
513 unsigned int i;
514
515 for (i = 0; i < elf_header.e_shnum; i++)
516 {
517 Elf_Internal_Shdr *sec = section_headers + i;
518 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
519 return sec;
520 }
521
522 return NULL;
523}
524
657d0d47
CC		 525/* Return a pointer to section NAME, or NULL if no such section exists,
526 restricted to the list of sections given in SET. */
527
528static Elf_Internal_Shdr *
529find_section_in_set (const char * name, unsigned int * set)
530{
531 unsigned int i;
532
533 if (set != NULL)
534 {
535 while ((i = *set++) > 0)
536 if (streq (SECTION_NAME (section_headers + i), name))
537 return section_headers + i;
538 }
539
540 return find_section (name);
541}
542
0b6ae522
DJ		 543/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
544 bytes read. */
545
f6f0e17b
NC		 546static inline unsigned long
547read_uleb128 (unsigned char *data,
548 unsigned int *length_return,
549 const unsigned char * const end)
0b6ae522 550{
f6f0e17b 551 return read_leb128 (data, length_return, FALSE, end);
0b6ae522
DJ		 552}
553
28f997cf
TG		 554/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
555 This OS has so many departures from the ELF standard that we test it at
556 many places. */
557
558static inline int
559is_ia64_vms (void)
560{
561 return elf_header.e_machine == EM_IA_64
562 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
563}
564
bcedfee6 565/* Guess the relocation size commonly used by the specific machines. */
252b5132 566
252b5132 567static int
2dc4cec1 568guess_is_rela (unsigned int e_machine)
252b5132 569{
9c19a809 570 switch (e_machine)
252b5132
RH		 571 {
572 /* Targets that use REL relocations. */
252b5132
RH		 573 case EM_386:
574 case EM_486:
63fcb9e9 575 case EM_960:
e9f53129 576 case EM_ARM:
2b0337b0 577 case EM_D10V:
252b5132 578 case EM_CYGNUS_D10V:
e9f53129 579 case EM_DLX:
252b5132 580 case EM_MIPS:
4fe85591 581 case EM_MIPS_RS3_LE:
e9f53129 582 case EM_CYGNUS_M32R:
1c0d3aa6 583 case EM_SCORE:
f6c1a2d5 584 case EM_XGATE:
9c19a809 585 return FALSE;
103f02d3 586
252b5132
RH		 587 /* Targets that use RELA relocations. */
588 case EM_68K:
e9f53129 589 case EM_860:
a06ea964 590 case EM_AARCH64:
cfb8c092 591 case EM_ADAPTEVA_EPIPHANY:
e9f53129
AM		 592 case EM_ALPHA:
593 case EM_ALTERA_NIOS2:
594 case EM_AVR:
595 case EM_AVR_OLD:
596 case EM_BLACKFIN:
60bca95a 597 case EM_CR16:
e9f53129
AM		 598 case EM_CRIS:
599 case EM_CRX:
2b0337b0 600 case EM_D30V:
252b5132 601 case EM_CYGNUS_D30V:
2b0337b0 602 case EM_FR30:
252b5132 603 case EM_CYGNUS_FR30:
5c70f934 604 case EM_CYGNUS_FRV:
e9f53129
AM		 605 case EM_H8S:
606 case EM_H8_300:
607 case EM_H8_300H:
800eeca4 608 case EM_IA_64:
1e4cf259
NC		 609 case EM_IP2K:
610 case EM_IP2K_OLD:
3b36097d 611 case EM_IQ2000:
84e94c90 612 case EM_LATTICEMICO32:
ff7eeb89 613 case EM_M32C_OLD:
49f58d10 614 case EM_M32C:
e9f53129
AM		 615 case EM_M32R:
616 case EM_MCORE:
15ab5209 617 case EM_CYGNUS_MEP:
a3c62988 618 case EM_METAG:
e9f53129
AM		 619 case EM_MMIX:
620 case EM_MN10200:
621 case EM_CYGNUS_MN10200:
622 case EM_MN10300:
623 case EM_CYGNUS_MN10300:
5506d11a 624 case EM_MOXIE:
e9f53129
AM		 625 case EM_MSP430:
626 case EM_MSP430_OLD:
d031aafb 627 case EM_MT:
35c08157 628 case EM_NDS32:
64fd6348 629 case EM_NIOS32:
73589c9d 630 case EM_OR1K:
e9f53129
AM		 631 case EM_PPC64:
632 case EM_PPC:
99c513f6 633 case EM_RL78:
c7927a3c 634 case EM_RX:
e9f53129
AM		 635 case EM_S390:
636 case EM_S390_OLD:
637 case EM_SH:
638 case EM_SPARC:
639 case EM_SPARC32PLUS:
640 case EM_SPARCV9:
641 case EM_SPU:
40b36596 642 case EM_TI_C6000:
aa137e4d
NC		 643 case EM_TILEGX:
644 case EM_TILEPRO:
708e2187 645 case EM_V800:
e9f53129
AM		 646 case EM_V850:
647 case EM_CYGNUS_V850:
648 case EM_VAX:
649 case EM_X86_64:
8a9036a4 650 case EM_L1OM:
7a9068fe 651 case EM_K1OM:
e9f53129
AM		 652 case EM_XSTORMY16:
653 case EM_XTENSA:
654 case EM_XTENSA_OLD:
7ba29e2a
NC		 655 case EM_MICROBLAZE:
656 case EM_MICROBLAZE_OLD:
9c19a809 657 return TRUE;
103f02d3 658
e9f53129
AM		 659 case EM_68HC05:
660 case EM_68HC08:
661 case EM_68HC11:
662 case EM_68HC16:
663 case EM_FX66:
664 case EM_ME16:
d1133906 665 case EM_MMA:
d1133906
NC		 666 case EM_NCPU:
667 case EM_NDR1:
e9f53129 668 case EM_PCP:
d1133906 669 case EM_ST100:
e9f53129 670 case EM_ST19:
d1133906 671 case EM_ST7:
e9f53129
AM		 672 case EM_ST9PLUS:
673 case EM_STARCORE:
d1133906 674 case EM_SVX:
e9f53129 675 case EM_TINYJ:
9c19a809
NC		 676 default:
677 warn (_("Don't know about relocations on this machine architecture\n"));
678 return FALSE;
679 }
680}
252b5132 681
9c19a809 682static int
2cf0635d 683slurp_rela_relocs (FILE * file,
d3ba0551
AM		 684 unsigned long rel_offset,
685 unsigned long rel_size,
2cf0635d
NC		 686 Elf_Internal_Rela ** relasp,
687 unsigned long * nrelasp)
9c19a809 688{
2cf0635d 689 Elf_Internal_Rela * relas;
4d6ed7c8
NC		 690 unsigned long nrelas;
691 unsigned int i;
252b5132 692
4d6ed7c8
NC		 693 if (is_32bit_elf)
694 {
2cf0635d 695 Elf32_External_Rela * erelas;
103f02d3 696
3f5e193b 697 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 698 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 699 if (!erelas)
700 return 0;
252b5132 701
4d6ed7c8 702 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 703
3f5e193b
NC		 704 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
705 sizeof (Elf_Internal_Rela));
103f02d3 706
4d6ed7c8
NC		 707 if (relas == NULL)
708 {
c256ffe7 709 free (erelas);
591a748a 710 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 711 return 0;
712 }
103f02d3 713
4d6ed7c8
NC		 714 for (i = 0; i < nrelas; i++)
715 {
716 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
717 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 718 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 719 }
103f02d3 720
4d6ed7c8
NC		 721 free (erelas);
722 }
723 else
724 {
2cf0635d 725 Elf64_External_Rela * erelas;
103f02d3 726
3f5e193b 727 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 728 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 729 if (!erelas)
730 return 0;
4d6ed7c8
NC		 731
732 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 733
3f5e193b
NC		 734 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
735 sizeof (Elf_Internal_Rela));
103f02d3 736
4d6ed7c8
NC		 737 if (relas == NULL)
738 {
c256ffe7 739 free (erelas);
591a748a 740 error (_("out of memory parsing relocs\n"));
4d6ed7c8 741 return 0;
9c19a809 742 }
4d6ed7c8
NC		 743
744 for (i = 0; i < nrelas; i++)
9c19a809 745 {
66543521
AM		 746 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
747 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 748 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 749
750 /* The #ifdef BFD64 below is to prevent a compile time
751 warning. We know that if we do not have a 64 bit data
752 type that we will never execute this code anyway. */
753#ifdef BFD64
754 if (elf_header.e_machine == EM_MIPS
755 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
756 {
757 /* In little-endian objects, r_info isn't really a
758 64-bit little-endian value: it has a 32-bit
759 little-endian symbol index followed by four
760 individual byte fields. Reorder INFO
761 accordingly. */
91d6fa6a
NC		 762 bfd_vma inf = relas[i].r_info;
763 inf = (((inf & 0xffffffff) << 32)
764 | ((inf >> 56) & 0xff)
765 | ((inf >> 40) & 0xff00)
766 | ((inf >> 24) & 0xff0000)
767 | ((inf >> 8) & 0xff000000));
768 relas[i].r_info = inf;
861fb55a
DJ		 769 }
770#endif /* BFD64 */
4d6ed7c8 771 }
103f02d3 772
4d6ed7c8
NC		 773 free (erelas);
774 }
775 *relasp = relas;
776 *nrelasp = nrelas;
777 return 1;
778}
103f02d3 779
4d6ed7c8 780static int
2cf0635d 781slurp_rel_relocs (FILE * file,
d3ba0551
AM		 782 unsigned long rel_offset,
783 unsigned long rel_size,
2cf0635d
NC		 784 Elf_Internal_Rela ** relsp,
785 unsigned long * nrelsp)
4d6ed7c8 786{
2cf0635d 787 Elf_Internal_Rela * rels;
4d6ed7c8
NC		 788 unsigned long nrels;
789 unsigned int i;
103f02d3 790
4d6ed7c8
NC		 791 if (is_32bit_elf)
792 {
2cf0635d 793 Elf32_External_Rel * erels;
103f02d3 794
3f5e193b 795 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 796 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 797 if (!erels)
798 return 0;
103f02d3 799
4d6ed7c8 800 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 801
3f5e193b 802 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 803
4d6ed7c8
NC		 804 if (rels == NULL)
805 {
c256ffe7 806 free (erels);
591a748a 807 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 808 return 0;
809 }
810
811 for (i = 0; i < nrels; i++)
812 {
813 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
814 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 815 rels[i].r_addend = 0;
9ea033b2 816 }
4d6ed7c8
NC		 817
818 free (erels);
9c19a809
NC		 819 }
820 else
821 {
2cf0635d 822 Elf64_External_Rel * erels;
9ea033b2 823
3f5e193b 824 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 825 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 826 if (!erels)
827 return 0;
103f02d3 828
4d6ed7c8 829 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 830
3f5e193b 831 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 832
4d6ed7c8 833 if (rels == NULL)
9c19a809 834 {
c256ffe7 835 free (erels);
591a748a 836 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 837 return 0;
838 }
103f02d3 839
4d6ed7c8
NC		 840 for (i = 0; i < nrels; i++)
841 {
66543521
AM		 842 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
843 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 844 rels[i].r_addend = 0;
861fb55a
DJ		 845
846 /* The #ifdef BFD64 below is to prevent a compile time
847 warning. We know that if we do not have a 64 bit data
848 type that we will never execute this code anyway. */
849#ifdef BFD64
850 if (elf_header.e_machine == EM_MIPS
851 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
852 {
853 /* In little-endian objects, r_info isn't really a
854 64-bit little-endian value: it has a 32-bit
855 little-endian symbol index followed by four
856 individual byte fields. Reorder INFO
857 accordingly. */
91d6fa6a
NC		 858 bfd_vma inf = rels[i].r_info;
859 inf = (((inf & 0xffffffff) << 32)
860 | ((inf >> 56) & 0xff)
861 | ((inf >> 40) & 0xff00)
862 | ((inf >> 24) & 0xff0000)
863 | ((inf >> 8) & 0xff000000));
864 rels[i].r_info = inf;
861fb55a
DJ		 865 }
866#endif /* BFD64 */
4d6ed7c8 867 }
103f02d3 868
4d6ed7c8
NC		 869 free (erels);
870 }
871 *relsp = rels;
872 *nrelsp = nrels;
873 return 1;
874}
103f02d3 875
aca88567
NC		 876/* Returns the reloc type extracted from the reloc info field. */
877
878static unsigned int
879get_reloc_type (bfd_vma reloc_info)
880{
881 if (is_32bit_elf)
882 return ELF32_R_TYPE (reloc_info);
883
884 switch (elf_header.e_machine)
885 {
886 case EM_MIPS:
887 /* Note: We assume that reloc_info has already been adjusted for us. */
888 return ELF64_MIPS_R_TYPE (reloc_info);
889
890 case EM_SPARCV9:
891 return ELF64_R_TYPE_ID (reloc_info);
892
893 default:
894 return ELF64_R_TYPE (reloc_info);
895 }
896}
897
898/* Return the symbol index extracted from the reloc info field. */
899
900static bfd_vma
901get_reloc_symindex (bfd_vma reloc_info)
902{
903 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
904}
905
13761a11
NC		 906static inline bfd_boolean
907uses_msp430x_relocs (void)
908{
909 return
910 elf_header.e_machine == EM_MSP430 /* Paranoia. */
911 /* GCC uses osabi == ELFOSBI_STANDALONE. */
912 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
913 /* TI compiler uses ELFOSABI_NONE. */
914 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
915}
916
d3ba0551
AM		 917/* Display the contents of the relocation data found at the specified
918 offset. */
ee42cf8c 919
41e92641 920static void
2cf0635d 921dump_relocations (FILE * file,
d3ba0551
AM		 922 unsigned long rel_offset,
923 unsigned long rel_size,
2cf0635d 924 Elf_Internal_Sym * symtab,
d3ba0551 925 unsigned long nsyms,
2cf0635d 926 char * strtab,
d79b3d50 927 unsigned long strtablen,
d3ba0551 928 int is_rela)
4d6ed7c8 929{
b34976b6 930 unsigned int i;
2cf0635d 931 Elf_Internal_Rela * rels;
103f02d3 932
4d6ed7c8
NC		 933 if (is_rela == UNKNOWN)
934 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 935
4d6ed7c8
NC		 936 if (is_rela)
937 {
c8286bd1 938 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 939 return;
4d6ed7c8
NC		 940 }
941 else
942 {
943 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 944 return;
252b5132
RH		 945 }
946
410f7a12
L		 947 if (is_32bit_elf)
948 {
949 if (is_rela)
2c71103e
NC		 950 {
951 if (do_wide)
952 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
953 else
954 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
955 }
410f7a12 956 else
2c71103e
NC		 957 {
958 if (do_wide)
959 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
960 else
961 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
962 }
410f7a12 963 }
252b5132 964 else
410f7a12
L		 965 {
966 if (is_rela)
2c71103e
NC		 967 {
968 if (do_wide)
8beeaeb7 969 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 970 else
971 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
972 }
410f7a12 973 else
2c71103e
NC		 974 {
975 if (do_wide)
8beeaeb7 976 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 977 else
978 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
979 }
410f7a12 980 }
252b5132
RH		 981
982 for (i = 0; i < rel_size; i++)
983 {
2cf0635d 984 const char * rtype;
b34976b6 985 bfd_vma offset;
91d6fa6a 986 bfd_vma inf;
b34976b6
AM		 987 bfd_vma symtab_index;
988 bfd_vma type;
103f02d3 989
b34976b6 990 offset = rels[i].r_offset;
91d6fa6a 991 inf = rels[i].r_info;
103f02d3 992
91d6fa6a
NC		 993 type = get_reloc_type (inf);
994 symtab_index = get_reloc_symindex (inf);
252b5132 995
410f7a12
L		 996 if (is_32bit_elf)
997 {
39dbeff8
AM		 998 printf ("%8.8lx %8.8lx ",
999 (unsigned long) offset & 0xffffffff,
91d6fa6a 1000 (unsigned long) inf & 0xffffffff);
410f7a12
L		 1001 }
1002 else
1003 {
39dbeff8
AM		 1004#if BFD_HOST_64BIT_LONG
1005 printf (do_wide
1006 ? "%16.16lx %16.16lx "
1007 : "%12.12lx %12.12lx ",
91d6fa6a 1008 offset, inf);
39dbeff8 1009#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 1010#ifndef __MSVCRT__
39dbeff8
AM		 1011 printf (do_wide
1012 ? "%16.16llx %16.16llx "
1013 : "%12.12llx %12.12llx ",
91d6fa6a 1014 offset, inf);
6e3d6dc1
NC		 1015#else
1016 printf (do_wide
1017 ? "%16.16I64x %16.16I64x "
1018 : "%12.12I64x %12.12I64x ",
91d6fa6a 1019 offset, inf);
6e3d6dc1 1020#endif
39dbeff8 1021#else
2c71103e
NC		 1022 printf (do_wide
1023 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1024 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 1025 _bfd_int64_high (offset),
1026 _bfd_int64_low (offset),
91d6fa6a
NC		 1027 _bfd_int64_high (inf),
1028 _bfd_int64_low (inf));
9ea033b2 1029#endif
410f7a12 1030 }
103f02d3 1031
252b5132
RH		 1032 switch (elf_header.e_machine)
1033 {
1034 default:
1035 rtype = NULL;
1036 break;
1037
a06ea964
NC		 1038 case EM_AARCH64:
1039 rtype = elf_aarch64_reloc_type (type);
1040 break;
1041
2b0337b0 1042 case EM_M32R:
252b5132 1043 case EM_CYGNUS_M32R:
9ea033b2 1044 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 1045 break;
1046
1047 case EM_386:
1048 case EM_486:
9ea033b2 1049 rtype = elf_i386_reloc_type (type);
252b5132
RH		 1050 break;
1051
ba2685cc
AM		 1052 case EM_68HC11:
1053 case EM_68HC12:
1054 rtype = elf_m68hc11_reloc_type (type);
1055 break;
75751cd9 1056
252b5132 1057 case EM_68K:
9ea033b2 1058 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1059 break;
1060
63fcb9e9 1061 case EM_960:
9ea033b2 1062 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1063 break;
1064
adde6300 1065 case EM_AVR:
2b0337b0 1066 case EM_AVR_OLD:
adde6300
AM		 1067 rtype = elf_avr_reloc_type (type);
1068 break;
1069
9ea033b2
NC		 1070 case EM_OLD_SPARCV9:
1071 case EM_SPARC32PLUS:
1072 case EM_SPARCV9:
252b5132 1073 case EM_SPARC:
9ea033b2 1074 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1075 break;
1076
e9f53129
AM		 1077 case EM_SPU:
1078 rtype = elf_spu_reloc_type (type);
1079 break;
1080
708e2187
NC		 1081 case EM_V800:
1082 rtype = v800_reloc_type (type);
1083 break;
2b0337b0 1084 case EM_V850:
252b5132 1085 case EM_CYGNUS_V850:
9ea033b2 1086 rtype = v850_reloc_type (type);
252b5132
RH		 1087 break;
1088
2b0337b0 1089 case EM_D10V:
252b5132 1090 case EM_CYGNUS_D10V:
9ea033b2 1091 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1092 break;
1093
2b0337b0 1094 case EM_D30V:
252b5132 1095 case EM_CYGNUS_D30V:
9ea033b2 1096 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1097 break;
1098
d172d4ba
NC		 1099 case EM_DLX:
1100 rtype = elf_dlx_reloc_type (type);
1101 break;
1102
252b5132 1103 case EM_SH:
9ea033b2 1104 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1105 break;
1106
2b0337b0 1107 case EM_MN10300:
252b5132 1108 case EM_CYGNUS_MN10300:
9ea033b2 1109 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1110 break;
1111
2b0337b0 1112 case EM_MN10200:
252b5132 1113 case EM_CYGNUS_MN10200:
9ea033b2 1114 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1115 break;
1116
2b0337b0 1117 case EM_FR30:
252b5132 1118 case EM_CYGNUS_FR30:
9ea033b2 1119 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1120 break;
1121
ba2685cc
AM		 1122 case EM_CYGNUS_FRV:
1123 rtype = elf_frv_reloc_type (type);
1124 break;
5c70f934 1125
252b5132 1126 case EM_MCORE:
9ea033b2 1127 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1128 break;
1129
3c3bdf30
NC		 1130 case EM_MMIX:
1131 rtype = elf_mmix_reloc_type (type);
1132 break;
1133
5506d11a
AM		 1134 case EM_MOXIE:
1135 rtype = elf_moxie_reloc_type (type);
1136 break;
1137
2469cfa2 1138 case EM_MSP430:
13761a11
NC		 1139 if (uses_msp430x_relocs ())
1140 {
1141 rtype = elf_msp430x_reloc_type (type);
1142 break;
1143 }
2469cfa2
NC		 1144 case EM_MSP430_OLD:
1145 rtype = elf_msp430_reloc_type (type);
1146 break;
1147
35c08157
KLC		 1148 case EM_NDS32:
1149 rtype = elf_nds32_reloc_type (type);
1150 break;
1151
252b5132 1152 case EM_PPC:
9ea033b2 1153 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1154 break;
1155
c833c019
AM		 1156 case EM_PPC64:
1157 rtype = elf_ppc64_reloc_type (type);
1158 break;
1159
252b5132 1160 case EM_MIPS:
4fe85591 1161 case EM_MIPS_RS3_LE:
9ea033b2 1162 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1163 break;
1164
1165 case EM_ALPHA:
9ea033b2 1166 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1167 break;
1168
1169 case EM_ARM:
9ea033b2 1170 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1171 break;
1172
584da044 1173 case EM_ARC:
9ea033b2 1174 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1175 break;
1176
1177 case EM_PARISC:
69e617ca 1178 rtype = elf_hppa_reloc_type (type);
252b5132 1179 break;
7d466069 1180
b8720f9d
JL		 1181 case EM_H8_300:
1182 case EM_H8_300H:
1183 case EM_H8S:
1184 rtype = elf_h8_reloc_type (type);
1185 break;
1186
73589c9d
CS		 1187 case EM_OR1K:
1188 rtype = elf_or1k_reloc_type (type);
3b16e843
NC		 1189 break;
1190
7d466069 1191 case EM_PJ:
2b0337b0 1192 case EM_PJ_OLD:
7d466069
ILT		 1193 rtype = elf_pj_reloc_type (type);
1194 break;
800eeca4
JW		 1195 case EM_IA_64:
1196 rtype = elf_ia64_reloc_type (type);
1197 break;
1b61cf92
HPN		 1198
1199 case EM_CRIS:
1200 rtype = elf_cris_reloc_type (type);
1201 break;
535c37ff
JE		 1202
1203 case EM_860:
1204 rtype = elf_i860_reloc_type (type);
1205 break;
bcedfee6
NC		 1206
1207 case EM_X86_64:
8a9036a4 1208 case EM_L1OM:
7a9068fe 1209 case EM_K1OM:
bcedfee6
NC		 1210 rtype = elf_x86_64_reloc_type (type);
1211 break;
a85d7ed0 1212
35b1837e
AM		 1213 case EM_S370:
1214 rtype = i370_reloc_type (type);
1215 break;
1216
53c7db4b
KH		 1217 case EM_S390_OLD:
1218 case EM_S390:
1219 rtype = elf_s390_reloc_type (type);
1220 break;
93fbbb04 1221
1c0d3aa6
NC		 1222 case EM_SCORE:
1223 rtype = elf_score_reloc_type (type);
1224 break;
1225
93fbbb04
GK		 1226 case EM_XSTORMY16:
1227 rtype = elf_xstormy16_reloc_type (type);
1228 break;
179d3252 1229
1fe1f39c
NC		 1230 case EM_CRX:
1231 rtype = elf_crx_reloc_type (type);
1232 break;
1233
179d3252
JT		 1234 case EM_VAX:
1235 rtype = elf_vax_reloc_type (type);
1236 break;
1e4cf259 1237
cfb8c092
NC		 1238 case EM_ADAPTEVA_EPIPHANY:
1239 rtype = elf_epiphany_reloc_type (type);
1240 break;
1241
1e4cf259
NC		 1242 case EM_IP2K:
1243 case EM_IP2K_OLD:
1244 rtype = elf_ip2k_reloc_type (type);
1245 break;
3b36097d
SC		 1246
1247 case EM_IQ2000:
1248 rtype = elf_iq2000_reloc_type (type);
1249 break;
88da6820
NC		 1250
1251 case EM_XTENSA_OLD:
1252 case EM_XTENSA:
1253 rtype = elf_xtensa_reloc_type (type);
1254 break;
a34e3ecb 1255
84e94c90
NC		 1256 case EM_LATTICEMICO32:
1257 rtype = elf_lm32_reloc_type (type);
1258 break;
1259
ff7eeb89 1260 case EM_M32C_OLD:
49f58d10
JB		 1261 case EM_M32C:
1262 rtype = elf_m32c_reloc_type (type);
1263 break;
1264
d031aafb
NS		 1265 case EM_MT:
1266 rtype = elf_mt_reloc_type (type);
a34e3ecb 1267 break;
1d65ded4
CM		 1268
1269 case EM_BLACKFIN:
1270 rtype = elf_bfin_reloc_type (type);
1271 break;
15ab5209
DB		 1272
1273 case EM_CYGNUS_MEP:
1274 rtype = elf_mep_reloc_type (type);
1275 break;
60bca95a
NC		 1276
1277 case EM_CR16:
1278 rtype = elf_cr16_reloc_type (type);
1279 break;
dd24e3da 1280
7ba29e2a
NC		 1281 case EM_MICROBLAZE:
1282 case EM_MICROBLAZE_OLD:
1283 rtype = elf_microblaze_reloc_type (type);
1284 break;
c7927a3c 1285
99c513f6
DD		 1286 case EM_RL78:
1287 rtype = elf_rl78_reloc_type (type);
1288 break;
1289
c7927a3c
NC		 1290 case EM_RX:
1291 rtype = elf_rx_reloc_type (type);
1292 break;
c29aca4a 1293
a3c62988
NC		 1294 case EM_METAG:
1295 rtype = elf_metag_reloc_type (type);
1296 break;
1297
c29aca4a
NC		 1298 case EM_XC16X:
1299 case EM_C166:
1300 rtype = elf_xc16x_reloc_type (type);
1301 break;
40b36596
JM		 1302
1303 case EM_TI_C6000:
1304 rtype = elf_tic6x_reloc_type (type);
1305 break;
aa137e4d
NC		 1306
1307 case EM_TILEGX:
1308 rtype = elf_tilegx_reloc_type (type);
1309 break;
1310
1311 case EM_TILEPRO:
1312 rtype = elf_tilepro_reloc_type (type);
1313 break;
f6c1a2d5
NC		 1314
1315 case EM_XGATE:
1316 rtype = elf_xgate_reloc_type (type);
1317 break;
36591ba1
SL		 1318
1319 case EM_ALTERA_NIOS2:
1320 rtype = elf_nios2_reloc_type (type);
1321 break;
252b5132
RH		 1322 }
1323
1324 if (rtype == NULL)
39dbeff8 1325 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1326 else
8beeaeb7 1327 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1328
7ace3541 1329 if (elf_header.e_machine == EM_ALPHA
157c2599 1330 && rtype != NULL
7ace3541
RH		 1331 && streq (rtype, "R_ALPHA_LITUSE")
1332 && is_rela)
1333 {
1334 switch (rels[i].r_addend)
1335 {
1336 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1337 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1338 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1339 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1340 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1341 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1342 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1343 default: rtype = NULL;
1344 }
1345 if (rtype)
1346 printf (" (%s)", rtype);
1347 else
1348 {
1349 putchar (' ');
1350 printf (_("<unknown addend: %lx>"),
1351 (unsigned long) rels[i].r_addend);
1352 }
1353 }
1354 else if (symtab_index)
252b5132 1355 {
af3fc3bc 1356 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1357 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1358 else
19936277 1359 {
2cf0635d 1360 Elf_Internal_Sym * psym;
19936277 1361
af3fc3bc 1362 psym = symtab + symtab_index;
103f02d3 1363
af3fc3bc 1364 printf (" ");
171191ba 1365
d8045f23
NC		 1366 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1367 {
1368 const char * name;
1369 unsigned int len;
1370 unsigned int width = is_32bit_elf ? 8 : 14;
1371
1372 /* Relocations against GNU_IFUNC symbols do not use the value
1373 of the symbol as the address to relocate against. Instead
1374 they invoke the function named by the symbol and use its
1375 result as the address for relocation.
1376
1377 To indicate this to the user, do not display the value of
1378 the symbol in the "Symbols's Value" field. Instead show
1379 its name followed by () as a hint that the symbol is
1380 invoked. */
1381
1382 if (strtab == NULL
1383 || psym->st_name == 0
1384 || psym->st_name >= strtablen)
1385 name = "??";
1386 else
1387 name = strtab + psym->st_name;
1388
1389 len = print_symbol (width, name);
1390 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1391 }
1392 else
1393 {
1394 print_vma (psym->st_value, LONG_HEX);
171191ba 1395
d8045f23
NC		 1396 printf (is_32bit_elf ? " " : " ");
1397 }
103f02d3 1398
af3fc3bc 1399 if (psym->st_name == 0)
f1ef08cb 1400 {
2cf0635d 1401 const char * sec_name = "<null>";
f1ef08cb
AM		 1402 char name_buf[40];
1403
1404 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1405 {
4fbb74a6
AM		 1406 if (psym->st_shndx < elf_header.e_shnum)
1407 sec_name
1408 = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1409 else if (psym->st_shndx == SHN_ABS)
1410 sec_name = "ABS";
1411 else if (psym->st_shndx == SHN_COMMON)
1412 sec_name = "COMMON";
ac145307
BS		 1413 else if ((elf_header.e_machine == EM_MIPS
1414 && psym->st_shndx == SHN_MIPS_SCOMMON)
1415 || (elf_header.e_machine == EM_TI_C6000
1416 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1417 sec_name = "SCOMMON";
1418 else if (elf_header.e_machine == EM_MIPS
1419 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1420 sec_name = "SUNDEF";
8a9036a4 1421 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1422 || elf_header.e_machine == EM_L1OM
1423 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1424 && psym->st_shndx == SHN_X86_64_LCOMMON)
1425 sec_name = "LARGE_COMMON";
9ce701e2
L		 1426 else if (elf_header.e_machine == EM_IA_64
1427 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1428 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1429 sec_name = "ANSI_COM";
28f997cf 1430 else if (is_ia64_vms ()
148b93f2
NC		 1431 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1432 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1433 else
1434 {
1435 sprintf (name_buf, "<section 0x%x>",
1436 (unsigned int) psym->st_shndx);
1437 sec_name = name_buf;
1438 }
1439 }
1440 print_symbol (22, sec_name);
1441 }
af3fc3bc 1442 else if (strtab == NULL)
d79b3d50 1443 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1444 else if (psym->st_name >= strtablen)
d79b3d50 1445 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1446 else
2c71103e 1447 print_symbol (22, strtab + psym->st_name);
103f02d3 1448
af3fc3bc 1449 if (is_rela)
171191ba 1450 {
598aaa76 1451 bfd_signed_vma off = rels[i].r_addend;
171191ba 1452
91d6fa6a 1453 if (off < 0)
598aaa76 1454 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1455 else
598aaa76 1456 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1457 }
19936277 1458 }
252b5132 1459 }
1b228002 1460 else if (is_rela)
f7a99963 1461 {
e04d7088
L		 1462 bfd_signed_vma off = rels[i].r_addend;
1463
1464 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1465 if (off < 0)
1466 printf ("-%" BFD_VMA_FMT "x", - off);
1467 else
1468 printf ("%" BFD_VMA_FMT "x", off);
f7a99963 1469 }
252b5132 1470
157c2599
NC		 1471 if (elf_header.e_machine == EM_SPARCV9
1472 && rtype != NULL
1473 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1474 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1475
252b5132 1476 putchar ('\n');
2c71103e 1477
aca88567 1478#ifdef BFD64
53c7db4b 1479 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1480 {
91d6fa6a
NC		 1481 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1482 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1483 const char * rtype2 = elf_mips_reloc_type (type2);
1484 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1485
2c71103e
NC		 1486 printf (" Type2: ");
1487
1488 if (rtype2 == NULL)
39dbeff8
AM		 1489 printf (_("unrecognized: %-7lx"),
1490 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1491 else
1492 printf ("%-17.17s", rtype2);
1493
18bd398b 1494 printf ("\n Type3: ");
2c71103e
NC		 1495
1496 if (rtype3 == NULL)
39dbeff8
AM		 1497 printf (_("unrecognized: %-7lx"),
1498 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1499 else
1500 printf ("%-17.17s", rtype3);
1501
53c7db4b 1502 putchar ('\n');
2c71103e 1503 }
aca88567 1504#endif /* BFD64 */
252b5132
RH		 1505 }
1506
c8286bd1 1507 free (rels);
252b5132
RH		 1508}
1509
1510static const char *
d3ba0551 1511get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1512{
1513 switch (type)
1514 {
1515 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1516 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1517 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1518 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1519 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1520 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1521 case DT_MIPS_MSYM: return "MIPS_MSYM";
1522 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1523 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1524 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1525 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1526 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1527 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1528 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1529 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1530 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1531 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1532 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1533 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1534 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1535 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1536 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1537 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1538 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1539 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1540 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1541 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1542 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1543 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1544 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1545 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1546 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1547 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1548 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1549 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1550 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1551 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1552 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1553 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1554 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1555 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1556 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1557 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1558 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1559 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1560 default:
1561 return NULL;
1562 }
1563}
1564
9a097730 1565static const char *
d3ba0551 1566get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1567{
1568 switch (type)
1569 {
1570 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1571 default:
1572 return NULL;
1573 }
103f02d3
UD		 1574}
1575
7490d522
AM		 1576static const char *
1577get_ppc_dynamic_type (unsigned long type)
1578{
1579 switch (type)
1580 {
a7f2871e 1581 case DT_PPC_GOT: return "PPC_GOT";
e8910a83 1582 case DT_PPC_OPT: return "PPC_OPT";
7490d522
AM		 1583 default:
1584 return NULL;
1585 }
1586}
1587
f1cb7e17 1588static const char *
d3ba0551 1589get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1590{
1591 switch (type)
1592 {
a7f2871e
AM		 1593 case DT_PPC64_GLINK: return "PPC64_GLINK";
1594 case DT_PPC64_OPD: return "PPC64_OPD";
1595 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
e8910a83 1596 case DT_PPC64_OPT: return "PPC64_OPT";
f1cb7e17
AM		 1597 default:
1598 return NULL;
1599 }
1600}
1601
103f02d3 1602static const char *
d3ba0551 1603get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1604{
1605 switch (type)
1606 {
1607 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1608 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1609 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1610 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1611 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1612 case DT_HP_PREINIT: return "HP_PREINIT";
1613 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1614 case DT_HP_NEEDED: return "HP_NEEDED";
1615 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1616 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1617 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1618 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1619 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1620 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1621 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1622 case DT_HP_FILTERED: return "HP_FILTERED";
1623 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1624 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1625 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1626 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1627 case DT_PLT: return "PLT";
1628 case DT_PLT_SIZE: return "PLT_SIZE";
1629 case DT_DLT: return "DLT";
1630 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1631 default:
1632 return NULL;
1633 }
1634}
9a097730 1635
ecc51f48 1636static const char *
d3ba0551 1637get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1638{
1639 switch (type)
1640 {
148b93f2
NC		 1641 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1642 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1643 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1644 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1645 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1646 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1647 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1648 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1649 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1650 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1651 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1652 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1653 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1654 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1655 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1656 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1657 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1658 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1659 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1660 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1661 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1662 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1663 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1664 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1665 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1666 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1667 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1668 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1669 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1670 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1671 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1672 default:
1673 return NULL;
1674 }
1675}
1676
fabcb361
RH		 1677static const char *
1678get_alpha_dynamic_type (unsigned long type)
1679{
1680 switch (type)
1681 {
1682 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1683 default:
1684 return NULL;
1685 }
1686}
1687
1c0d3aa6
NC		 1688static const char *
1689get_score_dynamic_type (unsigned long type)
1690{
1691 switch (type)
1692 {
1693 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1694 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1695 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1696 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1697 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1698 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1699 default:
1700 return NULL;
1701 }
1702}
1703
40b36596
JM		 1704static const char *
1705get_tic6x_dynamic_type (unsigned long type)
1706{
1707 switch (type)
1708 {
1709 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1710 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1711 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1712 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1713 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1714 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1715 default:
1716 return NULL;
1717 }
1718}
1c0d3aa6 1719
36591ba1
SL		 1720static const char *
1721get_nios2_dynamic_type (unsigned long type)
1722{
1723 switch (type)
1724 {
1725 case DT_NIOS2_GP: return "NIOS2_GP";
1726 default:
1727 return NULL;
1728 }
1729}
1730
252b5132 1731static const char *
d3ba0551 1732get_dynamic_type (unsigned long type)
252b5132 1733{
e9e44622 1734 static char buff[64];
252b5132
RH		 1735
1736 switch (type)
1737 {
1738 case DT_NULL: return "NULL";
1739 case DT_NEEDED: return "NEEDED";
1740 case DT_PLTRELSZ: return "PLTRELSZ";
1741 case DT_PLTGOT: return "PLTGOT";
1742 case DT_HASH: return "HASH";
1743 case DT_STRTAB: return "STRTAB";
1744 case DT_SYMTAB: return "SYMTAB";
1745 case DT_RELA: return "RELA";
1746 case DT_RELASZ: return "RELASZ";
1747 case DT_RELAENT: return "RELAENT";
1748 case DT_STRSZ: return "STRSZ";
1749 case DT_SYMENT: return "SYMENT";
1750 case DT_INIT: return "INIT";
1751 case DT_FINI: return "FINI";
1752 case DT_SONAME: return "SONAME";
1753 case DT_RPATH: return "RPATH";
1754 case DT_SYMBOLIC: return "SYMBOLIC";
1755 case DT_REL: return "REL";
1756 case DT_RELSZ: return "RELSZ";
1757 case DT_RELENT: return "RELENT";
1758 case DT_PLTREL: return "PLTREL";
1759 case DT_DEBUG: return "DEBUG";
1760 case DT_TEXTREL: return "TEXTREL";
1761 case DT_JMPREL: return "JMPREL";
1762 case DT_BIND_NOW: return "BIND_NOW";
1763 case DT_INIT_ARRAY: return "INIT_ARRAY";
1764 case DT_FINI_ARRAY: return "FINI_ARRAY";
1765 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1766 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1767 case DT_RUNPATH: return "RUNPATH";
1768 case DT_FLAGS: return "FLAGS";
2d0e6f43 1769
d1133906
NC		 1770 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1771 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1772
05107a46 1773 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1774 case DT_PLTPADSZ: return "PLTPADSZ";
1775 case DT_MOVEENT: return "MOVEENT";
1776 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1777 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1778 case DT_POSFLAG_1: return "POSFLAG_1";
1779 case DT_SYMINSZ: return "SYMINSZ";
1780 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1781
252b5132 1782 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1783 case DT_CONFIG: return "CONFIG";
1784 case DT_DEPAUDIT: return "DEPAUDIT";
1785 case DT_AUDIT: return "AUDIT";
1786 case DT_PLTPAD: return "PLTPAD";
1787 case DT_MOVETAB: return "MOVETAB";
252b5132 1788 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1789
252b5132 1790 case DT_VERSYM: return "VERSYM";
103f02d3 1791
67a4f2b7
AO		 1792 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1793 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1794 case DT_RELACOUNT: return "RELACOUNT";
1795 case DT_RELCOUNT: return "RELCOUNT";
1796 case DT_FLAGS_1: return "FLAGS_1";
1797 case DT_VERDEF: return "VERDEF";
1798 case DT_VERDEFNUM: return "VERDEFNUM";
1799 case DT_VERNEED: return "VERNEED";
1800 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1801
019148e4 1802 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1803 case DT_USED: return "USED";
1804 case DT_FILTER: return "FILTER";
103f02d3 1805
047b2264
JJ		 1806 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1807 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1808 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1809 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1810 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1811 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1812
252b5132
RH		 1813 default:
1814 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1815 {
2cf0635d 1816 const char * result;
103f02d3 1817
252b5132
RH		 1818 switch (elf_header.e_machine)
1819 {
1820 case EM_MIPS:
4fe85591 1821 case EM_MIPS_RS3_LE:
252b5132
RH		 1822 result = get_mips_dynamic_type (type);
1823 break;
9a097730
RH		 1824 case EM_SPARCV9:
1825 result = get_sparc64_dynamic_type (type);
1826 break;
7490d522
AM		 1827 case EM_PPC:
1828 result = get_ppc_dynamic_type (type);
1829 break;
f1cb7e17
AM		 1830 case EM_PPC64:
1831 result = get_ppc64_dynamic_type (type);
1832 break;
ecc51f48
NC		 1833 case EM_IA_64:
1834 result = get_ia64_dynamic_type (type);
1835 break;
fabcb361
RH		 1836 case EM_ALPHA:
1837 result = get_alpha_dynamic_type (type);
1838 break;
1c0d3aa6
NC		 1839 case EM_SCORE:
1840 result = get_score_dynamic_type (type);
1841 break;
40b36596
JM		 1842 case EM_TI_C6000:
1843 result = get_tic6x_dynamic_type (type);
1844 break;
36591ba1
SL		 1845 case EM_ALTERA_NIOS2:
1846 result = get_nios2_dynamic_type (type);
1847 break;
252b5132
RH		 1848 default:
1849 result = NULL;
1850 break;
1851 }
1852
1853 if (result != NULL)
1854 return result;
1855
e9e44622 1856 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 1857 }
eec8f817
DA		 1858 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1859 || (elf_header.e_machine == EM_PARISC
1860 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 1861 {
2cf0635d 1862 const char * result;
103f02d3
UD		 1863
1864 switch (elf_header.e_machine)
1865 {
1866 case EM_PARISC:
1867 result = get_parisc_dynamic_type (type);
1868 break;
148b93f2
NC		 1869 case EM_IA_64:
1870 result = get_ia64_dynamic_type (type);
1871 break;
103f02d3
UD		 1872 default:
1873 result = NULL;
1874 break;
1875 }
1876
1877 if (result != NULL)
1878 return result;
1879
e9e44622
JJ		 1880 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1881 type);
103f02d3 1882 }
252b5132 1883 else
e9e44622 1884 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 1885
252b5132
RH		 1886 return buff;
1887 }
1888}
1889
1890static char *
d3ba0551 1891get_file_type (unsigned e_type)
252b5132 1892{
b34976b6 1893 static char buff[32];
252b5132
RH		 1894
1895 switch (e_type)
1896 {
1897 case ET_NONE: return _("NONE (None)");
1898 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 1899 case ET_EXEC: return _("EXEC (Executable file)");
1900 case ET_DYN: return _("DYN (Shared object file)");
1901 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 1902
1903 default:
1904 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 1905 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 1906 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 1907 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 1908 else
e9e44622 1909 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 1910 return buff;
1911 }
1912}
1913
1914static char *
d3ba0551 1915get_machine_name (unsigned e_machine)
252b5132 1916{
b34976b6 1917 static char buff[64]; /* XXX */
252b5132
RH		 1918
1919 switch (e_machine)
1920 {
c45021f2 1921 case EM_NONE: return _("None");
a06ea964 1922 case EM_AARCH64: return "AArch64";
c45021f2
NC		 1923 case EM_M32: return "WE32100";
1924 case EM_SPARC: return "Sparc";
e9f53129 1925 case EM_SPU: return "SPU";
c45021f2
NC		 1926 case EM_386: return "Intel 80386";
1927 case EM_68K: return "MC68000";
1928 case EM_88K: return "MC88000";
1929 case EM_486: return "Intel 80486";
1930 case EM_860: return "Intel 80860";
1931 case EM_MIPS: return "MIPS R3000";
1932 case EM_S370: return "IBM System/370";
7036c0e1 1933 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 1934 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 1935 case EM_PARISC: return "HPPA";
252b5132 1936 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 1937 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 1938 case EM_960: return "Intel 90860";
1939 case EM_PPC: return "PowerPC";
285d1771 1940 case EM_PPC64: return "PowerPC64";
c45021f2
NC		 1941 case EM_FR20: return "Fujitsu FR20";
1942 case EM_RH32: return "TRW RH32";
b34976b6 1943 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 1944 case EM_ARM: return "ARM";
1945 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 1946 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 1947 case EM_SPARCV9: return "Sparc v9";
1948 case EM_TRICORE: return "Siemens Tricore";
584da044 1949 case EM_ARC: return "ARC";
c2dcd04e
NC		 1950 case EM_H8_300: return "Renesas H8/300";
1951 case EM_H8_300H: return "Renesas H8/300H";
1952 case EM_H8S: return "Renesas H8S";
1953 case EM_H8_500: return "Renesas H8/500";
30800947 1954 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 1955 case EM_MIPS_X: return "Stanford MIPS-X";
1956 case EM_COLDFIRE: return "Motorola Coldfire";
c45021f2 1957 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 1958 case EM_CYGNUS_D10V:
1959 case EM_D10V: return "d10v";
1960 case EM_CYGNUS_D30V:
b34976b6 1961 case EM_D30V: return "d30v";
2b0337b0 1962 case EM_CYGNUS_M32R:
26597c86 1963 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 1964 case EM_CYGNUS_V850:
708e2187 1965 case EM_V800: return "Renesas V850 (using RH850 ABI)";
f6c1a2d5 1966 case EM_V850: return "Renesas V850";
2b0337b0
AO		 1967 case EM_CYGNUS_MN10300:
1968 case EM_MN10300: return "mn10300";
1969 case EM_CYGNUS_MN10200:
1970 case EM_MN10200: return "mn10200";
5506d11a 1971 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 1972 case EM_CYGNUS_FR30:
1973 case EM_FR30: return "Fujitsu FR30";
b34976b6 1974 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 1975 case EM_PJ_OLD:
b34976b6 1976 case EM_PJ: return "picoJava";
7036c0e1
AJ		 1977 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1978 case EM_PCP: return "Siemens PCP";
1979 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1980 case EM_NDR1: return "Denso NDR1 microprocesspr";
1981 case EM_STARCORE: return "Motorola Star*Core processor";
1982 case EM_ME16: return "Toyota ME16 processor";
1983 case EM_ST100: return "STMicroelectronics ST100 processor";
1984 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 1985 case EM_PDSP: return "Sony DSP processor";
1986 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
1987 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 1988 case EM_FX66: return "Siemens FX66 microcontroller";
1989 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1990 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1991 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
6927f982 1992 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ		 1993 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1994 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1995 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1996 case EM_SVX: return "Silicon Graphics SVx";
1997 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1998 case EM_VAX: return "Digital VAX";
2b0337b0 1999 case EM_AVR_OLD:
b34976b6 2000 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 2001 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 2002 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2003 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2004 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 2005 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 2006 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 2007 case EM_PRISM: return "Vitesse Prism";
bcedfee6 2008 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 2009 case EM_L1OM: return "Intel L1OM";
7a9068fe 2010 case EM_K1OM: return "Intel K1OM";
b7498e0e 2011 case EM_S390_OLD:
b34976b6 2012 case EM_S390: return "IBM S/390";
1c0d3aa6 2013 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 2014 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
73589c9d 2015 case EM_OR1K: return "OpenRISC 1000";
11636f9e 2016 case EM_ARC_A5: return "ARC International ARCompact processor";
1fe1f39c 2017 case EM_CRX: return "National Semiconductor CRX microprocessor";
cfb8c092 2018 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
d172d4ba 2019 case EM_DLX: return "OpenDLX";
1e4cf259 2020 case EM_IP2K_OLD:
b34976b6 2021 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 2022 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 2023 case EM_XTENSA_OLD:
2024 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 2025 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2026 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2027 case EM_NS32K: return "National Semiconductor 32000 series";
2028 case EM_TPC: return "Tenor Network TPC processor";
2029 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2030 case EM_MAX: return "MAX Processor";
2031 case EM_CR: return "National Semiconductor CompactRISC";
2032 case EM_F2MC16: return "Fujitsu F2MC16";
2033 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 2034 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 2035 case EM_M32C_OLD:
49f58d10 2036 case EM_M32C: return "Renesas M32c";
d031aafb 2037 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 2038 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 2039 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2040 case EM_SEP: return "Sharp embedded microprocessor";
2041 case EM_ARCA: return "Arca RISC microprocessor";
2042 case EM_UNICORE: return "Unicore";
2043 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2044 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 2045 case EM_NIOS32: return "Altera Nios";
2046 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 2047 case EM_C166:
d70c5fc7 2048 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 2049 case EM_M16C: return "Renesas M16C series microprocessors";
2050 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2051 case EM_CE: return "Freescale Communication Engine RISC core";
2052 case EM_TSK3000: return "Altium TSK3000 core";
2053 case EM_RS08: return "Freescale RS08 embedded processor";
2054 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2055 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2056 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2057 case EM_SE_C17: return "Seiko Epson C17 family";
2058 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2059 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2060 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2061 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2062 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2063 case EM_R32C: return "Renesas R32C series microprocessors";
2064 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2065 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2066 case EM_8051: return "Intel 8051 and variants";
2067 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2068 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2069 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2070 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2071 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2072 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2073 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 2074 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 2075 case EM_CR16:
f6c1a2d5 2076 case EM_MICROBLAZE:
7ba29e2a 2077 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
99c513f6 2078 case EM_RL78: return "Renesas RL78";
c7927a3c 2079 case EM_RX: return "Renesas RX";
a3c62988 2080 case EM_METAG: return "Imagination Technologies Meta processor architecture";
11636f9e
JM		 2081 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2082 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2083 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2084 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2085 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2086 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2087 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2088 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 2089 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 2090 case EM_CUDA: return "NVIDIA CUDA architecture";
f6c1a2d5 2091 case EM_XGATE: return "Motorola XGATE embedded processor";
252b5132 2092 default:
35d9dd2f 2093 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2094 return buff;
2095 }
2096}
2097
f3485b74 2098static void
d3ba0551 2099decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2100{
2101 unsigned eabi;
2102 int unknown = 0;
2103
2104 eabi = EF_ARM_EABI_VERSION (e_flags);
2105 e_flags &= ~ EF_ARM_EABIMASK;
2106
2107 /* Handle "generic" ARM flags. */
2108 if (e_flags & EF_ARM_RELEXEC)
2109 {
2110 strcat (buf, ", relocatable executable");
2111 e_flags &= ~ EF_ARM_RELEXEC;
2112 }
76da6bbe 2113
f3485b74
NC		 2114 if (e_flags & EF_ARM_HASENTRY)
2115 {
2116 strcat (buf, ", has entry point");
2117 e_flags &= ~ EF_ARM_HASENTRY;
2118 }
76da6bbe 2119
f3485b74
NC		 2120 /* Now handle EABI specific flags. */
2121 switch (eabi)
2122 {
2123 default:
2c71103e 2124 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2125 if (e_flags)
2126 unknown = 1;
2127 break;
2128
2129 case EF_ARM_EABI_VER1:
a5bcd848 2130 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2131 while (e_flags)
2132 {
2133 unsigned flag;
76da6bbe 2134
f3485b74
NC		 2135 /* Process flags one bit at a time. */
2136 flag = e_flags & - e_flags;
2137 e_flags &= ~ flag;
76da6bbe 2138
f3485b74
NC		 2139 switch (flag)
2140 {
a5bcd848 2141 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2142 strcat (buf, ", sorted symbol tables");
2143 break;
76da6bbe 2144
f3485b74
NC		 2145 default:
2146 unknown = 1;
2147 break;
2148 }
2149 }
2150 break;
76da6bbe 2151
a5bcd848
PB		 2152 case EF_ARM_EABI_VER2:
2153 strcat (buf, ", Version2 EABI");
2154 while (e_flags)
2155 {
2156 unsigned flag;
2157
2158 /* Process flags one bit at a time. */
2159 flag = e_flags & - e_flags;
2160 e_flags &= ~ flag;
2161
2162 switch (flag)
2163 {
2164 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2165 strcat (buf, ", sorted symbol tables");
2166 break;
2167
2168 case EF_ARM_DYNSYMSUSESEGIDX:
2169 strcat (buf, ", dynamic symbols use segment index");
2170 break;
2171
2172 case EF_ARM_MAPSYMSFIRST:
2173 strcat (buf, ", mapping symbols precede others");
2174 break;
2175
2176 default:
2177 unknown = 1;
2178 break;
2179 }
2180 }
2181 break;
2182
d507cf36
PB		 2183 case EF_ARM_EABI_VER3:
2184 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2185 break;
2186
2187 case EF_ARM_EABI_VER4:
2188 strcat (buf, ", Version4 EABI");
3bfcb652
NC		 2189 while (e_flags)
2190 {
2191 unsigned flag;
2192
2193 /* Process flags one bit at a time. */
2194 flag = e_flags & - e_flags;
2195 e_flags &= ~ flag;
2196
2197 switch (flag)
2198 {
2199 case EF_ARM_BE8:
2200 strcat (buf, ", BE8");
2201 break;
2202
2203 case EF_ARM_LE8:
2204 strcat (buf, ", LE8");
2205 break;
2206
2207 default:
2208 unknown = 1;
2209 break;
2210 }
2211 break;
2212 }
2213 break;
3a4a14e9
PB		 2214
2215 case EF_ARM_EABI_VER5:
2216 strcat (buf, ", Version5 EABI");
d507cf36
PB		 2217 while (e_flags)
2218 {
2219 unsigned flag;
2220
2221 /* Process flags one bit at a time. */
2222 flag = e_flags & - e_flags;
2223 e_flags &= ~ flag;
2224
2225 switch (flag)
2226 {
2227 case EF_ARM_BE8:
2228 strcat (buf, ", BE8");
2229 break;
2230
2231 case EF_ARM_LE8:
2232 strcat (buf, ", LE8");
2233 break;
2234
3bfcb652
NC		 2235 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2236 strcat (buf, ", soft-float ABI");
2237 break;
2238
2239 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2240 strcat (buf, ", hard-float ABI");
2241 break;
2242
d507cf36
PB		 2243 default:
2244 unknown = 1;
2245 break;
2246 }
2247 }
2248 break;
2249
f3485b74 2250 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2251 strcat (buf, ", GNU EABI");
f3485b74
NC		 2252 while (e_flags)
2253 {
2254 unsigned flag;
76da6bbe 2255
f3485b74
NC		 2256 /* Process flags one bit at a time. */
2257 flag = e_flags & - e_flags;
2258 e_flags &= ~ flag;
76da6bbe 2259
f3485b74
NC		 2260 switch (flag)
2261 {
a5bcd848 2262 case EF_ARM_INTERWORK:
f3485b74
NC		 2263 strcat (buf, ", interworking enabled");
2264 break;
76da6bbe 2265
a5bcd848 2266 case EF_ARM_APCS_26:
f3485b74
NC		 2267 strcat (buf, ", uses APCS/26");
2268 break;
76da6bbe 2269
a5bcd848 2270 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2271 strcat (buf, ", uses APCS/float");
2272 break;
76da6bbe 2273
a5bcd848 2274 case EF_ARM_PIC:
f3485b74
NC		 2275 strcat (buf, ", position independent");
2276 break;
76da6bbe 2277
a5bcd848 2278 case EF_ARM_ALIGN8:
f3485b74
NC		 2279 strcat (buf, ", 8 bit structure alignment");
2280 break;
76da6bbe 2281
a5bcd848 2282 case EF_ARM_NEW_ABI:
f3485b74
NC		 2283 strcat (buf, ", uses new ABI");
2284 break;
76da6bbe 2285
a5bcd848 2286 case EF_ARM_OLD_ABI:
f3485b74
NC		 2287 strcat (buf, ", uses old ABI");
2288 break;
76da6bbe 2289
a5bcd848 2290 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2291 strcat (buf, ", software FP");
2292 break;
76da6bbe 2293
90e01f86
ILT		 2294 case EF_ARM_VFP_FLOAT:
2295 strcat (buf, ", VFP");
2296 break;
2297
fde78edd
NC		 2298 case EF_ARM_MAVERICK_FLOAT:
2299 strcat (buf, ", Maverick FP");
2300 break;
2301
f3485b74
NC		 2302 default:
2303 unknown = 1;
2304 break;
2305 }
2306 }
2307 }
f3485b74
NC		 2308
2309 if (unknown)
2b692964 2310 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2311}
2312
35c08157
KLC		 2313static void
2314decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2315{
2316 unsigned abi;
2317 unsigned arch;
2318 unsigned config;
2319 unsigned version;
2320 int has_fpu = 0;
2321 int r = 0;
2322
2323 static const char *ABI_STRINGS[] =
2324 {
2325 "ABI v0", /* use r5 as return register; only used in N1213HC */
2326 "ABI v1", /* use r0 as return register */
2327 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2328 "ABI v2fp", /* for FPU */
40c7a7cb
KLC		 2329 "AABI",
2330 "ABI2 FP+"
35c08157
KLC		 2331 };
2332 static const char *VER_STRINGS[] =
2333 {
2334 "Andes ELF V1.3 or older",
2335 "Andes ELF V1.3.1",
2336 "Andes ELF V1.4"
2337 };
2338 static const char *ARCH_STRINGS[] =
2339 {
2340 "",
2341 "Andes Star v1.0",
2342 "Andes Star v2.0",
2343 "Andes Star v3.0",
2344 "Andes Star v3.0m"
2345 };
2346
2347 abi = EF_NDS_ABI & e_flags;
2348 arch = EF_NDS_ARCH & e_flags;
2349 config = EF_NDS_INST & e_flags;
2350 version = EF_NDS32_ELF_VERSION & e_flags;
2351
2352 memset (buf, 0, size);
2353
2354 switch (abi)
2355 {
2356 case E_NDS_ABI_V0:
2357 case E_NDS_ABI_V1:
2358 case E_NDS_ABI_V2:
2359 case E_NDS_ABI_V2FP:
2360 case E_NDS_ABI_AABI:
40c7a7cb 2361 case E_NDS_ABI_V2FP_PLUS:
35c08157
KLC		 2362 /* In case there are holes in the array. */
2363 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2364 break;
2365
2366 default:
2367 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2368 break;
2369 }
2370
2371 switch (version)
2372 {
2373 case E_NDS32_ELF_VER_1_2:
2374 case E_NDS32_ELF_VER_1_3:
2375 case E_NDS32_ELF_VER_1_4:
2376 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2377 break;
2378
2379 default:
2380 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2381 break;
2382 }
2383
2384 if (E_NDS_ABI_V0 == abi)
2385 {
2386 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2387 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2388 if (arch == E_NDS_ARCH_STAR_V1_0)
2389 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2390 return;
2391 }
2392
2393 switch (arch)
2394 {
2395 case E_NDS_ARCH_STAR_V1_0:
2396 case E_NDS_ARCH_STAR_V2_0:
2397 case E_NDS_ARCH_STAR_V3_0:
2398 case E_NDS_ARCH_STAR_V3_M:
2399 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2400 break;
2401
2402 default:
2403 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2404 /* ARCH version determines how the e_flags are interpreted.
2405 If it is unknown, we cannot proceed. */
2406 return;
2407 }
2408
2409 /* Newer ABI; Now handle architecture specific flags. */
2410 if (arch == E_NDS_ARCH_STAR_V1_0)
2411 {
2412 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2413 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2414
2415 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2416 r += snprintf (buf + r, size -r, ", MAC");
2417
2418 if (config & E_NDS32_HAS_DIV_INST)
2419 r += snprintf (buf + r, size -r, ", DIV");
2420
2421 if (config & E_NDS32_HAS_16BIT_INST)
2422 r += snprintf (buf + r, size -r, ", 16b");
2423 }
2424 else
2425 {
2426 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2427 {
2428 if (version <= E_NDS32_ELF_VER_1_3)
2429 r += snprintf (buf + r, size -r, ", [B8]");
2430 else
2431 r += snprintf (buf + r, size -r, ", EX9");
2432 }
2433
2434 if (config & E_NDS32_HAS_MAC_DX_INST)
2435 r += snprintf (buf + r, size -r, ", MAC_DX");
2436
2437 if (config & E_NDS32_HAS_DIV_DX_INST)
2438 r += snprintf (buf + r, size -r, ", DIV_DX");
2439
2440 if (config & E_NDS32_HAS_16BIT_INST)
2441 {
2442 if (version <= E_NDS32_ELF_VER_1_3)
2443 r += snprintf (buf + r, size -r, ", 16b");
2444 else
2445 r += snprintf (buf + r, size -r, ", IFC");
2446 }
2447 }
2448
2449 if (config & E_NDS32_HAS_EXT_INST)
2450 r += snprintf (buf + r, size -r, ", PERF1");
2451
2452 if (config & E_NDS32_HAS_EXT2_INST)
2453 r += snprintf (buf + r, size -r, ", PERF2");
2454
2455 if (config & E_NDS32_HAS_FPU_INST)
2456 {
2457 has_fpu = 1;
2458 r += snprintf (buf + r, size -r, ", FPU_SP");
2459 }
2460
2461 if (config & E_NDS32_HAS_FPU_DP_INST)
2462 {
2463 has_fpu = 1;
2464 r += snprintf (buf + r, size -r, ", FPU_DP");
2465 }
2466
2467 if (config & E_NDS32_HAS_FPU_MAC_INST)
2468 {
2469 has_fpu = 1;
2470 r += snprintf (buf + r, size -r, ", FPU_MAC");
2471 }
2472
2473 if (has_fpu)
2474 {
2475 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2476 {
2477 case E_NDS32_FPU_REG_8SP_4DP:
2478 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2479 break;
2480 case E_NDS32_FPU_REG_16SP_8DP:
2481 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2482 break;
2483 case E_NDS32_FPU_REG_32SP_16DP:
2484 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2485 break;
2486 case E_NDS32_FPU_REG_32SP_32DP:
2487 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2488 break;
2489 }
2490 }
2491
2492 if (config & E_NDS32_HAS_AUDIO_INST)
2493 r += snprintf (buf + r, size -r, ", AUDIO");
2494
2495 if (config & E_NDS32_HAS_STRING_INST)
2496 r += snprintf (buf + r, size -r, ", STR");
2497
2498 if (config & E_NDS32_HAS_REDUCED_REGS)
2499 r += snprintf (buf + r, size -r, ", 16REG");
2500
2501 if (config & E_NDS32_HAS_VIDEO_INST)
2502 {
2503 if (version <= E_NDS32_ELF_VER_1_3)
2504 r += snprintf (buf + r, size -r, ", VIDEO");
2505 else
2506 r += snprintf (buf + r, size -r, ", SATURATION");
2507 }
2508
2509 if (config & E_NDS32_HAS_ENCRIPT_INST)
2510 r += snprintf (buf + r, size -r, ", ENCRP");
2511
2512 if (config & E_NDS32_HAS_L2C_INST)
2513 r += snprintf (buf + r, size -r, ", L2C");
2514}
2515
252b5132 2516static char *
d3ba0551 2517get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2518{
b34976b6 2519 static char buf[1024];
252b5132
RH		 2520
2521 buf[0] = '\0';
76da6bbe 2522
252b5132
RH		 2523 if (e_flags)
2524 {
2525 switch (e_machine)
2526 {
2527 default:
2528 break;
2529
f3485b74
NC		 2530 case EM_ARM:
2531 decode_ARM_machine_flags (e_flags, buf);
2532 break;
76da6bbe 2533
781303ce
MF		 2534 case EM_BLACKFIN:
2535 if (e_flags & EF_BFIN_PIC)
2536 strcat (buf, ", PIC");
2537
2538 if (e_flags & EF_BFIN_FDPIC)
2539 strcat (buf, ", FDPIC");
2540
2541 if (e_flags & EF_BFIN_CODE_IN_L1)
2542 strcat (buf, ", code in L1");
2543
2544 if (e_flags & EF_BFIN_DATA_IN_L1)
2545 strcat (buf, ", data in L1");
2546
2547 break;
2548
ec2dfb42
AO		 2549 case EM_CYGNUS_FRV:
2550 switch (e_flags & EF_FRV_CPU_MASK)
2551 {
2552 case EF_FRV_CPU_GENERIC:
2553 break;
2554
2555 default:
2556 strcat (buf, ", fr???");
2557 break;
57346661 2558
ec2dfb42
AO		 2559 case EF_FRV_CPU_FR300:
2560 strcat (buf, ", fr300");
2561 break;
2562
2563 case EF_FRV_CPU_FR400:
2564 strcat (buf, ", fr400");
2565 break;
2566 case EF_FRV_CPU_FR405:
2567 strcat (buf, ", fr405");
2568 break;
2569
2570 case EF_FRV_CPU_FR450:
2571 strcat (buf, ", fr450");
2572 break;
2573
2574 case EF_FRV_CPU_FR500:
2575 strcat (buf, ", fr500");
2576 break;
2577 case EF_FRV_CPU_FR550:
2578 strcat (buf, ", fr550");
2579 break;
2580
2581 case EF_FRV_CPU_SIMPLE:
2582 strcat (buf, ", simple");
2583 break;
2584 case EF_FRV_CPU_TOMCAT:
2585 strcat (buf, ", tomcat");
2586 break;
2587 }
1c877e87 2588 break;
ec2dfb42 2589
53c7db4b 2590 case EM_68K:
425c6cb0 2591 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2592 strcat (buf, ", m68000");
425c6cb0 2593 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2594 strcat (buf, ", cpu32");
2595 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2596 strcat (buf, ", fido_a");
425c6cb0 2597 else
266abb8f 2598 {
2cf0635d
NC		 2599 char const * isa = _("unknown");
2600 char const * mac = _("unknown mac");
2601 char const * additional = NULL;
0112cd26 2602
c694fd50 2603 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2604 {
c694fd50 2605 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2606 isa = "A";
2607 additional = ", nodiv";
2608 break;
c694fd50 2609 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2610 isa = "A";
2611 break;
c694fd50 2612 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2613 isa = "A+";
2614 break;
c694fd50 2615 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2616 isa = "B";
2617 additional = ", nousp";
2618 break;
c694fd50 2619 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2620 isa = "B";
2621 break;
f608cd77
NS		 2622 case EF_M68K_CF_ISA_C:
2623 isa = "C";
2624 break;
2625 case EF_M68K_CF_ISA_C_NODIV:
2626 isa = "C";
2627 additional = ", nodiv";
2628 break;
266abb8f
NS		 2629 }
2630 strcat (buf, ", cf, isa ");
2631 strcat (buf, isa);
0b2e31dc
NS		 2632 if (additional)
2633 strcat (buf, additional);
c694fd50 2634 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2635 strcat (buf, ", float");
c694fd50 2636 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2637 {
2638 case 0:
2639 mac = NULL;
2640 break;
c694fd50 2641 case EF_M68K_CF_MAC:
266abb8f
NS		 2642 mac = "mac";
2643 break;
c694fd50 2644 case EF_M68K_CF_EMAC:
266abb8f
NS		 2645 mac = "emac";
2646 break;
f608cd77
NS		 2647 case EF_M68K_CF_EMAC_B:
2648 mac = "emac_b";
2649 break;
266abb8f
NS		 2650 }
2651 if (mac)
2652 {
2653 strcat (buf, ", ");
2654 strcat (buf, mac);
2655 }
266abb8f 2656 }
53c7db4b 2657 break;
33c63f9d 2658
252b5132
RH		 2659 case EM_PPC:
2660 if (e_flags & EF_PPC_EMB)
2661 strcat (buf, ", emb");
2662
2663 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2664 strcat (buf, _(", relocatable"));
252b5132
RH		 2665
2666 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 2667 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 2668 break;
2669
ee67d69a
AM		 2670 case EM_PPC64:
2671 if (e_flags & EF_PPC64_ABI)
2672 {
2673 char abi[] = ", abiv0";
2674
2675 abi[6] += e_flags & EF_PPC64_ABI;
2676 strcat (buf, abi);
2677 }
2678 break;
2679
708e2187
NC		 2680 case EM_V800:
2681 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2682 strcat (buf, ", RH850 ABI");
0b4362b0 2683
708e2187
NC		 2684 if (e_flags & EF_V800_850E3)
2685 strcat (buf, ", V3 architecture");
2686
2687 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2688 strcat (buf, ", FPU not used");
2689
2690 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2691 strcat (buf, ", regmode: COMMON");
2692
2693 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2694 strcat (buf, ", r4 not used");
2695
2696 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2697 strcat (buf, ", r30 not used");
2698
2699 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2700 strcat (buf, ", r5 not used");
2701
2702 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2703 strcat (buf, ", r2 not used");
2704
2705 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2706 {
2707 switch (e_flags & - e_flags)
2708 {
2709 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2710 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2711 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2712 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2713 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2714 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2715 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2716 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2717 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2718 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2719 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2720 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2721 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2722 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2723 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2724 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2725 default: break;
2726 }
2727 }
2728 break;
2729
2b0337b0 2730 case EM_V850:
252b5132
RH		 2731 case EM_CYGNUS_V850:
2732 switch (e_flags & EF_V850_ARCH)
2733 {
78c8d46c
NC		 2734 case E_V850E3V5_ARCH:
2735 strcat (buf, ", v850e3v5");
2736 break;
1cd986c5
NC		 2737 case E_V850E2V3_ARCH:
2738 strcat (buf, ", v850e2v3");
2739 break;
2740 case E_V850E2_ARCH:
2741 strcat (buf, ", v850e2");
2742 break;
2743 case E_V850E1_ARCH:
2744 strcat (buf, ", v850e1");
8ad30312 2745 break;
252b5132
RH		 2746 case E_V850E_ARCH:
2747 strcat (buf, ", v850e");
2748 break;
252b5132
RH		 2749 case E_V850_ARCH:
2750 strcat (buf, ", v850");
2751 break;
2752 default:
2b692964 2753 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 2754 break;
2755 }
2756 break;
2757
2b0337b0 2758 case EM_M32R:
252b5132
RH		 2759 case EM_CYGNUS_M32R:
2760 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2761 strcat (buf, ", m32r");
252b5132
RH		 2762 break;
2763
2764 case EM_MIPS:
4fe85591 2765 case EM_MIPS_RS3_LE:
252b5132
RH		 2766 if (e_flags & EF_MIPS_NOREORDER)
2767 strcat (buf, ", noreorder");
2768
2769 if (e_flags & EF_MIPS_PIC)
2770 strcat (buf, ", pic");
2771
2772 if (e_flags & EF_MIPS_CPIC)
2773 strcat (buf, ", cpic");
2774
d1bdd336
TS		 2775 if (e_flags & EF_MIPS_UCODE)
2776 strcat (buf, ", ugen_reserved");
2777
252b5132
RH		 2778 if (e_flags & EF_MIPS_ABI2)
2779 strcat (buf, ", abi2");
2780
43521d43
TS		 2781 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2782 strcat (buf, ", odk first");
2783
a5d22d2a
TS		 2784 if (e_flags & EF_MIPS_32BITMODE)
2785 strcat (buf, ", 32bitmode");
2786
ba92f887
MR		 2787 if (e_flags & EF_MIPS_NAN2008)
2788 strcat (buf, ", nan2008");
2789
fef1b0b3
SE		 2790 if (e_flags & EF_MIPS_FP64)
2791 strcat (buf, ", fp64");
2792
156c2f8b
NC		 2793 switch ((e_flags & EF_MIPS_MACH))
2794 {
2795 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2796 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2797 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 2798 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 2799 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2800 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2801 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2802 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 2803 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 2804 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 2805 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2806 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 2807 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 2808 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 2809 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
d32e5c54 2810 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
52b6b6b9 2811 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 2812 case 0:
2813 /* We simply ignore the field in this case to avoid confusion:
2814 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2815 extension. */
2816 break;
2b692964 2817 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 2818 }
43521d43
TS		 2819
2820 switch ((e_flags & EF_MIPS_ABI))
2821 {
2822 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2823 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2824 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2825 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2826 case 0:
2827 /* We simply ignore the field in this case to avoid confusion:
2828 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2829 This means it is likely to be an o32 file, but not for
2830 sure. */
2831 break;
2b692964 2832 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 2833 }
2834
2835 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2836 strcat (buf, ", mdmx");
2837
2838 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2839 strcat (buf, ", mips16");
2840
df58fc94
RS		 2841 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2842 strcat (buf, ", micromips");
2843
43521d43
TS		 2844 switch ((e_flags & EF_MIPS_ARCH))
2845 {
2846 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2847 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2848 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2849 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2850 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2851 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 2852 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
7361da2c 2853 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
43521d43 2854 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 2855 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
7361da2c 2856 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
2b692964 2857 default: strcat (buf, _(", unknown ISA")); break;
43521d43 2858 }
252b5132 2859 break;
351b4b40 2860
35c08157
KLC		 2861 case EM_NDS32:
2862 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
2863 break;
2864
ccde1100
AO		 2865 case EM_SH:
2866 switch ((e_flags & EF_SH_MACH_MASK))
2867 {
2868 case EF_SH1: strcat (buf, ", sh1"); break;
2869 case EF_SH2: strcat (buf, ", sh2"); break;
2870 case EF_SH3: strcat (buf, ", sh3"); break;
2871 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2872 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2873 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2874 case EF_SH3E: strcat (buf, ", sh3e"); break;
2875 case EF_SH4: strcat (buf, ", sh4"); break;
2876 case EF_SH5: strcat (buf, ", sh5"); break;
2877 case EF_SH2E: strcat (buf, ", sh2e"); break;
2878 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 2879 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 2880 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2881 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 2882 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 2883 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2884 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2885 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2886 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2887 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2888 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 2889 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 2890 }
2891
cec6a5b8
MR		 2892 if (e_flags & EF_SH_PIC)
2893 strcat (buf, ", pic");
2894
2895 if (e_flags & EF_SH_FDPIC)
2896 strcat (buf, ", fdpic");
ccde1100 2897 break;
73589c9d
CS		 2898
2899 case EM_OR1K:
2900 if (e_flags & EF_OR1K_NODELAY)
2901 strcat (buf, ", no delay");
2902 break;
57346661 2903
351b4b40
RH		 2904 case EM_SPARCV9:
2905 if (e_flags & EF_SPARC_32PLUS)
2906 strcat (buf, ", v8+");
2907
2908 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 2909 strcat (buf, ", ultrasparcI");
2910
2911 if (e_flags & EF_SPARC_SUN_US3)
2912 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 2913
2914 if (e_flags & EF_SPARC_HAL_R1)
2915 strcat (buf, ", halr1");
2916
2917 if (e_flags & EF_SPARC_LEDATA)
2918 strcat (buf, ", ledata");
2919
2920 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2921 strcat (buf, ", tso");
2922
2923 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2924 strcat (buf, ", pso");
2925
2926 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2927 strcat (buf, ", rmo");
2928 break;
7d466069 2929
103f02d3
UD		 2930 case EM_PARISC:
2931 switch (e_flags & EF_PARISC_ARCH)
2932 {
2933 case EFA_PARISC_1_0:
2934 strcpy (buf, ", PA-RISC 1.0");
2935 break;
2936 case EFA_PARISC_1_1:
2937 strcpy (buf, ", PA-RISC 1.1");
2938 break;
2939 case EFA_PARISC_2_0:
2940 strcpy (buf, ", PA-RISC 2.0");
2941 break;
2942 default:
2943 break;
2944 }
2945 if (e_flags & EF_PARISC_TRAPNIL)
2946 strcat (buf, ", trapnil");
2947 if (e_flags & EF_PARISC_EXT)
2948 strcat (buf, ", ext");
2949 if (e_flags & EF_PARISC_LSB)
2950 strcat (buf, ", lsb");
2951 if (e_flags & EF_PARISC_WIDE)
2952 strcat (buf, ", wide");
2953 if (e_flags & EF_PARISC_NO_KABP)
2954 strcat (buf, ", no kabp");
2955 if (e_flags & EF_PARISC_LAZYSWAP)
2956 strcat (buf, ", lazyswap");
30800947 2957 break;
76da6bbe 2958
7d466069 2959 case EM_PJ:
2b0337b0 2960 case EM_PJ_OLD:
7d466069
ILT		 2961 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2962 strcat (buf, ", new calling convention");
2963
2964 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2965 strcat (buf, ", gnu calling convention");
2966 break;
4d6ed7c8
NC		 2967
2968 case EM_IA_64:
2969 if ((e_flags & EF_IA_64_ABI64))
2970 strcat (buf, ", 64-bit");
2971 else
2972 strcat (buf, ", 32-bit");
2973 if ((e_flags & EF_IA_64_REDUCEDFP))
2974 strcat (buf, ", reduced fp model");
2975 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2976 strcat (buf, ", no function descriptors, constant gp");
2977 else if ((e_flags & EF_IA_64_CONS_GP))
2978 strcat (buf, ", constant gp");
2979 if ((e_flags & EF_IA_64_ABSOLUTE))
2980 strcat (buf, ", absolute");
28f997cf
TG		 2981 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2982 {
2983 if ((e_flags & EF_IA_64_VMS_LINKAGES))
2984 strcat (buf, ", vms_linkages");
2985 switch ((e_flags & EF_IA_64_VMS_COMCOD))
2986 {
2987 case EF_IA_64_VMS_COMCOD_SUCCESS:
2988 break;
2989 case EF_IA_64_VMS_COMCOD_WARNING:
2990 strcat (buf, ", warning");
2991 break;
2992 case EF_IA_64_VMS_COMCOD_ERROR:
2993 strcat (buf, ", error");
2994 break;
2995 case EF_IA_64_VMS_COMCOD_ABORT:
2996 strcat (buf, ", abort");
2997 break;
2998 default:
2999 abort ();
3000 }
3001 }
4d6ed7c8 3002 break;
179d3252
JT		 3003
3004 case EM_VAX:
3005 if ((e_flags & EF_VAX_NONPIC))
3006 strcat (buf, ", non-PIC");
3007 if ((e_flags & EF_VAX_DFLOAT))
3008 strcat (buf, ", D-Float");
3009 if ((e_flags & EF_VAX_GFLOAT))
3010 strcat (buf, ", G-Float");
3011 break;
c7927a3c 3012
4046d87a
NC		 3013 case EM_RL78:
3014 if (e_flags & E_FLAG_RL78_G10)
3015 strcat (buf, ", G10");
856ea05c
KP		 3016 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3017 strcat (buf, ", 64-bit doubles");
4046d87a 3018 break;
0b4362b0 3019
c7927a3c
NC		 3020 case EM_RX:
3021 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3022 strcat (buf, ", 64-bit doubles");
3023 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 3024 strcat (buf, ", dsp");
d4cb0ea0 3025 if (e_flags & E_FLAG_RX_PID)
0b4362b0 3026 strcat (buf, ", pid");
708e2187
NC		 3027 if (e_flags & E_FLAG_RX_ABI)
3028 strcat (buf, ", RX ABI");
d4cb0ea0 3029 break;
55786da2
AK		 3030
3031 case EM_S390:
3032 if (e_flags & EF_S390_HIGH_GPRS)
3033 strcat (buf, ", highgprs");
d4cb0ea0 3034 break;
40b36596
JM		 3035
3036 case EM_TI_C6000:
3037 if ((e_flags & EF_C6000_REL))
3038 strcat (buf, ", relocatable module");
d4cb0ea0 3039 break;
13761a11
NC		 3040
3041 case EM_MSP430:
3042 strcat (buf, _(": architecture variant: "));
3043 switch (e_flags & EF_MSP430_MACH)
3044 {
3045 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3046 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3047 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3048 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3049 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3050 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3051 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3052 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3053 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3054 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3055 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3056 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3057 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3058 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3059 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3060 default:
3061 strcat (buf, _(": unknown")); break;
3062 }
3063
3064 if (e_flags & ~ EF_MSP430_MACH)
3065 strcat (buf, _(": unknown extra flag bits also present"));
252b5132
RH		 3066 }
3067 }
3068
3069 return buf;
3070}
3071
252b5132 3072static const char *
d3ba0551
AM		 3073get_osabi_name (unsigned int osabi)
3074{
3075 static char buff[32];
3076
3077 switch (osabi)
3078 {
3079 case ELFOSABI_NONE: return "UNIX - System V";
3080 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3081 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 3082 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 3083 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3084 case ELFOSABI_AIX: return "UNIX - AIX";
3085 case ELFOSABI_IRIX: return "UNIX - IRIX";
3086 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3087 case ELFOSABI_TRU64: return "UNIX - TRU64";
3088 case ELFOSABI_MODESTO: return "Novell - Modesto";
3089 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3090 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3091 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 3092 case ELFOSABI_AROS: return "AROS";
11636f9e 3093 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 3094 default:
40b36596
JM		 3095 if (osabi >= 64)
3096 switch (elf_header.e_machine)
3097 {
3098 case EM_ARM:
3099 switch (osabi)
3100 {
3101 case ELFOSABI_ARM: return "ARM";
3102 default:
3103 break;
3104 }
3105 break;
3106
3107 case EM_MSP430:
3108 case EM_MSP430_OLD:
3109 switch (osabi)
3110 {
3111 case ELFOSABI_STANDALONE: return _("Standalone App");
3112 default:
3113 break;
3114 }
3115 break;
3116
3117 case EM_TI_C6000:
3118 switch (osabi)
3119 {
3120 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3121 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3122 default:
3123 break;
3124 }
3125 break;
3126
3127 default:
3128 break;
3129 }
e9e44622 3130 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 3131 return buff;
3132 }
3133}
3134
a06ea964
NC		 3135static const char *
3136get_aarch64_segment_type (unsigned long type)
3137{
3138 switch (type)
3139 {
3140 case PT_AARCH64_ARCHEXT:
3141 return "AARCH64_ARCHEXT";
3142 default:
3143 break;
3144 }
3145
3146 return NULL;
3147}
3148
b294bdf8
MM		 3149static const char *
3150get_arm_segment_type (unsigned long type)
3151{
3152 switch (type)
3153 {
3154 case PT_ARM_EXIDX:
3155 return "EXIDX";
3156 default:
3157 break;
3158 }
3159
3160 return NULL;
3161}
3162
d3ba0551
AM		 3163static const char *
3164get_mips_segment_type (unsigned long type)
252b5132
RH		 3165{
3166 switch (type)
3167 {
3168 case PT_MIPS_REGINFO:
3169 return "REGINFO";
3170 case PT_MIPS_RTPROC:
3171 return "RTPROC";
3172 case PT_MIPS_OPTIONS:
3173 return "OPTIONS";
351cdf24
MF		 3174 case PT_MIPS_ABIFLAGS:
3175 return "ABIFLAGS";
252b5132
RH		 3176 default:
3177 break;
3178 }
3179
3180 return NULL;
3181}
3182
103f02d3 3183static const char *
d3ba0551 3184get_parisc_segment_type (unsigned long type)
103f02d3
UD		 3185{
3186 switch (type)
3187 {
3188 case PT_HP_TLS: return "HP_TLS";
3189 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3190 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3191 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3192 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3193 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3194 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3195 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3196 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3197 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3198 case PT_HP_PARALLEL: return "HP_PARALLEL";
3199 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 3200 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3201 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3202 case PT_HP_STACK: return "HP_STACK";
3203 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 3204 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3205 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 3206 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 3207 default:
3208 break;
3209 }
3210
3211 return NULL;
3212}
3213
4d6ed7c8 3214static const char *
d3ba0551 3215get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 3216{
3217 switch (type)
3218 {
3219 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3220 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 3221 case PT_HP_TLS: return "HP_TLS";
3222 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3223 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3224 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 3225 default:
3226 break;
3227 }
3228
3229 return NULL;
3230}
3231
40b36596
JM		 3232static const char *
3233get_tic6x_segment_type (unsigned long type)
3234{
3235 switch (type)
3236 {
3237 case PT_C6000_PHATTR: return "C6000_PHATTR";
3238 default:
3239 break;
3240 }
3241
3242 return NULL;
3243}
3244
252b5132 3245static const char *
d3ba0551 3246get_segment_type (unsigned long p_type)
252b5132 3247{
b34976b6 3248 static char buff[32];
252b5132
RH		 3249
3250 switch (p_type)
3251 {
b34976b6
AM		 3252 case PT_NULL: return "NULL";
3253 case PT_LOAD: return "LOAD";
252b5132 3254 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 3255 case PT_INTERP: return "INTERP";
3256 case PT_NOTE: return "NOTE";
3257 case PT_SHLIB: return "SHLIB";
3258 case PT_PHDR: return "PHDR";
13ae64f3 3259 case PT_TLS: return "TLS";
252b5132 3260
65765700
JJ		 3261 case PT_GNU_EH_FRAME:
3262 return "GNU_EH_FRAME";
2b05f1b7 3263 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 3264 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 3265
252b5132
RH		 3266 default:
3267 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3268 {
2cf0635d 3269 const char * result;
103f02d3 3270
252b5132
RH		 3271 switch (elf_header.e_machine)
3272 {
a06ea964
NC		 3273 case EM_AARCH64:
3274 result = get_aarch64_segment_type (p_type);
3275 break;
b294bdf8
MM		 3276 case EM_ARM:
3277 result = get_arm_segment_type (p_type);
3278 break;
252b5132 3279 case EM_MIPS:
4fe85591 3280 case EM_MIPS_RS3_LE:
252b5132
RH		 3281 result = get_mips_segment_type (p_type);
3282 break;
103f02d3
UD		 3283 case EM_PARISC:
3284 result = get_parisc_segment_type (p_type);
3285 break;
4d6ed7c8
NC		 3286 case EM_IA_64:
3287 result = get_ia64_segment_type (p_type);
3288 break;
40b36596
JM		 3289 case EM_TI_C6000:
3290 result = get_tic6x_segment_type (p_type);
3291 break;
252b5132
RH		 3292 default:
3293 result = NULL;
3294 break;
3295 }
103f02d3 3296
252b5132
RH		 3297 if (result != NULL)
3298 return result;
103f02d3 3299
252b5132
RH		 3300 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3301 }
3302 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3303 {
2cf0635d 3304 const char * result;
103f02d3
UD		 3305
3306 switch (elf_header.e_machine)
3307 {
3308 case EM_PARISC:
3309 result = get_parisc_segment_type (p_type);
3310 break;
00428cca
AM		 3311 case EM_IA_64:
3312 result = get_ia64_segment_type (p_type);
3313 break;
103f02d3
UD		 3314 default:
3315 result = NULL;
3316 break;
3317 }
3318
3319 if (result != NULL)
3320 return result;
3321
3322 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3323 }
252b5132 3324 else
e9e44622 3325 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3326
3327 return buff;
3328 }
3329}
3330
3331static const char *
d3ba0551 3332get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3333{
3334 switch (sh_type)
3335 {
b34976b6
AM		 3336 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3337 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3338 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3339 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3340 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3341 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3342 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3343 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3344 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3345 case SHT_MIPS_RELD: return "MIPS_RELD";
3346 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3347 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3348 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3349 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3350 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3351 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3352 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3353 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3354 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3355 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3356 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3357 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3358 case SHT_MIPS_LINE: return "MIPS_LINE";
3359 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3360 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3361 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3362 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3363 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3364 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3365 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3366 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3367 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3368 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3369 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3370 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3371 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3372 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3373 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132 3374 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
351cdf24 3375 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
252b5132
RH		 3376 default:
3377 break;
3378 }
3379 return NULL;
3380}
3381
103f02d3 3382static const char *
d3ba0551 3383get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3384{
3385 switch (sh_type)
3386 {
3387 case SHT_PARISC_EXT: return "PARISC_EXT";
3388 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3389 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3390 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3391 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3392 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3393 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3394 default:
3395 break;
3396 }
3397 return NULL;
3398}
3399
4d6ed7c8 3400static const char *
d3ba0551 3401get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3402{
18bd398b 3403 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3404 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3405 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3406
4d6ed7c8
NC		 3407 switch (sh_type)
3408 {
148b93f2
NC		 3409 case SHT_IA_64_EXT: return "IA_64_EXT";
3410 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3411 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3412 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3413 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3414 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3415 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3416 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3417 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3418 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3419 default:
3420 break;
3421 }
3422 return NULL;
3423}
3424
d2b2c203
DJ		 3425static const char *
3426get_x86_64_section_type_name (unsigned int sh_type)
3427{
3428 switch (sh_type)
3429 {
3430 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3431 default:
3432 break;
3433 }
3434 return NULL;
3435}
3436
a06ea964
NC		 3437static const char *
3438get_aarch64_section_type_name (unsigned int sh_type)
3439{
3440 switch (sh_type)
3441 {
3442 case SHT_AARCH64_ATTRIBUTES:
3443 return "AARCH64_ATTRIBUTES";
3444 default:
3445 break;
3446 }
3447 return NULL;
3448}
3449
40a18ebd
NC		 3450static const char *
3451get_arm_section_type_name (unsigned int sh_type)
3452{
3453 switch (sh_type)
3454 {
7f6fed87
NC		 3455 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3456 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3457 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3458 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3459 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3460 default:
3461 break;
3462 }
3463 return NULL;
3464}
3465
40b36596
JM		 3466static const char *
3467get_tic6x_section_type_name (unsigned int sh_type)
3468{
3469 switch (sh_type)
3470 {
3471 case SHT_C6000_UNWIND:
3472 return "C6000_UNWIND";
3473 case SHT_C6000_PREEMPTMAP:
3474 return "C6000_PREEMPTMAP";
3475 case SHT_C6000_ATTRIBUTES:
3476 return "C6000_ATTRIBUTES";
3477 case SHT_TI_ICODE:
3478 return "TI_ICODE";
3479 case SHT_TI_XREF:
3480 return "TI_XREF";
3481 case SHT_TI_HANDLER:
3482 return "TI_HANDLER";
3483 case SHT_TI_INITINFO:
3484 return "TI_INITINFO";
3485 case SHT_TI_PHATTRS:
3486 return "TI_PHATTRS";
3487 default:
3488 break;
3489 }
3490 return NULL;
3491}
3492
13761a11
NC		 3493static const char *
3494get_msp430x_section_type_name (unsigned int sh_type)
3495{
3496 switch (sh_type)
3497 {
3498 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3499 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3500 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3501 default: return NULL;
3502 }
3503}
3504
252b5132 3505static const char *
d3ba0551 3506get_section_type_name (unsigned int sh_type)
252b5132 3507{
b34976b6 3508 static char buff[32];
252b5132
RH		 3509
3510 switch (sh_type)
3511 {
3512 case SHT_NULL: return "NULL";
3513 case SHT_PROGBITS: return "PROGBITS";
3514 case SHT_SYMTAB: return "SYMTAB";
3515 case SHT_STRTAB: return "STRTAB";
3516 case SHT_RELA: return "RELA";
3517 case SHT_HASH: return "HASH";
3518 case SHT_DYNAMIC: return "DYNAMIC";
3519 case SHT_NOTE: return "NOTE";
3520 case SHT_NOBITS: return "NOBITS";
3521 case SHT_REL: return "REL";
3522 case SHT_SHLIB: return "SHLIB";
3523 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3524 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3525 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3526 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3527 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3528 case SHT_GROUP: return "GROUP";
3529 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3530 case SHT_GNU_verdef: return "VERDEF";
3531 case SHT_GNU_verneed: return "VERNEED";
3532 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3533 case 0x6ffffff0: return "VERSYM";
3534 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3535 case 0x7ffffffd: return "AUXILIARY";
3536 case 0x7fffffff: return "FILTER";
047b2264 3537 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3538
3539 default:
3540 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3541 {
2cf0635d 3542 const char * result;
252b5132
RH		 3543
3544 switch (elf_header.e_machine)
3545 {
3546 case EM_MIPS:
4fe85591 3547 case EM_MIPS_RS3_LE:
252b5132
RH		 3548 result = get_mips_section_type_name (sh_type);
3549 break;
103f02d3
UD		 3550 case EM_PARISC:
3551 result = get_parisc_section_type_name (sh_type);
3552 break;
4d6ed7c8
NC		 3553 case EM_IA_64:
3554 result = get_ia64_section_type_name (sh_type);
3555 break;
d2b2c203 3556 case EM_X86_64:
8a9036a4 3557 case EM_L1OM:
7a9068fe 3558 case EM_K1OM:
d2b2c203
DJ		 3559 result = get_x86_64_section_type_name (sh_type);
3560 break;
a06ea964
NC		 3561 case EM_AARCH64:
3562 result = get_aarch64_section_type_name (sh_type);
3563 break;
40a18ebd
NC		 3564 case EM_ARM:
3565 result = get_arm_section_type_name (sh_type);
3566 break;
40b36596
JM		 3567 case EM_TI_C6000:
3568 result = get_tic6x_section_type_name (sh_type);
3569 break;
13761a11
NC		 3570 case EM_MSP430:
3571 result = get_msp430x_section_type_name (sh_type);
3572 break;
252b5132
RH		 3573 default:
3574 result = NULL;
3575 break;
3576 }
3577
3578 if (result != NULL)
3579 return result;
3580
c91d0dfb 3581 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3582 }
3583 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3584 {
2cf0635d 3585 const char * result;
148b93f2
NC		 3586
3587 switch (elf_header.e_machine)
3588 {
3589 case EM_IA_64:
3590 result = get_ia64_section_type_name (sh_type);
3591 break;
3592 default:
3593 result = NULL;
3594 break;
3595 }
3596
3597 if (result != NULL)
3598 return result;
3599
3600 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3601 }
252b5132 3602 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
c91d0dfb 3603 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
252b5132 3604 else
a7dbfd1c
NC		 3605 /* This message is probably going to be displayed in a 15
3606 character wide field, so put the hex value first. */
3607 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3608
252b5132
RH		 3609 return buff;
3610 }
3611}
3612
2979dc34 3613#define OPTION_DEBUG_DUMP 512
2c610e4b 3614#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3615#define OPTION_DWARF_DEPTH 514
3616#define OPTION_DWARF_START 515
4723351a 3617#define OPTION_DWARF_CHECK 516
2979dc34 3618
85b1c36d 3619static struct option options[] =
252b5132 3620{
b34976b6 3621 {"all", no_argument, 0, 'a'},
252b5132
RH		 3622 {"file-header", no_argument, 0, 'h'},
3623 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3624 {"headers", no_argument, 0, 'e'},
3625 {"histogram", no_argument, 0, 'I'},
3626 {"segments", no_argument, 0, 'l'},
3627 {"sections", no_argument, 0, 'S'},
252b5132 3628 {"section-headers", no_argument, 0, 'S'},
f5842774 3629 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3630 {"section-details", no_argument, 0, 't'},
595cf52e 3631 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3632 {"symbols", no_argument, 0, 's'},
3633 {"syms", no_argument, 0, 's'},
2c610e4b 3634 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3635 {"relocs", no_argument, 0, 'r'},
3636 {"notes", no_argument, 0, 'n'},
3637 {"dynamic", no_argument, 0, 'd'},
a952a375 3638 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3639 {"version-info", no_argument, 0, 'V'},
3640 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3641 {"unwind", no_argument, 0, 'u'},
4145f1d5 3642 {"archive-index", no_argument, 0, 'c'},
b34976b6 3643 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3644 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3645 {"string-dump", required_argument, 0, 'p'},
252b5132
RH		 3646#ifdef SUPPORT_DISASSEMBLY
3647 {"instruction-dump", required_argument, 0, 'i'},
3648#endif
cf13d699 3649 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3650
fd2f0033
TT		 3651 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3652 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 3653 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 3654
b34976b6
AM		 3655 {"version", no_argument, 0, 'v'},
3656 {"wide", no_argument, 0, 'W'},
3657 {"help", no_argument, 0, 'H'},
3658 {0, no_argument, 0, 0}
252b5132
RH		 3659};
3660
3661static void
2cf0635d 3662usage (FILE * stream)
252b5132 3663{
92f01d61
JM		 3664 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3665 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3666 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3667 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3668 -h --file-header Display the ELF file header\n\
3669 -l --program-headers Display the program headers\n\
3670 --segments An alias for --program-headers\n\
3671 -S --section-headers Display the sections' header\n\
3672 --sections An alias for --section-headers\n\
f5842774 3673 -g --section-groups Display the section groups\n\
5477e8a0 3674 -t --section-details Display the section details\n\
8b53311e
NC		 3675 -e --headers Equivalent to: -h -l -S\n\
3676 -s --syms Display the symbol table\n\
3f08eb35 3677 --symbols An alias for --syms\n\
2c610e4b 3678 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3679 -n --notes Display the core notes (if present)\n\
3680 -r --relocs Display the relocations (if present)\n\
3681 -u --unwind Display the unwind info (if present)\n\
b2d38a17 3682 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 3683 -V --version-info Display the version sections (if present)\n\
1b31d05e 3684 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 3685 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 3686 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 3687 -x --hex-dump=<number|name>\n\
3688 Dump the contents of section <number|name> as bytes\n\
3689 -p --string-dump=<number|name>\n\
3690 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 3691 -R --relocated-dump=<number|name>\n\
3692 Dump the contents of section <number|name> as relocated bytes\n\
f9f0e732 3693 -w[lLiaprmfFsoRt] or\n\
1ed06042 3694 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 3695 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 3696 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3697 =addr,=cu_index]\n\
8b53311e 3698 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 3699 fprintf (stream, _("\
3700 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3701 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3702 or deeper\n"));
252b5132 3703#ifdef SUPPORT_DISASSEMBLY
92f01d61 3704 fprintf (stream, _("\
09c11c86
NC		 3705 -i --instruction-dump=<number|name>\n\
3706 Disassemble the contents of section <number|name>\n"));
252b5132 3707#endif
92f01d61 3708 fprintf (stream, _("\
8b53311e
NC		 3709 -I --histogram Display histogram of bucket list lengths\n\
3710 -W --wide Allow output width to exceed 80 characters\n\
07012eee 3711 @<file> Read options from <file>\n\
8b53311e
NC		 3712 -H --help Display this information\n\
3713 -v --version Display the version number of readelf\n"));
1118d252 3714
92f01d61
JM		 3715 if (REPORT_BUGS_TO[0] && stream == stdout)
3716 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 3717
92f01d61 3718 exit (stream == stdout ? 0 : 1);
252b5132
RH		 3719}
3720
18bd398b
NC		 3721/* Record the fact that the user wants the contents of section number
3722 SECTION to be displayed using the method(s) encoded as flags bits
3723 in TYPE. Note, TYPE can be zero if we are creating the array for
3724 the first time. */
3725
252b5132 3726static void
09c11c86 3727request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 3728{
3729 if (section >= num_dump_sects)
3730 {
2cf0635d 3731 dump_type * new_dump_sects;
252b5132 3732
3f5e193b
NC		 3733 new_dump_sects = (dump_type *) calloc (section + 1,
3734 sizeof (* dump_sects));
252b5132
RH		 3735
3736 if (new_dump_sects == NULL)
591a748a 3737 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 3738 else
3739 {
3740 /* Copy current flag settings. */
09c11c86 3741 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 3742
3743 free (dump_sects);
3744
3745 dump_sects = new_dump_sects;
3746 num_dump_sects = section + 1;
3747 }
3748 }
3749
3750 if (dump_sects)
b34976b6 3751 dump_sects[section] |= type;
252b5132
RH		 3752
3753 return;
3754}
3755
aef1f6d0
DJ		 3756/* Request a dump by section name. */
3757
3758static void
2cf0635d 3759request_dump_byname (const char * section, dump_type type)
aef1f6d0 3760{
2cf0635d 3761 struct dump_list_entry * new_request;
aef1f6d0 3762
3f5e193b
NC		 3763 new_request = (struct dump_list_entry *)
3764 malloc (sizeof (struct dump_list_entry));
aef1f6d0 3765 if (!new_request)
591a748a 3766 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3767
3768 new_request->name = strdup (section);
3769 if (!new_request->name)
591a748a 3770 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3771
3772 new_request->type = type;
3773
3774 new_request->next = dump_sects_byname;
3775 dump_sects_byname = new_request;
3776}
3777
cf13d699
NC		 3778static inline void
3779request_dump (dump_type type)
3780{
3781 int section;
3782 char * cp;
3783
3784 do_dump++;
3785 section = strtoul (optarg, & cp, 0);
3786
3787 if (! *cp && section >= 0)
3788 request_dump_bynumber (section, type);
3789 else
3790 request_dump_byname (optarg, type);
3791}
3792
3793
252b5132 3794static void
2cf0635d 3795parse_args (int argc, char ** argv)
252b5132
RH		 3796{
3797 int c;
3798
3799 if (argc < 2)
92f01d61 3800 usage (stderr);
252b5132
RH		 3801
3802 while ((c = getopt_long
cf13d699 3803 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
252b5132 3804 {
252b5132
RH		 3805 switch (c)
3806 {
3807 case 0:
3808 /* Long options. */
3809 break;
3810 case 'H':
92f01d61 3811 usage (stdout);
252b5132
RH		 3812 break;
3813
3814 case 'a':
b34976b6
AM		 3815 do_syms++;
3816 do_reloc++;
3817 do_unwind++;
3818 do_dynamic++;
3819 do_header++;
3820 do_sections++;
f5842774 3821 do_section_groups++;
b34976b6
AM		 3822 do_segments++;
3823 do_version++;
3824 do_histogram++;
3825 do_arch++;
3826 do_notes++;
252b5132 3827 break;
f5842774
L		 3828 case 'g':
3829 do_section_groups++;
3830 break;
5477e8a0 3831 case 't':
595cf52e 3832 case 'N':
5477e8a0
L		 3833 do_sections++;
3834 do_section_details++;
595cf52e 3835 break;
252b5132 3836 case 'e':
b34976b6
AM		 3837 do_header++;
3838 do_sections++;
3839 do_segments++;
252b5132 3840 break;
a952a375 3841 case 'A':
b34976b6 3842 do_arch++;
a952a375 3843 break;
252b5132 3844 case 'D':
b34976b6 3845 do_using_dynamic++;
252b5132
RH		 3846 break;
3847 case 'r':
b34976b6 3848 do_reloc++;
252b5132 3849 break;
4d6ed7c8 3850 case 'u':
b34976b6 3851 do_unwind++;
4d6ed7c8 3852 break;
252b5132 3853 case 'h':
b34976b6 3854 do_header++;
252b5132
RH		 3855 break;
3856 case 'l':
b34976b6 3857 do_segments++;
252b5132
RH		 3858 break;
3859 case 's':
b34976b6 3860 do_syms++;
252b5132
RH		 3861 break;
3862 case 'S':
b34976b6 3863 do_sections++;
252b5132
RH		 3864 break;
3865 case 'd':
b34976b6 3866 do_dynamic++;
252b5132 3867 break;
a952a375 3868 case 'I':
b34976b6 3869 do_histogram++;
a952a375 3870 break;
779fe533 3871 case 'n':
b34976b6 3872 do_notes++;
779fe533 3873 break;
4145f1d5
NC		 3874 case 'c':
3875 do_archive_index++;
3876 break;
252b5132 3877 case 'x':
cf13d699 3878 request_dump (HEX_DUMP);
aef1f6d0 3879 break;
09c11c86 3880 case 'p':
cf13d699
NC		 3881 request_dump (STRING_DUMP);
3882 break;
3883 case 'R':
3884 request_dump (RELOC_DUMP);
09c11c86 3885 break;
252b5132 3886 case 'w':
b34976b6 3887 do_dump++;
252b5132 3888 if (optarg == 0)
613ff48b
CC		 3889 {
3890 do_debugging = 1;
3891 dwarf_select_sections_all ();
3892 }
252b5132
RH		 3893 else
3894 {
3895 do_debugging = 0;
4cb93e3b 3896 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 3897 }
3898 break;
2979dc34 3899 case OPTION_DEBUG_DUMP:
b34976b6 3900 do_dump++;
2979dc34
JJ		 3901 if (optarg == 0)
3902 do_debugging = 1;
3903 else
3904 {
2979dc34 3905 do_debugging = 0;
4cb93e3b 3906 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 3907 }
3908 break;
fd2f0033
TT		 3909 case OPTION_DWARF_DEPTH:
3910 {
3911 char *cp;
3912
3913 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3914 }
3915 break;
3916 case OPTION_DWARF_START:
3917 {
3918 char *cp;
3919
3920 dwarf_start_die = strtoul (optarg, & cp, 0);
3921 }
3922 break;
4723351a
CC		 3923 case OPTION_DWARF_CHECK:
3924 dwarf_check = 1;
3925 break;
2c610e4b
L		 3926 case OPTION_DYN_SYMS:
3927 do_dyn_syms++;
3928 break;
252b5132
RH		 3929#ifdef SUPPORT_DISASSEMBLY
3930 case 'i':
cf13d699
NC		 3931 request_dump (DISASS_DUMP);
3932 break;
252b5132
RH		 3933#endif
3934 case 'v':
3935 print_version (program_name);
3936 break;
3937 case 'V':
b34976b6 3938 do_version++;
252b5132 3939 break;
d974e256 3940 case 'W':
b34976b6 3941 do_wide++;
d974e256 3942 break;
252b5132 3943 default:
252b5132
RH		 3944 /* xgettext:c-format */
3945 error (_("Invalid option '-%c'\n"), c);
3946 /* Drop through. */
3947 case '?':
92f01d61 3948 usage (stderr);
252b5132
RH		 3949 }
3950 }
3951
4d6ed7c8 3952 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 3953 && !do_segments && !do_header && !do_dump && !do_version
f5842774 3954 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 3955 && !do_section_groups && !do_archive_index
3956 && !do_dyn_syms)
92f01d61 3957 usage (stderr);
252b5132
RH		 3958 else if (argc < 3)
3959 {
3960 warn (_("Nothing to do.\n"));
92f01d61 3961 usage (stderr);
252b5132
RH		 3962 }
3963}
3964
3965static const char *
d3ba0551 3966get_elf_class (unsigned int elf_class)
252b5132 3967{
b34976b6 3968 static char buff[32];
103f02d3 3969
252b5132
RH		 3970 switch (elf_class)
3971 {
3972 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 3973 case ELFCLASS32: return "ELF32";
3974 case ELFCLASS64: return "ELF64";
ab5e7794 3975 default:
e9e44622 3976 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 3977 return buff;
252b5132
RH		 3978 }
3979}
3980
3981static const char *
d3ba0551 3982get_data_encoding (unsigned int encoding)
252b5132 3983{
b34976b6 3984 static char buff[32];
103f02d3 3985
252b5132
RH		 3986 switch (encoding)
3987 {
3988 case ELFDATANONE: return _("none");
33c63f9d
CM		 3989 case ELFDATA2LSB: return _("2's complement, little endian");
3990 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 3991 default:
e9e44622 3992 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 3993 return buff;
252b5132
RH		 3994 }
3995}
3996
252b5132 3997/* Decode the data held in 'elf_header'. */
ee42cf8c 3998
252b5132 3999static int
d3ba0551 4000process_file_header (void)
252b5132 4001{
b34976b6
AM		 4002 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4003 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4004 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4005 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 4006 {
4007 error
4008 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4009 return 0;
4010 }
4011
2dc4cec1
L		 4012 init_dwarf_regnames (elf_header.e_machine);
4013
252b5132
RH		 4014 if (do_header)
4015 {
4016 int i;
4017
4018 printf (_("ELF Header:\n"));
4019 printf (_(" Magic: "));
b34976b6
AM		 4020 for (i = 0; i < EI_NIDENT; i++)
4021 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 4022 printf ("\n");
4023 printf (_(" Class: %s\n"),
b34976b6 4024 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 4025 printf (_(" Data: %s\n"),
b34976b6 4026 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 4027 printf (_(" Version: %d %s\n"),
b34976b6
AM		 4028 elf_header.e_ident[EI_VERSION],
4029 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 4030 ? "(current)"
b34976b6 4031 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 4032 ? _("<unknown: %lx>")
789be9f7 4033 : "")));
252b5132 4034 printf (_(" OS/ABI: %s\n"),
b34976b6 4035 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 4036 printf (_(" ABI Version: %d\n"),
b34976b6 4037 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 4038 printf (_(" Type: %s\n"),
4039 get_file_type (elf_header.e_type));
4040 printf (_(" Machine: %s\n"),
4041 get_machine_name (elf_header.e_machine));
4042 printf (_(" Version: 0x%lx\n"),
4043 (unsigned long) elf_header.e_version);
76da6bbe 4044
f7a99963
NC		 4045 printf (_(" Entry point address: "));
4046 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4047 printf (_("\n Start of program headers: "));
4048 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4049 printf (_(" (bytes into file)\n Start of section headers: "));
4050 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4051 printf (_(" (bytes into file)\n"));
76da6bbe 4052
252b5132
RH		 4053 printf (_(" Flags: 0x%lx%s\n"),
4054 (unsigned long) elf_header.e_flags,
4055 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4056 printf (_(" Size of this header: %ld (bytes)\n"),
4057 (long) elf_header.e_ehsize);
4058 printf (_(" Size of program headers: %ld (bytes)\n"),
4059 (long) elf_header.e_phentsize);
2046a35d 4060 printf (_(" Number of program headers: %ld"),
252b5132 4061 (long) elf_header.e_phnum);
2046a35d
AM		 4062 if (section_headers != NULL
4063 && elf_header.e_phnum == PN_XNUM
4064 && section_headers[0].sh_info != 0)
cc5914eb 4065 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 4066 putc ('\n', stdout);
252b5132
RH		 4067 printf (_(" Size of section headers: %ld (bytes)\n"),
4068 (long) elf_header.e_shentsize);
560f3c1c 4069 printf (_(" Number of section headers: %ld"),
252b5132 4070 (long) elf_header.e_shnum);
4fbb74a6 4071 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 4072 printf (" (%ld)", (long) section_headers[0].sh_size);
4073 putc ('\n', stdout);
4074 printf (_(" Section header string table index: %ld"),
252b5132 4075 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 4076 if (section_headers != NULL
4077 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 4078 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 4079 else if (elf_header.e_shstrndx != SHN_UNDEF
4080 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 4081 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 4082 putc ('\n', stdout);
4083 }
4084
4085 if (section_headers != NULL)
4086 {
2046a35d
AM		 4087 if (elf_header.e_phnum == PN_XNUM
4088 && section_headers[0].sh_info != 0)
4089 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 4090 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 4091 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 4092 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 4093 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 4094 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 4095 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 4096 free (section_headers);
4097 section_headers = NULL;
252b5132 4098 }
103f02d3 4099
9ea033b2
NC		 4100 return 1;
4101}
4102
252b5132 4103
9ea033b2 4104static int
91d6fa6a 4105get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4106{
2cf0635d
NC		 4107 Elf32_External_Phdr * phdrs;
4108 Elf32_External_Phdr * external;
4109 Elf_Internal_Phdr * internal;
b34976b6 4110 unsigned int i;
103f02d3 4111
3f5e193b
NC		 4112 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4113 elf_header.e_phentsize,
4114 elf_header.e_phnum,
4115 _("program headers"));
a6e9f9df
AM		 4116 if (!phdrs)
4117 return 0;
9ea033b2 4118
91d6fa6a 4119 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4120 i < elf_header.e_phnum;
b34976b6 4121 i++, internal++, external++)
252b5132 4122 {
9ea033b2
NC		 4123 internal->p_type = BYTE_GET (external->p_type);
4124 internal->p_offset = BYTE_GET (external->p_offset);
4125 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4126 internal->p_paddr = BYTE_GET (external->p_paddr);
4127 internal->p_filesz = BYTE_GET (external->p_filesz);
4128 internal->p_memsz = BYTE_GET (external->p_memsz);
4129 internal->p_flags = BYTE_GET (external->p_flags);
4130 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 4131 }
4132
9ea033b2
NC		 4133 free (phdrs);
4134
252b5132
RH		 4135 return 1;
4136}
4137
9ea033b2 4138static int
91d6fa6a 4139get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4140{
2cf0635d
NC		 4141 Elf64_External_Phdr * phdrs;
4142 Elf64_External_Phdr * external;
4143 Elf_Internal_Phdr * internal;
b34976b6 4144 unsigned int i;
103f02d3 4145
3f5e193b
NC		 4146 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4147 elf_header.e_phentsize,
4148 elf_header.e_phnum,
4149 _("program headers"));
a6e9f9df
AM		 4150 if (!phdrs)
4151 return 0;
9ea033b2 4152
91d6fa6a 4153 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4154 i < elf_header.e_phnum;
b34976b6 4155 i++, internal++, external++)
9ea033b2
NC		 4156 {
4157 internal->p_type = BYTE_GET (external->p_type);
4158 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 4159 internal->p_offset = BYTE_GET (external->p_offset);
4160 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4161 internal->p_paddr = BYTE_GET (external->p_paddr);
4162 internal->p_filesz = BYTE_GET (external->p_filesz);
4163 internal->p_memsz = BYTE_GET (external->p_memsz);
4164 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 4165 }
4166
4167 free (phdrs);
4168
4169 return 1;
4170}
252b5132 4171
d93f0186
NC		 4172/* Returns 1 if the program headers were read into `program_headers'. */
4173
4174static int
2cf0635d 4175get_program_headers (FILE * file)
d93f0186 4176{
2cf0635d 4177 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 4178
4179 /* Check cache of prior read. */
4180 if (program_headers != NULL)
4181 return 1;
4182
3f5e193b
NC		 4183 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4184 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 4185
4186 if (phdrs == NULL)
4187 {
4188 error (_("Out of memory\n"));
4189 return 0;
4190 }
4191
4192 if (is_32bit_elf
4193 ? get_32bit_program_headers (file, phdrs)
4194 : get_64bit_program_headers (file, phdrs))
4195 {
4196 program_headers = phdrs;
4197 return 1;
4198 }
4199
4200 free (phdrs);
4201 return 0;
4202}
4203
2f62977e
NC		 4204/* Returns 1 if the program headers were loaded. */
4205
252b5132 4206static int
2cf0635d 4207process_program_headers (FILE * file)
252b5132 4208{
2cf0635d 4209 Elf_Internal_Phdr * segment;
b34976b6 4210 unsigned int i;
252b5132
RH		 4211
4212 if (elf_header.e_phnum == 0)
4213 {
82f2dbf7
NC		 4214 /* PR binutils/12467. */
4215 if (elf_header.e_phoff != 0)
4216 warn (_("possibly corrupt ELF header - it has a non-zero program"
4217 " header offset, but no program headers"));
4218 else if (do_segments)
252b5132 4219 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 4220 return 0;
252b5132
RH		 4221 }
4222
4223 if (do_segments && !do_header)
4224 {
f7a99963
NC		 4225 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4226 printf (_("Entry point "));
4227 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4228 printf (_("\nThere are %d program headers, starting at offset "),
4229 elf_header.e_phnum);
4230 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4231 printf ("\n");
252b5132
RH		 4232 }
4233
d93f0186 4234 if (! get_program_headers (file))
252b5132 4235 return 0;
103f02d3 4236
252b5132
RH		 4237 if (do_segments)
4238 {
3a1a2036
NC		 4239 if (elf_header.e_phnum > 1)
4240 printf (_("\nProgram Headers:\n"));
4241 else
4242 printf (_("\nProgram Headers:\n"));
76da6bbe 4243
f7a99963
NC		 4244 if (is_32bit_elf)
4245 printf
4246 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 4247 else if (do_wide)
4248 printf
4249 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 4250 else
4251 {
4252 printf
4253 (_(" Type Offset VirtAddr PhysAddr\n"));
4254 printf
4255 (_(" FileSiz MemSiz Flags Align\n"));
4256 }
252b5132
RH		 4257 }
4258
252b5132 4259 dynamic_addr = 0;
1b228002 4260 dynamic_size = 0;
252b5132
RH		 4261
4262 for (i = 0, segment = program_headers;
4263 i < elf_header.e_phnum;
b34976b6 4264 i++, segment++)
252b5132
RH		 4265 {
4266 if (do_segments)
4267 {
103f02d3 4268 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 4269
4270 if (is_32bit_elf)
4271 {
4272 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4273 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4274 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4275 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4276 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4277 printf ("%c%c%c ",
4278 (segment->p_flags & PF_R ? 'R' : ' '),
4279 (segment->p_flags & PF_W ? 'W' : ' '),
4280 (segment->p_flags & PF_X ? 'E' : ' '));
4281 printf ("%#lx", (unsigned long) segment->p_align);
4282 }
d974e256
JJ		 4283 else if (do_wide)
4284 {
4285 if ((unsigned long) segment->p_offset == segment->p_offset)
4286 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4287 else
4288 {
4289 print_vma (segment->p_offset, FULL_HEX);
4290 putchar (' ');
4291 }
4292
4293 print_vma (segment->p_vaddr, FULL_HEX);
4294 putchar (' ');
4295 print_vma (segment->p_paddr, FULL_HEX);
4296 putchar (' ');
4297
4298 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4299 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4300 else
4301 {
4302 print_vma (segment->p_filesz, FULL_HEX);
4303 putchar (' ');
4304 }
4305
4306 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4307 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4308 else
4309 {
f48e6c45 4310 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 4311 }
4312
4313 printf (" %c%c%c ",
4314 (segment->p_flags & PF_R ? 'R' : ' '),
4315 (segment->p_flags & PF_W ? 'W' : ' '),
4316 (segment->p_flags & PF_X ? 'E' : ' '));
4317
4318 if ((unsigned long) segment->p_align == segment->p_align)
4319 printf ("%#lx", (unsigned long) segment->p_align);
4320 else
4321 {
4322 print_vma (segment->p_align, PREFIX_HEX);
4323 }
4324 }
f7a99963
NC		 4325 else
4326 {
4327 print_vma (segment->p_offset, FULL_HEX);
4328 putchar (' ');
4329 print_vma (segment->p_vaddr, FULL_HEX);
4330 putchar (' ');
4331 print_vma (segment->p_paddr, FULL_HEX);
4332 printf ("\n ");
4333 print_vma (segment->p_filesz, FULL_HEX);
4334 putchar (' ');
4335 print_vma (segment->p_memsz, FULL_HEX);
4336 printf (" %c%c%c ",
4337 (segment->p_flags & PF_R ? 'R' : ' '),
4338 (segment->p_flags & PF_W ? 'W' : ' '),
4339 (segment->p_flags & PF_X ? 'E' : ' '));
4340 print_vma (segment->p_align, HEX);
4341 }
252b5132
RH		 4342 }
4343
4344 switch (segment->p_type)
4345 {
252b5132
RH		 4346 case PT_DYNAMIC:
4347 if (dynamic_addr)
4348 error (_("more than one dynamic segment\n"));
4349
20737c13
AM		 4350 /* By default, assume that the .dynamic section is the first
4351 section in the DYNAMIC segment. */
4352 dynamic_addr = segment->p_offset;
4353 dynamic_size = segment->p_filesz;
4354
b2d38a17
NC		 4355 /* Try to locate the .dynamic section. If there is
4356 a section header table, we can easily locate it. */
4357 if (section_headers != NULL)
4358 {
2cf0635d 4359 Elf_Internal_Shdr * sec;
b2d38a17 4360
89fac5e3
RS		 4361 sec = find_section (".dynamic");
4362 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4363 {
28f997cf
TG		 4364 /* A corresponding .dynamic section is expected, but on
4365 IA-64/OpenVMS it is OK for it to be missing. */
4366 if (!is_ia64_vms ())
4367 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 4368 break;
4369 }
4370
42bb2e33 4371 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 4372 {
4373 dynamic_size = 0;
4374 break;
4375 }
42bb2e33 4376
b2d38a17
NC		 4377 dynamic_addr = sec->sh_offset;
4378 dynamic_size = sec->sh_size;
4379
4380 if (dynamic_addr < segment->p_offset
4381 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 4382 warn (_("the .dynamic section is not contained"
4383 " within the dynamic segment\n"));
b2d38a17 4384 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 4385 warn (_("the .dynamic section is not the first section"
4386 " in the dynamic segment.\n"));
b2d38a17 4387 }
252b5132
RH		 4388 break;
4389
4390 case PT_INTERP:
fb52b2f4
NC		 4391 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4392 SEEK_SET))
252b5132
RH		 4393 error (_("Unable to find program interpreter name\n"));
4394 else
4395 {
f8eae8b2 4396 char fmt [32];
9495b2e6 4397 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
f8eae8b2
L		 4398
4399 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4400 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4401
252b5132 4402 program_interpreter[0] = 0;
7bd7b3ef
AM		 4403 if (fscanf (file, fmt, program_interpreter) <= 0)
4404 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 4405
4406 if (do_segments)
4407 printf (_("\n [Requesting program interpreter: %s]"),
4408 program_interpreter);
4409 }
4410 break;
4411 }
4412
4413 if (do_segments)
4414 putc ('\n', stdout);
4415 }
4416
c256ffe7 4417 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 4418 {
4419 printf (_("\n Section to Segment mapping:\n"));
4420 printf (_(" Segment Sections...\n"));
4421
252b5132
RH		 4422 for (i = 0; i < elf_header.e_phnum; i++)
4423 {
9ad5cbcf 4424 unsigned int j;
2cf0635d 4425 Elf_Internal_Shdr * section;
252b5132
RH		 4426
4427 segment = program_headers + i;
b391a3e3 4428 section = section_headers + 1;
252b5132
RH		 4429
4430 printf (" %2.2d ", i);
4431
b34976b6 4432 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4433 {
f4638467
AM		 4434 if (!ELF_TBSS_SPECIAL (section, segment)
4435 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
252b5132
RH		 4436 printf ("%s ", SECTION_NAME (section));
4437 }
4438
4439 putc ('\n',stdout);
4440 }
4441 }
4442
252b5132
RH		 4443 return 1;
4444}
4445
4446
d93f0186
NC		 4447/* Find the file offset corresponding to VMA by using the program headers. */
4448
4449static long
2cf0635d 4450offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4451{
2cf0635d 4452 Elf_Internal_Phdr * seg;
d93f0186
NC		 4453
4454 if (! get_program_headers (file))
4455 {
4456 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4457 return (long) vma;
4458 }
4459
4460 for (seg = program_headers;
4461 seg < program_headers + elf_header.e_phnum;
4462 ++seg)
4463 {
4464 if (seg->p_type != PT_LOAD)
4465 continue;
4466
4467 if (vma >= (seg->p_vaddr & -seg->p_align)
4468 && vma + size <= seg->p_vaddr + seg->p_filesz)
4469 return vma - seg->p_vaddr + seg->p_offset;
4470 }
4471
4472 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4473 (unsigned long) vma);
d93f0186
NC		 4474 return (long) vma;
4475}
4476
4477
252b5132 4478static int
2cf0635d 4479get_32bit_section_headers (FILE * file, unsigned int num)
252b5132 4480{
2cf0635d
NC		 4481 Elf32_External_Shdr * shdrs;
4482 Elf_Internal_Shdr * internal;
b34976b6 4483 unsigned int i;
252b5132 4484
3f5e193b
NC		 4485 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4486 elf_header.e_shentsize, num,
4487 _("section headers"));
a6e9f9df
AM		 4488 if (!shdrs)
4489 return 0;
252b5132 4490
3f5e193b
NC		 4491 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4492 sizeof (Elf_Internal_Shdr));
252b5132
RH		 4493
4494 if (section_headers == NULL)
4495 {
4496 error (_("Out of memory\n"));
4497 return 0;
4498 }
4499
4500 for (i = 0, internal = section_headers;
560f3c1c 4501 i < num;
b34976b6 4502 i++, internal++)
252b5132
RH		 4503 {
4504 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4505 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4506 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4507 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4508 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4509 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4510 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4511 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4512 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4513 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4514 }
4515
4516 free (shdrs);
4517
4518 return 1;
4519}
4520
9ea033b2 4521static int
2cf0635d 4522get_64bit_section_headers (FILE * file, unsigned int num)
9ea033b2 4523{
2cf0635d
NC		 4524 Elf64_External_Shdr * shdrs;
4525 Elf_Internal_Shdr * internal;
b34976b6 4526 unsigned int i;
9ea033b2 4527
3f5e193b
NC		 4528 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4529 elf_header.e_shentsize, num,
4530 _("section headers"));
a6e9f9df
AM		 4531 if (!shdrs)
4532 return 0;
9ea033b2 4533
3f5e193b
NC		 4534 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4535 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4536
4537 if (section_headers == NULL)
4538 {
4539 error (_("Out of memory\n"));
4540 return 0;
4541 }
4542
4543 for (i = 0, internal = section_headers;
560f3c1c 4544 i < num;
b34976b6 4545 i++, internal++)
9ea033b2
NC		 4546 {
4547 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4548 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4549 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4550 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4551 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4552 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4553 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4554 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4555 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4556 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4557 }
4558
4559 free (shdrs);
4560
4561 return 1;
4562}
4563
252b5132 4564static Elf_Internal_Sym *
ba5cdace
NC		 4565get_32bit_elf_symbols (FILE * file,
4566 Elf_Internal_Shdr * section,
4567 unsigned long * num_syms_return)
252b5132 4568{
ba5cdace 4569 unsigned long number = 0;
dd24e3da 4570 Elf32_External_Sym * esyms = NULL;
ba5cdace 4571 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 4572 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4573 Elf_Internal_Sym * psym;
b34976b6 4574 unsigned int j;
252b5132 4575
dd24e3da
NC		 4576 /* Run some sanity checks first. */
4577 if (section->sh_entsize == 0)
4578 {
4579 error (_("sh_entsize is zero\n"));
ba5cdace 4580 goto exit_point;
dd24e3da
NC		 4581 }
4582
4583 number = section->sh_size / section->sh_entsize;
4584
4585 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4586 {
4587 error (_("Invalid sh_entsize\n"));
ba5cdace 4588 goto exit_point;
dd24e3da
NC		 4589 }
4590
3f5e193b
NC		 4591 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4592 section->sh_size, _("symbols"));
dd24e3da 4593 if (esyms == NULL)
ba5cdace 4594 goto exit_point;
252b5132 4595
9ad5cbcf
AM		 4596 shndx = NULL;
4597 if (symtab_shndx_hdr != NULL
4598 && (symtab_shndx_hdr->sh_link
4fbb74a6 4599 == (unsigned long) (section - section_headers)))
9ad5cbcf 4600 {
3f5e193b
NC		 4601 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4602 symtab_shndx_hdr->sh_offset,
4603 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4604 _("symbol table section indicies"));
dd24e3da
NC		 4605 if (shndx == NULL)
4606 goto exit_point;
9ad5cbcf
AM		 4607 }
4608
3f5e193b 4609 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 4610
4611 if (isyms == NULL)
4612 {
4613 error (_("Out of memory\n"));
dd24e3da 4614 goto exit_point;
252b5132
RH		 4615 }
4616
dd24e3da 4617 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 4618 {
4619 psym->st_name = BYTE_GET (esyms[j].st_name);
4620 psym->st_value = BYTE_GET (esyms[j].st_value);
4621 psym->st_size = BYTE_GET (esyms[j].st_size);
4622 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4623 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4624 psym->st_shndx
4625 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4626 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4627 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 4628 psym->st_info = BYTE_GET (esyms[j].st_info);
4629 psym->st_other = BYTE_GET (esyms[j].st_other);
4630 }
4631
dd24e3da 4632 exit_point:
ba5cdace 4633 if (shndx != NULL)
9ad5cbcf 4634 free (shndx);
ba5cdace 4635 if (esyms != NULL)
dd24e3da 4636 free (esyms);
252b5132 4637
ba5cdace
NC		 4638 if (num_syms_return != NULL)
4639 * num_syms_return = isyms == NULL ? 0 : number;
4640
252b5132
RH		 4641 return isyms;
4642}
4643
9ea033b2 4644static Elf_Internal_Sym *
ba5cdace
NC		 4645get_64bit_elf_symbols (FILE * file,
4646 Elf_Internal_Shdr * section,
4647 unsigned long * num_syms_return)
9ea033b2 4648{
ba5cdace
NC		 4649 unsigned long number = 0;
4650 Elf64_External_Sym * esyms = NULL;
4651 Elf_External_Sym_Shndx * shndx = NULL;
4652 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4653 Elf_Internal_Sym * psym;
b34976b6 4654 unsigned int j;
9ea033b2 4655
dd24e3da
NC		 4656 /* Run some sanity checks first. */
4657 if (section->sh_entsize == 0)
4658 {
4659 error (_("sh_entsize is zero\n"));
ba5cdace 4660 goto exit_point;
dd24e3da
NC		 4661 }
4662
4663 number = section->sh_size / section->sh_entsize;
4664
4665 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4666 {
4667 error (_("Invalid sh_entsize\n"));
ba5cdace 4668 goto exit_point;
dd24e3da
NC		 4669 }
4670
3f5e193b
NC		 4671 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4672 section->sh_size, _("symbols"));
a6e9f9df 4673 if (!esyms)
ba5cdace 4674 goto exit_point;
9ea033b2 4675
9ad5cbcf
AM		 4676 if (symtab_shndx_hdr != NULL
4677 && (symtab_shndx_hdr->sh_link
4fbb74a6 4678 == (unsigned long) (section - section_headers)))
9ad5cbcf 4679 {
3f5e193b
NC		 4680 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4681 symtab_shndx_hdr->sh_offset,
4682 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4683 _("symbol table section indicies"));
ba5cdace
NC		 4684 if (shndx == NULL)
4685 goto exit_point;
9ad5cbcf
AM		 4686 }
4687
3f5e193b 4688 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 4689
4690 if (isyms == NULL)
4691 {
4692 error (_("Out of memory\n"));
ba5cdace 4693 goto exit_point;
9ea033b2
NC		 4694 }
4695
ba5cdace 4696 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 4697 {
4698 psym->st_name = BYTE_GET (esyms[j].st_name);
4699 psym->st_info = BYTE_GET (esyms[j].st_info);
4700 psym->st_other = BYTE_GET (esyms[j].st_other);
4701 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 4702
4fbb74a6 4703 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4704 psym->st_shndx
4705 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4706 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4707 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 4708
66543521
AM		 4709 psym->st_value = BYTE_GET (esyms[j].st_value);
4710 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 4711 }
4712
ba5cdace
NC		 4713 exit_point:
4714 if (shndx != NULL)
9ad5cbcf 4715 free (shndx);
ba5cdace
NC		 4716 if (esyms != NULL)
4717 free (esyms);
4718
4719 if (num_syms_return != NULL)
4720 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 4721
4722 return isyms;
4723}
4724
d1133906 4725static const char *
d3ba0551 4726get_elf_section_flags (bfd_vma sh_flags)
d1133906 4727{
5477e8a0 4728 static char buff[1024];
2cf0635d 4729 char * p = buff;
8d5ff12c 4730 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 4731 int sindex;
4732 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 4733 bfd_vma os_flags = 0;
4734 bfd_vma proc_flags = 0;
4735 bfd_vma unknown_flags = 0;
148b93f2 4736 static const struct
5477e8a0 4737 {
2cf0635d 4738 const char * str;
5477e8a0
L		 4739 int len;
4740 }
4741 flags [] =
4742 {
cfcac11d
NC		 4743 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4744 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4745 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4746 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4747 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4748 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4749 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4750 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4751 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4752 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4753 /* IA-64 specific. */
4754 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4755 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4756 /* IA-64 OpenVMS specific. */
4757 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4758 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4759 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4760 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4761 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4762 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 4763 /* Generic. */
cfcac11d 4764 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 4765 /* SPARC specific. */
cfcac11d 4766 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5477e8a0
L		 4767 };
4768
4769 if (do_section_details)
4770 {
8d5ff12c
L		 4771 sprintf (buff, "[%*.*lx]: ",
4772 field_size, field_size, (unsigned long) sh_flags);
4773 p += field_size + 4;
5477e8a0 4774 }
76da6bbe 4775
d1133906
NC		 4776 while (sh_flags)
4777 {
4778 bfd_vma flag;
4779
4780 flag = sh_flags & - sh_flags;
4781 sh_flags &= ~ flag;
76da6bbe 4782
5477e8a0 4783 if (do_section_details)
d1133906 4784 {
5477e8a0
L		 4785 switch (flag)
4786 {
91d6fa6a
NC		 4787 case SHF_WRITE: sindex = 0; break;
4788 case SHF_ALLOC: sindex = 1; break;
4789 case SHF_EXECINSTR: sindex = 2; break;
4790 case SHF_MERGE: sindex = 3; break;
4791 case SHF_STRINGS: sindex = 4; break;
4792 case SHF_INFO_LINK: sindex = 5; break;
4793 case SHF_LINK_ORDER: sindex = 6; break;
4794 case SHF_OS_NONCONFORMING: sindex = 7; break;
4795 case SHF_GROUP: sindex = 8; break;
4796 case SHF_TLS: sindex = 9; break;
18ae9cc1 4797 case SHF_EXCLUDE: sindex = 18; break;
76da6bbe 4798
5477e8a0 4799 default:
91d6fa6a 4800 sindex = -1;
cfcac11d 4801 switch (elf_header.e_machine)
148b93f2 4802 {
cfcac11d 4803 case EM_IA_64:
148b93f2 4804 if (flag == SHF_IA_64_SHORT)
91d6fa6a 4805 sindex = 10;
148b93f2 4806 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 4807 sindex = 11;
148b93f2
NC		 4808#ifdef BFD64
4809 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4810 switch (flag)
4811 {
91d6fa6a
NC		 4812 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4813 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4814 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4815 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4816 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4817 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 4818 default: break;
4819 }
4820#endif
cfcac11d
NC		 4821 break;
4822
caa83f8b
NC		 4823 case EM_386:
4824 case EM_486:
4825 case EM_X86_64:
7f502d6c 4826 case EM_L1OM:
7a9068fe 4827 case EM_K1OM:
cfcac11d
NC		 4828 case EM_OLD_SPARCV9:
4829 case EM_SPARC32PLUS:
4830 case EM_SPARCV9:
4831 case EM_SPARC:
18ae9cc1 4832 if (flag == SHF_ORDERED)
91d6fa6a 4833 sindex = 19;
cfcac11d
NC		 4834 break;
4835 default:
4836 break;
148b93f2 4837 }
5477e8a0
L		 4838 }
4839
91d6fa6a 4840 if (sindex != -1)
5477e8a0 4841 {
8d5ff12c
L		 4842 if (p != buff + field_size + 4)
4843 {
4844 if (size < (10 + 2))
4845 abort ();
4846 size -= 2;
4847 *p++ = ',';
4848 *p++ = ' ';
4849 }
4850
91d6fa6a
NC		 4851 size -= flags [sindex].len;
4852 p = stpcpy (p, flags [sindex].str);
5477e8a0 4853 }
3b22753a 4854 else if (flag & SHF_MASKOS)
8d5ff12c 4855 os_flags |= flag;
d1133906 4856 else if (flag & SHF_MASKPROC)
8d5ff12c 4857 proc_flags |= flag;
d1133906 4858 else
8d5ff12c 4859 unknown_flags |= flag;
5477e8a0
L		 4860 }
4861 else
4862 {
4863 switch (flag)
4864 {
4865 case SHF_WRITE: *p = 'W'; break;
4866 case SHF_ALLOC: *p = 'A'; break;
4867 case SHF_EXECINSTR: *p = 'X'; break;
4868 case SHF_MERGE: *p = 'M'; break;
4869 case SHF_STRINGS: *p = 'S'; break;
4870 case SHF_INFO_LINK: *p = 'I'; break;
4871 case SHF_LINK_ORDER: *p = 'L'; break;
4872 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4873 case SHF_GROUP: *p = 'G'; break;
4874 case SHF_TLS: *p = 'T'; break;
18ae9cc1 4875 case SHF_EXCLUDE: *p = 'E'; break;
5477e8a0
L		 4876
4877 default:
8a9036a4 4878 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 4879 || elf_header.e_machine == EM_L1OM
4880 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 4881 && flag == SHF_X86_64_LARGE)
4882 *p = 'l';
4883 else if (flag & SHF_MASKOS)
4884 {
4885 *p = 'o';
4886 sh_flags &= ~ SHF_MASKOS;
4887 }
4888 else if (flag & SHF_MASKPROC)
4889 {
4890 *p = 'p';
4891 sh_flags &= ~ SHF_MASKPROC;
4892 }
4893 else
4894 *p = 'x';
4895 break;
4896 }
4897 p++;
d1133906
NC		 4898 }
4899 }
76da6bbe 4900
8d5ff12c
L		 4901 if (do_section_details)
4902 {
4903 if (os_flags)
4904 {
4905 size -= 5 + field_size;
4906 if (p != buff + field_size + 4)
4907 {
4908 if (size < (2 + 1))
4909 abort ();
4910 size -= 2;
4911 *p++ = ',';
4912 *p++ = ' ';
4913 }
4914 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4915 (unsigned long) os_flags);
4916 p += 5 + field_size;
4917 }
4918 if (proc_flags)
4919 {
4920 size -= 7 + field_size;
4921 if (p != buff + field_size + 4)
4922 {
4923 if (size < (2 + 1))
4924 abort ();
4925 size -= 2;
4926 *p++ = ',';
4927 *p++ = ' ';
4928 }
4929 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4930 (unsigned long) proc_flags);
4931 p += 7 + field_size;
4932 }
4933 if (unknown_flags)
4934 {
4935 size -= 10 + field_size;
4936 if (p != buff + field_size + 4)
4937 {
4938 if (size < (2 + 1))
4939 abort ();
4940 size -= 2;
4941 *p++ = ',';
4942 *p++ = ' ';
4943 }
2b692964 4944 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 4945 (unsigned long) unknown_flags);
4946 p += 10 + field_size;
4947 }
4948 }
4949
e9e44622 4950 *p = '\0';
d1133906
NC		 4951 return buff;
4952}
4953
252b5132 4954static int
2cf0635d 4955process_section_headers (FILE * file)
252b5132 4956{
2cf0635d 4957 Elf_Internal_Shdr * section;
b34976b6 4958 unsigned int i;
252b5132
RH		 4959
4960 section_headers = NULL;
4961
4962 if (elf_header.e_shnum == 0)
4963 {
82f2dbf7
NC		 4964 /* PR binutils/12467. */
4965 if (elf_header.e_shoff != 0)
4966 warn (_("possibly corrupt ELF file header - it has a non-zero"
4967 " section header offset, but no section headers\n"));
4968 else if (do_sections)
252b5132
RH		 4969 printf (_("\nThere are no sections in this file.\n"));
4970
4971 return 1;
4972 }
4973
4974 if (do_sections && !do_header)
9ea033b2 4975 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 4976 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4977
9ea033b2
NC		 4978 if (is_32bit_elf)
4979 {
560f3c1c 4980 if (! get_32bit_section_headers (file, elf_header.e_shnum))
9ea033b2
NC		 4981 return 0;
4982 }
560f3c1c 4983 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
252b5132
RH		 4984 return 0;
4985
4986 /* Read in the string table, so that we have names to display. */
0b49d371 4987 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 4988 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 4989 {
4fbb74a6 4990 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 4991
c256ffe7
JJ		 4992 if (section->sh_size != 0)
4993 {
3f5e193b
NC		 4994 string_table = (char *) get_data (NULL, file, section->sh_offset,
4995 1, section->sh_size,
4996 _("string table"));
0de14b54 4997
c256ffe7
JJ		 4998 string_table_length = string_table != NULL ? section->sh_size : 0;
4999 }
252b5132
RH		 5000 }
5001
5002 /* Scan the sections for the dynamic symbol table
e3c8793a 5003 and dynamic string table and debug sections. */
252b5132
RH		 5004 dynamic_symbols = NULL;
5005 dynamic_strings = NULL;
5006 dynamic_syminfo = NULL;
f1ef08cb 5007 symtab_shndx_hdr = NULL;
103f02d3 5008
89fac5e3
RS		 5009 eh_addr_size = is_32bit_elf ? 4 : 8;
5010 switch (elf_header.e_machine)
5011 {
5012 case EM_MIPS:
5013 case EM_MIPS_RS3_LE:
5014 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5015 FDE addresses. However, the ABI also has a semi-official ILP32
5016 variant for which the normal FDE address size rules apply.
5017
5018 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5019 section, where XX is the size of longs in bits. Unfortunately,
5020 earlier compilers provided no way of distinguishing ILP32 objects
5021 from LP64 objects, so if there's any doubt, we should assume that
5022 the official LP64 form is being used. */
5023 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5024 && find_section (".gcc_compiled_long32") == NULL)
5025 eh_addr_size = 8;
5026 break;
0f56a26a
DD		 5027
5028 case EM_H8_300:
5029 case EM_H8_300H:
5030 switch (elf_header.e_flags & EF_H8_MACH)
5031 {
5032 case E_H8_MACH_H8300:
5033 case E_H8_MACH_H8300HN:
5034 case E_H8_MACH_H8300SN:
5035 case E_H8_MACH_H8300SXN:
5036 eh_addr_size = 2;
5037 break;
5038 case E_H8_MACH_H8300H:
5039 case E_H8_MACH_H8300S:
5040 case E_H8_MACH_H8300SX:
5041 eh_addr_size = 4;
5042 break;
5043 }
f4236fe4
DD		 5044 break;
5045
ff7eeb89 5046 case EM_M32C_OLD:
f4236fe4
DD		 5047 case EM_M32C:
5048 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5049 {
5050 case EF_M32C_CPU_M16C:
5051 eh_addr_size = 2;
5052 break;
5053 }
5054 break;
89fac5e3
RS		 5055 }
5056
08d8fa11
JJ		 5057#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5058 do \
5059 { \
9dd3a467 5060 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
08d8fa11 5061 if (section->sh_entsize != expected_entsize) \
9dd3a467 5062 { \
15b42fb0 5063 error (_("Section %d has invalid sh_entsize of %" BFD_VMA_FMT "x\n"), \
9dd3a467
NC		 5064 i, section->sh_entsize); \
5065 error (_("(Using the expected size of %d for the rest of this dump)\n"), \
5066 (int) expected_entsize); \
5067 section->sh_entsize = expected_entsize; \
5068 } \
08d8fa11
JJ		 5069 } \
5070 while (0)
9dd3a467
NC		 5071
5072#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 5073 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5074 sizeof (Elf64_External_##type))
5075
252b5132
RH		 5076 for (i = 0, section = section_headers;
5077 i < elf_header.e_shnum;
b34976b6 5078 i++, section++)
252b5132 5079 {
2cf0635d 5080 char * name = SECTION_NAME (section);
252b5132
RH		 5081
5082 if (section->sh_type == SHT_DYNSYM)
5083 {
5084 if (dynamic_symbols != NULL)
5085 {
5086 error (_("File contains multiple dynamic symbol tables\n"));
5087 continue;
5088 }
5089
08d8fa11 5090 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 5091 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 5092 }
5093 else if (section->sh_type == SHT_STRTAB
18bd398b 5094 && streq (name, ".dynstr"))
252b5132
RH		 5095 {
5096 if (dynamic_strings != NULL)
5097 {
5098 error (_("File contains multiple dynamic string tables\n"));
5099 continue;
5100 }
5101
3f5e193b
NC		 5102 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5103 1, section->sh_size,
5104 _("dynamic strings"));
59245841 5105 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 5106 }
9ad5cbcf
AM		 5107 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5108 {
5109 if (symtab_shndx_hdr != NULL)
5110 {
5111 error (_("File contains multiple symtab shndx tables\n"));
5112 continue;
5113 }
5114 symtab_shndx_hdr = section;
5115 }
08d8fa11
JJ		 5116 else if (section->sh_type == SHT_SYMTAB)
5117 CHECK_ENTSIZE (section, i, Sym);
5118 else if (section->sh_type == SHT_GROUP)
5119 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5120 else if (section->sh_type == SHT_REL)
5121 CHECK_ENTSIZE (section, i, Rel);
5122 else if (section->sh_type == SHT_RELA)
5123 CHECK_ENTSIZE (section, i, Rela);
252b5132 5124 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 5125 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 5126 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 5127 || do_debug_str || do_debug_loc || do_debug_ranges
5128 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 5129 && (const_strneq (name, ".debug_")
5130 || const_strneq (name, ".zdebug_")))
252b5132 5131 {
1b315056
CS		 5132 if (name[1] == 'z')
5133 name += sizeof (".zdebug_") - 1;
5134 else
5135 name += sizeof (".debug_") - 1;
252b5132
RH		 5136
5137 if (do_debugging
4723351a
CC		 5138 || (do_debug_info && const_strneq (name, "info"))
5139 || (do_debug_info && const_strneq (name, "types"))
5140 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 5141 || (do_debug_lines && strcmp (name, "line") == 0)
5142 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 5143 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5144 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
459d52c8
DE		 5145 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5146 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4723351a
CC		 5147 || (do_debug_aranges && const_strneq (name, "aranges"))
5148 || (do_debug_ranges && const_strneq (name, "ranges"))
5149 || (do_debug_frames && const_strneq (name, "frame"))
5150 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5151 || (do_debug_macinfo && const_strneq (name, "macro"))
5152 || (do_debug_str && const_strneq (name, "str"))
5153 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 5154 || (do_debug_addr && const_strneq (name, "addr"))
5155 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5156 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 5157 )
09c11c86 5158 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 5159 }
a262ae96 5160 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 5161 else if ((do_debugging || do_debug_info)
0112cd26 5162 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 5163 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 5164 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 5165 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 5166 else if (do_gdb_index && streq (name, ".gdb_index"))
5167 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 5168 /* Trace sections for Itanium VMS. */
5169 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5170 || do_trace_aranges)
5171 && const_strneq (name, ".trace_"))
5172 {
5173 name += sizeof (".trace_") - 1;
5174
5175 if (do_debugging
5176 || (do_trace_info && streq (name, "info"))
5177 || (do_trace_abbrevs && streq (name, "abbrev"))
5178 || (do_trace_aranges && streq (name, "aranges"))
5179 )
5180 request_dump_bynumber (i, DEBUG_DUMP);
5181 }
5182
252b5132
RH		 5183 }
5184
5185 if (! do_sections)
5186 return 1;
5187
3a1a2036
NC		 5188 if (elf_header.e_shnum > 1)
5189 printf (_("\nSection Headers:\n"));
5190 else
5191 printf (_("\nSection Header:\n"));
76da6bbe 5192
f7a99963 5193 if (is_32bit_elf)
595cf52e 5194 {
5477e8a0 5195 if (do_section_details)
595cf52e
L		 5196 {
5197 printf (_(" [Nr] Name\n"));
5477e8a0 5198 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 5199 }
5200 else
5201 printf
5202 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5203 }
d974e256 5204 else if (do_wide)
595cf52e 5205 {
5477e8a0 5206 if (do_section_details)
595cf52e
L		 5207 {
5208 printf (_(" [Nr] Name\n"));
5477e8a0 5209 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 5210 }
5211 else
5212 printf
5213 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5214 }
f7a99963
NC		 5215 else
5216 {
5477e8a0 5217 if (do_section_details)
595cf52e
L		 5218 {
5219 printf (_(" [Nr] Name\n"));
5477e8a0
L		 5220 printf (_(" Type Address Offset Link\n"));
5221 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 5222 }
5223 else
5224 {
5225 printf (_(" [Nr] Name Type Address Offset\n"));
5226 printf (_(" Size EntSize Flags Link Info Align\n"));
5227 }
f7a99963 5228 }
252b5132 5229
5477e8a0
L		 5230 if (do_section_details)
5231 printf (_(" Flags\n"));
5232
252b5132
RH		 5233 for (i = 0, section = section_headers;
5234 i < elf_header.e_shnum;
b34976b6 5235 i++, section++)
252b5132 5236 {
7bfd842d 5237 printf (" [%2u] ", i);
5477e8a0 5238 if (do_section_details)
595cf52e 5239 {
7bfd842d 5240 print_symbol (INT_MAX, SECTION_NAME (section));
ea52a088 5241 printf ("\n ");
595cf52e
L		 5242 }
5243 else
7bfd842d
NC		 5244 {
5245 print_symbol (-17, SECTION_NAME (section));
7bfd842d 5246 }
0b4362b0 5247
ea52a088
NC		 5248 printf (do_wide ? " %-15s " : " %-15.15s ",
5249 get_section_type_name (section->sh_type));
0b4362b0 5250
f7a99963
NC		 5251 if (is_32bit_elf)
5252 {
cfcac11d
NC		 5253 const char * link_too_big = NULL;
5254
f7a99963 5255 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 5256
f7a99963
NC		 5257 printf ( " %6.6lx %6.6lx %2.2lx",
5258 (unsigned long) section->sh_offset,
5259 (unsigned long) section->sh_size,
5260 (unsigned long) section->sh_entsize);
d1133906 5261
5477e8a0
L		 5262 if (do_section_details)
5263 fputs (" ", stdout);
5264 else
5265 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5266
cfcac11d
NC		 5267 if (section->sh_link >= elf_header.e_shnum)
5268 {
5269 link_too_big = "";
5270 /* The sh_link value is out of range. Normally this indicates
caa83f8b 5271 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 5272 switch (elf_header.e_machine)
5273 {
caa83f8b
NC		 5274 case EM_386:
5275 case EM_486:
5276 case EM_X86_64:
7f502d6c 5277 case EM_L1OM:
7a9068fe 5278 case EM_K1OM:
cfcac11d
NC		 5279 case EM_OLD_SPARCV9:
5280 case EM_SPARC32PLUS:
5281 case EM_SPARCV9:
5282 case EM_SPARC:
5283 if (section->sh_link == (SHN_BEFORE & 0xffff))
5284 link_too_big = "BEFORE";
5285 else if (section->sh_link == (SHN_AFTER & 0xffff))
5286 link_too_big = "AFTER";
5287 break;
5288 default:
5289 break;
5290 }
5291 }
5292
5293 if (do_section_details)
5294 {
5295 if (link_too_big != NULL && * link_too_big)
5296 printf ("<%s> ", link_too_big);
5297 else
5298 printf ("%2u ", section->sh_link);
5299 printf ("%3u %2lu\n", section->sh_info,
5300 (unsigned long) section->sh_addralign);
5301 }
5302 else
5303 printf ("%2u %3u %2lu\n",
5304 section->sh_link,
5305 section->sh_info,
5306 (unsigned long) section->sh_addralign);
5307
5308 if (link_too_big && ! * link_too_big)
5309 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5310 i, section->sh_link);
f7a99963 5311 }
d974e256
JJ		 5312 else if (do_wide)
5313 {
5314 print_vma (section->sh_addr, LONG_HEX);
5315
5316 if ((long) section->sh_offset == section->sh_offset)
5317 printf (" %6.6lx", (unsigned long) section->sh_offset);
5318 else
5319 {
5320 putchar (' ');
5321 print_vma (section->sh_offset, LONG_HEX);
5322 }
5323
5324 if ((unsigned long) section->sh_size == section->sh_size)
5325 printf (" %6.6lx", (unsigned long) section->sh_size);
5326 else
5327 {
5328 putchar (' ');
5329 print_vma (section->sh_size, LONG_HEX);
5330 }
5331
5332 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5333 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5334 else
5335 {
5336 putchar (' ');
5337 print_vma (section->sh_entsize, LONG_HEX);
5338 }
5339
5477e8a0
L		 5340 if (do_section_details)
5341 fputs (" ", stdout);
5342 else
5343 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 5344
72de5009 5345 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 5346
5347 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 5348 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 5349 else
5350 {
5351 print_vma (section->sh_addralign, DEC);
5352 putchar ('\n');
5353 }
5354 }
5477e8a0 5355 else if (do_section_details)
595cf52e 5356 {
5477e8a0 5357 printf (" %-15.15s ",
595cf52e 5358 get_section_type_name (section->sh_type));
595cf52e
L		 5359 print_vma (section->sh_addr, LONG_HEX);
5360 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 5361 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 5362 else
5363 {
5364 printf (" ");
5365 print_vma (section->sh_offset, LONG_HEX);
5366 }
72de5009 5367 printf (" %u\n ", section->sh_link);
595cf52e 5368 print_vma (section->sh_size, LONG_HEX);
5477e8a0 5369 putchar (' ');
595cf52e
L		 5370 print_vma (section->sh_entsize, LONG_HEX);
5371
72de5009
AM		 5372 printf (" %-16u %lu\n",
5373 section->sh_info,
595cf52e
L		 5374 (unsigned long) section->sh_addralign);
5375 }
f7a99963
NC		 5376 else
5377 {
5378 putchar (' ');
5379 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 5380 if ((long) section->sh_offset == section->sh_offset)
5381 printf (" %8.8lx", (unsigned long) section->sh_offset);
5382 else
5383 {
5384 printf (" ");
5385 print_vma (section->sh_offset, LONG_HEX);
5386 }
f7a99963
NC		 5387 printf ("\n ");
5388 print_vma (section->sh_size, LONG_HEX);
5389 printf (" ");
5390 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 5391
d1133906 5392 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5393
72de5009
AM		 5394 printf (" %2u %3u %lu\n",
5395 section->sh_link,
5396 section->sh_info,
f7a99963
NC		 5397 (unsigned long) section->sh_addralign);
5398 }
5477e8a0
L		 5399
5400 if (do_section_details)
5401 printf (" %s\n", get_elf_section_flags (section->sh_flags));
252b5132
RH		 5402 }
5403
5477e8a0 5404 if (!do_section_details)
3dbcc61d
NC		 5405 {
5406 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 5407 || elf_header.e_machine == EM_L1OM
5408 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 5409 printf (_("Key to Flags:\n\
5410 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5411 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5412 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5413 else
5414 printf (_("Key to Flags:\n\
e3c8793a 5415 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 5416 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 5417 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
0b4362b0 5418 }
d1133906 5419
252b5132
RH		 5420 return 1;
5421}
5422
f5842774
L		 5423static const char *
5424get_group_flags (unsigned int flags)
5425{
5426 static char buff[32];
5427 switch (flags)
5428 {
220453ec
AM		 5429 case 0:
5430 return "";
5431
f5842774 5432 case GRP_COMDAT:
220453ec 5433 return "COMDAT ";
f5842774
L		 5434
5435 default:
220453ec 5436 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 5437 break;
5438 }
5439 return buff;
5440}
5441
5442static int
2cf0635d 5443process_section_groups (FILE * file)
f5842774 5444{
2cf0635d 5445 Elf_Internal_Shdr * section;
f5842774 5446 unsigned int i;
2cf0635d
NC		 5447 struct group * group;
5448 Elf_Internal_Shdr * symtab_sec;
5449 Elf_Internal_Shdr * strtab_sec;
5450 Elf_Internal_Sym * symtab;
ba5cdace 5451 unsigned long num_syms;
2cf0635d 5452 char * strtab;
c256ffe7 5453 size_t strtab_size;
d1f5c6e3
L		 5454
5455 /* Don't process section groups unless needed. */
5456 if (!do_unwind && !do_section_groups)
5457 return 1;
f5842774
L		 5458
5459 if (elf_header.e_shnum == 0)
5460 {
5461 if (do_section_groups)
82f2dbf7 5462 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 5463
5464 return 1;
5465 }
5466
5467 if (section_headers == NULL)
5468 {
5469 error (_("Section headers are not available!\n"));
fa1908fd
NC		 5470 /* PR 13622: This can happen with a corrupt ELF header. */
5471 return 0;
f5842774
L		 5472 }
5473
3f5e193b
NC		 5474 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5475 sizeof (struct group *));
e4b17d5c
L		 5476
5477 if (section_headers_groups == NULL)
5478 {
5479 error (_("Out of memory\n"));
5480 return 0;
5481 }
5482
f5842774 5483 /* Scan the sections for the group section. */
d1f5c6e3 5484 group_count = 0;
f5842774
L		 5485 for (i = 0, section = section_headers;
5486 i < elf_header.e_shnum;
5487 i++, section++)
e4b17d5c
L		 5488 if (section->sh_type == SHT_GROUP)
5489 group_count++;
5490
d1f5c6e3
L		 5491 if (group_count == 0)
5492 {
5493 if (do_section_groups)
5494 printf (_("\nThere are no section groups in this file.\n"));
5495
5496 return 1;
5497 }
5498
3f5e193b 5499 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 5500
5501 if (section_groups == NULL)
5502 {
5503 error (_("Out of memory\n"));
5504 return 0;
5505 }
5506
d1f5c6e3
L		 5507 symtab_sec = NULL;
5508 strtab_sec = NULL;
5509 symtab = NULL;
ba5cdace 5510 num_syms = 0;
d1f5c6e3 5511 strtab = NULL;
c256ffe7 5512 strtab_size = 0;
e4b17d5c
L		 5513 for (i = 0, section = section_headers, group = section_groups;
5514 i < elf_header.e_shnum;
5515 i++, section++)
f5842774
L		 5516 {
5517 if (section->sh_type == SHT_GROUP)
5518 {
2cf0635d
NC		 5519 char * name = SECTION_NAME (section);
5520 char * group_name;
5521 unsigned char * start;
5522 unsigned char * indices;
f5842774 5523 unsigned int entry, j, size;
2cf0635d
NC		 5524 Elf_Internal_Shdr * sec;
5525 Elf_Internal_Sym * sym;
f5842774
L		 5526
5527 /* Get the symbol table. */
4fbb74a6
AM		 5528 if (section->sh_link >= elf_header.e_shnum
5529 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 5530 != SHT_SYMTAB))
f5842774
L		 5531 {
5532 error (_("Bad sh_link in group section `%s'\n"), name);
5533 continue;
5534 }
d1f5c6e3
L		 5535
5536 if (symtab_sec != sec)
5537 {
5538 symtab_sec = sec;
5539 if (symtab)
5540 free (symtab);
ba5cdace 5541 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 5542 }
f5842774 5543
dd24e3da
NC		 5544 if (symtab == NULL)
5545 {
5546 error (_("Corrupt header in group section `%s'\n"), name);
5547 continue;
5548 }
5549
ba5cdace
NC		 5550 if (section->sh_info >= num_syms)
5551 {
5552 error (_("Bad sh_info in group section `%s'\n"), name);
5553 continue;
5554 }
5555
f5842774
L		 5556 sym = symtab + section->sh_info;
5557
5558 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5559 {
4fbb74a6
AM		 5560 if (sym->st_shndx == 0
5561 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 5562 {
5563 error (_("Bad sh_info in group section `%s'\n"), name);
5564 continue;
5565 }
ba2685cc 5566
4fbb74a6 5567 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 5568 strtab_sec = NULL;
5569 if (strtab)
5570 free (strtab);
f5842774 5571 strtab = NULL;
c256ffe7 5572 strtab_size = 0;
f5842774
L		 5573 }
5574 else
5575 {
5576 /* Get the string table. */
4fbb74a6 5577 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 5578 {
5579 strtab_sec = NULL;
5580 if (strtab)
5581 free (strtab);
5582 strtab = NULL;
5583 strtab_size = 0;
5584 }
5585 else if (strtab_sec
4fbb74a6 5586 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 5587 {
5588 strtab_sec = sec;
5589 if (strtab)
5590 free (strtab);
3f5e193b
NC		 5591 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5592 1, strtab_sec->sh_size,
5593 _("string table"));
c256ffe7 5594 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 5595 }
c256ffe7 5596 group_name = sym->st_name < strtab_size
2b692964 5597 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 5598 }
5599
3f5e193b
NC		 5600 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5601 1, section->sh_size,
5602 _("section data"));
59245841
NC		 5603 if (start == NULL)
5604 continue;
f5842774
L		 5605
5606 indices = start;
5607 size = (section->sh_size / section->sh_entsize) - 1;
5608 entry = byte_get (indices, 4);
5609 indices += 4;
e4b17d5c
L		 5610
5611 if (do_section_groups)
5612 {
2b692964 5613 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 5614 get_group_flags (entry), i, name, group_name, size);
ba2685cc 5615
e4b17d5c
L		 5616 printf (_(" [Index] Name\n"));
5617 }
5618
5619 group->group_index = i;
5620
f5842774
L		 5621 for (j = 0; j < size; j++)
5622 {
2cf0635d 5623 struct group_list * g;
e4b17d5c 5624
f5842774
L		 5625 entry = byte_get (indices, 4);
5626 indices += 4;
5627
4fbb74a6 5628 if (entry >= elf_header.e_shnum)
391cb864
L		 5629 {
5630 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5631 entry, i, elf_header.e_shnum - 1);
5632 continue;
5633 }
391cb864 5634
4fbb74a6 5635 if (section_headers_groups [entry] != NULL)
e4b17d5c 5636 {
d1f5c6e3
L		 5637 if (entry)
5638 {
391cb864
L		 5639 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5640 entry, i,
4fbb74a6 5641 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5642 continue;
5643 }
5644 else
5645 {
5646 /* Intel C/C++ compiler may put section 0 in a
5647 section group. We just warn it the first time
5648 and ignore it afterwards. */
5649 static int warned = 0;
5650 if (!warned)
5651 {
5652 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 5653 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5654 warned++;
5655 }
5656 }
e4b17d5c
L		 5657 }
5658
4fbb74a6 5659 section_headers_groups [entry] = group;
e4b17d5c
L		 5660
5661 if (do_section_groups)
5662 {
4fbb74a6 5663 sec = section_headers + entry;
c256ffe7 5664 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
ba2685cc
AM		 5665 }
5666
3f5e193b 5667 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 5668 g->section_index = entry;
5669 g->next = group->root;
5670 group->root = g;
f5842774
L		 5671 }
5672
f5842774
L		 5673 if (start)
5674 free (start);
e4b17d5c
L		 5675
5676 group++;
f5842774
L		 5677 }
5678 }
5679
d1f5c6e3
L		 5680 if (symtab)
5681 free (symtab);
5682 if (strtab)
5683 free (strtab);
f5842774
L		 5684 return 1;
5685}
5686
28f997cf
TG		 5687/* Data used to display dynamic fixups. */
5688
5689struct ia64_vms_dynfixup
5690{
5691 bfd_vma needed_ident; /* Library ident number. */
5692 bfd_vma needed; /* Index in the dstrtab of the library name. */
5693 bfd_vma fixup_needed; /* Index of the library. */
5694 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5695 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5696};
5697
5698/* Data used to display dynamic relocations. */
5699
5700struct ia64_vms_dynimgrela
5701{
5702 bfd_vma img_rela_cnt; /* Number of relocations. */
5703 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5704};
5705
5706/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5707 library). */
5708
5709static void
5710dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5711 const char *strtab, unsigned int strtab_sz)
5712{
5713 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5714 long i;
5715 const char *lib_name;
5716
5717 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5718 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5719 _("dynamic section image fixups"));
5720 if (!imfs)
5721 return;
5722
5723 if (fixup->needed < strtab_sz)
5724 lib_name = strtab + fixup->needed;
5725 else
5726 {
5727 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 5728 (unsigned long) fixup->needed);
28f997cf
TG		 5729 lib_name = "???";
5730 }
5731 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5732 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5733 printf
5734 (_("Seg Offset Type SymVec DataType\n"));
5735
5736 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5737 {
5738 unsigned int type;
5739 const char *rtype;
5740
5741 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5742 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5743 type = BYTE_GET (imfs [i].type);
5744 rtype = elf_ia64_reloc_type (type);
5745 if (rtype == NULL)
5746 printf (" 0x%08x ", type);
5747 else
5748 printf (" %-32s ", rtype);
5749 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5750 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5751 }
5752
5753 free (imfs);
5754}
5755
5756/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5757
5758static void
5759dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5760{
5761 Elf64_External_VMS_IMAGE_RELA *imrs;
5762 long i;
5763
5764 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5765 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 5766 _("dynamic section image relocations"));
28f997cf
TG		 5767 if (!imrs)
5768 return;
5769
5770 printf (_("\nImage relocs\n"));
5771 printf
5772 (_("Seg Offset Type Addend Seg Sym Off\n"));
5773
5774 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5775 {
5776 unsigned int type;
5777 const char *rtype;
5778
5779 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5780 printf ("%08" BFD_VMA_FMT "x ",
5781 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5782 type = BYTE_GET (imrs [i].type);
5783 rtype = elf_ia64_reloc_type (type);
5784 if (rtype == NULL)
5785 printf ("0x%08x ", type);
5786 else
5787 printf ("%-31s ", rtype);
5788 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5789 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5790 printf ("%08" BFD_VMA_FMT "x\n",
5791 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5792 }
5793
5794 free (imrs);
5795}
5796
5797/* Display IA-64 OpenVMS dynamic relocations and fixups. */
5798
5799static int
5800process_ia64_vms_dynamic_relocs (FILE *file)
5801{
5802 struct ia64_vms_dynfixup fixup;
5803 struct ia64_vms_dynimgrela imgrela;
5804 Elf_Internal_Dyn *entry;
5805 int res = 0;
5806 bfd_vma strtab_off = 0;
5807 bfd_vma strtab_sz = 0;
5808 char *strtab = NULL;
5809
5810 memset (&fixup, 0, sizeof (fixup));
5811 memset (&imgrela, 0, sizeof (imgrela));
5812
5813 /* Note: the order of the entries is specified by the OpenVMS specs. */
5814 for (entry = dynamic_section;
5815 entry < dynamic_section + dynamic_nent;
5816 entry++)
5817 {
5818 switch (entry->d_tag)
5819 {
5820 case DT_IA_64_VMS_STRTAB_OFFSET:
5821 strtab_off = entry->d_un.d_val;
5822 break;
5823 case DT_STRSZ:
5824 strtab_sz = entry->d_un.d_val;
5825 if (strtab == NULL)
5826 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5827 1, strtab_sz, _("dynamic string section"));
5828 break;
5829
5830 case DT_IA_64_VMS_NEEDED_IDENT:
5831 fixup.needed_ident = entry->d_un.d_val;
5832 break;
5833 case DT_NEEDED:
5834 fixup.needed = entry->d_un.d_val;
5835 break;
5836 case DT_IA_64_VMS_FIXUP_NEEDED:
5837 fixup.fixup_needed = entry->d_un.d_val;
5838 break;
5839 case DT_IA_64_VMS_FIXUP_RELA_CNT:
5840 fixup.fixup_rela_cnt = entry->d_un.d_val;
5841 break;
5842 case DT_IA_64_VMS_FIXUP_RELA_OFF:
5843 fixup.fixup_rela_off = entry->d_un.d_val;
5844 res++;
5845 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5846 break;
5847
5848 case DT_IA_64_VMS_IMG_RELA_CNT:
5849 imgrela.img_rela_cnt = entry->d_un.d_val;
5850 break;
5851 case DT_IA_64_VMS_IMG_RELA_OFF:
5852 imgrela.img_rela_off = entry->d_un.d_val;
5853 res++;
5854 dump_ia64_vms_dynamic_relocs (file, &imgrela);
5855 break;
5856
5857 default:
5858 break;
5859 }
5860 }
5861
5862 if (strtab != NULL)
5863 free (strtab);
5864
5865 return res;
5866}
5867
85b1c36d 5868static struct
566b0d53 5869{
2cf0635d 5870 const char * name;
566b0d53
L		 5871 int reloc;
5872 int size;
5873 int rela;
5874} dynamic_relocations [] =
5875{
5876 { "REL", DT_REL, DT_RELSZ, FALSE },
5877 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5878 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5879};
5880
252b5132 5881/* Process the reloc section. */
18bd398b 5882
252b5132 5883static int
2cf0635d 5884process_relocs (FILE * file)
252b5132 5885{
b34976b6
AM		 5886 unsigned long rel_size;
5887 unsigned long rel_offset;
252b5132
RH		 5888
5889
5890 if (!do_reloc)
5891 return 1;
5892
5893 if (do_using_dynamic)
5894 {
566b0d53 5895 int is_rela;
2cf0635d 5896 const char * name;
566b0d53
L		 5897 int has_dynamic_reloc;
5898 unsigned int i;
0de14b54 5899
566b0d53 5900 has_dynamic_reloc = 0;
252b5132 5901
566b0d53 5902 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 5903 {
566b0d53
L		 5904 is_rela = dynamic_relocations [i].rela;
5905 name = dynamic_relocations [i].name;
5906 rel_size = dynamic_info [dynamic_relocations [i].size];
5907 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 5908
566b0d53
L		 5909 has_dynamic_reloc |= rel_size;
5910
5911 if (is_rela == UNKNOWN)
aa903cfb 5912 {
566b0d53
L		 5913 if (dynamic_relocations [i].reloc == DT_JMPREL)
5914 switch (dynamic_info[DT_PLTREL])
5915 {
5916 case DT_REL:
5917 is_rela = FALSE;
5918 break;
5919 case DT_RELA:
5920 is_rela = TRUE;
5921 break;
5922 }
aa903cfb 5923 }
252b5132 5924
566b0d53
L		 5925 if (rel_size)
5926 {
5927 printf
5928 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5929 name, rel_offset, rel_size);
252b5132 5930
d93f0186
NC		 5931 dump_relocations (file,
5932 offset_from_vma (file, rel_offset, rel_size),
5933 rel_size,
566b0d53 5934 dynamic_symbols, num_dynamic_syms,
d79b3d50 5935 dynamic_strings, dynamic_strings_length, is_rela);
566b0d53 5936 }
252b5132 5937 }
566b0d53 5938
28f997cf
TG		 5939 if (is_ia64_vms ())
5940 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5941
566b0d53 5942 if (! has_dynamic_reloc)
252b5132
RH		 5943 printf (_("\nThere are no dynamic relocations in this file.\n"));
5944 }
5945 else
5946 {
2cf0635d 5947 Elf_Internal_Shdr * section;
b34976b6
AM		 5948 unsigned long i;
5949 int found = 0;
252b5132
RH		 5950
5951 for (i = 0, section = section_headers;
5952 i < elf_header.e_shnum;
b34976b6 5953 i++, section++)
252b5132
RH		 5954 {
5955 if ( section->sh_type != SHT_RELA
5956 && section->sh_type != SHT_REL)
5957 continue;
5958
5959 rel_offset = section->sh_offset;
5960 rel_size = section->sh_size;
5961
5962 if (rel_size)
5963 {
2cf0635d 5964 Elf_Internal_Shdr * strsec;
b34976b6 5965 int is_rela;
103f02d3 5966
252b5132
RH		 5967 printf (_("\nRelocation section "));
5968
5969 if (string_table == NULL)
19936277 5970 printf ("%d", section->sh_name);
252b5132 5971 else
9cf03b7e 5972 printf ("'%s'", SECTION_NAME (section));
252b5132
RH		 5973
5974 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5975 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5976
d79b3d50
NC		 5977 is_rela = section->sh_type == SHT_RELA;
5978
4fbb74a6
AM		 5979 if (section->sh_link != 0
5980 && section->sh_link < elf_header.e_shnum)
af3fc3bc 5981 {
2cf0635d
NC		 5982 Elf_Internal_Shdr * symsec;
5983 Elf_Internal_Sym * symtab;
d79b3d50 5984 unsigned long nsyms;
c256ffe7 5985 unsigned long strtablen = 0;
2cf0635d 5986 char * strtab = NULL;
57346661 5987
4fbb74a6 5988 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 5989 if (symsec->sh_type != SHT_SYMTAB
5990 && symsec->sh_type != SHT_DYNSYM)
5991 continue;
5992
ba5cdace 5993 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 5994
af3fc3bc
AM		 5995 if (symtab == NULL)
5996 continue;
252b5132 5997
4fbb74a6
AM		 5998 if (symsec->sh_link != 0
5999 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 6000 {
4fbb74a6 6001 strsec = section_headers + symsec->sh_link;
103f02d3 6002
3f5e193b
NC		 6003 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6004 1, strsec->sh_size,
6005 _("string table"));
c256ffe7
JJ		 6006 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6007 }
252b5132 6008
d79b3d50
NC		 6009 dump_relocations (file, rel_offset, rel_size,
6010 symtab, nsyms, strtab, strtablen, is_rela);
6011 if (strtab)
6012 free (strtab);
6013 free (symtab);
6014 }
6015 else
6016 dump_relocations (file, rel_offset, rel_size,
6017 NULL, 0, NULL, 0, is_rela);
252b5132
RH		 6018
6019 found = 1;
6020 }
6021 }
6022
6023 if (! found)
6024 printf (_("\nThere are no relocations in this file.\n"));
6025 }
6026
6027 return 1;
6028}
6029
57346661
AM		 6030/* Process the unwind section. */
6031
4d6ed7c8
NC		 6032#include "unwind-ia64.h"
6033
6034/* An absolute address consists of a section and an offset. If the
6035 section is NULL, the offset itself is the address, otherwise, the
6036 address equals to LOAD_ADDRESS(section) + offset. */
6037
6038struct absaddr
6039 {
6040 unsigned short section;
6041 bfd_vma offset;
6042 };
6043
1949de15
L		 6044#define ABSADDR(a) \
6045 ((a).section \
6046 ? section_headers [(a).section].sh_addr + (a).offset \
6047 : (a).offset)
6048
3f5e193b
NC		 6049struct ia64_unw_table_entry
6050 {
6051 struct absaddr start;
6052 struct absaddr end;
6053 struct absaddr info;
6054 };
6055
57346661 6056struct ia64_unw_aux_info
4d6ed7c8 6057 {
3f5e193b
NC		 6058
6059 struct ia64_unw_table_entry *table; /* Unwind table. */
b34976b6 6060 unsigned long table_len; /* Length of unwind table. */
2cf0635d 6061 unsigned char * info; /* Unwind info. */
b34976b6
AM		 6062 unsigned long info_size; /* Size of unwind info. */
6063 bfd_vma info_addr; /* starting address of unwind info. */
6064 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 6065 Elf_Internal_Sym * symtab; /* The symbol table. */
b34976b6 6066 unsigned long nsyms; /* Number of symbols. */
2cf0635d 6067 char * strtab; /* The string table. */
b34976b6 6068 unsigned long strtab_size; /* Size of string table. */
4d6ed7c8
NC		 6069 };
6070
4d6ed7c8 6071static void
2cf0635d 6072find_symbol_for_address (Elf_Internal_Sym * symtab,
57346661 6073 unsigned long nsyms,
2cf0635d 6074 const char * strtab,
57346661 6075 unsigned long strtab_size,
d3ba0551 6076 struct absaddr addr,
2cf0635d
NC		 6077 const char ** symname,
6078 bfd_vma * offset)
4d6ed7c8 6079{
d3ba0551 6080 bfd_vma dist = 0x100000;
2cf0635d
NC		 6081 Elf_Internal_Sym * sym;
6082 Elf_Internal_Sym * best = NULL;
4d6ed7c8
NC		 6083 unsigned long i;
6084
0b6ae522
DJ		 6085 REMOVE_ARCH_BITS (addr.offset);
6086
57346661 6087 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4d6ed7c8 6088 {
0b6ae522
DJ		 6089 bfd_vma value = sym->st_value;
6090
6091 REMOVE_ARCH_BITS (value);
6092
4d6ed7c8
NC		 6093 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
6094 && sym->st_name != 0
6095 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 6096 && addr.offset >= value
6097 && addr.offset - value < dist)
4d6ed7c8
NC		 6098 {
6099 best = sym;
0b6ae522 6100 dist = addr.offset - value;
4d6ed7c8
NC		 6101 if (!dist)
6102 break;
6103 }
6104 }
1b31d05e 6105
4d6ed7c8
NC		 6106 if (best)
6107 {
57346661 6108 *symname = (best->st_name >= strtab_size
2b692964 6109 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 6110 *offset = dist;
6111 return;
6112 }
1b31d05e 6113
4d6ed7c8
NC		 6114 *symname = NULL;
6115 *offset = addr.offset;
6116}
6117
6118static void
2cf0635d 6119dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 6120{
2cf0635d 6121 struct ia64_unw_table_entry * tp;
4d6ed7c8 6122 int in_body;
7036c0e1 6123
4d6ed7c8
NC		 6124 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6125 {
6126 bfd_vma stamp;
6127 bfd_vma offset;
2cf0635d
NC		 6128 const unsigned char * dp;
6129 const unsigned char * head;
6130 const char * procname;
4d6ed7c8 6131
57346661
AM		 6132 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6133 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 6134
6135 fputs ("\n<", stdout);
6136
6137 if (procname)
6138 {
6139 fputs (procname, stdout);
6140
6141 if (offset)
6142 printf ("+%lx", (unsigned long) offset);
6143 }
6144
6145 fputs (">: [", stdout);
6146 print_vma (tp->start.offset, PREFIX_HEX);
6147 fputc ('-', stdout);
6148 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 6149 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 6150 (unsigned long) (tp->info.offset - aux->seg_base));
6151
1949de15 6152 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 6153 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 6154
86f55779 6155 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 6156 (unsigned) UNW_VER (stamp),
6157 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6158 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6159 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 6160 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 6161
6162 if (UNW_VER (stamp) != 1)
6163 {
2b692964 6164 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 6165 continue;
6166 }
6167
6168 in_body = 0;
89fac5e3 6169 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
4d6ed7c8
NC		 6170 dp = unw_decode (dp, in_body, & in_body);
6171 }
6172}
6173
6174static int
2cf0635d
NC		 6175slurp_ia64_unwind_table (FILE * file,
6176 struct ia64_unw_aux_info * aux,
6177 Elf_Internal_Shdr * sec)
4d6ed7c8 6178{
89fac5e3 6179 unsigned long size, nrelas, i;
2cf0635d
NC		 6180 Elf_Internal_Phdr * seg;
6181 struct ia64_unw_table_entry * tep;
6182 Elf_Internal_Shdr * relsec;
6183 Elf_Internal_Rela * rela;
6184 Elf_Internal_Rela * rp;
6185 unsigned char * table;
6186 unsigned char * tp;
6187 Elf_Internal_Sym * sym;
6188 const char * relname;
4d6ed7c8 6189
4d6ed7c8
NC		 6190 /* First, find the starting address of the segment that includes
6191 this section: */
6192
6193 if (elf_header.e_phnum)
6194 {
d93f0186 6195 if (! get_program_headers (file))
4d6ed7c8 6196 return 0;
4d6ed7c8 6197
d93f0186
NC		 6198 for (seg = program_headers;
6199 seg < program_headers + elf_header.e_phnum;
6200 ++seg)
4d6ed7c8
NC		 6201 {
6202 if (seg->p_type != PT_LOAD)
6203 continue;
6204
6205 if (sec->sh_addr >= seg->p_vaddr
6206 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6207 {
6208 aux->seg_base = seg->p_vaddr;
6209 break;
6210 }
6211 }
4d6ed7c8
NC		 6212 }
6213
6214 /* Second, build the unwind table from the contents of the unwind section: */
6215 size = sec->sh_size;
3f5e193b
NC		 6216 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6217 _("unwind table"));
a6e9f9df
AM		 6218 if (!table)
6219 return 0;
4d6ed7c8 6220
3f5e193b
NC		 6221 aux->table = (struct ia64_unw_table_entry *)
6222 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
89fac5e3 6223 tep = aux->table;
c6a0c689 6224 for (tp = table; tp < table + size; ++tep)
4d6ed7c8
NC		 6225 {
6226 tep->start.section = SHN_UNDEF;
6227 tep->end.section = SHN_UNDEF;
6228 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 6229 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6230 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6231 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 6232 tep->start.offset += aux->seg_base;
6233 tep->end.offset += aux->seg_base;
6234 tep->info.offset += aux->seg_base;
6235 }
6236 free (table);
6237
41e92641 6238 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 6239 for (relsec = section_headers;
6240 relsec < section_headers + elf_header.e_shnum;
6241 ++relsec)
6242 {
6243 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6244 || relsec->sh_info >= elf_header.e_shnum
6245 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 6246 continue;
6247
6248 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6249 & rela, & nrelas))
6250 return 0;
6251
6252 for (rp = rela; rp < rela + nrelas; ++rp)
6253 {
aca88567
NC		 6254 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6255 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 6256
0112cd26 6257 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 6258 {
e5fb9629 6259 warn (_("Skipping unexpected relocation type %s\n"), relname);
4d6ed7c8
NC		 6260 continue;
6261 }
6262
89fac5e3 6263 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 6264
89fac5e3 6265 switch (rp->r_offset/eh_addr_size % 3)
4d6ed7c8
NC		 6266 {
6267 case 0:
6268 aux->table[i].start.section = sym->st_shndx;
e466bc6e 6269 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6270 break;
6271 case 1:
6272 aux->table[i].end.section = sym->st_shndx;
e466bc6e 6273 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6274 break;
6275 case 2:
6276 aux->table[i].info.section = sym->st_shndx;
e466bc6e 6277 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6278 break;
6279 default:
6280 break;
6281 }
6282 }
6283
6284 free (rela);
6285 }
6286
89fac5e3 6287 aux->table_len = size / (3 * eh_addr_size);
4d6ed7c8
NC		 6288 return 1;
6289}
6290
1b31d05e 6291static void
2cf0635d 6292ia64_process_unwind (FILE * file)
4d6ed7c8 6293{
2cf0635d
NC		 6294 Elf_Internal_Shdr * sec;
6295 Elf_Internal_Shdr * unwsec = NULL;
6296 Elf_Internal_Shdr * strsec;
89fac5e3 6297 unsigned long i, unwcount = 0, unwstart = 0;
57346661 6298 struct ia64_unw_aux_info aux;
f1467e33 6299
4d6ed7c8
NC		 6300 memset (& aux, 0, sizeof (aux));
6301
4d6ed7c8
NC		 6302 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6303 {
c256ffe7 6304 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6305 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 6306 {
ba5cdace 6307 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 6308
4fbb74a6 6309 strsec = section_headers + sec->sh_link;
59245841 6310 assert (aux.strtab == NULL);
3f5e193b
NC		 6311 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6312 1, strsec->sh_size,
6313 _("string table"));
c256ffe7 6314 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 6315 }
6316 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 6317 unwcount++;
6318 }
6319
6320 if (!unwcount)
6321 printf (_("\nThere are no unwind sections in this file.\n"));
6322
6323 while (unwcount-- > 0)
6324 {
2cf0635d 6325 char * suffix;
579f31ac
JJ		 6326 size_t len, len2;
6327
6328 for (i = unwstart, sec = section_headers + unwstart;
6329 i < elf_header.e_shnum; ++i, ++sec)
6330 if (sec->sh_type == SHT_IA_64_UNWIND)
6331 {
6332 unwsec = sec;
6333 break;
6334 }
6335
6336 unwstart = i + 1;
6337 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6338
e4b17d5c
L		 6339 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6340 {
6341 /* We need to find which section group it is in. */
2cf0635d 6342 struct group_list * g = section_headers_groups [i]->root;
e4b17d5c
L		 6343
6344 for (; g != NULL; g = g->next)
6345 {
4fbb74a6 6346 sec = section_headers + g->section_index;
18bd398b
NC		 6347
6348 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
57346661 6349 break;
e4b17d5c
L		 6350 }
6351
6352 if (g == NULL)
6353 i = elf_header.e_shnum;
6354 }
18bd398b 6355 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 6356 {
18bd398b 6357 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 6358 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6359 suffix = SECTION_NAME (unwsec) + len;
6360 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6361 ++i, ++sec)
18bd398b
NC		 6362 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6363 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6364 break;
6365 }
6366 else
6367 {
6368 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 6369 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 6370 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6371 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6372 suffix = "";
18bd398b 6373 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 6374 suffix = SECTION_NAME (unwsec) + len;
6375 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6376 ++i, ++sec)
18bd398b
NC		 6377 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6378 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6379 break;
6380 }
6381
6382 if (i == elf_header.e_shnum)
6383 {
6384 printf (_("\nCould not find unwind info section for "));
6385
6386 if (string_table == NULL)
6387 printf ("%d", unwsec->sh_name);
6388 else
3a1a2036 6389 printf (_("'%s'"), SECTION_NAME (unwsec));
579f31ac
JJ		 6390 }
6391 else
4d6ed7c8 6392 {
4d6ed7c8 6393 aux.info_addr = sec->sh_addr;
3f5e193b 6394 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
59245841 6395 sec->sh_size,
3f5e193b 6396 _("unwind info"));
59245841 6397 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 6398
579f31ac 6399 printf (_("\nUnwind section "));
4d6ed7c8 6400
579f31ac
JJ		 6401 if (string_table == NULL)
6402 printf ("%d", unwsec->sh_name);
6403 else
3a1a2036 6404 printf (_("'%s'"), SECTION_NAME (unwsec));
4d6ed7c8 6405
579f31ac 6406 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 6407 (unsigned long) unwsec->sh_offset,
89fac5e3 6408 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 6409
579f31ac 6410 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4d6ed7c8 6411
579f31ac
JJ		 6412 if (aux.table_len > 0)
6413 dump_ia64_unwind (& aux);
6414
6415 if (aux.table)
6416 free ((char *) aux.table);
6417 if (aux.info)
6418 free ((char *) aux.info);
6419 aux.table = NULL;
6420 aux.info = NULL;
6421 }
4d6ed7c8 6422 }
4d6ed7c8 6423
4d6ed7c8
NC		 6424 if (aux.symtab)
6425 free (aux.symtab);
6426 if (aux.strtab)
6427 free ((char *) aux.strtab);
4d6ed7c8
NC		 6428}
6429
3f5e193b
NC		 6430struct hppa_unw_table_entry
6431 {
6432 struct absaddr start;
6433 struct absaddr end;
6434 unsigned int Cannot_unwind:1; /* 0 */
6435 unsigned int Millicode:1; /* 1 */
6436 unsigned int Millicode_save_sr0:1; /* 2 */
6437 unsigned int Region_description:2; /* 3..4 */
6438 unsigned int reserved1:1; /* 5 */
6439 unsigned int Entry_SR:1; /* 6 */
6440 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
6441 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
6442 unsigned int Args_stored:1; /* 16 */
6443 unsigned int Variable_Frame:1; /* 17 */
6444 unsigned int Separate_Package_Body:1; /* 18 */
6445 unsigned int Frame_Extension_Millicode:1; /* 19 */
6446 unsigned int Stack_Overflow_Check:1; /* 20 */
6447 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
6448 unsigned int Ada_Region:1; /* 22 */
6449 unsigned int cxx_info:1; /* 23 */
6450 unsigned int cxx_try_catch:1; /* 24 */
6451 unsigned int sched_entry_seq:1; /* 25 */
6452 unsigned int reserved2:1; /* 26 */
6453 unsigned int Save_SP:1; /* 27 */
6454 unsigned int Save_RP:1; /* 28 */
6455 unsigned int Save_MRP_in_frame:1; /* 29 */
6456 unsigned int extn_ptr_defined:1; /* 30 */
6457 unsigned int Cleanup_defined:1; /* 31 */
6458
6459 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
6460 unsigned int HP_UX_interrupt_marker:1; /* 1 */
6461 unsigned int Large_frame:1; /* 2 */
6462 unsigned int Pseudo_SP_Set:1; /* 3 */
6463 unsigned int reserved4:1; /* 4 */
6464 unsigned int Total_frame_size:27; /* 5..31 */
6465 };
6466
57346661
AM		 6467struct hppa_unw_aux_info
6468 {
3f5e193b 6469 struct hppa_unw_table_entry *table; /* Unwind table. */
57346661
AM		 6470 unsigned long table_len; /* Length of unwind table. */
6471 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 6472 Elf_Internal_Sym * symtab; /* The symbol table. */
57346661 6473 unsigned long nsyms; /* Number of symbols. */
2cf0635d 6474 char * strtab; /* The string table. */
57346661
AM		 6475 unsigned long strtab_size; /* Size of string table. */
6476 };
6477
6478static void
2cf0635d 6479dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 6480{
2cf0635d 6481 struct hppa_unw_table_entry * tp;
57346661 6482
57346661
AM		 6483 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6484 {
6485 bfd_vma offset;
2cf0635d 6486 const char * procname;
57346661
AM		 6487
6488 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6489 aux->strtab_size, tp->start, &procname,
6490 &offset);
6491
6492 fputs ("\n<", stdout);
6493
6494 if (procname)
6495 {
6496 fputs (procname, stdout);
6497
6498 if (offset)
6499 printf ("+%lx", (unsigned long) offset);
6500 }
6501
6502 fputs (">: [", stdout);
6503 print_vma (tp->start.offset, PREFIX_HEX);
6504 fputc ('-', stdout);
6505 print_vma (tp->end.offset, PREFIX_HEX);
6506 printf ("]\n\t");
6507
18bd398b
NC		 6508#define PF(_m) if (tp->_m) printf (#_m " ");
6509#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 6510 PF(Cannot_unwind);
6511 PF(Millicode);
6512 PF(Millicode_save_sr0);
18bd398b 6513 /* PV(Region_description); */
57346661
AM		 6514 PF(Entry_SR);
6515 PV(Entry_FR);
6516 PV(Entry_GR);
6517 PF(Args_stored);
6518 PF(Variable_Frame);
6519 PF(Separate_Package_Body);
6520 PF(Frame_Extension_Millicode);
6521 PF(Stack_Overflow_Check);
6522 PF(Two_Instruction_SP_Increment);
6523 PF(Ada_Region);
6524 PF(cxx_info);
6525 PF(cxx_try_catch);
6526 PF(sched_entry_seq);
6527 PF(Save_SP);
6528 PF(Save_RP);
6529 PF(Save_MRP_in_frame);
6530 PF(extn_ptr_defined);
6531 PF(Cleanup_defined);
6532 PF(MPE_XL_interrupt_marker);
6533 PF(HP_UX_interrupt_marker);
6534 PF(Large_frame);
6535 PF(Pseudo_SP_Set);
6536 PV(Total_frame_size);
6537#undef PF
6538#undef PV
6539 }
6540
18bd398b 6541 printf ("\n");
57346661
AM		 6542}
6543
6544static int
2cf0635d
NC		 6545slurp_hppa_unwind_table (FILE * file,
6546 struct hppa_unw_aux_info * aux,
6547 Elf_Internal_Shdr * sec)
57346661 6548{
1c0751b2 6549 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 6550 Elf_Internal_Phdr * seg;
6551 struct hppa_unw_table_entry * tep;
6552 Elf_Internal_Shdr * relsec;
6553 Elf_Internal_Rela * rela;
6554 Elf_Internal_Rela * rp;
6555 unsigned char * table;
6556 unsigned char * tp;
6557 Elf_Internal_Sym * sym;
6558 const char * relname;
57346661 6559
57346661
AM		 6560 /* First, find the starting address of the segment that includes
6561 this section. */
6562
6563 if (elf_header.e_phnum)
6564 {
6565 if (! get_program_headers (file))
6566 return 0;
6567
6568 for (seg = program_headers;
6569 seg < program_headers + elf_header.e_phnum;
6570 ++seg)
6571 {
6572 if (seg->p_type != PT_LOAD)
6573 continue;
6574
6575 if (sec->sh_addr >= seg->p_vaddr
6576 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6577 {
6578 aux->seg_base = seg->p_vaddr;
6579 break;
6580 }
6581 }
6582 }
6583
6584 /* Second, build the unwind table from the contents of the unwind
6585 section. */
6586 size = sec->sh_size;
3f5e193b
NC		 6587 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6588 _("unwind table"));
57346661
AM		 6589 if (!table)
6590 return 0;
6591
1c0751b2
DA		 6592 unw_ent_size = 16;
6593 nentries = size / unw_ent_size;
6594 size = unw_ent_size * nentries;
57346661 6595
3f5e193b
NC		 6596 tep = aux->table = (struct hppa_unw_table_entry *)
6597 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 6598
1c0751b2 6599 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 6600 {
6601 unsigned int tmp1, tmp2;
6602
6603 tep->start.section = SHN_UNDEF;
6604 tep->end.section = SHN_UNDEF;
6605
1c0751b2
DA		 6606 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6607 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6608 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6609 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6610
6611 tep->start.offset += aux->seg_base;
6612 tep->end.offset += aux->seg_base;
57346661
AM		 6613
6614 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6615 tep->Millicode = (tmp1 >> 30) & 0x1;
6616 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6617 tep->Region_description = (tmp1 >> 27) & 0x3;
6618 tep->reserved1 = (tmp1 >> 26) & 0x1;
6619 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6620 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6621 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6622 tep->Args_stored = (tmp1 >> 15) & 0x1;
6623 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6624 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6625 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6626 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6627 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6628 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6629 tep->cxx_info = (tmp1 >> 8) & 0x1;
6630 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6631 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6632 tep->reserved2 = (tmp1 >> 5) & 0x1;
6633 tep->Save_SP = (tmp1 >> 4) & 0x1;
6634 tep->Save_RP = (tmp1 >> 3) & 0x1;
6635 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6636 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6637 tep->Cleanup_defined = tmp1 & 0x1;
6638
6639 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6640 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6641 tep->Large_frame = (tmp2 >> 29) & 0x1;
6642 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6643 tep->reserved4 = (tmp2 >> 27) & 0x1;
6644 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 6645 }
6646 free (table);
6647
6648 /* Third, apply any relocations to the unwind table. */
57346661
AM		 6649 for (relsec = section_headers;
6650 relsec < section_headers + elf_header.e_shnum;
6651 ++relsec)
6652 {
6653 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6654 || relsec->sh_info >= elf_header.e_shnum
6655 || section_headers + relsec->sh_info != sec)
57346661
AM		 6656 continue;
6657
6658 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6659 & rela, & nrelas))
6660 return 0;
6661
6662 for (rp = rela; rp < rela + nrelas; ++rp)
6663 {
aca88567
NC		 6664 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6665 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 6666
6667 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 6668 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 6669 {
6670 warn (_("Skipping unexpected relocation type %s\n"), relname);
6671 continue;
6672 }
6673
6674 i = rp->r_offset / unw_ent_size;
6675
89fac5e3 6676 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 6677 {
6678 case 0:
6679 aux->table[i].start.section = sym->st_shndx;
1e456d54 6680 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 6681 break;
6682 case 1:
6683 aux->table[i].end.section = sym->st_shndx;
1e456d54 6684 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 6685 break;
6686 default:
6687 break;
6688 }
6689 }
6690
6691 free (rela);
6692 }
6693
1c0751b2 6694 aux->table_len = nentries;
57346661
AM		 6695
6696 return 1;
6697}
6698
1b31d05e 6699static void
2cf0635d 6700hppa_process_unwind (FILE * file)
57346661 6701{
57346661 6702 struct hppa_unw_aux_info aux;
2cf0635d
NC		 6703 Elf_Internal_Shdr * unwsec = NULL;
6704 Elf_Internal_Shdr * strsec;
6705 Elf_Internal_Shdr * sec;
18bd398b 6706 unsigned long i;
57346661 6707
c256ffe7 6708 if (string_table == NULL)
1b31d05e
NC		 6709 return;
6710
6711 memset (& aux, 0, sizeof (aux));
57346661
AM		 6712
6713 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6714 {
c256ffe7 6715 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6716 && sec->sh_link < elf_header.e_shnum)
57346661 6717 {
ba5cdace 6718 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 6719
4fbb74a6 6720 strsec = section_headers + sec->sh_link;
59245841 6721 assert (aux.strtab == NULL);
3f5e193b
NC		 6722 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6723 1, strsec->sh_size,
6724 _("string table"));
c256ffe7 6725 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 6726 }
18bd398b 6727 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 6728 unwsec = sec;
6729 }
6730
6731 if (!unwsec)
6732 printf (_("\nThere are no unwind sections in this file.\n"));
6733
6734 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6735 {
18bd398b 6736 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 6737 {
57346661
AM		 6738 printf (_("\nUnwind section "));
6739 printf (_("'%s'"), SECTION_NAME (sec));
6740
6741 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6742 (unsigned long) sec->sh_offset,
89fac5e3 6743 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 6744
6745 slurp_hppa_unwind_table (file, &aux, sec);
6746 if (aux.table_len > 0)
6747 dump_hppa_unwind (&aux);
6748
6749 if (aux.table)
6750 free ((char *) aux.table);
6751 aux.table = NULL;
6752 }
6753 }
6754
6755 if (aux.symtab)
6756 free (aux.symtab);
6757 if (aux.strtab)
6758 free ((char *) aux.strtab);
57346661
AM		 6759}
6760
0b6ae522
DJ		 6761struct arm_section
6762{
a734115a
NC		 6763 unsigned char * data; /* The unwind data. */
6764 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
6765 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
6766 unsigned long nrelas; /* The number of relocations. */
6767 unsigned int rel_type; /* REL or RELA ? */
6768 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 6769};
6770
6771struct arm_unw_aux_info
6772{
a734115a
NC		 6773 FILE * file; /* The file containing the unwind sections. */
6774 Elf_Internal_Sym * symtab; /* The file's symbol table. */
6775 unsigned long nsyms; /* Number of symbols. */
6776 char * strtab; /* The file's string table. */
6777 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 6778};
6779
6780static const char *
6781arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6782 bfd_vma fn, struct absaddr addr)
6783{
6784 const char *procname;
6785 bfd_vma sym_offset;
6786
6787 if (addr.section == SHN_UNDEF)
6788 addr.offset = fn;
6789
6790 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6791 aux->strtab_size, addr, &procname,
6792 &sym_offset);
6793
6794 print_vma (fn, PREFIX_HEX);
6795
6796 if (procname)
6797 {
6798 fputs (" <", stdout);
6799 fputs (procname, stdout);
6800
6801 if (sym_offset)
6802 printf ("+0x%lx", (unsigned long) sym_offset);
6803 fputc ('>', stdout);
6804 }
6805
6806 return procname;
6807}
6808
6809static void
6810arm_free_section (struct arm_section *arm_sec)
6811{
6812 if (arm_sec->data != NULL)
6813 free (arm_sec->data);
6814
6815 if (arm_sec->rela != NULL)
6816 free (arm_sec->rela);
6817}
6818
a734115a
NC		 6819/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6820 cached section and install SEC instead.
6821 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6822 and return its valued in * WORDP, relocating if necessary.
1b31d05e 6823 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 6824 relocation's offset in ADDR.
1b31d05e
NC		 6825 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6826 into the string table of the symbol associated with the reloc. If no
6827 reloc was applied store -1 there.
6828 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 6829
6830static bfd_boolean
1b31d05e
NC		 6831get_unwind_section_word (struct arm_unw_aux_info * aux,
6832 struct arm_section * arm_sec,
6833 Elf_Internal_Shdr * sec,
6834 bfd_vma word_offset,
6835 unsigned int * wordp,
6836 struct absaddr * addr,
6837 bfd_vma * sym_name)
0b6ae522
DJ		 6838{
6839 Elf_Internal_Rela *rp;
6840 Elf_Internal_Sym *sym;
6841 const char * relname;
6842 unsigned int word;
6843 bfd_boolean wrapped;
6844
6845 addr->section = SHN_UNDEF;
6846 addr->offset = 0;
6847
1b31d05e
NC		 6848 if (sym_name != NULL)
6849 *sym_name = (bfd_vma) -1;
6850
a734115a 6851 /* If necessary, update the section cache. */
0b6ae522
DJ		 6852 if (sec != arm_sec->sec)
6853 {
6854 Elf_Internal_Shdr *relsec;
6855
6856 arm_free_section (arm_sec);
6857
6858 arm_sec->sec = sec;
6859 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6860 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 6861 arm_sec->rela = NULL;
6862 arm_sec->nrelas = 0;
6863
6864 for (relsec = section_headers;
6865 relsec < section_headers + elf_header.e_shnum;
6866 ++relsec)
6867 {
6868 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 6869 || section_headers + relsec->sh_info != sec
6870 /* PR 15745: Check the section type as well. */
6871 || (relsec->sh_type != SHT_REL
6872 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 6873 continue;
6874
a734115a 6875 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 6876 if (relsec->sh_type == SHT_REL)
6877 {
6878 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6879 relsec->sh_size,
6880 & arm_sec->rela, & arm_sec->nrelas))
a734115a 6881 return FALSE;
0b6ae522 6882 }
1ae40aa4 6883 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 6884 {
6885 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6886 relsec->sh_size,
6887 & arm_sec->rela, & arm_sec->nrelas))
a734115a 6888 return FALSE;
0b6ae522 6889 }
1ae40aa4 6890 break;
0b6ae522
DJ		 6891 }
6892
6893 arm_sec->next_rela = arm_sec->rela;
6894 }
6895
a734115a 6896 /* If there is no unwind data we can do nothing. */
0b6ae522 6897 if (arm_sec->data == NULL)
a734115a 6898 return FALSE;
0b6ae522 6899
a734115a 6900 /* Get the word at the required offset. */
0b6ae522
DJ		 6901 word = byte_get (arm_sec->data + word_offset, 4);
6902
a734115a 6903 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 6904 wrapped = FALSE;
6905 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6906 {
6907 bfd_vma prelval, offset;
6908
6909 if (rp->r_offset > word_offset && !wrapped)
6910 {
6911 rp = arm_sec->rela;
6912 wrapped = TRUE;
6913 }
6914 if (rp->r_offset > word_offset)
6915 break;
6916
6917 if (rp->r_offset & 3)
6918 {
6919 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6920 (unsigned long) rp->r_offset);
6921 continue;
6922 }
6923
6924 if (rp->r_offset < word_offset)
6925 continue;
6926
0b6ae522
DJ		 6927 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6928
6929 if (arm_sec->rel_type == SHT_REL)
6930 {
6931 offset = word & 0x7fffffff;
6932 if (offset & 0x40000000)
6933 offset |= ~ (bfd_vma) 0x7fffffff;
6934 }
a734115a 6935 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 6936 offset = rp->r_addend;
a734115a
NC		 6937 else
6938 abort ();
0b6ae522
DJ		 6939
6940 offset += sym->st_value;
6941 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6942
a734115a
NC		 6943 /* Check that we are processing the expected reloc type. */
6944 if (elf_header.e_machine == EM_ARM)
6945 {
6946 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6947
6948 if (streq (relname, "R_ARM_NONE"))
6949 continue;
0b4362b0 6950
a734115a
NC		 6951 if (! streq (relname, "R_ARM_PREL31"))
6952 {
6953 warn (_("Skipping unexpected relocation type %s\n"), relname);
6954 continue;
6955 }
6956 }
6957 else if (elf_header.e_machine == EM_TI_C6000)
6958 {
6959 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
0b4362b0 6960
a734115a
NC		 6961 if (streq (relname, "R_C6000_NONE"))
6962 continue;
6963
6964 if (! streq (relname, "R_C6000_PREL31"))
6965 {
6966 warn (_("Skipping unexpected relocation type %s\n"), relname);
6967 continue;
6968 }
6969
6970 prelval >>= 1;
6971 }
6972 else
6973 /* This function currently only supports ARM and TI unwinders. */
6974 abort ();
fa197c1c 6975
0b6ae522
DJ		 6976 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6977 addr->section = sym->st_shndx;
6978 addr->offset = offset;
1b31d05e
NC		 6979 if (sym_name)
6980 * sym_name = sym->st_name;
0b6ae522
DJ		 6981 break;
6982 }
6983
6984 *wordp = word;
6985 arm_sec->next_rela = rp;
6986
a734115a 6987 return TRUE;
0b6ae522
DJ		 6988}
6989
a734115a
NC		 6990static const char *tic6x_unwind_regnames[16] =
6991{
0b4362b0
RM		 6992 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6993 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 6994 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6995};
fa197c1c 6996
0b6ae522 6997static void
fa197c1c 6998decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 6999{
fa197c1c
PB		 7000 int i;
7001
7002 for (i = 12; mask; mask >>= 1, i--)
7003 {
7004 if (mask & 1)
7005 {
7006 fputs (tic6x_unwind_regnames[i], stdout);
7007 if (mask > 1)
7008 fputs (", ", stdout);
7009 }
7010 }
7011}
0b6ae522
DJ		 7012
7013#define ADVANCE \
7014 if (remaining == 0 && more_words) \
7015 { \
7016 data_offset += 4; \
1b31d05e
NC		 7017 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7018 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 7019 return; \
7020 remaining = 4; \
7021 more_words--; \
7022 } \
7023
7024#define GET_OP(OP) \
7025 ADVANCE; \
7026 if (remaining) \
7027 { \
7028 remaining--; \
7029 (OP) = word >> 24; \
7030 word <<= 8; \
7031 } \
7032 else \
7033 { \
2b692964 7034 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 7035 return; \
7036 } \
cc5914eb 7037 printf ("0x%02x ", OP)
0b6ae522 7038
fa197c1c
PB		 7039static void
7040decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
7041 unsigned int word, unsigned int remaining,
7042 unsigned int more_words,
7043 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7044 struct arm_section *data_arm_sec)
7045{
7046 struct absaddr addr;
0b6ae522
DJ		 7047
7048 /* Decode the unwinding instructions. */
7049 while (1)
7050 {
7051 unsigned int op, op2;
7052
7053 ADVANCE;
7054 if (remaining == 0)
7055 break;
7056 remaining--;
7057 op = word >> 24;
7058 word <<= 8;
7059
cc5914eb 7060 printf (" 0x%02x ", op);
0b6ae522
DJ		 7061
7062 if ((op & 0xc0) == 0x00)
7063 {
7064 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7065
cc5914eb 7066 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 7067 }
7068 else if ((op & 0xc0) == 0x40)
7069 {
7070 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7071
cc5914eb 7072 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 7073 }
7074 else if ((op & 0xf0) == 0x80)
7075 {
7076 GET_OP (op2);
7077 if (op == 0x80 && op2 == 0)
7078 printf (_("Refuse to unwind"));
7079 else
7080 {
7081 unsigned int mask = ((op & 0x0f) << 8) | op2;
7082 int first = 1;
7083 int i;
2b692964 7084
0b6ae522
DJ		 7085 printf ("pop {");
7086 for (i = 0; i < 12; i++)
7087 if (mask & (1 << i))
7088 {
7089 if (first)
7090 first = 0;
7091 else
7092 printf (", ");
7093 printf ("r%d", 4 + i);
7094 }
7095 printf ("}");
7096 }
7097 }
7098 else if ((op & 0xf0) == 0x90)
7099 {
7100 if (op == 0x9d || op == 0x9f)
7101 printf (_(" [Reserved]"));
7102 else
cc5914eb 7103 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 7104 }
7105 else if ((op & 0xf0) == 0xa0)
7106 {
7107 int end = 4 + (op & 0x07);
7108 int first = 1;
7109 int i;
61865e30 7110
0b6ae522
DJ		 7111 printf (" pop {");
7112 for (i = 4; i <= end; i++)
7113 {
7114 if (first)
7115 first = 0;
7116 else
7117 printf (", ");
7118 printf ("r%d", i);
7119 }
7120 if (op & 0x08)
7121 {
1b31d05e 7122 if (!first)
0b6ae522
DJ		 7123 printf (", ");
7124 printf ("r14");
7125 }
7126 printf ("}");
7127 }
7128 else if (op == 0xb0)
7129 printf (_(" finish"));
7130 else if (op == 0xb1)
7131 {
7132 GET_OP (op2);
7133 if (op2 == 0 || (op2 & 0xf0) != 0)
7134 printf (_("[Spare]"));
7135 else
7136 {
7137 unsigned int mask = op2 & 0x0f;
7138 int first = 1;
7139 int i;
61865e30 7140
0b6ae522
DJ		 7141 printf ("pop {");
7142 for (i = 0; i < 12; i++)
7143 if (mask & (1 << i))
7144 {
7145 if (first)
7146 first = 0;
7147 else
7148 printf (", ");
7149 printf ("r%d", i);
7150 }
7151 printf ("}");
7152 }
7153 }
7154 else if (op == 0xb2)
7155 {
b115cf96 7156 unsigned char buf[9];
0b6ae522
DJ		 7157 unsigned int i, len;
7158 unsigned long offset;
61865e30 7159
b115cf96 7160 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 7161 {
7162 GET_OP (buf[i]);
7163 if ((buf[i] & 0x80) == 0)
7164 break;
7165 }
7166 assert (i < sizeof (buf));
f6f0e17b 7167 offset = read_uleb128 (buf, &len, buf + i + 1);
0b6ae522
DJ		 7168 assert (len == i + 1);
7169 offset = offset * 4 + 0x204;
cc5914eb 7170 printf ("vsp = vsp + %ld", offset);
0b6ae522 7171 }
61865e30 7172 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 7173 {
61865e30
NC		 7174 unsigned int first, last;
7175
7176 GET_OP (op2);
7177 first = op2 >> 4;
7178 last = op2 & 0x0f;
7179 if (op == 0xc8)
7180 first = first + 16;
7181 printf ("pop {D%d", first);
7182 if (last)
7183 printf ("-D%d", first + last);
7184 printf ("}");
7185 }
7186 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7187 {
7188 unsigned int count = op & 0x07;
7189
7190 printf ("pop {D8");
7191 if (count)
7192 printf ("-D%d", 8 + count);
7193 printf ("}");
7194 }
7195 else if (op >= 0xc0 && op <= 0xc5)
7196 {
7197 unsigned int count = op & 0x07;
7198
7199 printf (" pop {wR10");
7200 if (count)
7201 printf ("-wR%d", 10 + count);
7202 printf ("}");
7203 }
7204 else if (op == 0xc6)
7205 {
7206 unsigned int first, last;
7207
7208 GET_OP (op2);
7209 first = op2 >> 4;
7210 last = op2 & 0x0f;
7211 printf ("pop {wR%d", first);
7212 if (last)
7213 printf ("-wR%d", first + last);
7214 printf ("}");
7215 }
7216 else if (op == 0xc7)
7217 {
7218 GET_OP (op2);
7219 if (op2 == 0 || (op2 & 0xf0) != 0)
7220 printf (_("[Spare]"));
0b6ae522
DJ		 7221 else
7222 {
61865e30
NC		 7223 unsigned int mask = op2 & 0x0f;
7224 int first = 1;
7225 int i;
7226
7227 printf ("pop {");
7228 for (i = 0; i < 4; i++)
7229 if (mask & (1 << i))
7230 {
7231 if (first)
7232 first = 0;
7233 else
7234 printf (", ");
7235 printf ("wCGR%d", i);
7236 }
7237 printf ("}");
0b6ae522
DJ		 7238 }
7239 }
61865e30
NC		 7240 else
7241 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 7242 printf ("\n");
7243 }
fa197c1c
PB		 7244}
7245
7246static void
7247decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
7248 unsigned int word, unsigned int remaining,
7249 unsigned int more_words,
7250 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7251 struct arm_section *data_arm_sec)
7252{
7253 struct absaddr addr;
7254
7255 /* Decode the unwinding instructions. */
7256 while (1)
7257 {
7258 unsigned int op, op2;
7259
7260 ADVANCE;
7261 if (remaining == 0)
7262 break;
7263 remaining--;
7264 op = word >> 24;
7265 word <<= 8;
7266
9cf03b7e 7267 printf (" 0x%02x ", op);
fa197c1c
PB		 7268
7269 if ((op & 0xc0) == 0x00)
7270 {
7271 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 7272 printf (" sp = sp + %d", offset);
fa197c1c
PB		 7273 }
7274 else if ((op & 0xc0) == 0x80)
7275 {
7276 GET_OP (op2);
7277 if (op == 0x80 && op2 == 0)
7278 printf (_("Refuse to unwind"));
7279 else
7280 {
7281 unsigned int mask = ((op & 0x1f) << 8) | op2;
7282 if (op & 0x20)
7283 printf ("pop compact {");
7284 else
7285 printf ("pop {");
7286
7287 decode_tic6x_unwind_regmask (mask);
7288 printf("}");
7289 }
7290 }
7291 else if ((op & 0xf0) == 0xc0)
7292 {
7293 unsigned int reg;
7294 unsigned int nregs;
7295 unsigned int i;
7296 const char *name;
a734115a
NC		 7297 struct
7298 {
fa197c1c
PB		 7299 unsigned int offset;
7300 unsigned int reg;
7301 } regpos[16];
7302
7303 /* Scan entire instruction first so that GET_OP output is not
7304 interleaved with disassembly. */
7305 nregs = 0;
7306 for (i = 0; nregs < (op & 0xf); i++)
7307 {
7308 GET_OP (op2);
7309 reg = op2 >> 4;
7310 if (reg != 0xf)
7311 {
7312 regpos[nregs].offset = i * 2;
7313 regpos[nregs].reg = reg;
7314 nregs++;
7315 }
7316
7317 reg = op2 & 0xf;
7318 if (reg != 0xf)
7319 {
7320 regpos[nregs].offset = i * 2 + 1;
7321 regpos[nregs].reg = reg;
7322 nregs++;
7323 }
7324 }
7325
7326 printf (_("pop frame {"));
7327 reg = nregs - 1;
7328 for (i = i * 2; i > 0; i--)
7329 {
7330 if (regpos[reg].offset == i - 1)
7331 {
7332 name = tic6x_unwind_regnames[regpos[reg].reg];
7333 if (reg > 0)
7334 reg--;
7335 }
7336 else
7337 name = _("[pad]");
7338
7339 fputs (name, stdout);
7340 if (i > 1)
7341 printf (", ");
7342 }
7343
7344 printf ("}");
7345 }
7346 else if (op == 0xd0)
7347 printf (" MOV FP, SP");
7348 else if (op == 0xd1)
7349 printf (" __c6xabi_pop_rts");
7350 else if (op == 0xd2)
7351 {
7352 unsigned char buf[9];
7353 unsigned int i, len;
7354 unsigned long offset;
a734115a 7355
fa197c1c
PB		 7356 for (i = 0; i < sizeof (buf); i++)
7357 {
7358 GET_OP (buf[i]);
7359 if ((buf[i] & 0x80) == 0)
7360 break;
7361 }
7362 assert (i < sizeof (buf));
f6f0e17b 7363 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 7364 assert (len == i + 1);
7365 offset = offset * 8 + 0x408;
7366 printf (_("sp = sp + %ld"), offset);
7367 }
7368 else if ((op & 0xf0) == 0xe0)
7369 {
7370 if ((op & 0x0f) == 7)
7371 printf (" RETURN");
7372 else
7373 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7374 }
7375 else
7376 {
7377 printf (_(" [unsupported opcode]"));
7378 }
7379 putchar ('\n');
7380 }
7381}
7382
7383static bfd_vma
a734115a 7384arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 7385{
7386 bfd_vma offset;
7387
7388 offset = word & 0x7fffffff;
7389 if (offset & 0x40000000)
7390 offset |= ~ (bfd_vma) 0x7fffffff;
7391
7392 if (elf_header.e_machine == EM_TI_C6000)
7393 offset <<= 1;
7394
7395 return offset + where;
7396}
7397
7398static void
1b31d05e
NC		 7399decode_arm_unwind (struct arm_unw_aux_info * aux,
7400 unsigned int word,
7401 unsigned int remaining,
7402 bfd_vma data_offset,
7403 Elf_Internal_Shdr * data_sec,
7404 struct arm_section * data_arm_sec)
fa197c1c
PB		 7405{
7406 int per_index;
7407 unsigned int more_words = 0;
37e14bc3 7408 struct absaddr addr;
1b31d05e 7409 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 7410
7411 if (remaining == 0)
7412 {
1b31d05e
NC		 7413 /* Fetch the first word.
7414 Note - when decoding an object file the address extracted
7415 here will always be 0. So we also pass in the sym_name
7416 parameter so that we can find the symbol associated with
7417 the personality routine. */
7418 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7419 & word, & addr, & sym_name))
fa197c1c 7420 return;
1b31d05e 7421
fa197c1c
PB		 7422 remaining = 4;
7423 }
7424
7425 if ((word & 0x80000000) == 0)
7426 {
7427 /* Expand prel31 for personality routine. */
7428 bfd_vma fn;
7429 const char *procname;
7430
a734115a 7431 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 7432 printf (_(" Personality routine: "));
1b31d05e
NC		 7433 if (fn == 0
7434 && addr.section == SHN_UNDEF && addr.offset == 0
7435 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7436 {
7437 procname = aux->strtab + sym_name;
7438 print_vma (fn, PREFIX_HEX);
7439 if (procname)
7440 {
7441 fputs (" <", stdout);
7442 fputs (procname, stdout);
7443 fputc ('>', stdout);
7444 }
7445 }
7446 else
7447 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 7448 fputc ('\n', stdout);
7449
7450 /* The GCC personality routines use the standard compact
7451 encoding, starting with one byte giving the number of
7452 words. */
7453 if (procname != NULL
7454 && (const_strneq (procname, "__gcc_personality_v0")
7455 || const_strneq (procname, "__gxx_personality_v0")
7456 || const_strneq (procname, "__gcj_personality_v0")
7457 || const_strneq (procname, "__gnu_objc_personality_v0")))
7458 {
7459 remaining = 0;
7460 more_words = 1;
7461 ADVANCE;
7462 if (!remaining)
7463 {
7464 printf (_(" [Truncated data]\n"));
7465 return;
7466 }
7467 more_words = word >> 24;
7468 word <<= 8;
7469 remaining--;
7470 per_index = -1;
7471 }
7472 else
7473 return;
7474 }
7475 else
7476 {
1b31d05e 7477 /* ARM EHABI Section 6.3:
0b4362b0 7478
1b31d05e 7479 An exception-handling table entry for the compact model looks like:
0b4362b0 7480
1b31d05e
NC		 7481 31 30-28 27-24 23-0
7482 -- ----- ----- ----
7483 1 0 index Data for personalityRoutine[index] */
7484
7485 if (elf_header.e_machine == EM_ARM
7486 && (word & 0x70000000))
83c257ca 7487 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 7488
fa197c1c 7489 per_index = (word >> 24) & 0x7f;
1b31d05e 7490 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 7491 if (per_index == 0)
7492 {
7493 more_words = 0;
7494 word <<= 8;
7495 remaining--;
7496 }
7497 else if (per_index < 3)
7498 {
7499 more_words = (word >> 16) & 0xff;
7500 word <<= 16;
7501 remaining -= 2;
7502 }
7503 }
7504
7505 switch (elf_header.e_machine)
7506 {
7507 case EM_ARM:
7508 if (per_index < 3)
7509 {
7510 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7511 data_offset, data_sec, data_arm_sec);
7512 }
7513 else
1b31d05e
NC		 7514 {
7515 warn (_("Unknown ARM compact model index encountered\n"));
7516 printf (_(" [reserved]\n"));
7517 }
fa197c1c
PB		 7518 break;
7519
7520 case EM_TI_C6000:
7521 if (per_index < 3)
7522 {
7523 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 7524 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 7525 }
7526 else if (per_index < 5)
7527 {
7528 if (((word >> 17) & 0x7f) == 0x7f)
7529 printf (_(" Restore stack from frame pointer\n"));
7530 else
7531 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
7532 printf (_(" Registers restored: "));
7533 if (per_index == 4)
7534 printf (" (compact) ");
7535 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7536 putchar ('\n');
7537 printf (_(" Return register: %s\n"),
7538 tic6x_unwind_regnames[word & 0xf]);
7539 }
7540 else
1b31d05e 7541 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 7542 break;
7543
7544 default:
1b31d05e
NC		 7545 error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7546 elf_header.e_machine);
fa197c1c 7547 }
0b6ae522
DJ		 7548
7549 /* Decode the descriptors. Not implemented. */
7550}
7551
7552static void
7553dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7554{
7555 struct arm_section exidx_arm_sec, extab_arm_sec;
7556 unsigned int i, exidx_len;
7557
7558 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7559 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7560 exidx_len = exidx_sec->sh_size / 8;
7561
7562 for (i = 0; i < exidx_len; i++)
7563 {
7564 unsigned int exidx_fn, exidx_entry;
7565 struct absaddr fn_addr, entry_addr;
7566 bfd_vma fn;
7567
7568 fputc ('\n', stdout);
7569
1b31d05e
NC		 7570 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7571 8 * i, & exidx_fn, & fn_addr, NULL)
7572 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7573 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 7574 {
1b31d05e
NC		 7575 arm_free_section (& exidx_arm_sec);
7576 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 7577 return;
7578 }
7579
83c257ca
NC		 7580 /* ARM EHABI, Section 5:
7581 An index table entry consists of 2 words.
7582 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7583 if (exidx_fn & 0x80000000)
7584 warn (_("corrupt index table entry: %x\n"), exidx_fn);
7585
a734115a 7586 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 7587
a734115a 7588 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 7589 fputs (": ", stdout);
7590
7591 if (exidx_entry == 1)
7592 {
7593 print_vma (exidx_entry, PREFIX_HEX);
7594 fputs (" [cantunwind]\n", stdout);
7595 }
7596 else if (exidx_entry & 0x80000000)
7597 {
7598 print_vma (exidx_entry, PREFIX_HEX);
7599 fputc ('\n', stdout);
7600 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7601 }
7602 else
7603 {
8f73510c 7604 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 7605 Elf_Internal_Shdr *table_sec;
7606
7607 fputs ("@", stdout);
a734115a 7608 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 7609 print_vma (table, PREFIX_HEX);
7610 printf ("\n");
7611
7612 /* Locate the matching .ARM.extab. */
7613 if (entry_addr.section != SHN_UNDEF
7614 && entry_addr.section < elf_header.e_shnum)
7615 {
7616 table_sec = section_headers + entry_addr.section;
7617 table_offset = entry_addr.offset;
7618 }
7619 else
7620 {
7621 table_sec = find_section_by_address (table);
7622 if (table_sec != NULL)
7623 table_offset = table - table_sec->sh_addr;
7624 }
7625 if (table_sec == NULL)
7626 {
7627 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7628 (unsigned long) table);
7629 continue;
7630 }
7631 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7632 &extab_arm_sec);
7633 }
7634 }
7635
7636 printf ("\n");
7637
7638 arm_free_section (&exidx_arm_sec);
7639 arm_free_section (&extab_arm_sec);
7640}
7641
fa197c1c 7642/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 7643
7644static void
0b6ae522
DJ		 7645arm_process_unwind (FILE *file)
7646{
7647 struct arm_unw_aux_info aux;
7648 Elf_Internal_Shdr *unwsec = NULL;
7649 Elf_Internal_Shdr *strsec;
7650 Elf_Internal_Shdr *sec;
7651 unsigned long i;
fa197c1c 7652 unsigned int sec_type;
0b6ae522 7653
fa197c1c
PB		 7654 switch (elf_header.e_machine)
7655 {
7656 case EM_ARM:
7657 sec_type = SHT_ARM_EXIDX;
7658 break;
7659
7660 case EM_TI_C6000:
7661 sec_type = SHT_C6000_UNWIND;
7662 break;
7663
0b4362b0 7664 default:
1b31d05e
NC		 7665 error (_("Unsupported architecture type %d encountered when processing unwind table"),
7666 elf_header.e_machine);
7667 return;
fa197c1c
PB		 7668 }
7669
0b6ae522 7670 if (string_table == NULL)
1b31d05e
NC		 7671 return;
7672
7673 memset (& aux, 0, sizeof (aux));
7674 aux.file = file;
0b6ae522
DJ		 7675
7676 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7677 {
7678 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7679 {
ba5cdace 7680 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 7681
7682 strsec = section_headers + sec->sh_link;
59245841 7683 assert (aux.strtab == NULL);
0b6ae522
DJ		 7684 aux.strtab = get_data (NULL, file, strsec->sh_offset,
7685 1, strsec->sh_size, _("string table"));
7686 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7687 }
fa197c1c 7688 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 7689 unwsec = sec;
7690 }
7691
1b31d05e 7692 if (unwsec == NULL)
0b6ae522 7693 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 7694 else
7695 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7696 {
7697 if (sec->sh_type == sec_type)
7698 {
7699 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7700 SECTION_NAME (sec),
7701 (unsigned long) sec->sh_offset,
7702 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 7703
1b31d05e
NC		 7704 dump_arm_unwind (&aux, sec);
7705 }
7706 }
0b6ae522
DJ		 7707
7708 if (aux.symtab)
7709 free (aux.symtab);
7710 if (aux.strtab)
7711 free ((char *) aux.strtab);
0b6ae522
DJ		 7712}
7713
1b31d05e 7714static void
2cf0635d 7715process_unwind (FILE * file)
57346661 7716{
2cf0635d
NC		 7717 struct unwind_handler
7718 {
57346661 7719 int machtype;
1b31d05e 7720 void (* handler)(FILE *);
2cf0635d
NC		 7721 } handlers[] =
7722 {
0b6ae522 7723 { EM_ARM, arm_process_unwind },
57346661
AM		 7724 { EM_IA_64, ia64_process_unwind },
7725 { EM_PARISC, hppa_process_unwind },
fa197c1c 7726 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 7727 { 0, 0 }
7728 };
7729 int i;
7730
7731 if (!do_unwind)
1b31d05e 7732 return;
57346661
AM		 7733
7734 for (i = 0; handlers[i].handler != NULL; i++)
7735 if (elf_header.e_machine == handlers[i].machtype)
9f758fdc
NC		 7736 {
7737 handlers[i].handler (file);
7738 return;
7739 }
57346661 7740
1b31d05e
NC		 7741 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7742 get_machine_name (elf_header.e_machine));
57346661
AM		 7743}
7744
252b5132 7745static void
2cf0635d 7746dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 7747{
7748 switch (entry->d_tag)
7749 {
7750 case DT_MIPS_FLAGS:
7751 if (entry->d_un.d_val == 0)
4b68bca3 7752 printf (_("NONE"));
252b5132
RH		 7753 else
7754 {
7755 static const char * opts[] =
7756 {
7757 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7758 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7759 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7760 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7761 "RLD_ORDER_SAFE"
7762 };
7763 unsigned int cnt;
7764 int first = 1;
2b692964 7765
60bca95a 7766 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 7767 if (entry->d_un.d_val & (1 << cnt))
7768 {
7769 printf ("%s%s", first ? "" : " ", opts[cnt]);
7770 first = 0;
7771 }
252b5132
RH		 7772 }
7773 break;
103f02d3 7774
252b5132 7775 case DT_MIPS_IVERSION:
d79b3d50 7776 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 7777 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 7778 else
4b68bca3 7779 printf (_("<corrupt: %" BFD_VMA_FMT "d>"), entry->d_un.d_ptr);
252b5132 7780 break;
103f02d3 7781
252b5132
RH		 7782 case DT_MIPS_TIME_STAMP:
7783 {
7784 char timebuf[20];
2cf0635d 7785 struct tm * tmp;
50da7a9c 7786
91d6fa6a
NC		 7787 time_t atime = entry->d_un.d_val;
7788 tmp = gmtime (&atime);
e9e44622
JJ		 7789 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7790 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7791 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 7792 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 7793 }
7794 break;
103f02d3 7795
252b5132
RH		 7796 case DT_MIPS_RLD_VERSION:
7797 case DT_MIPS_LOCAL_GOTNO:
7798 case DT_MIPS_CONFLICTNO:
7799 case DT_MIPS_LIBLISTNO:
7800 case DT_MIPS_SYMTABNO:
7801 case DT_MIPS_UNREFEXTNO:
7802 case DT_MIPS_HIPAGENO:
7803 case DT_MIPS_DELTA_CLASS_NO:
7804 case DT_MIPS_DELTA_INSTANCE_NO:
7805 case DT_MIPS_DELTA_RELOC_NO:
7806 case DT_MIPS_DELTA_SYM_NO:
7807 case DT_MIPS_DELTA_CLASSSYM_NO:
7808 case DT_MIPS_COMPACT_SIZE:
4b68bca3 7809 print_vma (entry->d_un.d_ptr, DEC);
252b5132 7810 break;
103f02d3
UD		 7811
7812 default:
4b68bca3 7813 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 7814 }
4b68bca3 7815 putchar ('\n');
103f02d3
UD		 7816}
7817
103f02d3 7818static void
2cf0635d 7819dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 7820{
7821 switch (entry->d_tag)
7822 {
7823 case DT_HP_DLD_FLAGS:
7824 {
7825 static struct
7826 {
7827 long int bit;
2cf0635d 7828 const char * str;
5e220199
NC		 7829 }
7830 flags[] =
7831 {
7832 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7833 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7834 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7835 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7836 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7837 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7838 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7839 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7840 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7841 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 7842 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7843 { DT_HP_GST, "HP_GST" },
7844 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7845 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7846 { DT_HP_NODELETE, "HP_NODELETE" },
7847 { DT_HP_GROUP, "HP_GROUP" },
7848 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 7849 };
103f02d3 7850 int first = 1;
5e220199 7851 size_t cnt;
f7a99963 7852 bfd_vma val = entry->d_un.d_val;
103f02d3 7853
60bca95a 7854 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 7855 if (val & flags[cnt].bit)
30800947
NC		 7856 {
7857 if (! first)
7858 putchar (' ');
7859 fputs (flags[cnt].str, stdout);
7860 first = 0;
7861 val ^= flags[cnt].bit;
7862 }
76da6bbe 7863
103f02d3 7864 if (val != 0 || first)
f7a99963
NC		 7865 {
7866 if (! first)
7867 putchar (' ');
7868 print_vma (val, HEX);
7869 }
103f02d3
UD		 7870 }
7871 break;
76da6bbe 7872
252b5132 7873 default:
f7a99963
NC		 7874 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7875 break;
252b5132 7876 }
35b1837e 7877 putchar ('\n');
252b5132
RH		 7878}
7879
28f997cf
TG		 7880#ifdef BFD64
7881
7882/* VMS vs Unix time offset and factor. */
7883
7884#define VMS_EPOCH_OFFSET 35067168000000000LL
7885#define VMS_GRANULARITY_FACTOR 10000000
7886
7887/* Display a VMS time in a human readable format. */
7888
7889static void
7890print_vms_time (bfd_int64_t vmstime)
7891{
7892 struct tm *tm;
7893 time_t unxtime;
7894
7895 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7896 tm = gmtime (&unxtime);
7897 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7898 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7899 tm->tm_hour, tm->tm_min, tm->tm_sec);
7900}
7901#endif /* BFD64 */
7902
ecc51f48 7903static void
2cf0635d 7904dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 7905{
7906 switch (entry->d_tag)
7907 {
0de14b54 7908 case DT_IA_64_PLT_RESERVE:
bdf4d63a 7909 /* First 3 slots reserved. */
ecc51f48
NC		 7910 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7911 printf (" -- ");
7912 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 7913 break;
7914
28f997cf
TG		 7915 case DT_IA_64_VMS_LINKTIME:
7916#ifdef BFD64
7917 print_vms_time (entry->d_un.d_val);
7918#endif
7919 break;
7920
7921 case DT_IA_64_VMS_LNKFLAGS:
7922 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7923 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7924 printf (" CALL_DEBUG");
7925 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7926 printf (" NOP0BUFS");
7927 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7928 printf (" P0IMAGE");
7929 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7930 printf (" MKTHREADS");
7931 if (entry->d_un.d_val & VMS_LF_UPCALLS)
7932 printf (" UPCALLS");
7933 if (entry->d_un.d_val & VMS_LF_IMGSTA)
7934 printf (" IMGSTA");
7935 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7936 printf (" INITIALIZE");
7937 if (entry->d_un.d_val & VMS_LF_MAIN)
7938 printf (" MAIN");
7939 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7940 printf (" EXE_INIT");
7941 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7942 printf (" TBK_IN_IMG");
7943 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7944 printf (" DBG_IN_IMG");
7945 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7946 printf (" TBK_IN_DSF");
7947 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7948 printf (" DBG_IN_DSF");
7949 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7950 printf (" SIGNATURES");
7951 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7952 printf (" REL_SEG_OFF");
7953 break;
7954
bdf4d63a
JJ		 7955 default:
7956 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7957 break;
ecc51f48 7958 }
bdf4d63a 7959 putchar ('\n');
ecc51f48
NC		 7960}
7961
252b5132 7962static int
2cf0635d 7963get_32bit_dynamic_section (FILE * file)
252b5132 7964{
2cf0635d
NC		 7965 Elf32_External_Dyn * edyn;
7966 Elf32_External_Dyn * ext;
7967 Elf_Internal_Dyn * entry;
103f02d3 7968
3f5e193b
NC		 7969 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7970 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 7971 if (!edyn)
7972 return 0;
103f02d3 7973
ba2685cc
AM		 7974/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7975 might not have the luxury of section headers. Look for the DT_NULL
7976 terminator to determine the number of entries. */
7977 for (ext = edyn, dynamic_nent = 0;
7978 (char *) ext < (char *) edyn + dynamic_size;
7979 ext++)
7980 {
7981 dynamic_nent++;
7982 if (BYTE_GET (ext->d_tag) == DT_NULL)
7983 break;
7984 }
252b5132 7985
3f5e193b
NC		 7986 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7987 sizeof (* entry));
b2d38a17 7988 if (dynamic_section == NULL)
252b5132 7989 {
9ea033b2
NC		 7990 error (_("Out of memory\n"));
7991 free (edyn);
7992 return 0;
7993 }
252b5132 7994
fb514b26 7995 for (ext = edyn, entry = dynamic_section;
ba2685cc 7996 entry < dynamic_section + dynamic_nent;
fb514b26 7997 ext++, entry++)
9ea033b2 7998 {
fb514b26
AM		 7999 entry->d_tag = BYTE_GET (ext->d_tag);
8000 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8001 }
8002
9ea033b2
NC		 8003 free (edyn);
8004
8005 return 1;
8006}
8007
8008static int
2cf0635d 8009get_64bit_dynamic_section (FILE * file)
9ea033b2 8010{
2cf0635d
NC		 8011 Elf64_External_Dyn * edyn;
8012 Elf64_External_Dyn * ext;
8013 Elf_Internal_Dyn * entry;
103f02d3 8014
3f5e193b
NC		 8015 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8016 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8017 if (!edyn)
8018 return 0;
103f02d3 8019
ba2685cc
AM		 8020/* SGI's ELF has more than one section in the DYNAMIC segment, and we
8021 might not have the luxury of section headers. Look for the DT_NULL
8022 terminator to determine the number of entries. */
8023 for (ext = edyn, dynamic_nent = 0;
8024 (char *) ext < (char *) edyn + dynamic_size;
8025 ext++)
8026 {
8027 dynamic_nent++;
66543521 8028 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 8029 break;
8030 }
252b5132 8031
3f5e193b
NC		 8032 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8033 sizeof (* entry));
b2d38a17 8034 if (dynamic_section == NULL)
252b5132
RH		 8035 {
8036 error (_("Out of memory\n"));
8037 free (edyn);
8038 return 0;
8039 }
8040
fb514b26 8041 for (ext = edyn, entry = dynamic_section;
ba2685cc 8042 entry < dynamic_section + dynamic_nent;
fb514b26 8043 ext++, entry++)
252b5132 8044 {
66543521
AM		 8045 entry->d_tag = BYTE_GET (ext->d_tag);
8046 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8047 }
8048
8049 free (edyn);
8050
9ea033b2
NC		 8051 return 1;
8052}
8053
e9e44622
JJ		 8054static void
8055print_dynamic_flags (bfd_vma flags)
d1133906 8056{
e9e44622 8057 int first = 1;
13ae64f3 8058
d1133906
NC		 8059 while (flags)
8060 {
8061 bfd_vma flag;
8062
8063 flag = flags & - flags;
8064 flags &= ~ flag;
8065
e9e44622
JJ		 8066 if (first)
8067 first = 0;
8068 else
8069 putc (' ', stdout);
13ae64f3 8070
d1133906
NC		 8071 switch (flag)
8072 {
e9e44622
JJ		 8073 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
8074 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
8075 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
8076 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
8077 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 8078 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 8079 }
8080 }
e9e44622 8081 puts ("");
d1133906
NC		 8082}
8083
b2d38a17
NC		 8084/* Parse and display the contents of the dynamic section. */
8085
9ea033b2 8086static int
2cf0635d 8087process_dynamic_section (FILE * file)
9ea033b2 8088{
2cf0635d 8089 Elf_Internal_Dyn * entry;
9ea033b2
NC		 8090
8091 if (dynamic_size == 0)
8092 {
8093 if (do_dynamic)
b2d38a17 8094 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 8095
8096 return 1;
8097 }
8098
8099 if (is_32bit_elf)
8100 {
b2d38a17 8101 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 8102 return 0;
8103 }
b2d38a17 8104 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 8105 return 0;
8106
252b5132
RH		 8107 /* Find the appropriate symbol table. */
8108 if (dynamic_symbols == NULL)
8109 {
86dba8ee
AM		 8110 for (entry = dynamic_section;
8111 entry < dynamic_section + dynamic_nent;
8112 ++entry)
252b5132 8113 {
c8286bd1 8114 Elf_Internal_Shdr section;
252b5132
RH		 8115
8116 if (entry->d_tag != DT_SYMTAB)
8117 continue;
8118
8119 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8120
8121 /* Since we do not know how big the symbol table is,
8122 we default to reading in the entire file (!) and
8123 processing that. This is overkill, I know, but it
e3c8793a 8124 should work. */
d93f0186 8125 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 8126
fb52b2f4
NC		 8127 if (archive_file_offset != 0)
8128 section.sh_size = archive_file_size - section.sh_offset;
8129 else
8130 {
8131 if (fseek (file, 0, SEEK_END))
591a748a 8132 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 8133
8134 section.sh_size = ftell (file) - section.sh_offset;
8135 }
252b5132 8136
9ea033b2 8137 if (is_32bit_elf)
9ad5cbcf 8138 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 8139 else
9ad5cbcf 8140 section.sh_entsize = sizeof (Elf64_External_Sym);
252b5132 8141
ba5cdace 8142 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 8143 if (num_dynamic_syms < 1)
252b5132
RH		 8144 {
8145 error (_("Unable to determine the number of symbols to load\n"));
8146 continue;
8147 }
252b5132
RH		 8148 }
8149 }
8150
8151 /* Similarly find a string table. */
8152 if (dynamic_strings == NULL)
8153 {
86dba8ee
AM		 8154 for (entry = dynamic_section;
8155 entry < dynamic_section + dynamic_nent;
8156 ++entry)
252b5132
RH		 8157 {
8158 unsigned long offset;
b34976b6 8159 long str_tab_len;
252b5132
RH		 8160
8161 if (entry->d_tag != DT_STRTAB)
8162 continue;
8163
8164 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8165
8166 /* Since we do not know how big the string table is,
8167 we default to reading in the entire file (!) and
8168 processing that. This is overkill, I know, but it
e3c8793a 8169 should work. */
252b5132 8170
d93f0186 8171 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 8172
8173 if (archive_file_offset != 0)
8174 str_tab_len = archive_file_size - offset;
8175 else
8176 {
8177 if (fseek (file, 0, SEEK_END))
8178 error (_("Unable to seek to end of file\n"));
8179 str_tab_len = ftell (file) - offset;
8180 }
252b5132
RH		 8181
8182 if (str_tab_len < 1)
8183 {
8184 error
8185 (_("Unable to determine the length of the dynamic string table\n"));
8186 continue;
8187 }
8188
3f5e193b
NC		 8189 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8190 str_tab_len,
8191 _("dynamic string table"));
59245841 8192 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 8193 break;
8194 }
8195 }
8196
8197 /* And find the syminfo section if available. */
8198 if (dynamic_syminfo == NULL)
8199 {
3e8bba36 8200 unsigned long syminsz = 0;
252b5132 8201
86dba8ee
AM		 8202 for (entry = dynamic_section;
8203 entry < dynamic_section + dynamic_nent;
8204 ++entry)
252b5132
RH		 8205 {
8206 if (entry->d_tag == DT_SYMINENT)
8207 {
8208 /* Note: these braces are necessary to avoid a syntax
8209 error from the SunOS4 C compiler. */
8210 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
8211 }
8212 else if (entry->d_tag == DT_SYMINSZ)
8213 syminsz = entry->d_un.d_val;
8214 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 8215 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8216 syminsz);
252b5132
RH		 8217 }
8218
8219 if (dynamic_syminfo_offset != 0 && syminsz != 0)
8220 {
2cf0635d
NC		 8221 Elf_External_Syminfo * extsyminfo;
8222 Elf_External_Syminfo * extsym;
8223 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 8224
8225 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 8226 extsyminfo = (Elf_External_Syminfo *)
8227 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8228 _("symbol information"));
a6e9f9df
AM		 8229 if (!extsyminfo)
8230 return 0;
252b5132 8231
3f5e193b 8232 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 8233 if (dynamic_syminfo == NULL)
8234 {
8235 error (_("Out of memory\n"));
8236 return 0;
8237 }
8238
8239 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 8240 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8241 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8242 ++syminfo, ++extsym)
252b5132 8243 {
86dba8ee
AM		 8244 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8245 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 8246 }
8247
8248 free (extsyminfo);
8249 }
8250 }
8251
8252 if (do_dynamic && dynamic_addr)
86dba8ee
AM		 8253 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
8254 dynamic_addr, dynamic_nent);
252b5132
RH		 8255 if (do_dynamic)
8256 printf (_(" Tag Type Name/Value\n"));
8257
86dba8ee
AM		 8258 for (entry = dynamic_section;
8259 entry < dynamic_section + dynamic_nent;
8260 entry++)
252b5132
RH		 8261 {
8262 if (do_dynamic)
f7a99963 8263 {
2cf0635d 8264 const char * dtype;
e699b9ff 8265
f7a99963
NC		 8266 putchar (' ');
8267 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 8268 dtype = get_dynamic_type (entry->d_tag);
8269 printf (" (%s)%*s", dtype,
8270 ((is_32bit_elf ? 27 : 19)
8271 - (int) strlen (dtype)),
f7a99963
NC		 8272 " ");
8273 }
252b5132
RH		 8274
8275 switch (entry->d_tag)
8276 {
d1133906
NC		 8277 case DT_FLAGS:
8278 if (do_dynamic)
e9e44622 8279 print_dynamic_flags (entry->d_un.d_val);
d1133906 8280 break;
76da6bbe 8281
252b5132
RH		 8282 case DT_AUXILIARY:
8283 case DT_FILTER:
019148e4
L		 8284 case DT_CONFIG:
8285 case DT_DEPAUDIT:
8286 case DT_AUDIT:
252b5132
RH		 8287 if (do_dynamic)
8288 {
019148e4 8289 switch (entry->d_tag)
b34976b6 8290 {
019148e4
L		 8291 case DT_AUXILIARY:
8292 printf (_("Auxiliary library"));
8293 break;
8294
8295 case DT_FILTER:
8296 printf (_("Filter library"));
8297 break;
8298
b34976b6 8299 case DT_CONFIG:
019148e4
L		 8300 printf (_("Configuration file"));
8301 break;
8302
8303 case DT_DEPAUDIT:
8304 printf (_("Dependency audit library"));
8305 break;
8306
8307 case DT_AUDIT:
8308 printf (_("Audit library"));
8309 break;
8310 }
252b5132 8311
d79b3d50
NC		 8312 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8313 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8314 else
f7a99963
NC		 8315 {
8316 printf (": ");
8317 print_vma (entry->d_un.d_val, PREFIX_HEX);
8318 putchar ('\n');
8319 }
252b5132
RH		 8320 }
8321 break;
8322
dcefbbbd 8323 case DT_FEATURE:
252b5132
RH		 8324 if (do_dynamic)
8325 {
8326 printf (_("Flags:"));
86f55779 8327
252b5132
RH		 8328 if (entry->d_un.d_val == 0)
8329 printf (_(" None\n"));
8330 else
8331 {
8332 unsigned long int val = entry->d_un.d_val;
86f55779 8333
252b5132
RH		 8334 if (val & DTF_1_PARINIT)
8335 {
8336 printf (" PARINIT");
8337 val ^= DTF_1_PARINIT;
8338 }
dcefbbbd
L		 8339 if (val & DTF_1_CONFEXP)
8340 {
8341 printf (" CONFEXP");
8342 val ^= DTF_1_CONFEXP;
8343 }
252b5132
RH		 8344 if (val != 0)
8345 printf (" %lx", val);
8346 puts ("");
8347 }
8348 }
8349 break;
8350
8351 case DT_POSFLAG_1:
8352 if (do_dynamic)
8353 {
8354 printf (_("Flags:"));
86f55779 8355
252b5132
RH		 8356 if (entry->d_un.d_val == 0)
8357 printf (_(" None\n"));
8358 else
8359 {
8360 unsigned long int val = entry->d_un.d_val;
86f55779 8361
252b5132
RH		 8362 if (val & DF_P1_LAZYLOAD)
8363 {
8364 printf (" LAZYLOAD");
8365 val ^= DF_P1_LAZYLOAD;
8366 }
8367 if (val & DF_P1_GROUPPERM)
8368 {
8369 printf (" GROUPPERM");
8370 val ^= DF_P1_GROUPPERM;
8371 }
8372 if (val != 0)
8373 printf (" %lx", val);
8374 puts ("");
8375 }
8376 }
8377 break;
8378
8379 case DT_FLAGS_1:
8380 if (do_dynamic)
8381 {
8382 printf (_("Flags:"));
8383 if (entry->d_un.d_val == 0)
8384 printf (_(" None\n"));
8385 else
8386 {
8387 unsigned long int val = entry->d_un.d_val;
86f55779 8388
252b5132
RH		 8389 if (val & DF_1_NOW)
8390 {
8391 printf (" NOW");
8392 val ^= DF_1_NOW;
8393 }
8394 if (val & DF_1_GLOBAL)
8395 {
8396 printf (" GLOBAL");
8397 val ^= DF_1_GLOBAL;
8398 }
8399 if (val & DF_1_GROUP)
8400 {
8401 printf (" GROUP");
8402 val ^= DF_1_GROUP;
8403 }
8404 if (val & DF_1_NODELETE)
8405 {
8406 printf (" NODELETE");
8407 val ^= DF_1_NODELETE;
8408 }
8409 if (val & DF_1_LOADFLTR)
8410 {
8411 printf (" LOADFLTR");
8412 val ^= DF_1_LOADFLTR;
8413 }
8414 if (val & DF_1_INITFIRST)
8415 {
8416 printf (" INITFIRST");
8417 val ^= DF_1_INITFIRST;
8418 }
8419 if (val & DF_1_NOOPEN)
8420 {
8421 printf (" NOOPEN");
8422 val ^= DF_1_NOOPEN;
8423 }
8424 if (val & DF_1_ORIGIN)
8425 {
8426 printf (" ORIGIN");
8427 val ^= DF_1_ORIGIN;
8428 }
8429 if (val & DF_1_DIRECT)
8430 {
8431 printf (" DIRECT");
8432 val ^= DF_1_DIRECT;
8433 }
8434 if (val & DF_1_TRANS)
8435 {
8436 printf (" TRANS");
8437 val ^= DF_1_TRANS;
8438 }
8439 if (val & DF_1_INTERPOSE)
8440 {
8441 printf (" INTERPOSE");
8442 val ^= DF_1_INTERPOSE;
8443 }
f7db6139 8444 if (val & DF_1_NODEFLIB)
dcefbbbd 8445 {
f7db6139
L		 8446 printf (" NODEFLIB");
8447 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 8448 }
8449 if (val & DF_1_NODUMP)
8450 {
8451 printf (" NODUMP");
8452 val ^= DF_1_NODUMP;
8453 }
34b60028 8454 if (val & DF_1_CONFALT)
dcefbbbd 8455 {
34b60028
L		 8456 printf (" CONFALT");
8457 val ^= DF_1_CONFALT;
8458 }
8459 if (val & DF_1_ENDFILTEE)
8460 {
8461 printf (" ENDFILTEE");
8462 val ^= DF_1_ENDFILTEE;
8463 }
8464 if (val & DF_1_DISPRELDNE)
8465 {
8466 printf (" DISPRELDNE");
8467 val ^= DF_1_DISPRELDNE;
8468 }
8469 if (val & DF_1_DISPRELPND)
8470 {
8471 printf (" DISPRELPND");
8472 val ^= DF_1_DISPRELPND;
8473 }
8474 if (val & DF_1_NODIRECT)
8475 {
8476 printf (" NODIRECT");
8477 val ^= DF_1_NODIRECT;
8478 }
8479 if (val & DF_1_IGNMULDEF)
8480 {
8481 printf (" IGNMULDEF");
8482 val ^= DF_1_IGNMULDEF;
8483 }
8484 if (val & DF_1_NOKSYMS)
8485 {
8486 printf (" NOKSYMS");
8487 val ^= DF_1_NOKSYMS;
8488 }
8489 if (val & DF_1_NOHDR)
8490 {
8491 printf (" NOHDR");
8492 val ^= DF_1_NOHDR;
8493 }
8494 if (val & DF_1_EDITED)
8495 {
8496 printf (" EDITED");
8497 val ^= DF_1_EDITED;
8498 }
8499 if (val & DF_1_NORELOC)
8500 {
8501 printf (" NORELOC");
8502 val ^= DF_1_NORELOC;
8503 }
8504 if (val & DF_1_SYMINTPOSE)
8505 {
8506 printf (" SYMINTPOSE");
8507 val ^= DF_1_SYMINTPOSE;
8508 }
8509 if (val & DF_1_GLOBAUDIT)
8510 {
8511 printf (" GLOBAUDIT");
8512 val ^= DF_1_GLOBAUDIT;
8513 }
8514 if (val & DF_1_SINGLETON)
8515 {
8516 printf (" SINGLETON");
8517 val ^= DF_1_SINGLETON;
dcefbbbd 8518 }
252b5132
RH		 8519 if (val != 0)
8520 printf (" %lx", val);
8521 puts ("");
8522 }
8523 }
8524 break;
8525
8526 case DT_PLTREL:
566b0d53 8527 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 8528 if (do_dynamic)
8529 puts (get_dynamic_type (entry->d_un.d_val));
8530 break;
8531
8532 case DT_NULL :
8533 case DT_NEEDED :
8534 case DT_PLTGOT :
8535 case DT_HASH :
8536 case DT_STRTAB :
8537 case DT_SYMTAB :
8538 case DT_RELA :
8539 case DT_INIT :
8540 case DT_FINI :
8541 case DT_SONAME :
8542 case DT_RPATH :
8543 case DT_SYMBOLIC:
8544 case DT_REL :
8545 case DT_DEBUG :
8546 case DT_TEXTREL :
8547 case DT_JMPREL :
019148e4 8548 case DT_RUNPATH :
252b5132
RH		 8549 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8550
8551 if (do_dynamic)
8552 {
2cf0635d 8553 char * name;
252b5132 8554
d79b3d50
NC		 8555 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8556 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 8557 else
d79b3d50 8558 name = NULL;
252b5132
RH		 8559
8560 if (name)
8561 {
8562 switch (entry->d_tag)
8563 {
8564 case DT_NEEDED:
8565 printf (_("Shared library: [%s]"), name);
8566
18bd398b 8567 if (streq (name, program_interpreter))
f7a99963 8568 printf (_(" program interpreter"));
252b5132
RH		 8569 break;
8570
8571 case DT_SONAME:
f7a99963 8572 printf (_("Library soname: [%s]"), name);
252b5132
RH		 8573 break;
8574
8575 case DT_RPATH:
f7a99963 8576 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 8577 break;
8578
019148e4
L		 8579 case DT_RUNPATH:
8580 printf (_("Library runpath: [%s]"), name);
8581 break;
8582
252b5132 8583 default:
f7a99963
NC		 8584 print_vma (entry->d_un.d_val, PREFIX_HEX);
8585 break;
252b5132
RH		 8586 }
8587 }
8588 else
f7a99963
NC		 8589 print_vma (entry->d_un.d_val, PREFIX_HEX);
8590
8591 putchar ('\n');
252b5132
RH		 8592 }
8593 break;
8594
8595 case DT_PLTRELSZ:
8596 case DT_RELASZ :
8597 case DT_STRSZ :
8598 case DT_RELSZ :
8599 case DT_RELAENT :
8600 case DT_SYMENT :
8601 case DT_RELENT :
566b0d53 8602 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 8603 case DT_PLTPADSZ:
8604 case DT_MOVEENT :
8605 case DT_MOVESZ :
8606 case DT_INIT_ARRAYSZ:
8607 case DT_FINI_ARRAYSZ:
047b2264
JJ		 8608 case DT_GNU_CONFLICTSZ:
8609 case DT_GNU_LIBLISTSZ:
252b5132 8610 if (do_dynamic)
f7a99963
NC		 8611 {
8612 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 8613 printf (_(" (bytes)\n"));
f7a99963 8614 }
252b5132
RH		 8615 break;
8616
8617 case DT_VERDEFNUM:
8618 case DT_VERNEEDNUM:
8619 case DT_RELACOUNT:
8620 case DT_RELCOUNT:
8621 if (do_dynamic)
f7a99963
NC		 8622 {
8623 print_vma (entry->d_un.d_val, UNSIGNED);
8624 putchar ('\n');
8625 }
252b5132
RH		 8626 break;
8627
8628 case DT_SYMINSZ:
8629 case DT_SYMINENT:
8630 case DT_SYMINFO:
8631 case DT_USED:
8632 case DT_INIT_ARRAY:
8633 case DT_FINI_ARRAY:
8634 if (do_dynamic)
8635 {
d79b3d50
NC		 8636 if (entry->d_tag == DT_USED
8637 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 8638 {
2cf0635d 8639 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 8640
b34976b6 8641 if (*name)
252b5132
RH		 8642 {
8643 printf (_("Not needed object: [%s]\n"), name);
8644 break;
8645 }
8646 }
103f02d3 8647
f7a99963
NC		 8648 print_vma (entry->d_un.d_val, PREFIX_HEX);
8649 putchar ('\n');
252b5132
RH		 8650 }
8651 break;
8652
8653 case DT_BIND_NOW:
8654 /* The value of this entry is ignored. */
35b1837e
AM		 8655 if (do_dynamic)
8656 putchar ('\n');
252b5132 8657 break;
103f02d3 8658
047b2264
JJ		 8659 case DT_GNU_PRELINKED:
8660 if (do_dynamic)
8661 {
2cf0635d 8662 struct tm * tmp;
91d6fa6a 8663 time_t atime = entry->d_un.d_val;
047b2264 8664
91d6fa6a 8665 tmp = gmtime (&atime);
047b2264
JJ		 8666 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8667 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8668 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8669
8670 }
8671 break;
8672
fdc90cb4
JJ		 8673 case DT_GNU_HASH:
8674 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8675 if (do_dynamic)
8676 {
8677 print_vma (entry->d_un.d_val, PREFIX_HEX);
8678 putchar ('\n');
8679 }
8680 break;
8681
252b5132
RH		 8682 default:
8683 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 8684 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 8685 entry->d_un.d_val;
8686
8687 if (do_dynamic)
8688 {
8689 switch (elf_header.e_machine)
8690 {
8691 case EM_MIPS:
4fe85591 8692 case EM_MIPS_RS3_LE:
b2d38a17 8693 dynamic_section_mips_val (entry);
252b5132 8694 break;
103f02d3 8695 case EM_PARISC:
b2d38a17 8696 dynamic_section_parisc_val (entry);
103f02d3 8697 break;
ecc51f48 8698 case EM_IA_64:
b2d38a17 8699 dynamic_section_ia64_val (entry);
ecc51f48 8700 break;
252b5132 8701 default:
f7a99963
NC		 8702 print_vma (entry->d_un.d_val, PREFIX_HEX);
8703 putchar ('\n');
252b5132
RH		 8704 }
8705 }
8706 break;
8707 }
8708 }
8709
8710 return 1;
8711}
8712
8713static char *
d3ba0551 8714get_ver_flags (unsigned int flags)
252b5132 8715{
b34976b6 8716 static char buff[32];
252b5132
RH		 8717
8718 buff[0] = 0;
8719
8720 if (flags == 0)
8721 return _("none");
8722
8723 if (flags & VER_FLG_BASE)
8724 strcat (buff, "BASE ");
8725
8726 if (flags & VER_FLG_WEAK)
8727 {
8728 if (flags & VER_FLG_BASE)
8729 strcat (buff, "| ");
8730
8731 strcat (buff, "WEAK ");
8732 }
8733
44ec90b9
RO		 8734 if (flags & VER_FLG_INFO)
8735 {
8736 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8737 strcat (buff, "| ");
8738
8739 strcat (buff, "INFO ");
8740 }
8741
8742 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 8743 strcat (buff, _("| <unknown>"));
252b5132
RH		 8744
8745 return buff;
8746}
8747
8748/* Display the contents of the version sections. */
98fb390a 8749
252b5132 8750static int
2cf0635d 8751process_version_sections (FILE * file)
252b5132 8752{
2cf0635d 8753 Elf_Internal_Shdr * section;
b34976b6
AM		 8754 unsigned i;
8755 int found = 0;
252b5132
RH		 8756
8757 if (! do_version)
8758 return 1;
8759
8760 for (i = 0, section = section_headers;
8761 i < elf_header.e_shnum;
b34976b6 8762 i++, section++)
252b5132
RH		 8763 {
8764 switch (section->sh_type)
8765 {
8766 case SHT_GNU_verdef:
8767 {
2cf0635d 8768 Elf_External_Verdef * edefs;
b34976b6
AM		 8769 unsigned int idx;
8770 unsigned int cnt;
2cf0635d 8771 char * endbuf;
252b5132
RH		 8772
8773 found = 1;
8774
8775 printf
72de5009 8776 (_("\nVersion definition section '%s' contains %u entries:\n"),
252b5132
RH		 8777 SECTION_NAME (section), section->sh_info);
8778
8779 printf (_(" Addr: 0x"));
8780 printf_vma (section->sh_addr);
72de5009 8781 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8782 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8783 section->sh_link < elf_header.e_shnum
8784 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8785 : _("<corrupt>"));
252b5132 8786
3f5e193b
NC		 8787 edefs = (Elf_External_Verdef *)
8788 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8789 _("version definition section"));
a6e9f9df
AM		 8790 if (!edefs)
8791 break;
59245841 8792 endbuf = (char *) edefs + section->sh_size;
252b5132 8793
b34976b6 8794 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 8795 {
2cf0635d
NC		 8796 char * vstart;
8797 Elf_External_Verdef * edef;
b34976b6 8798 Elf_Internal_Verdef ent;
2cf0635d 8799 Elf_External_Verdaux * eaux;
b34976b6
AM		 8800 Elf_Internal_Verdaux aux;
8801 int j;
8802 int isum;
103f02d3 8803
7e26601c
NC		 8804 /* Check for very large indicies. */
8805 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 8806 break;
8807
252b5132 8808 vstart = ((char *) edefs) + idx;
54806181
AM		 8809 if (vstart + sizeof (*edef) > endbuf)
8810 break;
252b5132
RH		 8811
8812 edef = (Elf_External_Verdef *) vstart;
8813
8814 ent.vd_version = BYTE_GET (edef->vd_version);
8815 ent.vd_flags = BYTE_GET (edef->vd_flags);
8816 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
8817 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
8818 ent.vd_hash = BYTE_GET (edef->vd_hash);
8819 ent.vd_aux = BYTE_GET (edef->vd_aux);
8820 ent.vd_next = BYTE_GET (edef->vd_next);
8821
8822 printf (_(" %#06x: Rev: %d Flags: %s"),
8823 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8824
8825 printf (_(" Index: %d Cnt: %d "),
8826 ent.vd_ndx, ent.vd_cnt);
8827
dd24e3da 8828 /* Check for overflow. */
7e26601c 8829 if (ent.vd_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 8830 break;
8831
252b5132
RH		 8832 vstart += ent.vd_aux;
8833
8834 eaux = (Elf_External_Verdaux *) vstart;
8835
8836 aux.vda_name = BYTE_GET (eaux->vda_name);
8837 aux.vda_next = BYTE_GET (eaux->vda_next);
8838
d79b3d50
NC		 8839 if (VALID_DYNAMIC_NAME (aux.vda_name))
8840 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8841 else
8842 printf (_("Name index: %ld\n"), aux.vda_name);
8843
8844 isum = idx + ent.vd_aux;
8845
b34976b6 8846 for (j = 1; j < ent.vd_cnt; j++)
252b5132 8847 {
dd24e3da 8848 /* Check for overflow. */
7e26601c 8849 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 8850 break;
8851
252b5132
RH		 8852 isum += aux.vda_next;
8853 vstart += aux.vda_next;
8854
8855 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 8856 if (vstart + sizeof (*eaux) > endbuf)
8857 break;
252b5132
RH		 8858
8859 aux.vda_name = BYTE_GET (eaux->vda_name);
8860 aux.vda_next = BYTE_GET (eaux->vda_next);
8861
d79b3d50 8862 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 8863 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 8864 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8865 else
8866 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8867 isum, j, aux.vda_name);
8868 }
dd24e3da 8869
54806181
AM		 8870 if (j < ent.vd_cnt)
8871 printf (_(" Version def aux past end of section\n"));
252b5132
RH		 8872
8873 idx += ent.vd_next;
8874 }
dd24e3da 8875
54806181
AM		 8876 if (cnt < section->sh_info)
8877 printf (_(" Version definition past end of section\n"));
252b5132
RH		 8878
8879 free (edefs);
8880 }
8881 break;
103f02d3 8882
252b5132
RH		 8883 case SHT_GNU_verneed:
8884 {
2cf0635d 8885 Elf_External_Verneed * eneed;
b34976b6
AM		 8886 unsigned int idx;
8887 unsigned int cnt;
2cf0635d 8888 char * endbuf;
252b5132
RH		 8889
8890 found = 1;
8891
72de5009 8892 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
252b5132
RH		 8893 SECTION_NAME (section), section->sh_info);
8894
8895 printf (_(" Addr: 0x"));
8896 printf_vma (section->sh_addr);
72de5009 8897 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8898 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8899 section->sh_link < elf_header.e_shnum
8900 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8901 : _("<corrupt>"));
252b5132 8902
3f5e193b
NC		 8903 eneed = (Elf_External_Verneed *) get_data (NULL, file,
8904 section->sh_offset, 1,
8905 section->sh_size,
9cf03b7e 8906 _("Version Needs section"));
a6e9f9df
AM		 8907 if (!eneed)
8908 break;
59245841 8909 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 8910
8911 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8912 {
2cf0635d 8913 Elf_External_Verneed * entry;
b34976b6
AM		 8914 Elf_Internal_Verneed ent;
8915 int j;
8916 int isum;
2cf0635d 8917 char * vstart;
252b5132 8918
7e26601c 8919 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 8920 break;
8921
252b5132 8922 vstart = ((char *) eneed) + idx;
54806181
AM		 8923 if (vstart + sizeof (*entry) > endbuf)
8924 break;
252b5132
RH		 8925
8926 entry = (Elf_External_Verneed *) vstart;
8927
8928 ent.vn_version = BYTE_GET (entry->vn_version);
8929 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
8930 ent.vn_file = BYTE_GET (entry->vn_file);
8931 ent.vn_aux = BYTE_GET (entry->vn_aux);
8932 ent.vn_next = BYTE_GET (entry->vn_next);
8933
8934 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
8935
d79b3d50
NC		 8936 if (VALID_DYNAMIC_NAME (ent.vn_file))
8937 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 8938 else
8939 printf (_(" File: %lx"), ent.vn_file);
8940
8941 printf (_(" Cnt: %d\n"), ent.vn_cnt);
8942
dd24e3da 8943 /* Check for overflow. */
7e26601c 8944 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 8945 break;
8946
252b5132
RH		 8947 vstart += ent.vn_aux;
8948
8949 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8950 {
2cf0635d 8951 Elf_External_Vernaux * eaux;
b34976b6 8952 Elf_Internal_Vernaux aux;
252b5132 8953
54806181
AM		 8954 if (vstart + sizeof (*eaux) > endbuf)
8955 break;
252b5132
RH		 8956 eaux = (Elf_External_Vernaux *) vstart;
8957
8958 aux.vna_hash = BYTE_GET (eaux->vna_hash);
8959 aux.vna_flags = BYTE_GET (eaux->vna_flags);
8960 aux.vna_other = BYTE_GET (eaux->vna_other);
8961 aux.vna_name = BYTE_GET (eaux->vna_name);
8962 aux.vna_next = BYTE_GET (eaux->vna_next);
8963
d79b3d50 8964 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 8965 printf (_(" %#06x: Name: %s"),
d79b3d50 8966 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 8967 else
ecc2063b 8968 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 8969 isum, aux.vna_name);
8970
8971 printf (_(" Flags: %s Version: %d\n"),
8972 get_ver_flags (aux.vna_flags), aux.vna_other);
8973
dd24e3da 8974 /* Check for overflow. */
7e26601c 8975 if (aux.vna_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 8976 break;
8977
252b5132
RH		 8978 isum += aux.vna_next;
8979 vstart += aux.vna_next;
8980 }
9cf03b7e 8981
54806181 8982 if (j < ent.vn_cnt)
9cf03b7e 8983 warn (_("Missing Version Needs auxillary information\n"));
252b5132 8984
bcf83b2a 8985 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
c24cf8b6
NC		 8986 {
8987 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
8988 cnt = section->sh_info;
8989 break;
8990 }
252b5132
RH		 8991 idx += ent.vn_next;
8992 }
9cf03b7e 8993
54806181 8994 if (cnt < section->sh_info)
9cf03b7e 8995 warn (_("Missing Version Needs information\n"));
103f02d3 8996
252b5132
RH		 8997 free (eneed);
8998 }
8999 break;
9000
9001 case SHT_GNU_versym:
9002 {
2cf0635d 9003 Elf_Internal_Shdr * link_section;
b34976b6
AM		 9004 int total;
9005 int cnt;
2cf0635d
NC		 9006 unsigned char * edata;
9007 unsigned short * data;
9008 char * strtab;
9009 Elf_Internal_Sym * symbols;
9010 Elf_Internal_Shdr * string_sec;
ba5cdace 9011 unsigned long num_syms;
d3ba0551 9012 long off;
252b5132 9013
4fbb74a6 9014 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9015 break;
9016
4fbb74a6 9017 link_section = section_headers + section->sh_link;
08d8fa11 9018 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 9019
4fbb74a6 9020 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9021 break;
9022
252b5132
RH		 9023 found = 1;
9024
ba5cdace 9025 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 9026 if (symbols == NULL)
9027 break;
252b5132 9028
4fbb74a6 9029 string_sec = section_headers + link_section->sh_link;
252b5132 9030
3f5e193b
NC		 9031 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9032 string_sec->sh_size,
9033 _("version string table"));
a6e9f9df 9034 if (!strtab)
0429c154
MS		 9035 {
9036 free (symbols);
9037 break;
9038 }
252b5132
RH		 9039
9040 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
9041 SECTION_NAME (section), total);
9042
9043 printf (_(" Addr: "));
9044 printf_vma (section->sh_addr);
72de5009 9045 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9046 (unsigned long) section->sh_offset, section->sh_link,
252b5132
RH		 9047 SECTION_NAME (link_section));
9048
d3ba0551
AM		 9049 off = offset_from_vma (file,
9050 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9051 total * sizeof (short));
3f5e193b
NC		 9052 edata = (unsigned char *) get_data (NULL, file, off, total,
9053 sizeof (short),
9054 _("version symbol data"));
a6e9f9df
AM		 9055 if (!edata)
9056 {
9057 free (strtab);
0429c154 9058 free (symbols);
a6e9f9df
AM		 9059 break;
9060 }
252b5132 9061
3f5e193b 9062 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 9063
9064 for (cnt = total; cnt --;)
b34976b6
AM		 9065 data[cnt] = byte_get (edata + cnt * sizeof (short),
9066 sizeof (short));
252b5132
RH		 9067
9068 free (edata);
9069
9070 for (cnt = 0; cnt < total; cnt += 4)
9071 {
9072 int j, nn;
00d93f34 9073 int check_def, check_need;
2cf0635d 9074 char * name;
252b5132
RH		 9075
9076 printf (" %03x:", cnt);
9077
9078 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 9079 switch (data[cnt + j])
252b5132
RH		 9080 {
9081 case 0:
9082 fputs (_(" 0 (*local*) "), stdout);
9083 break;
9084
9085 case 1:
9086 fputs (_(" 1 (*global*) "), stdout);
9087 break;
9088
9089 default:
c244d050
NC		 9090 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9091 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 9092
dd24e3da 9093 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 9094 array, break to avoid an out-of-bounds read. */
9095 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 9096 {
9097 warn (_("invalid index into symbol array\n"));
9098 break;
9099 }
9100
00d93f34
JJ		 9101 check_def = 1;
9102 check_need = 1;
4fbb74a6
AM		 9103 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9104 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 9105 != SHT_NOBITS)
252b5132 9106 {
b34976b6 9107 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 9108 check_def = 0;
9109 else
9110 check_need = 0;
252b5132 9111 }
00d93f34
JJ		 9112
9113 if (check_need
b34976b6 9114 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 9115 {
b34976b6
AM		 9116 Elf_Internal_Verneed ivn;
9117 unsigned long offset;
252b5132 9118
d93f0186
NC		 9119 offset = offset_from_vma
9120 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9121 sizeof (Elf_External_Verneed));
252b5132 9122
b34976b6 9123 do
252b5132 9124 {
b34976b6
AM		 9125 Elf_Internal_Vernaux ivna;
9126 Elf_External_Verneed evn;
9127 Elf_External_Vernaux evna;
9128 unsigned long a_off;
252b5132 9129
59245841
NC		 9130 if (get_data (&evn, file, offset, sizeof (evn), 1,
9131 _("version need")) == NULL)
9132 break;
0b4362b0 9133
252b5132
RH		 9134 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9135 ivn.vn_next = BYTE_GET (evn.vn_next);
9136
9137 a_off = offset + ivn.vn_aux;
9138
9139 do
9140 {
59245841
NC		 9141 if (get_data (&evna, file, a_off, sizeof (evna),
9142 1, _("version need aux (2)")) == NULL)
9143 {
9144 ivna.vna_next = 0;
9145 ivna.vna_other = 0;
9146 }
9147 else
9148 {
9149 ivna.vna_next = BYTE_GET (evna.vna_next);
9150 ivna.vna_other = BYTE_GET (evna.vna_other);
9151 }
252b5132
RH		 9152
9153 a_off += ivna.vna_next;
9154 }
b34976b6 9155 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 9156 && ivna.vna_next != 0);
9157
b34976b6 9158 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 9159 {
9160 ivna.vna_name = BYTE_GET (evna.vna_name);
9161
54806181
AM		 9162 if (ivna.vna_name >= string_sec->sh_size)
9163 name = _("*invalid*");
9164 else
9165 name = strtab + ivna.vna_name;
252b5132 9166 nn += printf ("(%s%-*s",
16062207
ILT		 9167 name,
9168 12 - (int) strlen (name),
252b5132 9169 ")");
00d93f34 9170 check_def = 0;
252b5132
RH		 9171 break;
9172 }
9173
9174 offset += ivn.vn_next;
9175 }
9176 while (ivn.vn_next);
9177 }
00d93f34 9178
b34976b6
AM		 9179 if (check_def && data[cnt + j] != 0x8001
9180 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9181 {
b34976b6
AM		 9182 Elf_Internal_Verdef ivd;
9183 Elf_External_Verdef evd;
9184 unsigned long offset;
252b5132 9185
d93f0186
NC		 9186 offset = offset_from_vma
9187 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9188 sizeof evd);
252b5132
RH		 9189
9190 do
9191 {
59245841
NC		 9192 if (get_data (&evd, file, offset, sizeof (evd), 1,
9193 _("version def")) == NULL)
9194 {
9195 ivd.vd_next = 0;
9196 ivd.vd_ndx = 0;
9197 }
9198 else
9199 {
9200 ivd.vd_next = BYTE_GET (evd.vd_next);
9201 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9202 }
252b5132
RH		 9203
9204 offset += ivd.vd_next;
9205 }
c244d050 9206 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 9207 && ivd.vd_next != 0);
9208
c244d050 9209 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 9210 {
b34976b6
AM		 9211 Elf_External_Verdaux evda;
9212 Elf_Internal_Verdaux ivda;
252b5132
RH		 9213
9214 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9215
59245841
NC		 9216 if (get_data (&evda, file,
9217 offset - ivd.vd_next + ivd.vd_aux,
9218 sizeof (evda), 1,
9219 _("version def aux")) == NULL)
9220 break;
252b5132
RH		 9221
9222 ivda.vda_name = BYTE_GET (evda.vda_name);
9223
54806181
AM		 9224 if (ivda.vda_name >= string_sec->sh_size)
9225 name = _("*invalid*");
9226 else
9227 name = strtab + ivda.vda_name;
252b5132 9228 nn += printf ("(%s%-*s",
16062207
ILT		 9229 name,
9230 12 - (int) strlen (name),
252b5132
RH		 9231 ")");
9232 }
9233 }
9234
9235 if (nn < 18)
9236 printf ("%*c", 18 - nn, ' ');
9237 }
9238
9239 putchar ('\n');
9240 }
9241
9242 free (data);
9243 free (strtab);
9244 free (symbols);
9245 }
9246 break;
103f02d3 9247
252b5132
RH		 9248 default:
9249 break;
9250 }
9251 }
9252
9253 if (! found)
9254 printf (_("\nNo version information found in this file.\n"));
9255
9256 return 1;
9257}
9258
d1133906 9259static const char *
d3ba0551 9260get_symbol_binding (unsigned int binding)
252b5132 9261{
b34976b6 9262 static char buff[32];
252b5132
RH		 9263
9264 switch (binding)
9265 {
b34976b6
AM		 9266 case STB_LOCAL: return "LOCAL";
9267 case STB_GLOBAL: return "GLOBAL";
9268 case STB_WEAK: return "WEAK";
252b5132
RH		 9269 default:
9270 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 9271 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9272 binding);
252b5132 9273 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 9274 {
9275 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 9276 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9277 /* GNU is still using the default value 0. */
3e7a7d11
NC		 9278 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9279 return "UNIQUE";
9280 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9281 }
252b5132 9282 else
e9e44622 9283 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 9284 return buff;
9285 }
9286}
9287
d1133906 9288static const char *
d3ba0551 9289get_symbol_type (unsigned int type)
252b5132 9290{
b34976b6 9291 static char buff[32];
252b5132
RH		 9292
9293 switch (type)
9294 {
b34976b6
AM		 9295 case STT_NOTYPE: return "NOTYPE";
9296 case STT_OBJECT: return "OBJECT";
9297 case STT_FUNC: return "FUNC";
9298 case STT_SECTION: return "SECTION";
9299 case STT_FILE: return "FILE";
9300 case STT_COMMON: return "COMMON";
9301 case STT_TLS: return "TLS";
15ab5209
DB		 9302 case STT_RELC: return "RELC";
9303 case STT_SRELC: return "SRELC";
252b5132
RH		 9304 default:
9305 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 9306 {
3510a7b8
NC		 9307 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
9308 return "THUMB_FUNC";
103f02d3 9309
351b4b40 9310 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 9311 return "REGISTER";
9312
9313 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
9314 return "PARISC_MILLI";
9315
e9e44622 9316 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 9317 }
252b5132 9318 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 9319 {
9320 if (elf_header.e_machine == EM_PARISC)
9321 {
9322 if (type == STT_HP_OPAQUE)
9323 return "HP_OPAQUE";
9324 if (type == STT_HP_STUB)
9325 return "HP_STUB";
9326 }
9327
d8045f23 9328 if (type == STT_GNU_IFUNC
9c55345c 9329 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 9330 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 9331 /* GNU is still using the default value 0. */
d8045f23
NC		 9332 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9333 return "IFUNC";
9334
e9e44622 9335 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 9336 }
252b5132 9337 else
e9e44622 9338 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 9339 return buff;
9340 }
9341}
9342
d1133906 9343static const char *
d3ba0551 9344get_symbol_visibility (unsigned int visibility)
d1133906
NC		 9345{
9346 switch (visibility)
9347 {
b34976b6
AM		 9348 case STV_DEFAULT: return "DEFAULT";
9349 case STV_INTERNAL: return "INTERNAL";
9350 case STV_HIDDEN: return "HIDDEN";
d1133906
NC		 9351 case STV_PROTECTED: return "PROTECTED";
9352 default: abort ();
9353 }
9354}
9355
5e2b0d47
NC		 9356static const char *
9357get_mips_symbol_other (unsigned int other)
9358{
9359 switch (other)
9360 {
df58fc94
RS		 9361 case STO_OPTIONAL:
9362 return "OPTIONAL";
9363 case STO_MIPS_PLT:
9364 return "MIPS PLT";
9365 case STO_MIPS_PIC:
9366 return "MIPS PIC";
9367 case STO_MICROMIPS:
9368 return "MICROMIPS";
9369 case STO_MICROMIPS | STO_MIPS_PIC:
9370 return "MICROMIPS, MIPS PIC";
9371 case STO_MIPS16:
9372 return "MIPS16";
9373 default:
9374 return NULL;
5e2b0d47
NC		 9375 }
9376}
9377
28f997cf
TG		 9378static const char *
9379get_ia64_symbol_other (unsigned int other)
9380{
9381 if (is_ia64_vms ())
9382 {
9383 static char res[32];
9384
9385 res[0] = 0;
9386
9387 /* Function types is for images and .STB files only. */
9388 switch (elf_header.e_type)
9389 {
9390 case ET_DYN:
9391 case ET_EXEC:
9392 switch (VMS_ST_FUNC_TYPE (other))
9393 {
9394 case VMS_SFT_CODE_ADDR:
9395 strcat (res, " CA");
9396 break;
9397 case VMS_SFT_SYMV_IDX:
9398 strcat (res, " VEC");
9399 break;
9400 case VMS_SFT_FD:
9401 strcat (res, " FD");
9402 break;
9403 case VMS_SFT_RESERVE:
9404 strcat (res, " RSV");
9405 break;
9406 default:
9407 abort ();
9408 }
9409 break;
9410 default:
9411 break;
9412 }
9413 switch (VMS_ST_LINKAGE (other))
9414 {
9415 case VMS_STL_IGNORE:
9416 strcat (res, " IGN");
9417 break;
9418 case VMS_STL_RESERVE:
9419 strcat (res, " RSV");
9420 break;
9421 case VMS_STL_STD:
9422 strcat (res, " STD");
9423 break;
9424 case VMS_STL_LNK:
9425 strcat (res, " LNK");
9426 break;
9427 default:
9428 abort ();
9429 }
9430
9431 if (res[0] != 0)
9432 return res + 1;
9433 else
9434 return res;
9435 }
9436 return NULL;
9437}
9438
6911b7dc
AM		 9439static const char *
9440get_ppc64_symbol_other (unsigned int other)
9441{
9442 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
9443 {
9444 static char buf[32];
9445 snprintf (buf, sizeof buf, _("<localentry>: %d"),
9446 PPC64_LOCAL_ENTRY_OFFSET (other));
9447 return buf;
9448 }
9449 return NULL;
9450}
9451
5e2b0d47
NC		 9452static const char *
9453get_symbol_other (unsigned int other)
9454{
9455 const char * result = NULL;
9456 static char buff [32];
9457
9458 if (other == 0)
9459 return "";
9460
9461 switch (elf_header.e_machine)
9462 {
9463 case EM_MIPS:
9464 result = get_mips_symbol_other (other);
28f997cf
TG		 9465 break;
9466 case EM_IA_64:
9467 result = get_ia64_symbol_other (other);
9468 break;
6911b7dc
AM		 9469 case EM_PPC64:
9470 result = get_ppc64_symbol_other (other);
9471 break;
5e2b0d47
NC		 9472 default:
9473 break;
9474 }
9475
9476 if (result)
9477 return result;
9478
9479 snprintf (buff, sizeof buff, _("<other>: %x"), other);
9480 return buff;
9481}
9482
d1133906 9483static const char *
d3ba0551 9484get_symbol_index_type (unsigned int type)
252b5132 9485{
b34976b6 9486 static char buff[32];
5cf1065c 9487
252b5132
RH		 9488 switch (type)
9489 {
b34976b6
AM		 9490 case SHN_UNDEF: return "UND";
9491 case SHN_ABS: return "ABS";
9492 case SHN_COMMON: return "COM";
252b5132 9493 default:
9ce701e2
L		 9494 if (type == SHN_IA_64_ANSI_COMMON
9495 && elf_header.e_machine == EM_IA_64
9496 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
9497 return "ANSI_COM";
8a9036a4 9498 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 9499 || elf_header.e_machine == EM_L1OM
9500 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 9501 && type == SHN_X86_64_LCOMMON)
9502 return "LARGE_COM";
ac145307
BS		 9503 else if ((type == SHN_MIPS_SCOMMON
9504 && elf_header.e_machine == EM_MIPS)
9505 || (type == SHN_TIC6X_SCOMMON
9506 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 9507 return "SCOM";
9508 else if (type == SHN_MIPS_SUNDEFINED
9509 && elf_header.e_machine == EM_MIPS)
9510 return "SUND";
9ce701e2 9511 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 9512 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 9513 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 9514 sprintf (buff, "OS [0x%04x]", type & 0xffff);
9515 else if (type >= SHN_LORESERVE)
9516 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4
L		 9517 else if (type >= elf_header.e_shnum)
9518 sprintf (buff, "bad section index[%3d]", type);
252b5132 9519 else
232e7cb8 9520 sprintf (buff, "%3d", type);
5cf1065c 9521 break;
252b5132 9522 }
5cf1065c
NC		 9523
9524 return buff;
252b5132
RH		 9525}
9526
66543521 9527static bfd_vma *
2cf0635d 9528get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
252b5132 9529{
2cf0635d
NC		 9530 unsigned char * e_data;
9531 bfd_vma * i_data;
252b5132 9532
3f5e193b 9533 e_data = (unsigned char *) cmalloc (number, ent_size);
252b5132
RH		 9534
9535 if (e_data == NULL)
9536 {
9537 error (_("Out of memory\n"));
9538 return NULL;
9539 }
9540
66543521 9541 if (fread (e_data, ent_size, number, file) != number)
252b5132
RH		 9542 {
9543 error (_("Unable to read in dynamic data\n"));
9544 return NULL;
9545 }
9546
3f5e193b 9547 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
252b5132
RH		 9548
9549 if (i_data == NULL)
9550 {
9551 error (_("Out of memory\n"));
9552 free (e_data);
9553 return NULL;
9554 }
9555
9556 while (number--)
66543521 9557 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 9558
9559 free (e_data);
9560
9561 return i_data;
9562}
9563
6bd1a22c
L		 9564static void
9565print_dynamic_symbol (bfd_vma si, unsigned long hn)
9566{
2cf0635d 9567 Elf_Internal_Sym * psym;
6bd1a22c
L		 9568 int n;
9569
9570 psym = dynamic_symbols + si;
9571
9572 n = print_vma (si, DEC_5);
9573 if (n < 5)
0b4362b0 9574 fputs (&" "[n], stdout);
6bd1a22c
L		 9575 printf (" %3lu: ", hn);
9576 print_vma (psym->st_value, LONG_HEX);
9577 putchar (' ');
9578 print_vma (psym->st_size, DEC_5);
9579
f4be36b3
AM		 9580 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9581 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9582 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 9583 /* Check to see if any other bits in the st_other field are set.
9584 Note - displaying this information disrupts the layout of the
9585 table being generated, but for the moment this case is very
9586 rare. */
9587 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9588 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9589 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9590 if (VALID_DYNAMIC_NAME (psym->st_name))
9591 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9592 else
2b692964 9593 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 9594 putchar ('\n');
9595}
9596
e3c8793a 9597/* Dump the symbol table. */
252b5132 9598static int
2cf0635d 9599process_symbol_table (FILE * file)
252b5132 9600{
2cf0635d 9601 Elf_Internal_Shdr * section;
66543521
AM		 9602 bfd_vma nbuckets = 0;
9603 bfd_vma nchains = 0;
2cf0635d
NC		 9604 bfd_vma * buckets = NULL;
9605 bfd_vma * chains = NULL;
fdc90cb4 9606 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 9607 bfd_vma * gnubuckets = NULL;
9608 bfd_vma * gnuchains = NULL;
6bd1a22c 9609 bfd_vma gnusymidx = 0;
252b5132 9610
2c610e4b 9611 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 9612 return 1;
9613
6bd1a22c
L		 9614 if (dynamic_info[DT_HASH]
9615 && (do_histogram
2c610e4b
L		 9616 || (do_using_dynamic
9617 && !do_dyn_syms
9618 && dynamic_strings != NULL)))
252b5132 9619 {
66543521
AM		 9620 unsigned char nb[8];
9621 unsigned char nc[8];
9622 int hash_ent_size = 4;
9623
9624 if ((elf_header.e_machine == EM_ALPHA
9625 || elf_header.e_machine == EM_S390
9626 || elf_header.e_machine == EM_S390_OLD)
9627 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
9628 hash_ent_size = 8;
9629
fb52b2f4
NC		 9630 if (fseek (file,
9631 (archive_file_offset
9632 + offset_from_vma (file, dynamic_info[DT_HASH],
9633 sizeof nb + sizeof nc)),
d93f0186 9634 SEEK_SET))
252b5132 9635 {
591a748a 9636 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9637 goto no_hash;
252b5132
RH		 9638 }
9639
66543521 9640 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 9641 {
9642 error (_("Failed to read in number of buckets\n"));
d3a44ec6 9643 goto no_hash;
252b5132
RH		 9644 }
9645
66543521 9646 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 9647 {
9648 error (_("Failed to read in number of chains\n"));
d3a44ec6 9649 goto no_hash;
252b5132
RH		 9650 }
9651
66543521
AM		 9652 nbuckets = byte_get (nb, hash_ent_size);
9653 nchains = byte_get (nc, hash_ent_size);
252b5132 9654
66543521
AM		 9655 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
9656 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 9657
d3a44ec6 9658 no_hash:
252b5132 9659 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 9660 {
9661 if (do_using_dynamic)
9662 return 0;
9663 free (buckets);
9664 free (chains);
9665 buckets = NULL;
9666 chains = NULL;
9667 nbuckets = 0;
9668 nchains = 0;
9669 }
252b5132
RH		 9670 }
9671
6bd1a22c
L		 9672 if (dynamic_info_DT_GNU_HASH
9673 && (do_histogram
2c610e4b
L		 9674 || (do_using_dynamic
9675 && !do_dyn_syms
9676 && dynamic_strings != NULL)))
252b5132 9677 {
6bd1a22c
L		 9678 unsigned char nb[16];
9679 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
9680 bfd_vma buckets_vma;
9681
9682 if (fseek (file,
9683 (archive_file_offset
9684 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
9685 sizeof nb)),
9686 SEEK_SET))
9687 {
9688 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9689 goto no_gnu_hash;
6bd1a22c 9690 }
252b5132 9691
6bd1a22c
L		 9692 if (fread (nb, 16, 1, file) != 1)
9693 {
9694 error (_("Failed to read in number of buckets\n"));
d3a44ec6 9695 goto no_gnu_hash;
6bd1a22c
L		 9696 }
9697
9698 ngnubuckets = byte_get (nb, 4);
9699 gnusymidx = byte_get (nb + 4, 4);
9700 bitmaskwords = byte_get (nb + 8, 4);
9701 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 9702 if (is_32bit_elf)
6bd1a22c 9703 buckets_vma += bitmaskwords * 4;
f7a99963 9704 else
6bd1a22c 9705 buckets_vma += bitmaskwords * 8;
252b5132 9706
6bd1a22c
L		 9707 if (fseek (file,
9708 (archive_file_offset
9709 + offset_from_vma (file, buckets_vma, 4)),
9710 SEEK_SET))
252b5132 9711 {
6bd1a22c 9712 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9713 goto no_gnu_hash;
6bd1a22c
L		 9714 }
9715
9716 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 9717
6bd1a22c 9718 if (gnubuckets == NULL)
d3a44ec6 9719 goto no_gnu_hash;
6bd1a22c
L		 9720
9721 for (i = 0; i < ngnubuckets; i++)
9722 if (gnubuckets[i] != 0)
9723 {
9724 if (gnubuckets[i] < gnusymidx)
9725 return 0;
9726
9727 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9728 maxchain = gnubuckets[i];
9729 }
9730
9731 if (maxchain == 0xffffffff)
d3a44ec6 9732 goto no_gnu_hash;
6bd1a22c
L		 9733
9734 maxchain -= gnusymidx;
9735
9736 if (fseek (file,
9737 (archive_file_offset
9738 + offset_from_vma (file, buckets_vma
9739 + 4 * (ngnubuckets + maxchain), 4)),
9740 SEEK_SET))
9741 {
9742 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9743 goto no_gnu_hash;
6bd1a22c
L		 9744 }
9745
9746 do
9747 {
9748 if (fread (nb, 4, 1, file) != 1)
252b5132 9749 {
6bd1a22c 9750 error (_("Failed to determine last chain length\n"));
d3a44ec6 9751 goto no_gnu_hash;
6bd1a22c 9752 }
252b5132 9753
6bd1a22c 9754 if (maxchain + 1 == 0)
d3a44ec6 9755 goto no_gnu_hash;
252b5132 9756
6bd1a22c
L		 9757 ++maxchain;
9758 }
9759 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 9760
6bd1a22c
L		 9761 if (fseek (file,
9762 (archive_file_offset
9763 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9764 SEEK_SET))
9765 {
9766 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9767 goto no_gnu_hash;
6bd1a22c
L		 9768 }
9769
9770 gnuchains = get_dynamic_data (file, maxchain, 4);
9771
d3a44ec6 9772 no_gnu_hash:
6bd1a22c 9773 if (gnuchains == NULL)
d3a44ec6
JJ		 9774 {
9775 free (gnubuckets);
d3a44ec6
JJ		 9776 gnubuckets = NULL;
9777 ngnubuckets = 0;
f64fddf1
NC		 9778 if (do_using_dynamic)
9779 return 0;
d3a44ec6 9780 }
6bd1a22c
L		 9781 }
9782
9783 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9784 && do_syms
9785 && do_using_dynamic
9786 && dynamic_strings != NULL)
9787 {
9788 unsigned long hn;
9789
9790 if (dynamic_info[DT_HASH])
9791 {
9792 bfd_vma si;
9793
9794 printf (_("\nSymbol table for image:\n"));
9795 if (is_32bit_elf)
9796 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9797 else
9798 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9799
9800 for (hn = 0; hn < nbuckets; hn++)
9801 {
9802 if (! buckets[hn])
9803 continue;
9804
9805 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9806 print_dynamic_symbol (si, hn);
252b5132
RH		 9807 }
9808 }
6bd1a22c
L		 9809
9810 if (dynamic_info_DT_GNU_HASH)
9811 {
9812 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9813 if (is_32bit_elf)
9814 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9815 else
9816 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9817
9818 for (hn = 0; hn < ngnubuckets; ++hn)
9819 if (gnubuckets[hn] != 0)
9820 {
9821 bfd_vma si = gnubuckets[hn];
9822 bfd_vma off = si - gnusymidx;
9823
9824 do
9825 {
9826 print_dynamic_symbol (si, hn);
9827 si++;
9828 }
9829 while ((gnuchains[off++] & 1) == 0);
9830 }
9831 }
252b5132 9832 }
2c610e4b 9833 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
252b5132 9834 {
b34976b6 9835 unsigned int i;
252b5132
RH		 9836
9837 for (i = 0, section = section_headers;
9838 i < elf_header.e_shnum;
9839 i++, section++)
9840 {
b34976b6 9841 unsigned int si;
2cf0635d 9842 char * strtab = NULL;
c256ffe7 9843 unsigned long int strtab_size = 0;
2cf0635d
NC		 9844 Elf_Internal_Sym * symtab;
9845 Elf_Internal_Sym * psym;
ba5cdace 9846 unsigned long num_syms;
252b5132 9847
2c610e4b
L		 9848 if ((section->sh_type != SHT_SYMTAB
9849 && section->sh_type != SHT_DYNSYM)
9850 || (!do_syms
9851 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 9852 continue;
9853
dd24e3da
NC		 9854 if (section->sh_entsize == 0)
9855 {
9856 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9857 SECTION_NAME (section));
9858 continue;
9859 }
9860
252b5132
RH		 9861 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9862 SECTION_NAME (section),
9863 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 9864
f7a99963 9865 if (is_32bit_elf)
ca47b30c 9866 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 9867 else
ca47b30c 9868 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 9869
ba5cdace 9870 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 9871 if (symtab == NULL)
9872 continue;
9873
9874 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 9875 {
9876 strtab = string_table;
9877 strtab_size = string_table_length;
9878 }
4fbb74a6 9879 else if (section->sh_link < elf_header.e_shnum)
252b5132 9880 {
2cf0635d 9881 Elf_Internal_Shdr * string_sec;
252b5132 9882
4fbb74a6 9883 string_sec = section_headers + section->sh_link;
252b5132 9884
3f5e193b
NC		 9885 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9886 1, string_sec->sh_size,
9887 _("string table"));
c256ffe7 9888 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 9889 }
9890
ba5cdace 9891 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 9892 {
5e220199 9893 printf ("%6d: ", si);
f7a99963
NC		 9894 print_vma (psym->st_value, LONG_HEX);
9895 putchar (' ');
9896 print_vma (psym->st_size, DEC_5);
d1133906
NC		 9897 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9898 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 9899 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 9900 /* Check to see if any other bits in the st_other field are set.
9901 Note - displaying this information disrupts the layout of the
9902 table being generated, but for the moment this case is very rare. */
9903 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9904 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 9905 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 9906 print_symbol (25, psym->st_name < strtab_size
2b692964 9907 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 9908
59245841
NC		 9909 if (section->sh_type == SHT_DYNSYM
9910 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
252b5132 9911 {
b34976b6
AM		 9912 unsigned char data[2];
9913 unsigned short vers_data;
9914 unsigned long offset;
9915 int is_nobits;
9916 int check_def;
252b5132 9917
d93f0186
NC		 9918 offset = offset_from_vma
9919 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9920 sizeof data + si * sizeof (vers_data));
252b5132 9921
59245841
NC		 9922 if (get_data (&data, file, offset + si * sizeof (vers_data),
9923 sizeof (data), 1, _("version data")) == NULL)
9924 break;
252b5132
RH		 9925
9926 vers_data = byte_get (data, 2);
9927
4fbb74a6
AM		 9928 is_nobits = (psym->st_shndx < elf_header.e_shnum
9929 && section_headers[psym->st_shndx].sh_type
c256ffe7 9930 == SHT_NOBITS);
252b5132
RH		 9931
9932 check_def = (psym->st_shndx != SHN_UNDEF);
9933
c244d050 9934 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
252b5132 9935 {
b34976b6 9936 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
00d93f34 9937 && (is_nobits || ! check_def))
252b5132 9938 {
b34976b6
AM		 9939 Elf_External_Verneed evn;
9940 Elf_Internal_Verneed ivn;
9941 Elf_Internal_Vernaux ivna;
252b5132
RH		 9942
9943 /* We must test both. */
d93f0186
NC		 9944 offset = offset_from_vma
9945 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9946 sizeof evn);
252b5132 9947
252b5132
RH		 9948 do
9949 {
b34976b6 9950 unsigned long vna_off;
252b5132 9951
59245841
NC		 9952 if (get_data (&evn, file, offset, sizeof (evn), 1,
9953 _("version need")) == NULL)
9954 {
9955 ivna.vna_next = 0;
9956 ivna.vna_other = 0;
9957 ivna.vna_name = 0;
9958 break;
9959 }
dd27201e
L		 9960
9961 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9962 ivn.vn_next = BYTE_GET (evn.vn_next);
9963
252b5132
RH		 9964 vna_off = offset + ivn.vn_aux;
9965
9966 do
9967 {
b34976b6 9968 Elf_External_Vernaux evna;
252b5132 9969
59245841
NC		 9970 if (get_data (&evna, file, vna_off,
9971 sizeof (evna), 1,
9972 _("version need aux (3)")) == NULL)
9973 {
9974 ivna.vna_next = 0;
9975 ivna.vna_other = 0;
9976 ivna.vna_name = 0;
9977 }
9978 else
9979 {
9980 ivna.vna_other = BYTE_GET (evna.vna_other);
9981 ivna.vna_next = BYTE_GET (evna.vna_next);
9982 ivna.vna_name = BYTE_GET (evna.vna_name);
9983 }
252b5132
RH		 9984
9985 vna_off += ivna.vna_next;
9986 }
9987 while (ivna.vna_other != vers_data
9988 && ivna.vna_next != 0);
9989
9990 if (ivna.vna_other == vers_data)
9991 break;
9992
9993 offset += ivn.vn_next;
9994 }
9995 while (ivn.vn_next != 0);
9996
9997 if (ivna.vna_other == vers_data)
9998 {
9999 printf ("@%s (%d)",
c256ffe7 10000 ivna.vna_name < strtab_size
2b692964 10001 ? strtab + ivna.vna_name : _("<corrupt>"),
c256ffe7 10002 ivna.vna_other);
252b5132
RH		 10003 check_def = 0;
10004 }
10005 else if (! is_nobits)
591a748a 10006 error (_("bad dynamic symbol\n"));
252b5132
RH		 10007 else
10008 check_def = 1;
10009 }
10010
10011 if (check_def)
10012 {
00d93f34 10013 if (vers_data != 0x8001
b34976b6 10014 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 10015 {
b34976b6
AM		 10016 Elf_Internal_Verdef ivd;
10017 Elf_Internal_Verdaux ivda;
10018 Elf_External_Verdaux evda;
91d6fa6a 10019 unsigned long off;
252b5132 10020
91d6fa6a 10021 off = offset_from_vma
d93f0186
NC		 10022 (file,
10023 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10024 sizeof (Elf_External_Verdef));
252b5132
RH		 10025
10026 do
10027 {
b34976b6 10028 Elf_External_Verdef evd;
252b5132 10029
59245841
NC		 10030 if (get_data (&evd, file, off, sizeof (evd),
10031 1, _("version def")) == NULL)
10032 {
10033 ivd.vd_ndx = 0;
10034 ivd.vd_aux = 0;
10035 ivd.vd_next = 0;
10036 }
10037 else
10038 {
10039 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10040 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10041 ivd.vd_next = BYTE_GET (evd.vd_next);
10042 }
252b5132 10043
91d6fa6a 10044 off += ivd.vd_next;
252b5132 10045 }
c244d050 10046 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
252b5132
RH		 10047 && ivd.vd_next != 0);
10048
91d6fa6a
NC		 10049 off -= ivd.vd_next;
10050 off += ivd.vd_aux;
252b5132 10051
59245841
NC		 10052 if (get_data (&evda, file, off, sizeof (evda),
10053 1, _("version def aux")) == NULL)
10054 break;
252b5132
RH		 10055
10056 ivda.vda_name = BYTE_GET (evda.vda_name);
10057
10058 if (psym->st_name != ivda.vda_name)
c244d050 10059 printf ((vers_data & VERSYM_HIDDEN)
252b5132 10060 ? "@%s" : "@@%s",
c256ffe7 10061 ivda.vda_name < strtab_size
2b692964 10062 ? strtab + ivda.vda_name : _("<corrupt>"));
252b5132
RH		 10063 }
10064 }
10065 }
10066 }
10067
10068 putchar ('\n');
10069 }
10070
10071 free (symtab);
10072 if (strtab != string_table)
10073 free (strtab);
10074 }
10075 }
10076 else if (do_syms)
10077 printf
10078 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10079
10080 if (do_histogram && buckets != NULL)
10081 {
2cf0635d
NC		 10082 unsigned long * lengths;
10083 unsigned long * counts;
66543521
AM		 10084 unsigned long hn;
10085 bfd_vma si;
10086 unsigned long maxlength = 0;
10087 unsigned long nzero_counts = 0;
10088 unsigned long nsyms = 0;
252b5132 10089
66543521
AM		 10090 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10091 (unsigned long) nbuckets);
252b5132
RH		 10092 printf (_(" Length Number %% of total Coverage\n"));
10093
3f5e193b 10094 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 10095 if (lengths == NULL)
10096 {
591a748a 10097 error (_("Out of memory\n"));
252b5132
RH		 10098 return 0;
10099 }
10100 for (hn = 0; hn < nbuckets; ++hn)
10101 {
f7a99963 10102 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
252b5132 10103 {
b34976b6 10104 ++nsyms;
252b5132 10105 if (maxlength < ++lengths[hn])
b34976b6 10106 ++maxlength;
252b5132
RH		 10107 }
10108 }
10109
3f5e193b 10110 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 10111 if (counts == NULL)
10112 {
b2e951ec 10113 free (lengths);
591a748a 10114 error (_("Out of memory\n"));
252b5132
RH		 10115 return 0;
10116 }
10117
10118 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 10119 ++counts[lengths[hn]];
252b5132 10120
103f02d3 10121 if (nbuckets > 0)
252b5132 10122 {
66543521
AM		 10123 unsigned long i;
10124 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 10125 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 10126 for (i = 1; i <= maxlength; ++i)
103f02d3 10127 {
66543521
AM		 10128 nzero_counts += counts[i] * i;
10129 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10130 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 10131 (nzero_counts * 100.0) / nsyms);
10132 }
252b5132
RH		 10133 }
10134
10135 free (counts);
10136 free (lengths);
10137 }
10138
10139 if (buckets != NULL)
10140 {
10141 free (buckets);
10142 free (chains);
10143 }
10144
d3a44ec6 10145 if (do_histogram && gnubuckets != NULL)
fdc90cb4 10146 {
2cf0635d
NC		 10147 unsigned long * lengths;
10148 unsigned long * counts;
fdc90cb4
JJ		 10149 unsigned long hn;
10150 unsigned long maxlength = 0;
10151 unsigned long nzero_counts = 0;
10152 unsigned long nsyms = 0;
fdc90cb4 10153
3f5e193b 10154 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 10155 if (lengths == NULL)
10156 {
591a748a 10157 error (_("Out of memory\n"));
fdc90cb4
JJ		 10158 return 0;
10159 }
10160
10161 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10162 (unsigned long) ngnubuckets);
10163 printf (_(" Length Number %% of total Coverage\n"));
10164
10165 for (hn = 0; hn < ngnubuckets; ++hn)
10166 if (gnubuckets[hn] != 0)
10167 {
10168 bfd_vma off, length = 1;
10169
6bd1a22c 10170 for (off = gnubuckets[hn] - gnusymidx;
fdc90cb4
JJ		 10171 (gnuchains[off] & 1) == 0; ++off)
10172 ++length;
10173 lengths[hn] = length;
10174 if (length > maxlength)
10175 maxlength = length;
10176 nsyms += length;
10177 }
10178
3f5e193b 10179 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 10180 if (counts == NULL)
10181 {
b2e951ec 10182 free (lengths);
591a748a 10183 error (_("Out of memory\n"));
fdc90cb4
JJ		 10184 return 0;
10185 }
10186
10187 for (hn = 0; hn < ngnubuckets; ++hn)
10188 ++counts[lengths[hn]];
10189
10190 if (ngnubuckets > 0)
10191 {
10192 unsigned long j;
10193 printf (" 0 %-10lu (%5.1f%%)\n",
10194 counts[0], (counts[0] * 100.0) / ngnubuckets);
10195 for (j = 1; j <= maxlength; ++j)
10196 {
10197 nzero_counts += counts[j] * j;
10198 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10199 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
10200 (nzero_counts * 100.0) / nsyms);
10201 }
10202 }
10203
10204 free (counts);
10205 free (lengths);
10206 free (gnubuckets);
10207 free (gnuchains);
10208 }
10209
252b5132
RH		 10210 return 1;
10211}
10212
10213static int
2cf0635d 10214process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 10215{
b4c96d0d 10216 unsigned int i;
252b5132
RH		 10217
10218 if (dynamic_syminfo == NULL
10219 || !do_dynamic)
10220 /* No syminfo, this is ok. */
10221 return 1;
10222
10223 /* There better should be a dynamic symbol section. */
10224 if (dynamic_symbols == NULL || dynamic_strings == NULL)
10225 return 0;
10226
10227 if (dynamic_addr)
10228 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10229 dynamic_syminfo_offset, dynamic_syminfo_nent);
10230
10231 printf (_(" Num: Name BoundTo Flags\n"));
10232 for (i = 0; i < dynamic_syminfo_nent; ++i)
10233 {
10234 unsigned short int flags = dynamic_syminfo[i].si_flags;
10235
31104126 10236 printf ("%4d: ", i);
d79b3d50
NC		 10237 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
10238 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
10239 else
2b692964 10240 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 10241 putchar (' ');
252b5132
RH		 10242
10243 switch (dynamic_syminfo[i].si_boundto)
10244 {
10245 case SYMINFO_BT_SELF:
10246 fputs ("SELF ", stdout);
10247 break;
10248 case SYMINFO_BT_PARENT:
10249 fputs ("PARENT ", stdout);
10250 break;
10251 default:
10252 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 10253 && dynamic_syminfo[i].si_boundto < dynamic_nent
10254 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 10255 {
d79b3d50 10256 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 10257 putchar (' ' );
10258 }
252b5132
RH		 10259 else
10260 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
10261 break;
10262 }
10263
10264 if (flags & SYMINFO_FLG_DIRECT)
10265 printf (" DIRECT");
10266 if (flags & SYMINFO_FLG_PASSTHRU)
10267 printf (" PASSTHRU");
10268 if (flags & SYMINFO_FLG_COPY)
10269 printf (" COPY");
10270 if (flags & SYMINFO_FLG_LAZYLOAD)
10271 printf (" LAZYLOAD");
10272
10273 puts ("");
10274 }
10275
10276 return 1;
10277}
10278
cf13d699
NC		 10279/* Check to see if the given reloc needs to be handled in a target specific
10280 manner. If so then process the reloc and return TRUE otherwise return
10281 FALSE. */
09c11c86 10282
cf13d699
NC		 10283static bfd_boolean
10284target_specific_reloc_handling (Elf_Internal_Rela * reloc,
10285 unsigned char * start,
10286 Elf_Internal_Sym * symtab)
252b5132 10287{
cf13d699 10288 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 10289
cf13d699 10290 switch (elf_header.e_machine)
252b5132 10291 {
13761a11
NC		 10292 case EM_MSP430:
10293 case EM_MSP430_OLD:
10294 {
10295 static Elf_Internal_Sym * saved_sym = NULL;
10296
10297 switch (reloc_type)
10298 {
10299 case 10: /* R_MSP430_SYM_DIFF */
10300 if (uses_msp430x_relocs ())
10301 break;
10302 case 21: /* R_MSP430X_SYM_DIFF */
10303 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10304 return TRUE;
10305
10306 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10307 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10308 goto handle_sym_diff;
0b4362b0 10309
13761a11
NC		 10310 case 5: /* R_MSP430_16_BYTE */
10311 case 9: /* R_MSP430_8 */
10312 if (uses_msp430x_relocs ())
10313 break;
10314 goto handle_sym_diff;
10315
10316 case 2: /* R_MSP430_ABS16 */
10317 case 15: /* R_MSP430X_ABS16 */
10318 if (! uses_msp430x_relocs ())
10319 break;
10320 goto handle_sym_diff;
0b4362b0 10321
13761a11
NC		 10322 handle_sym_diff:
10323 if (saved_sym != NULL)
10324 {
10325 bfd_vma value;
10326
10327 value = reloc->r_addend
10328 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10329 - saved_sym->st_value);
10330
10331 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10332
10333 saved_sym = NULL;
10334 return TRUE;
10335 }
10336 break;
10337
10338 default:
10339 if (saved_sym != NULL)
10340 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc"));
10341 break;
10342 }
10343 break;
10344 }
10345
cf13d699
NC		 10346 case EM_MN10300:
10347 case EM_CYGNUS_MN10300:
10348 {
10349 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 10350
cf13d699
NC		 10351 switch (reloc_type)
10352 {
10353 case 34: /* R_MN10300_ALIGN */
10354 return TRUE;
10355 case 33: /* R_MN10300_SYM_DIFF */
10356 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10357 return TRUE;
10358 case 1: /* R_MN10300_32 */
10359 case 2: /* R_MN10300_16 */
10360 if (saved_sym != NULL)
10361 {
10362 bfd_vma value;
252b5132 10363
cf13d699
NC		 10364 value = reloc->r_addend
10365 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10366 - saved_sym->st_value);
252b5132 10367
cf13d699 10368 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 10369
cf13d699
NC		 10370 saved_sym = NULL;
10371 return TRUE;
10372 }
10373 break;
10374 default:
10375 if (saved_sym != NULL)
10376 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
10377 break;
10378 }
10379 break;
10380 }
252b5132
RH		 10381 }
10382
cf13d699 10383 return FALSE;
252b5132
RH		 10384}
10385
aca88567
NC		 10386/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10387 DWARF debug sections. This is a target specific test. Note - we do not
10388 go through the whole including-target-headers-multiple-times route, (as
10389 we have already done with <elf/h8.h>) because this would become very
10390 messy and even then this function would have to contain target specific
10391 information (the names of the relocs instead of their numeric values).
10392 FIXME: This is not the correct way to solve this problem. The proper way
10393 is to have target specific reloc sizing and typing functions created by
10394 the reloc-macros.h header, in the same way that it already creates the
10395 reloc naming functions. */
10396
10397static bfd_boolean
10398is_32bit_abs_reloc (unsigned int reloc_type)
10399{
10400 switch (elf_header.e_machine)
10401 {
41e92641
NC		 10402 case EM_386:
10403 case EM_486:
10404 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 10405 case EM_68K:
10406 return reloc_type == 1; /* R_68K_32. */
10407 case EM_860:
10408 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 10409 case EM_960:
10410 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 10411 case EM_AARCH64:
10412 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 10413 case EM_ALPHA:
137b6b5f 10414 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 10415 case EM_ARC:
10416 return reloc_type == 1; /* R_ARC_32. */
10417 case EM_ARM:
10418 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 10419 case EM_AVR_OLD:
aca88567
NC		 10420 case EM_AVR:
10421 return reloc_type == 1;
cfb8c092
NC		 10422 case EM_ADAPTEVA_EPIPHANY:
10423 return reloc_type == 3;
aca88567
NC		 10424 case EM_BLACKFIN:
10425 return reloc_type == 0x12; /* R_byte4_data. */
10426 case EM_CRIS:
10427 return reloc_type == 3; /* R_CRIS_32. */
10428 case EM_CR16:
10429 return reloc_type == 3; /* R_CR16_NUM32. */
10430 case EM_CRX:
10431 return reloc_type == 15; /* R_CRX_NUM32. */
10432 case EM_CYGNUS_FRV:
10433 return reloc_type == 1;
41e92641
NC		 10434 case EM_CYGNUS_D10V:
10435 case EM_D10V:
10436 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 10437 case EM_CYGNUS_D30V:
10438 case EM_D30V:
10439 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 10440 case EM_DLX:
10441 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 10442 case EM_CYGNUS_FR30:
10443 case EM_FR30:
10444 return reloc_type == 3; /* R_FR30_32. */
10445 case EM_H8S:
10446 case EM_H8_300:
10447 case EM_H8_300H:
10448 return reloc_type == 1; /* R_H8_DIR32. */
3730236a
NC		 10449 case EM_IA_64:
10450 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
aca88567
NC		 10451 case EM_IP2K_OLD:
10452 case EM_IP2K:
10453 return reloc_type == 2; /* R_IP2K_32. */
10454 case EM_IQ2000:
10455 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 10456 case EM_LATTICEMICO32:
10457 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 10458 case EM_M32C_OLD:
aca88567
NC		 10459 case EM_M32C:
10460 return reloc_type == 3; /* R_M32C_32. */
10461 case EM_M32R:
10462 return reloc_type == 34; /* R_M32R_32_RELA. */
10463 case EM_MCORE:
10464 return reloc_type == 1; /* R_MCORE_ADDR32. */
10465 case EM_CYGNUS_MEP:
10466 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 10467 case EM_METAG:
10468 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 10469 case EM_MICROBLAZE:
10470 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 10471 case EM_MIPS:
10472 return reloc_type == 2; /* R_MIPS_32. */
10473 case EM_MMIX:
10474 return reloc_type == 4; /* R_MMIX_32. */
10475 case EM_CYGNUS_MN10200:
10476 case EM_MN10200:
10477 return reloc_type == 1; /* R_MN10200_32. */
10478 case EM_CYGNUS_MN10300:
10479 case EM_MN10300:
10480 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 10481 case EM_MOXIE:
10482 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 10483 case EM_MSP430_OLD:
10484 case EM_MSP430:
13761a11 10485 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 10486 case EM_MT:
10487 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 10488 case EM_NDS32:
10489 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 10490 case EM_ALTERA_NIOS2:
36591ba1 10491 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 10492 case EM_NIOS32:
10493 return reloc_type == 1; /* R_NIOS_32. */
73589c9d
CS		 10494 case EM_OR1K:
10495 return reloc_type == 1; /* R_OR1K_32. */
aca88567 10496 case EM_PARISC:
5fda8eca
NC		 10497 return (reloc_type == 1 /* R_PARISC_DIR32. */
10498 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 10499 case EM_PJ:
10500 case EM_PJ_OLD:
10501 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
10502 case EM_PPC64:
10503 return reloc_type == 1; /* R_PPC64_ADDR32. */
10504 case EM_PPC:
10505 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 10506 case EM_RL78:
10507 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 10508 case EM_RX:
10509 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 10510 case EM_S370:
10511 return reloc_type == 1; /* R_I370_ADDR31. */
10512 case EM_S390_OLD:
10513 case EM_S390:
10514 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 10515 case EM_SCORE:
10516 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 10517 case EM_SH:
10518 return reloc_type == 1; /* R_SH_DIR32. */
10519 case EM_SPARC32PLUS:
10520 case EM_SPARCV9:
10521 case EM_SPARC:
10522 return reloc_type == 3 /* R_SPARC_32. */
10523 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 10524 case EM_SPU:
10525 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 10526 case EM_TI_C6000:
10527 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 10528 case EM_TILEGX:
10529 return reloc_type == 2; /* R_TILEGX_32. */
10530 case EM_TILEPRO:
10531 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 10532 case EM_CYGNUS_V850:
10533 case EM_V850:
10534 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 10535 case EM_V800:
10536 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 10537 case EM_VAX:
10538 return reloc_type == 1; /* R_VAX_32. */
10539 case EM_X86_64:
8a9036a4 10540 case EM_L1OM:
7a9068fe 10541 case EM_K1OM:
aca88567 10542 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 10543 case EM_XC16X:
10544 case EM_C166:
10545 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 10546 case EM_XGATE:
10547 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 10548 case EM_XSTORMY16:
10549 return reloc_type == 1; /* R_XSTROMY16_32. */
10550 case EM_XTENSA_OLD:
10551 case EM_XTENSA:
10552 return reloc_type == 1; /* R_XTENSA_32. */
aca88567
NC		 10553 default:
10554 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10555 elf_header.e_machine);
10556 abort ();
10557 }
10558}
10559
10560/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10561 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10562
10563static bfd_boolean
10564is_32bit_pcrel_reloc (unsigned int reloc_type)
10565{
10566 switch (elf_header.e_machine)
10567 {
41e92641
NC		 10568 case EM_386:
10569 case EM_486:
3e0873ac 10570 return reloc_type == 2; /* R_386_PC32. */
aca88567 10571 case EM_68K:
3e0873ac 10572 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 10573 case EM_AARCH64:
10574 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 10575 case EM_ADAPTEVA_EPIPHANY:
10576 return reloc_type == 6;
aca88567
NC		 10577 case EM_ALPHA:
10578 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 10579 case EM_ARM:
3e0873ac 10580 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 10581 case EM_MICROBLAZE:
10582 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
73589c9d
CS		 10583 case EM_OR1K:
10584 return reloc_type == 9; /* R_OR1K_32_PCREL. */
aca88567 10585 case EM_PARISC:
85acf597 10586 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 10587 case EM_PPC:
10588 return reloc_type == 26; /* R_PPC_REL32. */
10589 case EM_PPC64:
3e0873ac 10590 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 10591 case EM_S390_OLD:
10592 case EM_S390:
3e0873ac 10593 return reloc_type == 5; /* R_390_PC32. */
aca88567 10594 case EM_SH:
3e0873ac 10595 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 10596 case EM_SPARC32PLUS:
10597 case EM_SPARCV9:
10598 case EM_SPARC:
3e0873ac 10599 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 10600 case EM_SPU:
10601 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 10602 case EM_TILEGX:
10603 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
10604 case EM_TILEPRO:
10605 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
aca88567 10606 case EM_X86_64:
8a9036a4 10607 case EM_L1OM:
7a9068fe 10608 case EM_K1OM:
3e0873ac 10609 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 10610 case EM_XTENSA_OLD:
10611 case EM_XTENSA:
10612 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 10613 default:
10614 /* Do not abort or issue an error message here. Not all targets use
10615 pc-relative 32-bit relocs in their DWARF debug information and we
10616 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 10617 more helpful warning message will be generated by apply_relocations
10618 anyway, so just return. */
aca88567
NC		 10619 return FALSE;
10620 }
10621}
10622
10623/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10624 a 64-bit absolute RELA relocation used in DWARF debug sections. */
10625
10626static bfd_boolean
10627is_64bit_abs_reloc (unsigned int reloc_type)
10628{
10629 switch (elf_header.e_machine)
10630 {
a06ea964
NC		 10631 case EM_AARCH64:
10632 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 10633 case EM_ALPHA:
10634 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 10635 case EM_IA_64:
10636 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 10637 case EM_PARISC:
10638 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 10639 case EM_PPC64:
10640 return reloc_type == 38; /* R_PPC64_ADDR64. */
10641 case EM_SPARC32PLUS:
10642 case EM_SPARCV9:
10643 case EM_SPARC:
10644 return reloc_type == 54; /* R_SPARC_UA64. */
10645 case EM_X86_64:
8a9036a4 10646 case EM_L1OM:
7a9068fe 10647 case EM_K1OM:
aca88567 10648 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 10649 case EM_S390_OLD:
10650 case EM_S390:
aa137e4d
NC		 10651 return reloc_type == 22; /* R_S390_64. */
10652 case EM_TILEGX:
10653 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 10654 case EM_MIPS:
aa137e4d 10655 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 10656 default:
10657 return FALSE;
10658 }
10659}
10660
85acf597
RH		 10661/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10662 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10663
10664static bfd_boolean
10665is_64bit_pcrel_reloc (unsigned int reloc_type)
10666{
10667 switch (elf_header.e_machine)
10668 {
a06ea964
NC		 10669 case EM_AARCH64:
10670 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 10671 case EM_ALPHA:
aa137e4d 10672 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 10673 case EM_IA_64:
aa137e4d 10674 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 10675 case EM_PARISC:
aa137e4d 10676 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 10677 case EM_PPC64:
aa137e4d 10678 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 10679 case EM_SPARC32PLUS:
10680 case EM_SPARCV9:
10681 case EM_SPARC:
aa137e4d 10682 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 10683 case EM_X86_64:
8a9036a4 10684 case EM_L1OM:
7a9068fe 10685 case EM_K1OM:
aa137e4d 10686 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 10687 case EM_S390_OLD:
10688 case EM_S390:
aa137e4d
NC		 10689 return reloc_type == 23; /* R_S390_PC64. */
10690 case EM_TILEGX:
10691 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 10692 default:
10693 return FALSE;
10694 }
10695}
10696
4dc3c23d
AM		 10697/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10698 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10699
10700static bfd_boolean
10701is_24bit_abs_reloc (unsigned int reloc_type)
10702{
10703 switch (elf_header.e_machine)
10704 {
10705 case EM_CYGNUS_MN10200:
10706 case EM_MN10200:
10707 return reloc_type == 4; /* R_MN10200_24. */
10708 default:
10709 return FALSE;
10710 }
10711}
10712
aca88567
NC		 10713/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10714 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10715
10716static bfd_boolean
10717is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 10718{
10719 switch (elf_header.e_machine)
10720 {
aca88567
NC		 10721 case EM_AVR_OLD:
10722 case EM_AVR:
10723 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 10724 case EM_ADAPTEVA_EPIPHANY:
10725 return reloc_type == 5;
41e92641
NC		 10726 case EM_CYGNUS_D10V:
10727 case EM_D10V:
10728 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 10729 case EM_H8S:
10730 case EM_H8_300:
10731 case EM_H8_300H:
aca88567
NC		 10732 return reloc_type == R_H8_DIR16;
10733 case EM_IP2K_OLD:
10734 case EM_IP2K:
10735 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 10736 case EM_M32C_OLD:
f4236fe4
DD		 10737 case EM_M32C:
10738 return reloc_type == 1; /* R_M32C_16 */
aca88567 10739 case EM_MSP430:
13761a11
NC		 10740 if (uses_msp430x_relocs ())
10741 return reloc_type == 2; /* R_MSP430_ABS16. */
78c8d46c 10742 case EM_MSP430_OLD:
aca88567 10743 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 10744 case EM_NDS32:
10745 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 10746 case EM_ALTERA_NIOS2:
36591ba1 10747 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 10748 case EM_NIOS32:
10749 return reloc_type == 9; /* R_NIOS_16. */
73589c9d
CS		 10750 case EM_OR1K:
10751 return reloc_type == 2; /* R_OR1K_16. */
40b36596
JM		 10752 case EM_TI_C6000:
10753 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 10754 case EM_XC16X:
10755 case EM_C166:
10756 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 10757 case EM_CYGNUS_MN10200:
10758 case EM_MN10200:
10759 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 10760 case EM_CYGNUS_MN10300:
10761 case EM_MN10300:
10762 return reloc_type == 2; /* R_MN10300_16. */
f6c1a2d5
NC		 10763 case EM_XGATE:
10764 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 10765 default:
aca88567 10766 return FALSE;
4b78141a
NC		 10767 }
10768}
10769
2a7b2e88
JK		 10770/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10771 relocation entries (possibly formerly used for SHT_GROUP sections). */
10772
10773static bfd_boolean
10774is_none_reloc (unsigned int reloc_type)
10775{
10776 switch (elf_header.e_machine)
10777 {
cb8f3167
NC		 10778 case EM_68K: /* R_68K_NONE. */
10779 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 10780 case EM_SPARC32PLUS:
10781 case EM_SPARCV9:
cb8f3167
NC		 10782 case EM_SPARC: /* R_SPARC_NONE. */
10783 case EM_MIPS: /* R_MIPS_NONE. */
10784 case EM_PARISC: /* R_PARISC_NONE. */
10785 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 10786 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 10787 case EM_PPC: /* R_PPC_NONE. */
10788 case EM_PPC64: /* R_PPC64_NONE. */
10789 case EM_ARM: /* R_ARM_NONE. */
10790 case EM_IA_64: /* R_IA64_NONE. */
10791 case EM_SH: /* R_SH_NONE. */
2a7b2e88 10792 case EM_S390_OLD:
cb8f3167
NC		 10793 case EM_S390: /* R_390_NONE. */
10794 case EM_CRIS: /* R_CRIS_NONE. */
10795 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 10796 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 10797 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 10798 case EM_MN10300: /* R_MN10300_NONE. */
5506d11a 10799 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 10800 case EM_M32R: /* R_M32R_NONE. */
40b36596 10801 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 10802 case EM_TILEGX: /* R_TILEGX_NONE. */
10803 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 10804 case EM_XC16X:
10805 case EM_C166: /* R_XC16X_NONE. */
36591ba1
SL		 10806 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
10807 case EM_NIOS32: /* R_NIOS_NONE. */
73589c9d 10808 case EM_OR1K: /* R_OR1K_NONE. */
cb8f3167 10809 return reloc_type == 0;
a06ea964
NC		 10810 case EM_AARCH64:
10811 return reloc_type == 0 || reloc_type == 256;
35c08157
KLC		 10812 case EM_NDS32:
10813 return (reloc_type == 0 /* R_XTENSA_NONE. */
10814 || reloc_type == 204 /* R_NDS32_DIFF8. */
10815 || reloc_type == 205 /* R_NDS32_DIFF16. */
10816 || reloc_type == 206 /* R_NDS32_DIFF32. */
10817 || reloc_type == 207 /* R_NDS32_ULEB128. */);
58332dda
JK		 10818 case EM_XTENSA_OLD:
10819 case EM_XTENSA:
4dc3c23d
AM		 10820 return (reloc_type == 0 /* R_XTENSA_NONE. */
10821 || reloc_type == 17 /* R_XTENSA_DIFF8. */
10822 || reloc_type == 18 /* R_XTENSA_DIFF16. */
10823 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
a3c62988
NC		 10824 case EM_METAG:
10825 return reloc_type == 3; /* R_METAG_NONE. */
2a7b2e88
JK		 10826 }
10827 return FALSE;
10828}
10829
cf13d699
NC		 10830/* Apply relocations to a section.
10831 Note: So far support has been added only for those relocations
10832 which can be found in debug sections.
10833 FIXME: Add support for more relocations ? */
1b315056 10834
cf13d699
NC		 10835static void
10836apply_relocations (void * file,
10837 Elf_Internal_Shdr * section,
10838 unsigned char * start)
1b315056 10839{
cf13d699
NC		 10840 Elf_Internal_Shdr * relsec;
10841 unsigned char * end = start + section->sh_size;
cb8f3167 10842
cf13d699
NC		 10843 if (elf_header.e_type != ET_REL)
10844 return;
1b315056 10845
cf13d699 10846 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 10847 for (relsec = section_headers;
10848 relsec < section_headers + elf_header.e_shnum;
10849 ++relsec)
252b5132 10850 {
41e92641
NC		 10851 bfd_boolean is_rela;
10852 unsigned long num_relocs;
2cf0635d
NC		 10853 Elf_Internal_Rela * relocs;
10854 Elf_Internal_Rela * rp;
10855 Elf_Internal_Shdr * symsec;
10856 Elf_Internal_Sym * symtab;
ba5cdace 10857 unsigned long num_syms;
2cf0635d 10858 Elf_Internal_Sym * sym;
252b5132 10859
41e92641 10860 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 10861 || relsec->sh_info >= elf_header.e_shnum
10862 || section_headers + relsec->sh_info != section
c256ffe7 10863 || relsec->sh_size == 0
4fbb74a6 10864 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 10865 continue;
428409d5 10866
41e92641
NC		 10867 is_rela = relsec->sh_type == SHT_RELA;
10868
10869 if (is_rela)
10870 {
3f5e193b
NC		 10871 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10872 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10873 return;
10874 }
10875 else
10876 {
3f5e193b
NC		 10877 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10878 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10879 return;
10880 }
10881
10882 /* SH uses RELA but uses in place value instead of the addend field. */
10883 if (elf_header.e_machine == EM_SH)
10884 is_rela = FALSE;
428409d5 10885
4fbb74a6 10886 symsec = section_headers + relsec->sh_link;
ba5cdace 10887 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 10888
41e92641 10889 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 10890 {
41e92641
NC		 10891 bfd_vma addend;
10892 unsigned int reloc_type;
10893 unsigned int reloc_size;
91d6fa6a 10894 unsigned char * rloc;
ba5cdace 10895 unsigned long sym_index;
4b78141a 10896
aca88567 10897 reloc_type = get_reloc_type (rp->r_info);
41e92641 10898
98fb390a 10899 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 10900 continue;
98fb390a
NC		 10901 else if (is_none_reloc (reloc_type))
10902 continue;
10903 else if (is_32bit_abs_reloc (reloc_type)
10904 || is_32bit_pcrel_reloc (reloc_type))
aca88567 10905 reloc_size = 4;
85acf597
RH		 10906 else if (is_64bit_abs_reloc (reloc_type)
10907 || is_64bit_pcrel_reloc (reloc_type))
aca88567 10908 reloc_size = 8;
4dc3c23d
AM		 10909 else if (is_24bit_abs_reloc (reloc_type))
10910 reloc_size = 3;
aca88567
NC		 10911 else if (is_16bit_abs_reloc (reloc_type))
10912 reloc_size = 2;
10913 else
4b78141a 10914 {
41e92641 10915 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
aca88567 10916 reloc_type, SECTION_NAME (section));
4b78141a
NC		 10917 continue;
10918 }
103f02d3 10919
91d6fa6a 10920 rloc = start + rp->r_offset;
c8da6823 10921 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 10922 {
10923 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10924 (unsigned long) rp->r_offset,
10925 SECTION_NAME (section));
10926 continue;
10927 }
103f02d3 10928
ba5cdace
NC		 10929 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
10930 if (sym_index >= num_syms)
10931 {
10932 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10933 sym_index, SECTION_NAME (section));
10934 continue;
10935 }
10936 sym = symtab + sym_index;
41e92641
NC		 10937
10938 /* If the reloc has a symbol associated with it,
55f25fc3
L		 10939 make sure that it is of an appropriate type.
10940
10941 Relocations against symbols without type can happen.
10942 Gcc -feliminate-dwarf2-dups may generate symbols
10943 without type for debug info.
10944
10945 Icc generates relocations against function symbols
10946 instead of local labels.
10947
10948 Relocations against object symbols can happen, eg when
10949 referencing a global array. For an example of this see
10950 the _clz.o binary in libgcc.a. */
aca88567 10951 if (sym != symtab
55f25fc3 10952 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 10953 {
41e92641 10954 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 10955 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 10956 (long int)(rp - relocs),
41e92641 10957 SECTION_NAME (relsec));
aca88567 10958 continue;
5b18a4bc 10959 }
252b5132 10960
4dc3c23d
AM		 10961 addend = 0;
10962 if (is_rela)
10963 addend += rp->r_addend;
c47320c3
AM		 10964 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10965 partial_inplace. */
4dc3c23d
AM		 10966 if (!is_rela
10967 || (elf_header.e_machine == EM_XTENSA
10968 && reloc_type == 1)
10969 || ((elf_header.e_machine == EM_PJ
10970 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 10971 && reloc_type == 1)
10972 || ((elf_header.e_machine == EM_D30V
10973 || elf_header.e_machine == EM_CYGNUS_D30V)
10974 && reloc_type == 12))
91d6fa6a 10975 addend += byte_get (rloc, reloc_size);
cb8f3167 10976
85acf597
RH		 10977 if (is_32bit_pcrel_reloc (reloc_type)
10978 || is_64bit_pcrel_reloc (reloc_type))
10979 {
10980 /* On HPPA, all pc-relative relocations are biased by 8. */
10981 if (elf_header.e_machine == EM_PARISC)
10982 addend -= 8;
91d6fa6a 10983 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 10984 reloc_size);
10985 }
41e92641 10986 else
91d6fa6a 10987 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 10988 }
252b5132 10989
5b18a4bc 10990 free (symtab);
41e92641 10991 free (relocs);
5b18a4bc
NC		 10992 break;
10993 }
5b18a4bc 10994}
103f02d3 10995
cf13d699
NC		 10996#ifdef SUPPORT_DISASSEMBLY
10997static int
10998disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10999{
11000 printf (_("\nAssembly dump of section %s\n"),
11001 SECTION_NAME (section));
11002
11003 /* XXX -- to be done --- XXX */
11004
11005 return 1;
11006}
11007#endif
11008
11009/* Reads in the contents of SECTION from FILE, returning a pointer
11010 to a malloc'ed buffer or NULL if something went wrong. */
11011
11012static char *
11013get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11014{
11015 bfd_size_type num_bytes;
11016
11017 num_bytes = section->sh_size;
11018
11019 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11020 {
11021 printf (_("\nSection '%s' has no data to dump.\n"),
11022 SECTION_NAME (section));
11023 return NULL;
11024 }
11025
3f5e193b
NC		 11026 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11027 _("section contents"));
cf13d699
NC		 11028}
11029
dd24e3da 11030
cf13d699
NC		 11031static void
11032dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
11033{
11034 Elf_Internal_Shdr * relsec;
11035 bfd_size_type num_bytes;
cf13d699
NC		 11036 char * data;
11037 char * end;
11038 char * start;
11039 char * name = SECTION_NAME (section);
11040 bfd_boolean some_strings_shown;
11041
11042 start = get_section_contents (section, file);
11043 if (start == NULL)
11044 return;
11045
11046 printf (_("\nString dump of section '%s':\n"), name);
11047
11048 /* If the section being dumped has relocations against it the user might
11049 be expecting these relocations to have been applied. Check for this
11050 case and issue a warning message in order to avoid confusion.
11051 FIXME: Maybe we ought to have an option that dumps a section with
11052 relocs applied ? */
11053 for (relsec = section_headers;
11054 relsec < section_headers + elf_header.e_shnum;
11055 ++relsec)
11056 {
11057 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11058 || relsec->sh_info >= elf_header.e_shnum
11059 || section_headers + relsec->sh_info != section
11060 || relsec->sh_size == 0
11061 || relsec->sh_link >= elf_header.e_shnum)
11062 continue;
11063
11064 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11065 break;
11066 }
11067
11068 num_bytes = section->sh_size;
cf13d699
NC		 11069 data = start;
11070 end = start + num_bytes;
11071 some_strings_shown = FALSE;
11072
11073 while (data < end)
11074 {
11075 while (!ISPRINT (* data))
11076 if (++ data >= end)
11077 break;
11078
11079 if (data < end)
11080 {
11081#ifndef __MSVCRT__
c975cc98
NC		 11082 /* PR 11128: Use two separate invocations in order to work
11083 around bugs in the Solaris 8 implementation of printf. */
11084 printf (" [%6tx] ", data - start);
11085 printf ("%s\n", data);
cf13d699
NC		 11086#else
11087 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
11088#endif
11089 data += strlen (data);
11090 some_strings_shown = TRUE;
11091 }
11092 }
11093
11094 if (! some_strings_shown)
11095 printf (_(" No strings found in this section."));
11096
11097 free (start);
11098
11099 putchar ('\n');
11100}
11101
11102static void
11103dump_section_as_bytes (Elf_Internal_Shdr * section,
11104 FILE * file,
11105 bfd_boolean relocate)
11106{
11107 Elf_Internal_Shdr * relsec;
11108 bfd_size_type bytes;
11109 bfd_vma addr;
11110 unsigned char * data;
11111 unsigned char * start;
11112
11113 start = (unsigned char *) get_section_contents (section, file);
11114 if (start == NULL)
11115 return;
11116
11117 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
11118
11119 if (relocate)
11120 {
11121 apply_relocations (file, section, start);
11122 }
11123 else
11124 {
11125 /* If the section being dumped has relocations against it the user might
11126 be expecting these relocations to have been applied. Check for this
11127 case and issue a warning message in order to avoid confusion.
11128 FIXME: Maybe we ought to have an option that dumps a section with
11129 relocs applied ? */
11130 for (relsec = section_headers;
11131 relsec < section_headers + elf_header.e_shnum;
11132 ++relsec)
11133 {
11134 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11135 || relsec->sh_info >= elf_header.e_shnum
11136 || section_headers + relsec->sh_info != section
11137 || relsec->sh_size == 0
11138 || relsec->sh_link >= elf_header.e_shnum)
11139 continue;
11140
11141 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11142 break;
11143 }
11144 }
11145
11146 addr = section->sh_addr;
11147 bytes = section->sh_size;
11148 data = start;
11149
11150 while (bytes)
11151 {
11152 int j;
11153 int k;
11154 int lbytes;
11155
11156 lbytes = (bytes > 16 ? 16 : bytes);
11157
11158 printf (" 0x%8.8lx ", (unsigned long) addr);
11159
11160 for (j = 0; j < 16; j++)
11161 {
11162 if (j < lbytes)
11163 printf ("%2.2x", data[j]);
11164 else
11165 printf (" ");
11166
11167 if ((j & 3) == 3)
11168 printf (" ");
11169 }
11170
11171 for (j = 0; j < lbytes; j++)
11172 {
11173 k = data[j];
11174 if (k >= ' ' && k < 0x7f)
11175 printf ("%c", k);
11176 else
11177 printf (".");
11178 }
11179
11180 putchar ('\n');
11181
11182 data += lbytes;
11183 addr += lbytes;
11184 bytes -= lbytes;
11185 }
11186
11187 free (start);
11188
11189 putchar ('\n');
11190}
11191
4a114e3e 11192/* Uncompresses a section that was compressed using zlib, in place. */
cf13d699
NC		 11193
11194static int
d3dbc530
AM		 11195uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
11196 dwarf_size_type *size ATTRIBUTE_UNUSED)
cf13d699
NC		 11197{
11198#ifndef HAVE_ZLIB_H
cf13d699
NC		 11199 return FALSE;
11200#else
11201 dwarf_size_type compressed_size = *size;
11202 unsigned char * compressed_buffer = *buffer;
11203 dwarf_size_type uncompressed_size;
11204 unsigned char * uncompressed_buffer;
11205 z_stream strm;
11206 int rc;
11207 dwarf_size_type header_size = 12;
11208
11209 /* Read the zlib header. In this case, it should be "ZLIB" followed
11210 by the uncompressed section size, 8 bytes in big-endian order. */
11211 if (compressed_size < header_size
11212 || ! streq ((char *) compressed_buffer, "ZLIB"))
11213 return 0;
11214
11215 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
11216 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
11217 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
11218 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
11219 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
11220 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
11221 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
11222 uncompressed_size += compressed_buffer[11];
11223
11224 /* It is possible the section consists of several compressed
11225 buffers concatenated together, so we uncompress in a loop. */
11226 strm.zalloc = NULL;
11227 strm.zfree = NULL;
11228 strm.opaque = NULL;
11229 strm.avail_in = compressed_size - header_size;
11230 strm.next_in = (Bytef *) compressed_buffer + header_size;
11231 strm.avail_out = uncompressed_size;
3f5e193b 11232 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
cf13d699
NC		 11233
11234 rc = inflateInit (& strm);
11235 while (strm.avail_in > 0)
11236 {
11237 if (rc != Z_OK)
11238 goto fail;
11239 strm.next_out = ((Bytef *) uncompressed_buffer
11240 + (uncompressed_size - strm.avail_out));
11241 rc = inflate (&strm, Z_FINISH);
11242 if (rc != Z_STREAM_END)
11243 goto fail;
11244 rc = inflateReset (& strm);
11245 }
11246 rc = inflateEnd (& strm);
11247 if (rc != Z_OK
11248 || strm.avail_out != 0)
11249 goto fail;
11250
11251 free (compressed_buffer);
11252 *buffer = uncompressed_buffer;
11253 *size = uncompressed_size;
11254 return 1;
11255
11256 fail:
11257 free (uncompressed_buffer);
4a114e3e
L		 11258 /* Indicate decompression failure. */
11259 *buffer = NULL;
cf13d699
NC		 11260 return 0;
11261#endif /* HAVE_ZLIB_H */
11262}
11263
d966045b
DJ		 11264static int
11265load_specific_debug_section (enum dwarf_section_display_enum debug,
2cf0635d 11266 Elf_Internal_Shdr * sec, void * file)
1007acb3 11267{
2cf0635d 11268 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 11269 char buf [64];
1007acb3 11270
19e6b90e
L		 11271 /* If it is already loaded, do nothing. */
11272 if (section->start != NULL)
11273 return 1;
1007acb3 11274
19e6b90e
L		 11275 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
11276 section->address = sec->sh_addr;
3f5e193b
NC		 11277 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
11278 sec->sh_offset, 1,
11279 sec->sh_size, buf);
59245841
NC		 11280 if (section->start == NULL)
11281 section->size = 0;
11282 else
11283 {
11284 section->size = sec->sh_size;
11285 if (uncompress_section_contents (&section->start, &section->size))
11286 sec->sh_size = section->size;
11287 }
4a114e3e 11288
1b315056
CS		 11289 if (section->start == NULL)
11290 return 0;
11291
19e6b90e 11292 if (debug_displays [debug].relocate)
3f5e193b 11293 apply_relocations ((FILE *) file, sec, section->start);
1007acb3 11294
1b315056 11295 return 1;
1007acb3
L		 11296}
11297
657d0d47
CC		 11298/* If this is not NULL, load_debug_section will only look for sections
11299 within the list of sections given here. */
11300unsigned int *section_subset = NULL;
11301
d966045b 11302int
2cf0635d 11303load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 11304{
2cf0635d
NC		 11305 struct dwarf_section * section = &debug_displays [debug].section;
11306 Elf_Internal_Shdr * sec;
d966045b
DJ		 11307
11308 /* Locate the debug section. */
657d0d47 11309 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 11310 if (sec != NULL)
11311 section->name = section->uncompressed_name;
11312 else
11313 {
657d0d47 11314 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 11315 if (sec != NULL)
11316 section->name = section->compressed_name;
11317 }
11318 if (sec == NULL)
11319 return 0;
11320
657d0d47
CC		 11321 /* If we're loading from a subset of sections, and we've loaded
11322 a section matching this name before, it's likely that it's a
11323 different one. */
11324 if (section_subset != NULL)
11325 free_debug_section (debug);
11326
3f5e193b 11327 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 11328}
11329
19e6b90e
L		 11330void
11331free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 11332{
2cf0635d 11333 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 11334
19e6b90e
L		 11335 if (section->start == NULL)
11336 return;
1007acb3 11337
19e6b90e
L		 11338 free ((char *) section->start);
11339 section->start = NULL;
11340 section->address = 0;
11341 section->size = 0;
1007acb3
L		 11342}
11343
1007acb3 11344static int
657d0d47 11345display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 11346{
2cf0635d 11347 char * name = SECTION_NAME (section);
19e6b90e
L		 11348 bfd_size_type length;
11349 int result = 1;
3f5e193b 11350 int i;
1007acb3 11351
19e6b90e
L		 11352 length = section->sh_size;
11353 if (length == 0)
1007acb3 11354 {
19e6b90e
L		 11355 printf (_("\nSection '%s' has no debugging data.\n"), name);
11356 return 0;
1007acb3 11357 }
5dff79d8
NC		 11358 if (section->sh_type == SHT_NOBITS)
11359 {
11360 /* There is no point in dumping the contents of a debugging section
11361 which has the NOBITS type - the bits in the file will be random.
11362 This can happen when a file containing a .eh_frame section is
11363 stripped with the --only-keep-debug command line option. */
11364 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
11365 return 0;
11366 }
1007acb3 11367
0112cd26 11368 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 11369 name = ".debug_info";
1007acb3 11370
19e6b90e
L		 11371 /* See if we know how to display the contents of this section. */
11372 for (i = 0; i < max; i++)
1b315056 11373 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 11374 || (i == line && const_strneq (name, ".debug_line."))
1b315056 11375 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 11376 {
2cf0635d 11377 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 11378 int secondary = (section != find_section (name));
11379
11380 if (secondary)
3f5e193b 11381 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 11382
b40bf0a2
NC		 11383 if (i == line && const_strneq (name, ".debug_line."))
11384 sec->name = name;
11385 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 11386 sec->name = sec->uncompressed_name;
11387 else
11388 sec->name = sec->compressed_name;
3f5e193b
NC		 11389 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
11390 section, file))
19e6b90e 11391 {
657d0d47
CC		 11392 /* If this debug section is part of a CU/TU set in a .dwp file,
11393 restrict load_debug_section to the sections in that set. */
11394 section_subset = find_cu_tu_set (file, shndx);
11395
19e6b90e 11396 result &= debug_displays[i].display (sec, file);
1007acb3 11397
657d0d47
CC		 11398 section_subset = NULL;
11399
d966045b 11400 if (secondary || (i != info && i != abbrev))
3f5e193b 11401 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 11402 }
1007acb3 11403
19e6b90e
L		 11404 break;
11405 }
1007acb3 11406
19e6b90e 11407 if (i == max)
1007acb3 11408 {
19e6b90e
L		 11409 printf (_("Unrecognized debug section: %s\n"), name);
11410 result = 0;
1007acb3
L		 11411 }
11412
19e6b90e 11413 return result;
5b18a4bc 11414}
103f02d3 11415
aef1f6d0
DJ		 11416/* Set DUMP_SECTS for all sections where dumps were requested
11417 based on section name. */
11418
11419static void
11420initialise_dumps_byname (void)
11421{
2cf0635d 11422 struct dump_list_entry * cur;
aef1f6d0
DJ		 11423
11424 for (cur = dump_sects_byname; cur; cur = cur->next)
11425 {
11426 unsigned int i;
11427 int any;
11428
11429 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
11430 if (streq (SECTION_NAME (section_headers + i), cur->name))
11431 {
09c11c86 11432 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 11433 any = 1;
11434 }
11435
11436 if (!any)
11437 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11438 cur->name);
11439 }
11440}
11441
5b18a4bc 11442static void
2cf0635d 11443process_section_contents (FILE * file)
5b18a4bc 11444{
2cf0635d 11445 Elf_Internal_Shdr * section;
19e6b90e 11446 unsigned int i;
103f02d3 11447
19e6b90e
L		 11448 if (! do_dump)
11449 return;
103f02d3 11450
aef1f6d0
DJ		 11451 initialise_dumps_byname ();
11452
19e6b90e
L		 11453 for (i = 0, section = section_headers;
11454 i < elf_header.e_shnum && i < num_dump_sects;
11455 i++, section++)
11456 {
11457#ifdef SUPPORT_DISASSEMBLY
11458 if (dump_sects[i] & DISASS_DUMP)
11459 disassemble_section (section, file);
11460#endif
11461 if (dump_sects[i] & HEX_DUMP)
cf13d699 11462 dump_section_as_bytes (section, file, FALSE);
103f02d3 11463
cf13d699
NC		 11464 if (dump_sects[i] & RELOC_DUMP)
11465 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 11466
11467 if (dump_sects[i] & STRING_DUMP)
11468 dump_section_as_strings (section, file);
cf13d699
NC		 11469
11470 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 11471 display_debug_section (i, section, file);
5b18a4bc 11472 }
103f02d3 11473
19e6b90e
L		 11474 /* Check to see if the user requested a
11475 dump of a section that does not exist. */
11476 while (i++ < num_dump_sects)
11477 if (dump_sects[i])
11478 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 11479}
103f02d3 11480
5b18a4bc 11481static void
19e6b90e 11482process_mips_fpe_exception (int mask)
5b18a4bc 11483{
19e6b90e
L		 11484 if (mask)
11485 {
11486 int first = 1;
11487 if (mask & OEX_FPU_INEX)
11488 fputs ("INEX", stdout), first = 0;
11489 if (mask & OEX_FPU_UFLO)
11490 printf ("%sUFLO", first ? "" : "|"), first = 0;
11491 if (mask & OEX_FPU_OFLO)
11492 printf ("%sOFLO", first ? "" : "|"), first = 0;
11493 if (mask & OEX_FPU_DIV0)
11494 printf ("%sDIV0", first ? "" : "|"), first = 0;
11495 if (mask & OEX_FPU_INVAL)
11496 printf ("%sINVAL", first ? "" : "|");
11497 }
5b18a4bc 11498 else
19e6b90e 11499 fputs ("0", stdout);
5b18a4bc 11500}
103f02d3 11501
f6f0e17b
NC		 11502/* Display's the value of TAG at location P. If TAG is
11503 greater than 0 it is assumed to be an unknown tag, and
11504 a message is printed to this effect. Otherwise it is
11505 assumed that a message has already been printed.
11506
11507 If the bottom bit of TAG is set it assumed to have a
11508 string value, otherwise it is assumed to have an integer
11509 value.
11510
11511 Returns an updated P pointing to the first unread byte
11512 beyond the end of TAG's value.
11513
11514 Reads at or beyond END will not be made. */
11515
11516static unsigned char *
11517display_tag_value (int tag,
11518 unsigned char * p,
11519 const unsigned char * const end)
11520{
11521 unsigned long val;
11522
11523 if (tag > 0)
11524 printf (" Tag_unknown_%d: ", tag);
11525
11526 if (p >= end)
11527 {
11528 warn (_("corrupt tag\n"));
11529 }
11530 else if (tag & 1)
11531 {
11532 /* FIXME: we could read beyond END here. */
11533 printf ("\"%s\"\n", p);
11534 p += strlen ((char *) p) + 1;
11535 }
11536 else
11537 {
11538 unsigned int len;
11539
11540 val = read_uleb128 (p, &len, end);
11541 p += len;
11542 printf ("%ld (0x%lx)\n", val, val);
11543 }
11544
11545 return p;
11546}
11547
11c1ff18
PB		 11548/* ARM EABI attributes section. */
11549typedef struct
11550{
70e99720 11551 unsigned int tag;
2cf0635d 11552 const char * name;
11c1ff18 11553 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 11554 unsigned int type;
2cf0635d 11555 const char ** table;
11c1ff18
PB		 11556} arm_attr_public_tag;
11557
2cf0635d 11558static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 11559 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 11560 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 11561static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
11562static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 11563 {"No", "Thumb-1", "Thumb-2"};
75375b3e 11564static const char * arm_attr_tag_FP_arch[] =
bca38921
MGD		 11565 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11566 "FP for ARMv8"};
2cf0635d 11567static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 11568static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 11569 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 11570static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 11571 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11572 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 11573static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 11574 {"V6", "SB", "TLS", "Unused"};
2cf0635d 11575static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 11576 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 11577static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 11578 {"Absolute", "PC-relative", "None"};
2cf0635d 11579static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 11580 {"None", "direct", "GOT-indirect"};
2cf0635d 11581static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 11582 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 11583static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
11584static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 11585 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 11586static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
11587static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
11588static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 11589 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 11590static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 11591 {"Unused", "small", "int", "forced to int"};
2cf0635d 11592static const char * arm_attr_tag_ABI_HardFP_use[] =
75375b3e 11593 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
2cf0635d 11594static const char * arm_attr_tag_ABI_VFP_args[] =
11c1ff18 11595 {"AAPCS", "VFP registers", "custom"};
2cf0635d 11596static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 11597 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 11598static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 11599 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11600 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 11601static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 11602 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11603 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 11604static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 11605static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 11606 {"Not Allowed", "Allowed"};
2cf0635d 11607static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 11608 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 11609static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 11610 {"Not Allowed", "Allowed"};
11611static const char * arm_attr_tag_DIV_use[] =
dd24e3da 11612 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 11613 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 11614static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
11615static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 11616 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 11617 "TrustZone and Virtualization Extensions"};
dd24e3da 11618static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 11619 {"Not Allowed", "Allowed"};
11c1ff18
PB		 11620
11621#define LOOKUP(id, name) \
11622 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 11623static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 11624{
11625 {4, "CPU_raw_name", 1, NULL},
11626 {5, "CPU_name", 1, NULL},
11627 LOOKUP(6, CPU_arch),
11628 {7, "CPU_arch_profile", 0, NULL},
11629 LOOKUP(8, ARM_ISA_use),
11630 LOOKUP(9, THUMB_ISA_use),
75375b3e 11631 LOOKUP(10, FP_arch),
11c1ff18 11632 LOOKUP(11, WMMX_arch),
f5f53991
AS		 11633 LOOKUP(12, Advanced_SIMD_arch),
11634 LOOKUP(13, PCS_config),
11c1ff18
PB		 11635 LOOKUP(14, ABI_PCS_R9_use),
11636 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 11637 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 11638 LOOKUP(17, ABI_PCS_GOT_use),
11639 LOOKUP(18, ABI_PCS_wchar_t),
11640 LOOKUP(19, ABI_FP_rounding),
11641 LOOKUP(20, ABI_FP_denormal),
11642 LOOKUP(21, ABI_FP_exceptions),
11643 LOOKUP(22, ABI_FP_user_exceptions),
11644 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 11645 {24, "ABI_align_needed", 0, NULL},
11646 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 11647 LOOKUP(26, ABI_enum_size),
11648 LOOKUP(27, ABI_HardFP_use),
11649 LOOKUP(28, ABI_VFP_args),
11650 LOOKUP(29, ABI_WMMX_args),
11651 LOOKUP(30, ABI_optimization_goals),
11652 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 11653 {32, "compatibility", 0, NULL},
f5f53991 11654 LOOKUP(34, CPU_unaligned_access),
75375b3e 11655 LOOKUP(36, FP_HP_extension),
8e79c3df 11656 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 11657 LOOKUP(42, MPextension_use),
11658 LOOKUP(44, DIV_use),
f5f53991
AS		 11659 {64, "nodefaults", 0, NULL},
11660 {65, "also_compatible_with", 0, NULL},
11661 LOOKUP(66, T2EE_use),
11662 {67, "conformance", 1, NULL},
11663 LOOKUP(68, Virtualization_use),
cd21e546 11664 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 11665};
11666#undef LOOKUP
11667
11c1ff18 11668static unsigned char *
f6f0e17b
NC		 11669display_arm_attribute (unsigned char * p,
11670 const unsigned char * const end)
11c1ff18 11671{
70e99720 11672 unsigned int tag;
11c1ff18 11673 unsigned int len;
70e99720 11674 unsigned int val;
2cf0635d 11675 arm_attr_public_tag * attr;
11c1ff18 11676 unsigned i;
70e99720 11677 unsigned int type;
11c1ff18 11678
f6f0e17b 11679 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 11680 p += len;
11681 attr = NULL;
2cf0635d 11682 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 11683 {
11684 if (arm_attr_public_tags[i].tag == tag)
11685 {
11686 attr = &arm_attr_public_tags[i];
11687 break;
11688 }
11689 }
11690
11691 if (attr)
11692 {
11693 printf (" Tag_%s: ", attr->name);
11694 switch (attr->type)
11695 {
11696 case 0:
11697 switch (tag)
11698 {
11699 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 11700 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 11701 p += len;
11702 switch (val)
11703 {
2b692964
NC		 11704 case 0: printf (_("None\n")); break;
11705 case 'A': printf (_("Application\n")); break;
11706 case 'R': printf (_("Realtime\n")); break;
11707 case 'M': printf (_("Microcontroller\n")); break;
11708 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 11709 default: printf ("??? (%d)\n", val); break;
11710 }
11711 break;
11712
75375b3e 11713 case 24: /* Tag_align_needed. */
f6f0e17b 11714 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 11715 p += len;
11716 switch (val)
11717 {
2b692964
NC		 11718 case 0: printf (_("None\n")); break;
11719 case 1: printf (_("8-byte\n")); break;
11720 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 11721 case 3: printf ("??? 3\n"); break;
11722 default:
11723 if (val <= 12)
dd24e3da 11724 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 11725 1 << val);
11726 else
11727 printf ("??? (%d)\n", val);
11728 break;
11729 }
11730 break;
11731
11732 case 25: /* Tag_align_preserved. */
f6f0e17b 11733 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 11734 p += len;
11735 switch (val)
11736 {
2b692964
NC		 11737 case 0: printf (_("None\n")); break;
11738 case 1: printf (_("8-byte, except leaf SP\n")); break;
11739 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 11740 case 3: printf ("??? 3\n"); break;
11741 default:
11742 if (val <= 12)
dd24e3da 11743 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 11744 1 << val);
11745 else
11746 printf ("??? (%d)\n", val);
11747 break;
11748 }
11749 break;
11750
11c1ff18 11751 case 32: /* Tag_compatibility. */
f6f0e17b 11752 val = read_uleb128 (p, &len, end);
11c1ff18 11753 p += len;
2b692964 11754 printf (_("flag = %d, vendor = %s\n"), val, p);
2cf0635d 11755 p += strlen ((char *) p) + 1;
11c1ff18
PB		 11756 break;
11757
f5f53991
AS		 11758 case 64: /* Tag_nodefaults. */
11759 p++;
2b692964 11760 printf (_("True\n"));
f5f53991
AS		 11761 break;
11762
11763 case 65: /* Tag_also_compatible_with. */
f6f0e17b 11764 val = read_uleb128 (p, &len, end);
f5f53991
AS		 11765 p += len;
11766 if (val == 6 /* Tag_CPU_arch. */)
11767 {
f6f0e17b 11768 val = read_uleb128 (p, &len, end);
f5f53991 11769 p += len;
2cf0635d 11770 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 11771 printf ("??? (%d)\n", val);
11772 else
11773 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
11774 }
11775 else
11776 printf ("???\n");
11777 while (*(p++) != '\0' /* NUL terminator. */);
11778 break;
11779
11c1ff18 11780 default:
2cf0635d 11781 abort ();
11c1ff18
PB		 11782 }
11783 return p;
11784
11785 case 1:
f6f0e17b 11786 return display_tag_value (-1, p, end);
11c1ff18 11787 case 2:
f6f0e17b 11788 return display_tag_value (0, p, end);
11c1ff18
PB		 11789
11790 default:
11791 assert (attr->type & 0x80);
f6f0e17b 11792 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 11793 p += len;
11794 type = attr->type & 0x7f;
11795 if (val >= type)
11796 printf ("??? (%d)\n", val);
11797 else
11798 printf ("%s\n", attr->table[val]);
11799 return p;
11800 }
11801 }
11c1ff18 11802
f6f0e17b 11803 return display_tag_value (tag, p, end);
11c1ff18
PB		 11804}
11805
104d59d1 11806static unsigned char *
60bca95a 11807display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 11808 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
11809 const unsigned char * const end)
104d59d1
JM		 11810{
11811 int tag;
11812 unsigned int len;
11813 int val;
104d59d1 11814
f6f0e17b 11815 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 11816 p += len;
11817
11818 /* Tag_compatibility is the only generic GNU attribute defined at
11819 present. */
11820 if (tag == 32)
11821 {
f6f0e17b 11822 val = read_uleb128 (p, &len, end);
104d59d1 11823 p += len;
f6f0e17b
NC		 11824 if (p == end)
11825 {
11826 printf (_("flag = %d, vendor = <corrupt>\n"), val);
11827 warn (_("corrupt vendor attribute\n"));
11828 }
11829 else
11830 {
11831 printf (_("flag = %d, vendor = %s\n"), val, p);
11832 p += strlen ((char *) p) + 1;
11833 }
104d59d1
JM		 11834 return p;
11835 }
11836
11837 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 11838 return display_proc_gnu_attribute (p, tag, end);
104d59d1 11839
f6f0e17b 11840 return display_tag_value (tag, p, end);
104d59d1
JM		 11841}
11842
34c8bcba 11843static unsigned char *
f6f0e17b
NC		 11844display_power_gnu_attribute (unsigned char * p,
11845 int tag,
11846 const unsigned char * const end)
34c8bcba 11847{
34c8bcba
JM		 11848 unsigned int len;
11849 int val;
11850
11851 if (tag == Tag_GNU_Power_ABI_FP)
11852 {
f6f0e17b 11853 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 11854 p += len;
11855 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 11856
34c8bcba
JM		 11857 switch (val)
11858 {
11859 case 0:
2b692964 11860 printf (_("Hard or soft float\n"));
34c8bcba
JM		 11861 break;
11862 case 1:
2b692964 11863 printf (_("Hard float\n"));
34c8bcba
JM		 11864 break;
11865 case 2:
2b692964 11866 printf (_("Soft float\n"));
34c8bcba 11867 break;
3c7b9897 11868 case 3:
2b692964 11869 printf (_("Single-precision hard float\n"));
3c7b9897 11870 break;
34c8bcba
JM		 11871 default:
11872 printf ("??? (%d)\n", val);
11873 break;
11874 }
11875 return p;
11876 }
11877
c6e65352
DJ		 11878 if (tag == Tag_GNU_Power_ABI_Vector)
11879 {
f6f0e17b 11880 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 11881 p += len;
11882 printf (" Tag_GNU_Power_ABI_Vector: ");
11883 switch (val)
11884 {
11885 case 0:
2b692964 11886 printf (_("Any\n"));
c6e65352
DJ		 11887 break;
11888 case 1:
2b692964 11889 printf (_("Generic\n"));
c6e65352
DJ		 11890 break;
11891 case 2:
11892 printf ("AltiVec\n");
11893 break;
11894 case 3:
11895 printf ("SPE\n");
11896 break;
11897 default:
11898 printf ("??? (%d)\n", val);
11899 break;
11900 }
11901 return p;
11902 }
11903
f82e0623
NF		 11904 if (tag == Tag_GNU_Power_ABI_Struct_Return)
11905 {
f6f0e17b
NC		 11906 if (p == end)
11907 {
11908 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return"));
11909 return p;
11910 }
0b4362b0 11911
f6f0e17b 11912 val = read_uleb128 (p, &len, end);
f82e0623
NF		 11913 p += len;
11914 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11915 switch (val)
11916 {
11917 case 0:
2b692964 11918 printf (_("Any\n"));
f82e0623
NF		 11919 break;
11920 case 1:
11921 printf ("r3/r4\n");
11922 break;
11923 case 2:
2b692964 11924 printf (_("Memory\n"));
f82e0623
NF		 11925 break;
11926 default:
11927 printf ("??? (%d)\n", val);
11928 break;
11929 }
11930 return p;
11931 }
11932
f6f0e17b 11933 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 11934}
11935
9e8c70f9
DM		 11936static void
11937display_sparc_hwcaps (int mask)
11938{
11939 if (mask)
11940 {
11941 int first = 1;
11942 if (mask & ELF_SPARC_HWCAP_MUL32)
11943 fputs ("mul32", stdout), first = 0;
11944 if (mask & ELF_SPARC_HWCAP_DIV32)
11945 printf ("%sdiv32", first ? "" : "|"), first = 0;
11946 if (mask & ELF_SPARC_HWCAP_FSMULD)
11947 printf ("%sfsmuld", first ? "" : "|"), first = 0;
11948 if (mask & ELF_SPARC_HWCAP_V8PLUS)
11949 printf ("%sv8plus", first ? "" : "|"), first = 0;
11950 if (mask & ELF_SPARC_HWCAP_POPC)
11951 printf ("%spopc", first ? "" : "|"), first = 0;
11952 if (mask & ELF_SPARC_HWCAP_VIS)
11953 printf ("%svis", first ? "" : "|"), first = 0;
11954 if (mask & ELF_SPARC_HWCAP_VIS2)
11955 printf ("%svis2", first ? "" : "|"), first = 0;
11956 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
11957 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
11958 if (mask & ELF_SPARC_HWCAP_FMAF)
11959 printf ("%sfmaf", first ? "" : "|"), first = 0;
11960 if (mask & ELF_SPARC_HWCAP_VIS3)
11961 printf ("%svis3", first ? "" : "|"), first = 0;
11962 if (mask & ELF_SPARC_HWCAP_HPC)
11963 printf ("%shpc", first ? "" : "|"), first = 0;
11964 if (mask & ELF_SPARC_HWCAP_RANDOM)
11965 printf ("%srandom", first ? "" : "|"), first = 0;
11966 if (mask & ELF_SPARC_HWCAP_TRANS)
11967 printf ("%strans", first ? "" : "|"), first = 0;
11968 if (mask & ELF_SPARC_HWCAP_FJFMAU)
11969 printf ("%sfjfmau", first ? "" : "|"), first = 0;
11970 if (mask & ELF_SPARC_HWCAP_IMA)
11971 printf ("%sima", first ? "" : "|"), first = 0;
11972 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
11973 printf ("%scspare", first ? "" : "|"), first = 0;
11974 }
11975 else
11976 fputc('0', stdout);
11977 fputc('\n', stdout);
11978}
11979
3d68f91c
JM		 11980static void
11981display_sparc_hwcaps2 (int mask)
11982{
11983 if (mask)
11984 {
11985 int first = 1;
11986 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
11987 fputs ("fjathplus", stdout), first = 0;
11988 if (mask & ELF_SPARC_HWCAP2_VIS3B)
11989 printf ("%svis3b", first ? "" : "|"), first = 0;
11990 if (mask & ELF_SPARC_HWCAP2_ADP)
11991 printf ("%sadp", first ? "" : "|"), first = 0;
11992 if (mask & ELF_SPARC_HWCAP2_SPARC5)
11993 printf ("%ssparc5", first ? "" : "|"), first = 0;
11994 if (mask & ELF_SPARC_HWCAP2_MWAIT)
11995 printf ("%smwait", first ? "" : "|"), first = 0;
11996 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
11997 printf ("%sxmpmul", first ? "" : "|"), first = 0;
11998 if (mask & ELF_SPARC_HWCAP2_XMONT)
11999 printf ("%sxmont2", first ? "" : "|"), first = 0;
12000 if (mask & ELF_SPARC_HWCAP2_NSEC)
12001 printf ("%snsec", first ? "" : "|"), first = 0;
12002 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
12003 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
12004 if (mask & ELF_SPARC_HWCAP2_FJDES)
12005 printf ("%sfjdes", first ? "" : "|"), first = 0;
12006 if (mask & ELF_SPARC_HWCAP2_FJAES)
12007 printf ("%sfjaes", first ? "" : "|"), first = 0;
12008 }
12009 else
12010 fputc('0', stdout);
12011 fputc('\n', stdout);
12012}
12013
9e8c70f9 12014static unsigned char *
f6f0e17b
NC		 12015display_sparc_gnu_attribute (unsigned char * p,
12016 int tag,
12017 const unsigned char * const end)
9e8c70f9 12018{
3d68f91c
JM		 12019 unsigned int len;
12020 int val;
12021
9e8c70f9
DM		 12022 if (tag == Tag_GNU_Sparc_HWCAPS)
12023 {
f6f0e17b 12024 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 12025 p += len;
12026 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 12027 display_sparc_hwcaps (val);
12028 return p;
3d68f91c
JM		 12029 }
12030 if (tag == Tag_GNU_Sparc_HWCAPS2)
12031 {
12032 val = read_uleb128 (p, &len, end);
12033 p += len;
12034 printf (" Tag_GNU_Sparc_HWCAPS2: ");
12035 display_sparc_hwcaps2 (val);
12036 return p;
12037 }
9e8c70f9 12038
f6f0e17b 12039 return display_tag_value (tag, p, end);
9e8c70f9
DM		 12040}
12041
351cdf24
MF		 12042static void
12043print_mips_fp_abi_value (int val)
12044{
12045 switch (val)
12046 {
12047 case Val_GNU_MIPS_ABI_FP_ANY:
12048 printf (_("Hard or soft float\n"));
12049 break;
12050 case Val_GNU_MIPS_ABI_FP_DOUBLE:
12051 printf (_("Hard float (double precision)\n"));
12052 break;
12053 case Val_GNU_MIPS_ABI_FP_SINGLE:
12054 printf (_("Hard float (single precision)\n"));
12055 break;
12056 case Val_GNU_MIPS_ABI_FP_SOFT:
12057 printf (_("Soft float\n"));
12058 break;
12059 case Val_GNU_MIPS_ABI_FP_OLD_64:
12060 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12061 break;
12062 case Val_GNU_MIPS_ABI_FP_XX:
12063 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12064 break;
12065 case Val_GNU_MIPS_ABI_FP_64:
12066 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12067 break;
12068 case Val_GNU_MIPS_ABI_FP_64A:
12069 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12070 break;
12071 default:
12072 printf ("??? (%d)\n", val);
12073 break;
12074 }
12075}
12076
2cf19d5c 12077static unsigned char *
f6f0e17b
NC		 12078display_mips_gnu_attribute (unsigned char * p,
12079 int tag,
12080 const unsigned char * const end)
2cf19d5c 12081{
2cf19d5c
JM		 12082 if (tag == Tag_GNU_MIPS_ABI_FP)
12083 {
f6f0e17b
NC		 12084 unsigned int len;
12085 int val;
12086
12087 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 12088 p += len;
12089 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 12090
351cdf24
MF		 12091 print_mips_fp_abi_value (val);
12092
2cf19d5c
JM		 12093 return p;
12094 }
12095
a9f58168
CF		 12096 if (tag == Tag_GNU_MIPS_ABI_MSA)
12097 {
12098 unsigned int len;
12099 int val;
12100
12101 val = read_uleb128 (p, &len, end);
12102 p += len;
12103 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12104
12105 switch (val)
12106 {
12107 case Val_GNU_MIPS_ABI_MSA_ANY:
12108 printf (_("Any MSA or not\n"));
12109 break;
12110 case Val_GNU_MIPS_ABI_MSA_128:
12111 printf (_("128-bit MSA\n"));
12112 break;
12113 default:
12114 printf ("??? (%d)\n", val);
12115 break;
12116 }
12117 return p;
12118 }
12119
f6f0e17b 12120 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 12121}
12122
59e6276b 12123static unsigned char *
f6f0e17b
NC		 12124display_tic6x_attribute (unsigned char * p,
12125 const unsigned char * const end)
59e6276b
JM		 12126{
12127 int tag;
12128 unsigned int len;
12129 int val;
12130
f6f0e17b 12131 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 12132 p += len;
12133
12134 switch (tag)
12135 {
75fa6dc1 12136 case Tag_ISA:
f6f0e17b 12137 val = read_uleb128 (p, &len, end);
59e6276b 12138 p += len;
75fa6dc1 12139 printf (" Tag_ISA: ");
59e6276b
JM		 12140
12141 switch (val)
12142 {
75fa6dc1 12143 case C6XABI_Tag_ISA_none:
59e6276b
JM		 12144 printf (_("None\n"));
12145 break;
75fa6dc1 12146 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 12147 printf ("C62x\n");
12148 break;
75fa6dc1 12149 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 12150 printf ("C67x\n");
12151 break;
75fa6dc1 12152 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 12153 printf ("C67x+\n");
12154 break;
75fa6dc1 12155 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 12156 printf ("C64x\n");
12157 break;
75fa6dc1 12158 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 12159 printf ("C64x+\n");
12160 break;
75fa6dc1 12161 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 12162 printf ("C674x\n");
12163 break;
12164 default:
12165 printf ("??? (%d)\n", val);
12166 break;
12167 }
12168 return p;
12169
87779176 12170 case Tag_ABI_wchar_t:
f6f0e17b 12171 val = read_uleb128 (p, &len, end);
87779176
JM		 12172 p += len;
12173 printf (" Tag_ABI_wchar_t: ");
12174 switch (val)
12175 {
12176 case 0:
12177 printf (_("Not used\n"));
12178 break;
12179 case 1:
12180 printf (_("2 bytes\n"));
12181 break;
12182 case 2:
12183 printf (_("4 bytes\n"));
12184 break;
12185 default:
12186 printf ("??? (%d)\n", val);
12187 break;
12188 }
12189 return p;
12190
12191 case Tag_ABI_stack_align_needed:
f6f0e17b 12192 val = read_uleb128 (p, &len, end);
87779176
JM		 12193 p += len;
12194 printf (" Tag_ABI_stack_align_needed: ");
12195 switch (val)
12196 {
12197 case 0:
12198 printf (_("8-byte\n"));
12199 break;
12200 case 1:
12201 printf (_("16-byte\n"));
12202 break;
12203 default:
12204 printf ("??? (%d)\n", val);
12205 break;
12206 }
12207 return p;
12208
12209 case Tag_ABI_stack_align_preserved:
f6f0e17b 12210 val = read_uleb128 (p, &len, end);
87779176
JM		 12211 p += len;
12212 printf (" Tag_ABI_stack_align_preserved: ");
12213 switch (val)
12214 {
12215 case 0:
12216 printf (_("8-byte\n"));
12217 break;
12218 case 1:
12219 printf (_("16-byte\n"));
12220 break;
12221 default:
12222 printf ("??? (%d)\n", val);
12223 break;
12224 }
12225 return p;
12226
b5593623 12227 case Tag_ABI_DSBT:
f6f0e17b 12228 val = read_uleb128 (p, &len, end);
b5593623
JM		 12229 p += len;
12230 printf (" Tag_ABI_DSBT: ");
12231 switch (val)
12232 {
12233 case 0:
12234 printf (_("DSBT addressing not used\n"));
12235 break;
12236 case 1:
12237 printf (_("DSBT addressing used\n"));
12238 break;
12239 default:
12240 printf ("??? (%d)\n", val);
12241 break;
12242 }
12243 return p;
12244
87779176 12245 case Tag_ABI_PID:
f6f0e17b 12246 val = read_uleb128 (p, &len, end);
87779176
JM		 12247 p += len;
12248 printf (" Tag_ABI_PID: ");
12249 switch (val)
12250 {
12251 case 0:
12252 printf (_("Data addressing position-dependent\n"));
12253 break;
12254 case 1:
12255 printf (_("Data addressing position-independent, GOT near DP\n"));
12256 break;
12257 case 2:
12258 printf (_("Data addressing position-independent, GOT far from DP\n"));
12259 break;
12260 default:
12261 printf ("??? (%d)\n", val);
12262 break;
12263 }
12264 return p;
12265
12266 case Tag_ABI_PIC:
f6f0e17b 12267 val = read_uleb128 (p, &len, end);
87779176
JM		 12268 p += len;
12269 printf (" Tag_ABI_PIC: ");
12270 switch (val)
12271 {
12272 case 0:
12273 printf (_("Code addressing position-dependent\n"));
12274 break;
12275 case 1:
12276 printf (_("Code addressing position-independent\n"));
12277 break;
12278 default:
12279 printf ("??? (%d)\n", val);
12280 break;
12281 }
12282 return p;
12283
12284 case Tag_ABI_array_object_alignment:
f6f0e17b 12285 val = read_uleb128 (p, &len, end);
87779176
JM		 12286 p += len;
12287 printf (" Tag_ABI_array_object_alignment: ");
12288 switch (val)
12289 {
12290 case 0:
12291 printf (_("8-byte\n"));
12292 break;
12293 case 1:
12294 printf (_("4-byte\n"));
12295 break;
12296 case 2:
12297 printf (_("16-byte\n"));
12298 break;
12299 default:
12300 printf ("??? (%d)\n", val);
12301 break;
12302 }
12303 return p;
12304
12305 case Tag_ABI_array_object_align_expected:
f6f0e17b 12306 val = read_uleb128 (p, &len, end);
87779176
JM		 12307 p += len;
12308 printf (" Tag_ABI_array_object_align_expected: ");
12309 switch (val)
12310 {
12311 case 0:
12312 printf (_("8-byte\n"));
12313 break;
12314 case 1:
12315 printf (_("4-byte\n"));
12316 break;
12317 case 2:
12318 printf (_("16-byte\n"));
12319 break;
12320 default:
12321 printf ("??? (%d)\n", val);
12322 break;
12323 }
12324 return p;
12325
3cbd1c06 12326 case Tag_ABI_compatibility:
f6f0e17b 12327 val = read_uleb128 (p, &len, end);
59e6276b 12328 p += len;
3cbd1c06 12329 printf (" Tag_ABI_compatibility: ");
59e6276b
JM		 12330 printf (_("flag = %d, vendor = %s\n"), val, p);
12331 p += strlen ((char *) p) + 1;
12332 return p;
87779176
JM		 12333
12334 case Tag_ABI_conformance:
12335 printf (" Tag_ABI_conformance: ");
12336 printf ("\"%s\"\n", p);
12337 p += strlen ((char *) p) + 1;
12338 return p;
59e6276b
JM		 12339 }
12340
f6f0e17b
NC		 12341 return display_tag_value (tag, p, end);
12342}
59e6276b 12343
f6f0e17b
NC		 12344static void
12345display_raw_attribute (unsigned char * p, unsigned char * end)
12346{
12347 unsigned long addr = 0;
12348 size_t bytes = end - p;
12349
12350 while (bytes)
87779176 12351 {
f6f0e17b
NC		 12352 int j;
12353 int k;
12354 int lbytes = (bytes > 16 ? 16 : bytes);
12355
12356 printf (" 0x%8.8lx ", addr);
12357
12358 for (j = 0; j < 16; j++)
12359 {
12360 if (j < lbytes)
12361 printf ("%2.2x", p[j]);
12362 else
12363 printf (" ");
12364
12365 if ((j & 3) == 3)
12366 printf (" ");
12367 }
12368
12369 for (j = 0; j < lbytes; j++)
12370 {
12371 k = p[j];
12372 if (k >= ' ' && k < 0x7f)
12373 printf ("%c", k);
12374 else
12375 printf (".");
12376 }
12377
12378 putchar ('\n');
12379
12380 p += lbytes;
12381 bytes -= lbytes;
12382 addr += lbytes;
87779176 12383 }
59e6276b 12384
f6f0e17b 12385 putchar ('\n');
59e6276b
JM		 12386}
12387
13761a11
NC		 12388static unsigned char *
12389display_msp430x_attribute (unsigned char * p,
12390 const unsigned char * const end)
12391{
12392 unsigned int len;
12393 int val;
12394 int tag;
12395
12396 tag = read_uleb128 (p, & len, end);
12397 p += len;
0b4362b0 12398
13761a11
NC		 12399 switch (tag)
12400 {
12401 case OFBA_MSPABI_Tag_ISA:
12402 val = read_uleb128 (p, &len, end);
12403 p += len;
12404 printf (" Tag_ISA: ");
12405 switch (val)
12406 {
12407 case 0: printf (_("None\n")); break;
12408 case 1: printf (_("MSP430\n")); break;
12409 case 2: printf (_("MSP430X\n")); break;
12410 default: printf ("??? (%d)\n", val); break;
12411 }
12412 break;
12413
12414 case OFBA_MSPABI_Tag_Code_Model:
12415 val = read_uleb128 (p, &len, end);
12416 p += len;
12417 printf (" Tag_Code_Model: ");
12418 switch (val)
12419 {
12420 case 0: printf (_("None\n")); break;
12421 case 1: printf (_("Small\n")); break;
12422 case 2: printf (_("Large\n")); break;
12423 default: printf ("??? (%d)\n", val); break;
12424 }
12425 break;
12426
12427 case OFBA_MSPABI_Tag_Data_Model:
12428 val = read_uleb128 (p, &len, end);
12429 p += len;
12430 printf (" Tag_Data_Model: ");
12431 switch (val)
12432 {
12433 case 0: printf (_("None\n")); break;
12434 case 1: printf (_("Small\n")); break;
12435 case 2: printf (_("Large\n")); break;
12436 case 3: printf (_("Restricted Large\n")); break;
12437 default: printf ("??? (%d)\n", val); break;
12438 }
12439 break;
12440
12441 default:
12442 printf (_(" <unknown tag %d>: "), tag);
12443
12444 if (tag & 1)
12445 {
12446 printf ("\"%s\"\n", p);
12447 p += strlen ((char *) p) + 1;
12448 }
12449 else
12450 {
12451 val = read_uleb128 (p, &len, end);
12452 p += len;
12453 printf ("%d (0x%x)\n", val, val);
12454 }
12455 break;
12456 }
12457
12458 return p;
12459}
12460
11c1ff18 12461static int
60bca95a
NC		 12462process_attributes (FILE * file,
12463 const char * public_name,
104d59d1 12464 unsigned int proc_type,
f6f0e17b
NC		 12465 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
12466 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 12467{
2cf0635d
NC		 12468 Elf_Internal_Shdr * sect;
12469 unsigned char * contents;
12470 unsigned char * p;
12471 unsigned char * end;
11c1ff18
PB		 12472 bfd_vma section_len;
12473 bfd_vma len;
12474 unsigned i;
12475
12476 /* Find the section header so that we get the size. */
12477 for (i = 0, sect = section_headers;
12478 i < elf_header.e_shnum;
12479 i++, sect++)
12480 {
104d59d1 12481 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 12482 continue;
12483
3f5e193b
NC		 12484 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
12485 sect->sh_size, _("attributes"));
60bca95a 12486 if (contents == NULL)
11c1ff18 12487 continue;
60bca95a 12488
11c1ff18
PB		 12489 p = contents;
12490 if (*p == 'A')
12491 {
12492 len = sect->sh_size - 1;
12493 p++;
60bca95a 12494
11c1ff18
PB		 12495 while (len > 0)
12496 {
e9847026 12497 unsigned int namelen;
11c1ff18 12498 bfd_boolean public_section;
104d59d1 12499 bfd_boolean gnu_section;
11c1ff18
PB		 12500
12501 section_len = byte_get (p, 4);
12502 p += 4;
60bca95a 12503
11c1ff18
PB		 12504 if (section_len > len)
12505 {
e9847026
NC		 12506 error (_("Length of attribute (%u) greater than length of section (%u)\n"),
12507 (unsigned) section_len, (unsigned) len);
11c1ff18
PB		 12508 section_len = len;
12509 }
60bca95a 12510
11c1ff18 12511 len -= section_len;
e9847026
NC		 12512 section_len -= 4;
12513
12514 namelen = strnlen ((char *) p, section_len) + 1;
12515 if (namelen == 0 || namelen >= section_len)
12516 {
12517 error (_("Corrupt attribute section name\n"));
12518 break;
12519 }
12520
2b692964 12521 printf (_("Attribute Section: %s\n"), p);
60bca95a
NC		 12522
12523 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 12524 public_section = TRUE;
12525 else
12526 public_section = FALSE;
60bca95a
NC		 12527
12528 if (streq ((char *) p, "gnu"))
104d59d1
JM		 12529 gnu_section = TRUE;
12530 else
12531 gnu_section = FALSE;
60bca95a 12532
11c1ff18 12533 p += namelen;
e9847026 12534 section_len -= namelen;
11c1ff18
PB		 12535 while (section_len > 0)
12536 {
12537 int tag = *(p++);
12538 int val;
12539 bfd_vma size;
60bca95a 12540
11c1ff18
PB		 12541 size = byte_get (p, 4);
12542 if (size > section_len)
12543 {
e9847026
NC		 12544 error (_("Bad subsection length (%u > %u)\n"),
12545 (unsigned) size, (unsigned) section_len);
11c1ff18
PB		 12546 size = section_len;
12547 }
60bca95a 12548
11c1ff18
PB		 12549 section_len -= size;
12550 end = p + size - 1;
12551 p += 4;
60bca95a 12552
11c1ff18
PB		 12553 switch (tag)
12554 {
12555 case 1:
2b692964 12556 printf (_("File Attributes\n"));
11c1ff18
PB		 12557 break;
12558 case 2:
2b692964 12559 printf (_("Section Attributes:"));
11c1ff18
PB		 12560 goto do_numlist;
12561 case 3:
2b692964 12562 printf (_("Symbol Attributes:"));
11c1ff18
PB		 12563 do_numlist:
12564 for (;;)
12565 {
91d6fa6a 12566 unsigned int j;
60bca95a 12567
f6f0e17b 12568 val = read_uleb128 (p, &j, end);
91d6fa6a 12569 p += j;
11c1ff18
PB		 12570 if (val == 0)
12571 break;
12572 printf (" %d", val);
12573 }
12574 printf ("\n");
12575 break;
12576 default:
2b692964 12577 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 12578 public_section = FALSE;
12579 break;
12580 }
60bca95a 12581
11c1ff18
PB		 12582 if (public_section)
12583 {
12584 while (p < end)
f6f0e17b 12585 p = display_pub_attribute (p, end);
104d59d1
JM		 12586 }
12587 else if (gnu_section)
12588 {
12589 while (p < end)
12590 p = display_gnu_attribute (p,
f6f0e17b
NC		 12591 display_proc_gnu_attribute,
12592 end);
11c1ff18
PB		 12593 }
12594 else
12595 {
2b692964 12596 printf (_(" Unknown section contexts\n"));
f6f0e17b 12597 display_raw_attribute (p, end);
11c1ff18
PB		 12598 p = end;
12599 }
12600 }
12601 }
12602 }
12603 else
e9847026 12604 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
d70c5fc7 12605
60bca95a 12606 free (contents);
11c1ff18
PB		 12607 }
12608 return 1;
12609}
12610
104d59d1 12611static int
2cf0635d 12612process_arm_specific (FILE * file)
104d59d1
JM		 12613{
12614 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
12615 display_arm_attribute, NULL);
12616}
12617
34c8bcba 12618static int
2cf0635d 12619process_power_specific (FILE * file)
34c8bcba
JM		 12620{
12621 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12622 display_power_gnu_attribute);
12623}
12624
9e8c70f9
DM		 12625static int
12626process_sparc_specific (FILE * file)
12627{
12628 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12629 display_sparc_gnu_attribute);
12630}
12631
59e6276b
JM		 12632static int
12633process_tic6x_specific (FILE * file)
12634{
12635 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
12636 display_tic6x_attribute, NULL);
12637}
12638
13761a11
NC		 12639static int
12640process_msp430x_specific (FILE * file)
12641{
12642 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
12643 display_msp430x_attribute, NULL);
12644}
12645
ccb4c951
RS		 12646/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12647 Print the Address, Access and Initial fields of an entry at VMA ADDR
12648 and return the VMA of the next entry. */
12649
12650static bfd_vma
2cf0635d 12651print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
ccb4c951
RS		 12652{
12653 printf (" ");
12654 print_vma (addr, LONG_HEX);
12655 printf (" ");
12656 if (addr < pltgot + 0xfff0)
12657 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
12658 else
12659 printf ("%10s", "");
12660 printf (" ");
12661 if (data == NULL)
2b692964 12662 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 12663 else
12664 {
12665 bfd_vma entry;
12666
12667 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12668 print_vma (entry, LONG_HEX);
12669 }
12670 return addr + (is_32bit_elf ? 4 : 8);
12671}
12672
861fb55a
DJ		 12673/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12674 PLTGOT. Print the Address and Initial fields of an entry at VMA
12675 ADDR and return the VMA of the next entry. */
12676
12677static bfd_vma
2cf0635d 12678print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 12679{
12680 printf (" ");
12681 print_vma (addr, LONG_HEX);
12682 printf (" ");
12683 if (data == NULL)
2b692964 12684 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 12685 else
12686 {
12687 bfd_vma entry;
12688
12689 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12690 print_vma (entry, LONG_HEX);
12691 }
12692 return addr + (is_32bit_elf ? 4 : 8);
12693}
12694
351cdf24
MF		 12695static void
12696print_mips_ases (unsigned int mask)
12697{
12698 if (mask & AFL_ASE_DSP)
12699 fputs ("\n\tDSP ASE", stdout);
12700 if (mask & AFL_ASE_DSPR2)
12701 fputs ("\n\tDSP R2 ASE", stdout);
12702 if (mask & AFL_ASE_EVA)
12703 fputs ("\n\tEnhanced VA Scheme", stdout);
12704 if (mask & AFL_ASE_MCU)
12705 fputs ("\n\tMCU (MicroController) ASE", stdout);
12706 if (mask & AFL_ASE_MDMX)
12707 fputs ("\n\tMDMX ASE", stdout);
12708 if (mask & AFL_ASE_MIPS3D)
12709 fputs ("\n\tMIPS-3D ASE", stdout);
12710 if (mask & AFL_ASE_MT)
12711 fputs ("\n\tMT ASE", stdout);
12712 if (mask & AFL_ASE_SMARTMIPS)
12713 fputs ("\n\tSmartMIPS ASE", stdout);
12714 if (mask & AFL_ASE_VIRT)
12715 fputs ("\n\tVZ ASE", stdout);
12716 if (mask & AFL_ASE_MSA)
12717 fputs ("\n\tMSA ASE", stdout);
12718 if (mask & AFL_ASE_MIPS16)
12719 fputs ("\n\tMIPS16 ASE", stdout);
12720 if (mask & AFL_ASE_MICROMIPS)
12721 fputs ("\n\tMICROMIPS ASE", stdout);
12722 if (mask & AFL_ASE_XPA)
12723 fputs ("\n\tXPA ASE", stdout);
12724 if (mask == 0)
12725 fprintf (stdout, "\n\t%s", _("None"));
12726}
12727
12728static void
12729print_mips_isa_ext (unsigned int isa_ext)
12730{
12731 switch (isa_ext)
12732 {
12733 case 0:
12734 fputs (_("None"), stdout);
12735 break;
12736 case AFL_EXT_XLR:
12737 fputs ("RMI XLR", stdout);
12738 break;
12739 case AFL_EXT_OCTEON2:
12740 fputs ("Cavium Networks Octeon2", stdout);
12741 break;
12742 case AFL_EXT_OCTEONP:
12743 fputs ("Cavium Networks OcteonP", stdout);
12744 break;
12745 case AFL_EXT_LOONGSON_3A:
12746 fputs ("Loongson 3A", stdout);
12747 break;
12748 case AFL_EXT_OCTEON:
12749 fputs ("Cavium Networks Octeon", stdout);
12750 break;
12751 case AFL_EXT_5900:
12752 fputs ("Toshiba R5900", stdout);
12753 break;
12754 case AFL_EXT_4650:
12755 fputs ("MIPS R4650", stdout);
12756 break;
12757 case AFL_EXT_4010:
12758 fputs ("LSI R4010", stdout);
12759 break;
12760 case AFL_EXT_4100:
12761 fputs ("NEC VR4100", stdout);
12762 break;
12763 case AFL_EXT_3900:
12764 fputs ("Toshiba R3900", stdout);
12765 break;
12766 case AFL_EXT_10000:
12767 fputs ("MIPS R10000", stdout);
12768 break;
12769 case AFL_EXT_SB1:
12770 fputs ("Broadcom SB-1", stdout);
12771 break;
12772 case AFL_EXT_4111:
12773 fputs ("NEC VR4111/VR4181", stdout);
12774 break;
12775 case AFL_EXT_4120:
12776 fputs ("NEC VR4120", stdout);
12777 break;
12778 case AFL_EXT_5400:
12779 fputs ("NEC VR5400", stdout);
12780 break;
12781 case AFL_EXT_5500:
12782 fputs ("NEC VR5500", stdout);
12783 break;
12784 case AFL_EXT_LOONGSON_2E:
12785 fputs ("ST Microelectronics Loongson 2E", stdout);
12786 break;
12787 case AFL_EXT_LOONGSON_2F:
12788 fputs ("ST Microelectronics Loongson 2F", stdout);
12789 break;
12790 default:
12791 fputs (_("Unknown"), stdout);
12792 }
12793}
12794
12795static int
12796get_mips_reg_size (int reg_size)
12797{
12798 return (reg_size == AFL_REG_NONE) ? 0
12799 : (reg_size == AFL_REG_32) ? 32
12800 : (reg_size == AFL_REG_64) ? 64
12801 : (reg_size == AFL_REG_128) ? 128
12802 : -1;
12803}
12804
19e6b90e 12805static int
2cf0635d 12806process_mips_specific (FILE * file)
5b18a4bc 12807{
2cf0635d 12808 Elf_Internal_Dyn * entry;
351cdf24 12809 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 12810 size_t liblist_offset = 0;
12811 size_t liblistno = 0;
12812 size_t conflictsno = 0;
12813 size_t options_offset = 0;
12814 size_t conflicts_offset = 0;
861fb55a
DJ		 12815 size_t pltrelsz = 0;
12816 size_t pltrel = 0;
ccb4c951 12817 bfd_vma pltgot = 0;
861fb55a
DJ		 12818 bfd_vma mips_pltgot = 0;
12819 bfd_vma jmprel = 0;
ccb4c951
RS		 12820 bfd_vma local_gotno = 0;
12821 bfd_vma gotsym = 0;
12822 bfd_vma symtabno = 0;
103f02d3 12823
2cf19d5c
JM		 12824 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12825 display_mips_gnu_attribute);
12826
351cdf24
MF		 12827 sect = find_section (".MIPS.abiflags");
12828
12829 if (sect != NULL)
12830 {
12831 Elf_External_ABIFlags_v0 *abiflags_ext;
12832 Elf_Internal_ABIFlags_v0 abiflags_in;
12833
12834 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
12835 fputs ("\nCorrupt ABI Flags section.\n", stdout);
12836 else
12837 {
12838 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
12839 sect->sh_size, _("MIPS ABI Flags section"));
12840 if (abiflags_ext)
12841 {
12842 abiflags_in.version = BYTE_GET (abiflags_ext->version);
12843 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
12844 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
12845 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
12846 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
12847 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
12848 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
12849 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
12850 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
12851 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
12852 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
12853
12854 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
12855 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
12856 if (abiflags_in.isa_rev > 1)
12857 printf ("r%d", abiflags_in.isa_rev);
12858 printf ("\nGPR size: %d",
12859 get_mips_reg_size (abiflags_in.gpr_size));
12860 printf ("\nCPR1 size: %d",
12861 get_mips_reg_size (abiflags_in.cpr1_size));
12862 printf ("\nCPR2 size: %d",
12863 get_mips_reg_size (abiflags_in.cpr2_size));
12864 fputs ("\nFP ABI: ", stdout);
12865 print_mips_fp_abi_value (abiflags_in.fp_abi);
12866 fputs ("ISA Extension: ", stdout);
12867 print_mips_isa_ext (abiflags_in.isa_ext);
12868 fputs ("\nASEs:", stdout);
12869 print_mips_ases (abiflags_in.ases);
12870 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
12871 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
12872 fputc ('\n', stdout);
12873 free (abiflags_ext);
12874 }
12875 }
12876 }
12877
19e6b90e
L		 12878 /* We have a lot of special sections. Thanks SGI! */
12879 if (dynamic_section == NULL)
12880 /* No information available. */
12881 return 0;
252b5132 12882
b2d38a17 12883 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
252b5132
RH		 12884 switch (entry->d_tag)
12885 {
12886 case DT_MIPS_LIBLIST:
d93f0186
NC		 12887 liblist_offset
12888 = offset_from_vma (file, entry->d_un.d_val,
12889 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 12890 break;
12891 case DT_MIPS_LIBLISTNO:
12892 liblistno = entry->d_un.d_val;
12893 break;
12894 case DT_MIPS_OPTIONS:
d93f0186 12895 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 12896 break;
12897 case DT_MIPS_CONFLICT:
d93f0186
NC		 12898 conflicts_offset
12899 = offset_from_vma (file, entry->d_un.d_val,
12900 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 12901 break;
12902 case DT_MIPS_CONFLICTNO:
12903 conflictsno = entry->d_un.d_val;
12904 break;
ccb4c951 12905 case DT_PLTGOT:
861fb55a
DJ		 12906 pltgot = entry->d_un.d_ptr;
12907 break;
ccb4c951
RS		 12908 case DT_MIPS_LOCAL_GOTNO:
12909 local_gotno = entry->d_un.d_val;
12910 break;
12911 case DT_MIPS_GOTSYM:
12912 gotsym = entry->d_un.d_val;
12913 break;
12914 case DT_MIPS_SYMTABNO:
12915 symtabno = entry->d_un.d_val;
12916 break;
861fb55a
DJ		 12917 case DT_MIPS_PLTGOT:
12918 mips_pltgot = entry->d_un.d_ptr;
12919 break;
12920 case DT_PLTREL:
12921 pltrel = entry->d_un.d_val;
12922 break;
12923 case DT_PLTRELSZ:
12924 pltrelsz = entry->d_un.d_val;
12925 break;
12926 case DT_JMPREL:
12927 jmprel = entry->d_un.d_ptr;
12928 break;
252b5132
RH		 12929 default:
12930 break;
12931 }
12932
12933 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
12934 {
2cf0635d 12935 Elf32_External_Lib * elib;
252b5132
RH		 12936 size_t cnt;
12937
3f5e193b
NC		 12938 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
12939 liblistno,
12940 sizeof (Elf32_External_Lib),
9cf03b7e 12941 _("liblist section data"));
a6e9f9df 12942 if (elib)
252b5132 12943 {
2b692964 12944 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 12945 (unsigned long) liblistno);
2b692964 12946 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 12947 stdout);
12948
12949 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 12950 {
a6e9f9df 12951 Elf32_Lib liblist;
91d6fa6a 12952 time_t atime;
a6e9f9df 12953 char timebuf[20];
2cf0635d 12954 struct tm * tmp;
a6e9f9df
AM		 12955
12956 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 12957 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 12958 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12959 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12960 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12961
91d6fa6a 12962 tmp = gmtime (&atime);
e9e44622
JJ		 12963 snprintf (timebuf, sizeof (timebuf),
12964 "%04u-%02u-%02uT%02u:%02u:%02u",
12965 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12966 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 12967
31104126 12968 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 12969 if (VALID_DYNAMIC_NAME (liblist.l_name))
12970 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
12971 else
2b692964 12972 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 12973 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
12974 liblist.l_version);
a6e9f9df
AM		 12975
12976 if (liblist.l_flags == 0)
2b692964 12977 puts (_(" NONE"));
a6e9f9df
AM		 12978 else
12979 {
12980 static const struct
252b5132 12981 {
2cf0635d 12982 const char * name;
a6e9f9df 12983 int bit;
252b5132 12984 }
a6e9f9df
AM		 12985 l_flags_vals[] =
12986 {
12987 { " EXACT_MATCH", LL_EXACT_MATCH },
12988 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
12989 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
12990 { " EXPORTS", LL_EXPORTS },
12991 { " DELAY_LOAD", LL_DELAY_LOAD },
12992 { " DELTA", LL_DELTA }
12993 };
12994 int flags = liblist.l_flags;
12995 size_t fcnt;
12996
60bca95a 12997 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 12998 if ((flags & l_flags_vals[fcnt].bit) != 0)
12999 {
13000 fputs (l_flags_vals[fcnt].name, stdout);
13001 flags ^= l_flags_vals[fcnt].bit;
13002 }
13003 if (flags != 0)
13004 printf (" %#x", (unsigned int) flags);
252b5132 13005
a6e9f9df
AM		 13006 puts ("");
13007 }
252b5132 13008 }
252b5132 13009
a6e9f9df
AM		 13010 free (elib);
13011 }
252b5132
RH		 13012 }
13013
13014 if (options_offset != 0)
13015 {
2cf0635d 13016 Elf_External_Options * eopt;
2cf0635d
NC		 13017 Elf_Internal_Options * iopt;
13018 Elf_Internal_Options * option;
252b5132
RH		 13019 size_t offset;
13020 int cnt;
351cdf24 13021 sect = section_headers;
252b5132
RH		 13022
13023 /* Find the section header so that we get the size. */
13024 while (sect->sh_type != SHT_MIPS_OPTIONS)
b34976b6 13025 ++sect;
252b5132 13026
3f5e193b
NC		 13027 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
13028 sect->sh_size, _("options"));
a6e9f9df 13029 if (eopt)
252b5132 13030 {
3f5e193b
NC		 13031 iopt = (Elf_Internal_Options *)
13032 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 13033 if (iopt == NULL)
13034 {
591a748a 13035 error (_("Out of memory\n"));
a6e9f9df
AM		 13036 return 0;
13037 }
76da6bbe 13038
a6e9f9df
AM		 13039 offset = cnt = 0;
13040 option = iopt;
252b5132 13041
a6e9f9df
AM		 13042 while (offset < sect->sh_size)
13043 {
2cf0635d 13044 Elf_External_Options * eoption;
252b5132 13045
a6e9f9df 13046 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 13047
a6e9f9df
AM		 13048 option->kind = BYTE_GET (eoption->kind);
13049 option->size = BYTE_GET (eoption->size);
13050 option->section = BYTE_GET (eoption->section);
13051 option->info = BYTE_GET (eoption->info);
76da6bbe 13052
a6e9f9df 13053 offset += option->size;
252b5132 13054
a6e9f9df
AM		 13055 ++option;
13056 ++cnt;
13057 }
252b5132 13058
a6e9f9df
AM		 13059 printf (_("\nSection '%s' contains %d entries:\n"),
13060 SECTION_NAME (sect), cnt);
76da6bbe 13061
a6e9f9df 13062 option = iopt;
252b5132 13063
a6e9f9df 13064 while (cnt-- > 0)
252b5132 13065 {
a6e9f9df
AM		 13066 size_t len;
13067
13068 switch (option->kind)
252b5132 13069 {
a6e9f9df
AM		 13070 case ODK_NULL:
13071 /* This shouldn't happen. */
13072 printf (" NULL %d %lx", option->section, option->info);
13073 break;
13074 case ODK_REGINFO:
13075 printf (" REGINFO ");
13076 if (elf_header.e_machine == EM_MIPS)
13077 {
13078 /* 32bit form. */
2cf0635d 13079 Elf32_External_RegInfo * ereg;
b34976b6 13080 Elf32_RegInfo reginfo;
a6e9f9df
AM		 13081
13082 ereg = (Elf32_External_RegInfo *) (option + 1);
13083 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
13084 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13085 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13086 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13087 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
13088 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
13089
13090 printf ("GPR %08lx GP 0x%lx\n",
13091 reginfo.ri_gprmask,
13092 (unsigned long) reginfo.ri_gp_value);
13093 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13094 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13095 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13096 }
13097 else
13098 {
13099 /* 64 bit form. */
2cf0635d 13100 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 13101 Elf64_Internal_RegInfo reginfo;
13102
13103 ereg = (Elf64_External_RegInfo *) (option + 1);
13104 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
13105 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13106 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13107 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13108 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 13109 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 13110
13111 printf ("GPR %08lx GP 0x",
13112 reginfo.ri_gprmask);
13113 printf_vma (reginfo.ri_gp_value);
13114 printf ("\n");
13115
13116 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13117 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13118 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13119 }
13120 ++option;
13121 continue;
13122 case ODK_EXCEPTIONS:
13123 fputs (" EXCEPTIONS fpe_min(", stdout);
13124 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
13125 fputs (") fpe_max(", stdout);
13126 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
13127 fputs (")", stdout);
13128
13129 if (option->info & OEX_PAGE0)
13130 fputs (" PAGE0", stdout);
13131 if (option->info & OEX_SMM)
13132 fputs (" SMM", stdout);
13133 if (option->info & OEX_FPDBUG)
13134 fputs (" FPDBUG", stdout);
13135 if (option->info & OEX_DISMISS)
13136 fputs (" DISMISS", stdout);
13137 break;
13138 case ODK_PAD:
13139 fputs (" PAD ", stdout);
13140 if (option->info & OPAD_PREFIX)
13141 fputs (" PREFIX", stdout);
13142 if (option->info & OPAD_POSTFIX)
13143 fputs (" POSTFIX", stdout);
13144 if (option->info & OPAD_SYMBOL)
13145 fputs (" SYMBOL", stdout);
13146 break;
13147 case ODK_HWPATCH:
13148 fputs (" HWPATCH ", stdout);
13149 if (option->info & OHW_R4KEOP)
13150 fputs (" R4KEOP", stdout);
13151 if (option->info & OHW_R8KPFETCH)
13152 fputs (" R8KPFETCH", stdout);
13153 if (option->info & OHW_R5KEOP)
13154 fputs (" R5KEOP", stdout);
13155 if (option->info & OHW_R5KCVTL)
13156 fputs (" R5KCVTL", stdout);
13157 break;
13158 case ODK_FILL:
13159 fputs (" FILL ", stdout);
13160 /* XXX Print content of info word? */
13161 break;
13162 case ODK_TAGS:
13163 fputs (" TAGS ", stdout);
13164 /* XXX Print content of info word? */
13165 break;
13166 case ODK_HWAND:
13167 fputs (" HWAND ", stdout);
13168 if (option->info & OHWA0_R4KEOP_CHECKED)
13169 fputs (" R4KEOP_CHECKED", stdout);
13170 if (option->info & OHWA0_R4KEOP_CLEAN)
13171 fputs (" R4KEOP_CLEAN", stdout);
13172 break;
13173 case ODK_HWOR:
13174 fputs (" HWOR ", stdout);
13175 if (option->info & OHWA0_R4KEOP_CHECKED)
13176 fputs (" R4KEOP_CHECKED", stdout);
13177 if (option->info & OHWA0_R4KEOP_CLEAN)
13178 fputs (" R4KEOP_CLEAN", stdout);
13179 break;
13180 case ODK_GP_GROUP:
13181 printf (" GP_GROUP %#06lx self-contained %#06lx",
13182 option->info & OGP_GROUP,
13183 (option->info & OGP_SELF) >> 16);
13184 break;
13185 case ODK_IDENT:
13186 printf (" IDENT %#06lx self-contained %#06lx",
13187 option->info & OGP_GROUP,
13188 (option->info & OGP_SELF) >> 16);
13189 break;
13190 default:
13191 /* This shouldn't happen. */
13192 printf (" %3d ??? %d %lx",
13193 option->kind, option->section, option->info);
13194 break;
252b5132 13195 }
a6e9f9df 13196
2cf0635d 13197 len = sizeof (* eopt);
a6e9f9df
AM		 13198 while (len < option->size)
13199 if (((char *) option)[len] >= ' '
13200 && ((char *) option)[len] < 0x7f)
13201 printf ("%c", ((char *) option)[len++]);
13202 else
13203 printf ("\\%03o", ((char *) option)[len++]);
13204
13205 fputs ("\n", stdout);
252b5132 13206 ++option;
252b5132
RH		 13207 }
13208
a6e9f9df 13209 free (eopt);
252b5132 13210 }
252b5132
RH		 13211 }
13212
13213 if (conflicts_offset != 0 && conflictsno != 0)
13214 {
2cf0635d 13215 Elf32_Conflict * iconf;
252b5132
RH		 13216 size_t cnt;
13217
13218 if (dynamic_symbols == NULL)
13219 {
591a748a 13220 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 13221 return 0;
13222 }
13223
3f5e193b 13224 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 13225 if (iconf == NULL)
13226 {
591a748a 13227 error (_("Out of memory\n"));
252b5132
RH		 13228 return 0;
13229 }
13230
9ea033b2 13231 if (is_32bit_elf)
252b5132 13232 {
2cf0635d 13233 Elf32_External_Conflict * econf32;
a6e9f9df 13234
3f5e193b
NC		 13235 econf32 = (Elf32_External_Conflict *)
13236 get_data (NULL, file, conflicts_offset, conflictsno,
13237 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 13238 if (!econf32)
13239 return 0;
252b5132
RH		 13240
13241 for (cnt = 0; cnt < conflictsno; ++cnt)
13242 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 13243
13244 free (econf32);
252b5132
RH		 13245 }
13246 else
13247 {
2cf0635d 13248 Elf64_External_Conflict * econf64;
a6e9f9df 13249
3f5e193b
NC		 13250 econf64 = (Elf64_External_Conflict *)
13251 get_data (NULL, file, conflicts_offset, conflictsno,
13252 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 13253 if (!econf64)
13254 return 0;
252b5132
RH		 13255
13256 for (cnt = 0; cnt < conflictsno; ++cnt)
13257 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 13258
13259 free (econf64);
252b5132
RH		 13260 }
13261
c7e7ca54
NC		 13262 printf (_("\nSection '.conflict' contains %lu entries:\n"),
13263 (unsigned long) conflictsno);
252b5132
RH		 13264 puts (_(" Num: Index Value Name"));
13265
13266 for (cnt = 0; cnt < conflictsno; ++cnt)
13267 {
2cf0635d 13268 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
252b5132 13269
b34976b6 13270 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
f7a99963 13271 print_vma (psym->st_value, FULL_HEX);
31104126 13272 putchar (' ');
d79b3d50
NC		 13273 if (VALID_DYNAMIC_NAME (psym->st_name))
13274 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
13275 else
2b692964 13276 printf (_("<corrupt: %14ld>"), psym->st_name);
31104126 13277 putchar ('\n');
252b5132
RH		 13278 }
13279
252b5132
RH		 13280 free (iconf);
13281 }
13282
ccb4c951
RS		 13283 if (pltgot != 0 && local_gotno != 0)
13284 {
91d6fa6a 13285 bfd_vma ent, local_end, global_end;
bbeee7ea 13286 size_t i, offset;
2cf0635d 13287 unsigned char * data;
bbeee7ea 13288 int addr_size;
ccb4c951 13289
91d6fa6a 13290 ent = pltgot;
ccb4c951
RS		 13291 addr_size = (is_32bit_elf ? 4 : 8);
13292 local_end = pltgot + local_gotno * addr_size;
13293 global_end = local_end + (symtabno - gotsym) * addr_size;
13294
13295 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 13296 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 13297 global_end - pltgot, 1,
13298 _("Global Offset Table data"));
59245841
NC		 13299 if (data == NULL)
13300 return 0;
13301
ccb4c951
RS		 13302 printf (_("\nPrimary GOT:\n"));
13303 printf (_(" Canonical gp value: "));
13304 print_vma (pltgot + 0x7ff0, LONG_HEX);
13305 printf ("\n\n");
13306
13307 printf (_(" Reserved entries:\n"));
13308 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 13309 addr_size * 2, _("Address"), _("Access"),
13310 addr_size * 2, _("Initial"));
91d6fa6a 13311 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 13312 printf (_(" Lazy resolver\n"));
ccb4c951 13313 if (data
91d6fa6a 13314 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 13315 >> (addr_size * 8 - 1)) != 0)
13316 {
91d6fa6a 13317 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 13318 printf (_(" Module pointer (GNU extension)\n"));
ccb4c951
RS		 13319 }
13320 printf ("\n");
13321
91d6fa6a 13322 if (ent < local_end)
ccb4c951
RS		 13323 {
13324 printf (_(" Local entries:\n"));
cc5914eb 13325 printf (" %*s %10s %*s\n",
2b692964
NC		 13326 addr_size * 2, _("Address"), _("Access"),
13327 addr_size * 2, _("Initial"));
91d6fa6a 13328 while (ent < local_end)
ccb4c951 13329 {
91d6fa6a 13330 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 13331 printf ("\n");
13332 }
13333 printf ("\n");
13334 }
13335
13336 if (gotsym < symtabno)
13337 {
13338 int sym_width;
13339
13340 printf (_(" Global entries:\n"));
cc5914eb 13341 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 13342 addr_size * 2, _("Address"),
13343 _("Access"),
2b692964 13344 addr_size * 2, _("Initial"),
9cf03b7e
NC		 13345 addr_size * 2, _("Sym.Val."),
13346 _("Type"),
13347 /* Note for translators: "Ndx" = abbreviated form of "Index". */
13348 _("Ndx"), _("Name"));
0b4362b0 13349
ccb4c951
RS		 13350 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
13351 for (i = gotsym; i < symtabno; i++)
13352 {
2cf0635d 13353 Elf_Internal_Sym * psym;
ccb4c951
RS		 13354
13355 psym = dynamic_symbols + i;
91d6fa6a 13356 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 13357 printf (" ");
13358 print_vma (psym->st_value, LONG_HEX);
13359 printf (" %-7s %3s ",
13360 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
13361 get_symbol_index_type (psym->st_shndx));
13362 if (VALID_DYNAMIC_NAME (psym->st_name))
13363 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
13364 else
2b692964 13365 printf (_("<corrupt: %14ld>"), psym->st_name);
ccb4c951
RS		 13366 printf ("\n");
13367 }
13368 printf ("\n");
13369 }
13370
13371 if (data)
13372 free (data);
13373 }
13374
861fb55a
DJ		 13375 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
13376 {
91d6fa6a 13377 bfd_vma ent, end;
861fb55a
DJ		 13378 size_t offset, rel_offset;
13379 unsigned long count, i;
2cf0635d 13380 unsigned char * data;
861fb55a 13381 int addr_size, sym_width;
2cf0635d 13382 Elf_Internal_Rela * rels;
861fb55a
DJ		 13383
13384 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
13385 if (pltrel == DT_RELA)
13386 {
13387 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
13388 return 0;
13389 }
13390 else
13391 {
13392 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
13393 return 0;
13394 }
13395
91d6fa6a 13396 ent = mips_pltgot;
861fb55a
DJ		 13397 addr_size = (is_32bit_elf ? 4 : 8);
13398 end = mips_pltgot + (2 + count) * addr_size;
13399
13400 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 13401 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 13402 1, _("Procedure Linkage Table data"));
59245841
NC		 13403 if (data == NULL)
13404 return 0;
13405
9cf03b7e 13406 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 13407 printf (_(" Reserved entries:\n"));
13408 printf (_(" %*s %*s Purpose\n"),
2b692964 13409 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 13410 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 13411 printf (_(" PLT lazy resolver\n"));
91d6fa6a 13412 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 13413 printf (_(" Module pointer\n"));
861fb55a
DJ		 13414 printf ("\n");
13415
13416 printf (_(" Entries:\n"));
cc5914eb 13417 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 13418 addr_size * 2, _("Address"),
13419 addr_size * 2, _("Initial"),
13420 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 13421 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
13422 for (i = 0; i < count; i++)
13423 {
2cf0635d 13424 Elf_Internal_Sym * psym;
861fb55a
DJ		 13425
13426 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
91d6fa6a 13427 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a
DJ		 13428 printf (" ");
13429 print_vma (psym->st_value, LONG_HEX);
13430 printf (" %-7s %3s ",
13431 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
13432 get_symbol_index_type (psym->st_shndx));
13433 if (VALID_DYNAMIC_NAME (psym->st_name))
13434 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
13435 else
2b692964 13436 printf (_("<corrupt: %14ld>"), psym->st_name);
861fb55a
DJ		 13437 printf ("\n");
13438 }
13439 printf ("\n");
13440
13441 if (data)
13442 free (data);
13443 free (rels);
13444 }
13445
252b5132
RH		 13446 return 1;
13447}
13448
35c08157
KLC		 13449static int
13450process_nds32_specific (FILE * file)
13451{
13452 Elf_Internal_Shdr *sect = NULL;
13453
13454 sect = find_section (".nds32_e_flags");
13455 if (sect != NULL)
13456 {
13457 unsigned int *flag;
13458
13459 printf ("\nNDS32 elf flags section:\n");
13460 flag = get_data (NULL, file, sect->sh_offset, 1,
13461 sect->sh_size, _("NDS32 elf flags section"));
13462
13463 switch ((*flag) & 0x3)
13464 {
13465 case 0:
13466 printf ("(VEC_SIZE):\tNo entry.\n");
13467 break;
13468 case 1:
13469 printf ("(VEC_SIZE):\t4 bytes\n");
13470 break;
13471 case 2:
13472 printf ("(VEC_SIZE):\t16 bytes\n");
13473 break;
13474 case 3:
13475 printf ("(VEC_SIZE):\treserved\n");
13476 break;
13477 }
13478 }
13479
13480 return TRUE;
13481}
13482
047b2264 13483static int
2cf0635d 13484process_gnu_liblist (FILE * file)
047b2264 13485{
2cf0635d
NC		 13486 Elf_Internal_Shdr * section;
13487 Elf_Internal_Shdr * string_sec;
13488 Elf32_External_Lib * elib;
13489 char * strtab;
c256ffe7 13490 size_t strtab_size;
047b2264
JJ		 13491 size_t cnt;
13492 unsigned i;
13493
13494 if (! do_arch)
13495 return 0;
13496
13497 for (i = 0, section = section_headers;
13498 i < elf_header.e_shnum;
b34976b6 13499 i++, section++)
047b2264
JJ		 13500 {
13501 switch (section->sh_type)
13502 {
13503 case SHT_GNU_LIBLIST:
4fbb74a6 13504 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 13505 break;
13506
3f5e193b
NC		 13507 elib = (Elf32_External_Lib *)
13508 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 13509 _("liblist section data"));
047b2264
JJ		 13510
13511 if (elib == NULL)
13512 break;
4fbb74a6 13513 string_sec = section_headers + section->sh_link;
047b2264 13514
3f5e193b
NC		 13515 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
13516 string_sec->sh_size,
13517 _("liblist string table"));
047b2264
JJ		 13518 if (strtab == NULL
13519 || section->sh_entsize != sizeof (Elf32_External_Lib))
13520 {
13521 free (elib);
2842702f 13522 free (strtab);
047b2264
JJ		 13523 break;
13524 }
59245841 13525 strtab_size = string_sec->sh_size;
047b2264
JJ		 13526
13527 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
13528 SECTION_NAME (section),
0af1713e 13529 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 13530
2b692964 13531 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 13532
13533 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
13534 ++cnt)
13535 {
13536 Elf32_Lib liblist;
91d6fa6a 13537 time_t atime;
047b2264 13538 char timebuf[20];
2cf0635d 13539 struct tm * tmp;
047b2264
JJ		 13540
13541 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 13542 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 13543 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13544 liblist.l_version = BYTE_GET (elib[cnt].l_version);
13545 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13546
91d6fa6a 13547 tmp = gmtime (&atime);
e9e44622
JJ		 13548 snprintf (timebuf, sizeof (timebuf),
13549 "%04u-%02u-%02uT%02u:%02u:%02u",
13550 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13551 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 13552
13553 printf ("%3lu: ", (unsigned long) cnt);
13554 if (do_wide)
c256ffe7 13555 printf ("%-20s", liblist.l_name < strtab_size
2b692964 13556 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 13557 else
c256ffe7 13558 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 13559 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 13560 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
13561 liblist.l_version, liblist.l_flags);
13562 }
13563
13564 free (elib);
2842702f 13565 free (strtab);
047b2264
JJ		 13566 }
13567 }
13568
13569 return 1;
13570}
13571
9437c45b 13572static const char *
d3ba0551 13573get_note_type (unsigned e_type)
779fe533
NC		 13574{
13575 static char buff[64];
103f02d3 13576
1ec5cd37
NC		 13577 if (elf_header.e_type == ET_CORE)
13578 switch (e_type)
13579 {
57346661 13580 case NT_AUXV:
1ec5cd37 13581 return _("NT_AUXV (auxiliary vector)");
57346661 13582 case NT_PRSTATUS:
1ec5cd37 13583 return _("NT_PRSTATUS (prstatus structure)");
57346661 13584 case NT_FPREGSET:
1ec5cd37 13585 return _("NT_FPREGSET (floating point registers)");
57346661 13586 case NT_PRPSINFO:
1ec5cd37 13587 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 13588 case NT_TASKSTRUCT:
1ec5cd37 13589 return _("NT_TASKSTRUCT (task structure)");
57346661 13590 case NT_PRXFPREG:
1ec5cd37 13591 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 13592 case NT_PPC_VMX:
13593 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 13594 case NT_PPC_VSX:
13595 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 13596 case NT_386_TLS:
13597 return _("NT_386_TLS (x86 TLS information)");
13598 case NT_386_IOPERM:
13599 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 13600 case NT_X86_XSTATE:
13601 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 13602 case NT_S390_HIGH_GPRS:
13603 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 13604 case NT_S390_TIMER:
13605 return _("NT_S390_TIMER (s390 timer register)");
13606 case NT_S390_TODCMP:
13607 return _("NT_S390_TODCMP (s390 TOD comparator register)");
13608 case NT_S390_TODPREG:
13609 return _("NT_S390_TODPREG (s390 TOD programmable register)");
13610 case NT_S390_CTRS:
13611 return _("NT_S390_CTRS (s390 control registers)");
13612 case NT_S390_PREFIX:
13613 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 13614 case NT_S390_LAST_BREAK:
13615 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
13616 case NT_S390_SYSTEM_CALL:
13617 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 13618 case NT_S390_TDB:
13619 return _("NT_S390_TDB (s390 transaction diagnostic block)");
faa9a424
UW		 13620 case NT_ARM_VFP:
13621 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 13622 case NT_ARM_TLS:
13623 return _("NT_ARM_TLS (AArch TLS registers)");
13624 case NT_ARM_HW_BREAK:
13625 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
13626 case NT_ARM_HW_WATCH:
13627 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 13628 case NT_PSTATUS:
1ec5cd37 13629 return _("NT_PSTATUS (pstatus structure)");
57346661 13630 case NT_FPREGS:
1ec5cd37 13631 return _("NT_FPREGS (floating point registers)");
57346661 13632 case NT_PSINFO:
1ec5cd37 13633 return _("NT_PSINFO (psinfo structure)");
57346661 13634 case NT_LWPSTATUS:
1ec5cd37 13635 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 13636 case NT_LWPSINFO:
1ec5cd37 13637 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 13638 case NT_WIN32PSTATUS:
1ec5cd37 13639 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 13640 case NT_SIGINFO:
13641 return _("NT_SIGINFO (siginfo_t data)");
13642 case NT_FILE:
13643 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 13644 default:
13645 break;
13646 }
13647 else
13648 switch (e_type)
13649 {
13650 case NT_VERSION:
13651 return _("NT_VERSION (version)");
13652 case NT_ARCH:
13653 return _("NT_ARCH (architecture)");
13654 default:
13655 break;
13656 }
13657
e9e44622 13658 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 13659 return buff;
779fe533
NC		 13660}
13661
9ece1fa9
TT		 13662static int
13663print_core_note (Elf_Internal_Note *pnote)
13664{
13665 unsigned int addr_size = is_32bit_elf ? 4 : 8;
13666 bfd_vma count, page_size;
13667 unsigned char *descdata, *filenames, *descend;
13668
13669 if (pnote->type != NT_FILE)
13670 return 1;
13671
13672#ifndef BFD64
13673 if (!is_32bit_elf)
13674 {
13675 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
13676 /* Still "successful". */
13677 return 1;
13678 }
13679#endif
13680
13681 if (pnote->descsz < 2 * addr_size)
13682 {
13683 printf (_(" Malformed note - too short for header\n"));
13684 return 0;
13685 }
13686
13687 descdata = (unsigned char *) pnote->descdata;
13688 descend = descdata + pnote->descsz;
13689
13690 if (descdata[pnote->descsz - 1] != '\0')
13691 {
13692 printf (_(" Malformed note - does not end with \\0\n"));
13693 return 0;
13694 }
13695
13696 count = byte_get (descdata, addr_size);
13697 descdata += addr_size;
13698
13699 page_size = byte_get (descdata, addr_size);
13700 descdata += addr_size;
13701
13702 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
13703 {
13704 printf (_(" Malformed note - too short for supplied file count\n"));
13705 return 0;
13706 }
13707
13708 printf (_(" Page size: "));
13709 print_vma (page_size, DEC);
13710 printf ("\n");
13711
13712 printf (_(" %*s%*s%*s\n"),
13713 (int) (2 + 2 * addr_size), _("Start"),
13714 (int) (4 + 2 * addr_size), _("End"),
13715 (int) (4 + 2 * addr_size), _("Page Offset"));
13716 filenames = descdata + count * 3 * addr_size;
13717 while (--count > 0)
13718 {
13719 bfd_vma start, end, file_ofs;
13720
13721 if (filenames == descend)
13722 {
13723 printf (_(" Malformed note - filenames end too early\n"));
13724 return 0;
13725 }
13726
13727 start = byte_get (descdata, addr_size);
13728 descdata += addr_size;
13729 end = byte_get (descdata, addr_size);
13730 descdata += addr_size;
13731 file_ofs = byte_get (descdata, addr_size);
13732 descdata += addr_size;
13733
13734 printf (" ");
13735 print_vma (start, FULL_HEX);
13736 printf (" ");
13737 print_vma (end, FULL_HEX);
13738 printf (" ");
13739 print_vma (file_ofs, FULL_HEX);
13740 printf ("\n %s\n", filenames);
13741
13742 filenames += 1 + strlen ((char *) filenames);
13743 }
13744
13745 return 1;
13746}
13747
1118d252
RM		 13748static const char *
13749get_gnu_elf_note_type (unsigned e_type)
13750{
13751 static char buff[64];
13752
13753 switch (e_type)
13754 {
13755 case NT_GNU_ABI_TAG:
13756 return _("NT_GNU_ABI_TAG (ABI version tag)");
13757 case NT_GNU_HWCAP:
13758 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
13759 case NT_GNU_BUILD_ID:
13760 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 13761 case NT_GNU_GOLD_VERSION:
13762 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 13763 default:
13764 break;
13765 }
13766
13767 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13768 return buff;
13769}
13770
664f90a3
TT		 13771static int
13772print_gnu_note (Elf_Internal_Note *pnote)
13773{
13774 switch (pnote->type)
13775 {
13776 case NT_GNU_BUILD_ID:
13777 {
13778 unsigned long i;
13779
13780 printf (_(" Build ID: "));
13781 for (i = 0; i < pnote->descsz; ++i)
13782 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 13783 printf ("\n");
664f90a3
TT		 13784 }
13785 break;
13786
13787 case NT_GNU_ABI_TAG:
13788 {
13789 unsigned long os, major, minor, subminor;
13790 const char *osname;
13791
13792 os = byte_get ((unsigned char *) pnote->descdata, 4);
13793 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
13794 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
13795 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
13796
13797 switch (os)
13798 {
13799 case GNU_ABI_TAG_LINUX:
13800 osname = "Linux";
13801 break;
13802 case GNU_ABI_TAG_HURD:
13803 osname = "Hurd";
13804 break;
13805 case GNU_ABI_TAG_SOLARIS:
13806 osname = "Solaris";
13807 break;
13808 case GNU_ABI_TAG_FREEBSD:
13809 osname = "FreeBSD";
13810 break;
13811 case GNU_ABI_TAG_NETBSD:
13812 osname = "NetBSD";
13813 break;
13814 default:
13815 osname = "Unknown";
13816 break;
13817 }
13818
13819 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
13820 major, minor, subminor);
13821 }
13822 break;
926c5385
CC		 13823
13824 case NT_GNU_GOLD_VERSION:
13825 {
13826 unsigned long i;
13827
13828 printf (_(" Version: "));
13829 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
13830 printf ("%c", pnote->descdata[i]);
13831 printf ("\n");
13832 }
13833 break;
664f90a3
TT		 13834 }
13835
13836 return 1;
13837}
13838
9437c45b 13839static const char *
d3ba0551 13840get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 13841{
13842 static char buff[64];
13843
b4db1224 13844 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 13845 {
13846 /* NetBSD core "procinfo" structure. */
13847 return _("NetBSD procinfo structure");
13848 }
13849
13850 /* As of Jan 2002 there are no other machine-independent notes
13851 defined for NetBSD core files. If the note type is less
13852 than the start of the machine-dependent note types, we don't
13853 understand it. */
13854
b4db1224 13855 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 13856 {
e9e44622 13857 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 13858 return buff;
13859 }
13860
13861 switch (elf_header.e_machine)
13862 {
13863 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
13864 and PT_GETFPREGS == mach+2. */
13865
13866 case EM_OLD_ALPHA:
13867 case EM_ALPHA:
13868 case EM_SPARC:
13869 case EM_SPARC32PLUS:
13870 case EM_SPARCV9:
13871 switch (e_type)
13872 {
2b692964 13873 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 13874 return _("PT_GETREGS (reg structure)");
2b692964 13875 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 13876 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 13877 default:
13878 break;
13879 }
13880 break;
13881
13882 /* On all other arch's, PT_GETREGS == mach+1 and
13883 PT_GETFPREGS == mach+3. */
13884 default:
13885 switch (e_type)
13886 {
2b692964 13887 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 13888 return _("PT_GETREGS (reg structure)");
2b692964 13889 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 13890 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 13891 default:
13892 break;
13893 }
13894 }
13895
9cf03b7e 13896 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 13897 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 13898 return buff;
13899}
13900
70616151
TT		 13901static const char *
13902get_stapsdt_note_type (unsigned e_type)
13903{
13904 static char buff[64];
13905
13906 switch (e_type)
13907 {
13908 case NT_STAPSDT:
13909 return _("NT_STAPSDT (SystemTap probe descriptors)");
13910
13911 default:
13912 break;
13913 }
13914
13915 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13916 return buff;
13917}
13918
c6a9fc58
TT		 13919static int
13920print_stapsdt_note (Elf_Internal_Note *pnote)
13921{
13922 int addr_size = is_32bit_elf ? 4 : 8;
13923 char *data = pnote->descdata;
13924 char *data_end = pnote->descdata + pnote->descsz;
13925 bfd_vma pc, base_addr, semaphore;
13926 char *provider, *probe, *arg_fmt;
13927
13928 pc = byte_get ((unsigned char *) data, addr_size);
13929 data += addr_size;
13930 base_addr = byte_get ((unsigned char *) data, addr_size);
13931 data += addr_size;
13932 semaphore = byte_get ((unsigned char *) data, addr_size);
13933 data += addr_size;
13934
13935 provider = data;
13936 data += strlen (data) + 1;
13937 probe = data;
13938 data += strlen (data) + 1;
13939 arg_fmt = data;
13940 data += strlen (data) + 1;
13941
13942 printf (_(" Provider: %s\n"), provider);
13943 printf (_(" Name: %s\n"), probe);
13944 printf (_(" Location: "));
13945 print_vma (pc, FULL_HEX);
13946 printf (_(", Base: "));
13947 print_vma (base_addr, FULL_HEX);
13948 printf (_(", Semaphore: "));
13949 print_vma (semaphore, FULL_HEX);
9cf03b7e 13950 printf ("\n");
c6a9fc58
TT		 13951 printf (_(" Arguments: %s\n"), arg_fmt);
13952
13953 return data == data_end;
13954}
13955
00e98fc7
TG		 13956static const char *
13957get_ia64_vms_note_type (unsigned e_type)
13958{
13959 static char buff[64];
13960
13961 switch (e_type)
13962 {
13963 case NT_VMS_MHD:
13964 return _("NT_VMS_MHD (module header)");
13965 case NT_VMS_LNM:
13966 return _("NT_VMS_LNM (language name)");
13967 case NT_VMS_SRC:
13968 return _("NT_VMS_SRC (source files)");
13969 case NT_VMS_TITLE:
9cf03b7e 13970 return "NT_VMS_TITLE";
00e98fc7
TG		 13971 case NT_VMS_EIDC:
13972 return _("NT_VMS_EIDC (consistency check)");
13973 case NT_VMS_FPMODE:
13974 return _("NT_VMS_FPMODE (FP mode)");
13975 case NT_VMS_LINKTIME:
9cf03b7e 13976 return "NT_VMS_LINKTIME";
00e98fc7
TG		 13977 case NT_VMS_IMGNAM:
13978 return _("NT_VMS_IMGNAM (image name)");
13979 case NT_VMS_IMGID:
13980 return _("NT_VMS_IMGID (image id)");
13981 case NT_VMS_LINKID:
13982 return _("NT_VMS_LINKID (link id)");
13983 case NT_VMS_IMGBID:
13984 return _("NT_VMS_IMGBID (build id)");
13985 case NT_VMS_GSTNAM:
13986 return _("NT_VMS_GSTNAM (sym table name)");
13987 case NT_VMS_ORIG_DYN:
9cf03b7e 13988 return "NT_VMS_ORIG_DYN";
00e98fc7 13989 case NT_VMS_PATCHTIME:
9cf03b7e 13990 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 13991 default:
13992 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13993 return buff;
13994 }
13995}
13996
13997static int
13998print_ia64_vms_note (Elf_Internal_Note * pnote)
13999{
14000 switch (pnote->type)
14001 {
14002 case NT_VMS_MHD:
14003 if (pnote->descsz > 36)
14004 {
14005 size_t l = strlen (pnote->descdata + 34);
14006 printf (_(" Creation date : %.17s\n"), pnote->descdata);
14007 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
14008 printf (_(" Module name : %s\n"), pnote->descdata + 34);
14009 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
14010 }
14011 else
14012 printf (_(" Invalid size\n"));
14013 break;
14014 case NT_VMS_LNM:
14015 printf (_(" Language: %s\n"), pnote->descdata);
14016 break;
14017#ifdef BFD64
14018 case NT_VMS_FPMODE:
9cf03b7e 14019 printf (_(" Floating Point mode: "));
4a5cb34f 14020 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 14021 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
14022 break;
14023 case NT_VMS_LINKTIME:
14024 printf (_(" Link time: "));
14025 print_vms_time
14026 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14027 printf ("\n");
14028 break;
14029 case NT_VMS_PATCHTIME:
14030 printf (_(" Patch time: "));
14031 print_vms_time
14032 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14033 printf ("\n");
14034 break;
14035 case NT_VMS_ORIG_DYN:
14036 printf (_(" Major id: %u, minor id: %u\n"),
14037 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
14038 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 14039 printf (_(" Last modified : "));
00e98fc7
TG		 14040 print_vms_time
14041 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 14042 printf (_("\n Link flags : "));
4a5cb34f 14043 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 14044 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
14045 printf (_(" Header flags: 0x%08x\n"),
14046 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
14047 printf (_(" Image id : %s\n"), pnote->descdata + 32);
14048 break;
14049#endif
14050 case NT_VMS_IMGNAM:
14051 printf (_(" Image name: %s\n"), pnote->descdata);
14052 break;
14053 case NT_VMS_GSTNAM:
14054 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
14055 break;
14056 case NT_VMS_IMGID:
14057 printf (_(" Image id: %s\n"), pnote->descdata);
14058 break;
14059 case NT_VMS_LINKID:
14060 printf (_(" Linker id: %s\n"), pnote->descdata);
14061 break;
14062 default:
14063 break;
14064 }
14065 return 1;
14066}
14067
6d118b09
NC		 14068/* Note that by the ELF standard, the name field is already null byte
14069 terminated, and namesz includes the terminating null byte.
14070 I.E. the value of namesz for the name "FSF" is 4.
14071
e3c8793a 14072 If the value of namesz is zero, there is no name present. */
779fe533 14073static int
2cf0635d 14074process_note (Elf_Internal_Note * pnote)
779fe533 14075{
2cf0635d
NC		 14076 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
14077 const char * nt;
9437c45b
JT		 14078
14079 if (pnote->namesz == 0)
1ec5cd37
NC		 14080 /* If there is no note name, then use the default set of
14081 note type strings. */
14082 nt = get_note_type (pnote->type);
14083
1118d252
RM		 14084 else if (const_strneq (pnote->namedata, "GNU"))
14085 /* GNU-specific object file notes. */
14086 nt = get_gnu_elf_note_type (pnote->type);
14087
0112cd26 14088 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 14089 /* NetBSD-specific core file notes. */
14090 nt = get_netbsd_elfcore_note_type (pnote->type);
14091
b15fa79e
AM		 14092 else if (strneq (pnote->namedata, "SPU/", 4))
14093 {
14094 /* SPU-specific core file notes. */
14095 nt = pnote->namedata + 4;
14096 name = "SPU";
14097 }
14098
00e98fc7
TG		 14099 else if (const_strneq (pnote->namedata, "IPF/VMS"))
14100 /* VMS/ia64-specific file notes. */
14101 nt = get_ia64_vms_note_type (pnote->type);
14102
70616151
TT		 14103 else if (const_strneq (pnote->namedata, "stapsdt"))
14104 nt = get_stapsdt_note_type (pnote->type);
14105
9437c45b 14106 else
1ec5cd37
NC		 14107 /* Don't recognize this note name; just use the default set of
14108 note type strings. */
00e98fc7 14109 nt = get_note_type (pnote->type);
9437c45b 14110
2aee03ae 14111 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 14112
14113 if (const_strneq (pnote->namedata, "IPF/VMS"))
14114 return print_ia64_vms_note (pnote);
664f90a3
TT		 14115 else if (const_strneq (pnote->namedata, "GNU"))
14116 return print_gnu_note (pnote);
c6a9fc58
TT		 14117 else if (const_strneq (pnote->namedata, "stapsdt"))
14118 return print_stapsdt_note (pnote);
9ece1fa9
TT		 14119 else if (const_strneq (pnote->namedata, "CORE"))
14120 return print_core_note (pnote);
00e98fc7
TG		 14121 else
14122 return 1;
779fe533
NC		 14123}
14124
6d118b09 14125
779fe533 14126static int
2cf0635d 14127process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 14128{
2cf0635d
NC		 14129 Elf_External_Note * pnotes;
14130 Elf_External_Note * external;
b34976b6 14131 int res = 1;
103f02d3 14132
779fe533
NC		 14133 if (length <= 0)
14134 return 0;
103f02d3 14135
3f5e193b 14136 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 14137 _("notes"));
dd24e3da 14138 if (pnotes == NULL)
a6e9f9df 14139 return 0;
779fe533 14140
103f02d3 14141 external = pnotes;
103f02d3 14142
9dd3a467 14143 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 14144 (unsigned long) offset, (unsigned long) length);
2aee03ae 14145 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 14146
15b42fb0 14147 while ((char *) external < (char *) pnotes + length)
779fe533 14148 {
b34976b6 14149 Elf_Internal_Note inote;
15b42fb0
AM		 14150 size_t min_notesz;
14151 char *next;
2cf0635d 14152 char * temp = NULL;
15b42fb0 14153 size_t data_remaining = ((char *) pnotes + length) - (char *) external;
6d118b09 14154
00e98fc7 14155 if (!is_ia64_vms ())
15b42fb0 14156 {
9dd3a467
NC		 14157 /* PR binutils/15191
14158 Make sure that there is enough data to read. */
15b42fb0
AM		 14159 min_notesz = offsetof (Elf_External_Note, name);
14160 if (data_remaining < min_notesz)
9dd3a467
NC		 14161 {
14162 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14163 (int) data_remaining);
14164 break;
14165 }
15b42fb0
AM		 14166 inote.type = BYTE_GET (external->type);
14167 inote.namesz = BYTE_GET (external->namesz);
14168 inote.namedata = external->name;
14169 inote.descsz = BYTE_GET (external->descsz);
14170 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
14171 inote.descpos = offset + (inote.descdata - (char *) pnotes);
14172 next = inote.descdata + align_power (inote.descsz, 2);
14173 }
00e98fc7 14174 else
15b42fb0
AM		 14175 {
14176 Elf64_External_VMS_Note *vms_external;
00e98fc7 14177
9dd3a467
NC		 14178 /* PR binutils/15191
14179 Make sure that there is enough data to read. */
15b42fb0
AM		 14180 min_notesz = offsetof (Elf64_External_VMS_Note, name);
14181 if (data_remaining < min_notesz)
9dd3a467
NC		 14182 {
14183 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14184 (int) data_remaining);
14185 break;
14186 }
3e55a963 14187
15b42fb0
AM		 14188 vms_external = (Elf64_External_VMS_Note *) external;
14189 inote.type = BYTE_GET (vms_external->type);
14190 inote.namesz = BYTE_GET (vms_external->namesz);
14191 inote.namedata = vms_external->name;
14192 inote.descsz = BYTE_GET (vms_external->descsz);
14193 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
14194 inote.descpos = offset + (inote.descdata - (char *) pnotes);
14195 next = inote.descdata + align_power (inote.descsz, 3);
14196 }
14197
14198 if (inote.descdata < (char *) external + min_notesz
14199 || next < (char *) external + min_notesz
14200 || data_remaining < (size_t)(next - (char *) external))
3e55a963 14201 {
15b42fb0 14202 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 14203 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 14204 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 14205 inote.type, inote.namesz, inote.descsz);
14206 break;
14207 }
14208
15b42fb0 14209 external = (Elf_External_Note *) next;
dd24e3da 14210
6d118b09
NC		 14211 /* Verify that name is null terminated. It appears that at least
14212 one version of Linux (RedHat 6.0) generates corefiles that don't
14213 comply with the ELF spec by failing to include the null byte in
14214 namesz. */
8b971f9f 14215 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 14216 {
3f5e193b 14217 temp = (char *) malloc (inote.namesz + 1);
76da6bbe 14218
6d118b09
NC		 14219 if (temp == NULL)
14220 {
14221 error (_("Out of memory\n"));
14222 res = 0;
14223 break;
14224 }
76da6bbe 14225
6d118b09
NC		 14226 strncpy (temp, inote.namedata, inote.namesz);
14227 temp[inote.namesz] = 0;
76da6bbe 14228
6d118b09
NC		 14229 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
14230 inote.namedata = temp;
14231 }
14232
14233 res &= process_note (& inote);
103f02d3 14234
6d118b09
NC		 14235 if (temp != NULL)
14236 {
14237 free (temp);
14238 temp = NULL;
14239 }
779fe533
NC		 14240 }
14241
14242 free (pnotes);
103f02d3 14243
779fe533
NC		 14244 return res;
14245}
14246
14247static int
2cf0635d 14248process_corefile_note_segments (FILE * file)
779fe533 14249{
2cf0635d 14250 Elf_Internal_Phdr * segment;
b34976b6
AM		 14251 unsigned int i;
14252 int res = 1;
103f02d3 14253
d93f0186 14254 if (! get_program_headers (file))
779fe533 14255 return 0;
103f02d3 14256
779fe533
NC		 14257 for (i = 0, segment = program_headers;
14258 i < elf_header.e_phnum;
b34976b6 14259 i++, segment++)
779fe533
NC		 14260 {
14261 if (segment->p_type == PT_NOTE)
103f02d3 14262 res &= process_corefile_note_segment (file,
30800947
NC		 14263 (bfd_vma) segment->p_offset,
14264 (bfd_vma) segment->p_filesz);
779fe533 14265 }
103f02d3 14266
779fe533
NC		 14267 return res;
14268}
14269
14270static int
2cf0635d 14271process_note_sections (FILE * file)
1ec5cd37 14272{
2cf0635d 14273 Elf_Internal_Shdr * section;
1ec5cd37 14274 unsigned long i;
df565f32 14275 int n = 0;
1ec5cd37
NC		 14276 int res = 1;
14277
14278 for (i = 0, section = section_headers;
fa1908fd 14279 i < elf_header.e_shnum && section != NULL;
1ec5cd37
NC		 14280 i++, section++)
14281 if (section->sh_type == SHT_NOTE)
df565f32
NC		 14282 {
14283 res &= process_corefile_note_segment (file,
14284 (bfd_vma) section->sh_offset,
14285 (bfd_vma) section->sh_size);
14286 n++;
14287 }
14288
14289 if (n == 0)
14290 /* Try processing NOTE segments instead. */
14291 return process_corefile_note_segments (file);
1ec5cd37
NC		 14292
14293 return res;
14294}
14295
14296static int
2cf0635d 14297process_notes (FILE * file)
779fe533
NC		 14298{
14299 /* If we have not been asked to display the notes then do nothing. */
14300 if (! do_notes)
14301 return 1;
103f02d3 14302
779fe533 14303 if (elf_header.e_type != ET_CORE)
1ec5cd37 14304 return process_note_sections (file);
103f02d3 14305
779fe533 14306 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 14307 if (elf_header.e_phnum > 0)
14308 return process_corefile_note_segments (file);
779fe533 14309
1ec5cd37
NC		 14310 printf (_("No note segments present in the core file.\n"));
14311 return 1;
779fe533
NC		 14312}
14313
252b5132 14314static int
2cf0635d 14315process_arch_specific (FILE * file)
252b5132 14316{
a952a375
NC		 14317 if (! do_arch)
14318 return 1;
14319
252b5132
RH		 14320 switch (elf_header.e_machine)
14321 {
11c1ff18
PB		 14322 case EM_ARM:
14323 return process_arm_specific (file);
252b5132 14324 case EM_MIPS:
4fe85591 14325 case EM_MIPS_RS3_LE:
252b5132
RH		 14326 return process_mips_specific (file);
14327 break;
35c08157
KLC		 14328 case EM_NDS32:
14329 return process_nds32_specific (file);
14330 break;
34c8bcba
JM		 14331 case EM_PPC:
14332 return process_power_specific (file);
14333 break;
9e8c70f9
DM		 14334 case EM_SPARC:
14335 case EM_SPARC32PLUS:
14336 case EM_SPARCV9:
14337 return process_sparc_specific (file);
14338 break;
59e6276b
JM		 14339 case EM_TI_C6000:
14340 return process_tic6x_specific (file);
14341 break;
13761a11
NC		 14342 case EM_MSP430:
14343 return process_msp430x_specific (file);
252b5132
RH		 14344 default:
14345 break;
14346 }
14347 return 1;
14348}
14349
14350static int
2cf0635d 14351get_file_header (FILE * file)
252b5132 14352{
9ea033b2
NC		 14353 /* Read in the identity array. */
14354 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 14355 return 0;
14356
9ea033b2 14357 /* Determine how to read the rest of the header. */
b34976b6 14358 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 14359 {
14360 default: /* fall through */
14361 case ELFDATANONE: /* fall through */
adab8cdc
AO		 14362 case ELFDATA2LSB:
14363 byte_get = byte_get_little_endian;
14364 byte_put = byte_put_little_endian;
14365 break;
14366 case ELFDATA2MSB:
14367 byte_get = byte_get_big_endian;
14368 byte_put = byte_put_big_endian;
14369 break;
9ea033b2
NC		 14370 }
14371
14372 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 14373 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 14374
14375 /* Read in the rest of the header. */
14376 if (is_32bit_elf)
14377 {
14378 Elf32_External_Ehdr ehdr32;
252b5132 14379
9ea033b2
NC		 14380 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
14381 return 0;
103f02d3 14382
9ea033b2
NC		 14383 elf_header.e_type = BYTE_GET (ehdr32.e_type);
14384 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
14385 elf_header.e_version = BYTE_GET (ehdr32.e_version);
14386 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
14387 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
14388 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
14389 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
14390 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
14391 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
14392 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
14393 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
14394 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
14395 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
14396 }
252b5132 14397 else
9ea033b2
NC		 14398 {
14399 Elf64_External_Ehdr ehdr64;
a952a375
NC		 14400
14401 /* If we have been compiled with sizeof (bfd_vma) == 4, then
14402 we will not be able to cope with the 64bit data found in
14403 64 ELF files. Detect this now and abort before we start
50c2245b 14404 overwriting things. */
a952a375
NC		 14405 if (sizeof (bfd_vma) < 8)
14406 {
e3c8793a
NC		 14407 error (_("This instance of readelf has been built without support for a\n\
1440864 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 14409 return 0;
14410 }
103f02d3 14411
9ea033b2
NC		 14412 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
14413 return 0;
103f02d3 14414
9ea033b2
NC		 14415 elf_header.e_type = BYTE_GET (ehdr64.e_type);
14416 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
14417 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 14418 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
14419 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
14420 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 14421 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
14422 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
14423 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
14424 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
14425 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
14426 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
14427 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
14428 }
252b5132 14429
7ece0d85
JJ		 14430 if (elf_header.e_shoff)
14431 {
14432 /* There may be some extensions in the first section header. Don't
14433 bomb if we can't read it. */
14434 if (is_32bit_elf)
14435 get_32bit_section_headers (file, 1);
14436 else
14437 get_64bit_section_headers (file, 1);
14438 }
560f3c1c 14439
252b5132
RH		 14440 return 1;
14441}
14442
fb52b2f4
NC		 14443/* Process one ELF object file according to the command line options.
14444 This file may actually be stored in an archive. The file is
14445 positioned at the start of the ELF object. */
14446
ff78d6d6 14447static int
2cf0635d 14448process_object (char * file_name, FILE * file)
252b5132 14449{
252b5132
RH		 14450 unsigned int i;
14451
252b5132
RH		 14452 if (! get_file_header (file))
14453 {
14454 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 14455 return 1;
252b5132
RH		 14456 }
14457
14458 /* Initialise per file variables. */
60bca95a 14459 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 14460 version_info[i] = 0;
14461
60bca95a 14462 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 14463 dynamic_info[i] = 0;
5115b233 14464 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 14465
14466 /* Process the file. */
14467 if (show_name)
14468 printf (_("\nFile: %s\n"), file_name);
14469
18bd398b
NC		 14470 /* Initialise the dump_sects array from the cmdline_dump_sects array.
14471 Note we do this even if cmdline_dump_sects is empty because we
14472 must make sure that the dump_sets array is zeroed out before each
14473 object file is processed. */
14474 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 14475 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 14476
14477 if (num_cmdline_dump_sects > 0)
14478 {
14479 if (num_dump_sects == 0)
14480 /* A sneaky way of allocating the dump_sects array. */
09c11c86 14481 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 14482
14483 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 14484 memcpy (dump_sects, cmdline_dump_sects,
14485 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 14486 }
d70c5fc7 14487
252b5132 14488 if (! process_file_header ())
fb52b2f4 14489 return 1;
252b5132 14490
d1f5c6e3 14491 if (! process_section_headers (file))
2f62977e 14492 {
d1f5c6e3
L		 14493 /* Without loaded section headers we cannot process lots of
14494 things. */
2f62977e 14495 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 14496
2f62977e 14497 if (! do_using_dynamic)
2c610e4b 14498 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 14499 }
252b5132 14500
d1f5c6e3
L		 14501 if (! process_section_groups (file))
14502 {
14503 /* Without loaded section groups we cannot process unwind. */
14504 do_unwind = 0;
14505 }
14506
2f62977e 14507 if (process_program_headers (file))
b2d38a17 14508 process_dynamic_section (file);
252b5132
RH		 14509
14510 process_relocs (file);
14511
4d6ed7c8
NC		 14512 process_unwind (file);
14513
252b5132
RH		 14514 process_symbol_table (file);
14515
14516 process_syminfo (file);
14517
14518 process_version_sections (file);
14519
14520 process_section_contents (file);
f5842774 14521
1ec5cd37 14522 process_notes (file);
103f02d3 14523
047b2264
JJ		 14524 process_gnu_liblist (file);
14525
252b5132
RH		 14526 process_arch_specific (file);
14527
d93f0186
NC		 14528 if (program_headers)
14529 {
14530 free (program_headers);
14531 program_headers = NULL;
14532 }
14533
252b5132
RH		 14534 if (section_headers)
14535 {
14536 free (section_headers);
14537 section_headers = NULL;
14538 }
14539
14540 if (string_table)
14541 {
14542 free (string_table);
14543 string_table = NULL;
d40ac9bd 14544 string_table_length = 0;
252b5132
RH		 14545 }
14546
14547 if (dynamic_strings)
14548 {
14549 free (dynamic_strings);
14550 dynamic_strings = NULL;
d79b3d50 14551 dynamic_strings_length = 0;
252b5132
RH		 14552 }
14553
14554 if (dynamic_symbols)
14555 {
14556 free (dynamic_symbols);
14557 dynamic_symbols = NULL;
19936277 14558 num_dynamic_syms = 0;
252b5132
RH		 14559 }
14560
14561 if (dynamic_syminfo)
14562 {
14563 free (dynamic_syminfo);
14564 dynamic_syminfo = NULL;
14565 }
ff78d6d6 14566
293c573e
MR		 14567 if (dynamic_section)
14568 {
14569 free (dynamic_section);
14570 dynamic_section = NULL;
14571 }
14572
e4b17d5c
L		 14573 if (section_headers_groups)
14574 {
14575 free (section_headers_groups);
14576 section_headers_groups = NULL;
14577 }
14578
14579 if (section_groups)
14580 {
2cf0635d
NC		 14581 struct group_list * g;
14582 struct group_list * next;
e4b17d5c
L		 14583
14584 for (i = 0; i < group_count; i++)
14585 {
14586 for (g = section_groups [i].root; g != NULL; g = next)
14587 {
14588 next = g->next;
14589 free (g);
14590 }
14591 }
14592
14593 free (section_groups);
14594 section_groups = NULL;
14595 }
14596
19e6b90e 14597 free_debug_memory ();
18bd398b 14598
ff78d6d6 14599 return 0;
252b5132
RH		 14600}
14601
2cf0635d
NC		 14602/* Process an ELF archive.
14603 On entry the file is positioned just after the ARMAG string. */
14604
14605static int
14606process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
14607{
14608 struct archive_info arch;
14609 struct archive_info nested_arch;
14610 size_t got;
2cf0635d
NC		 14611 int ret;
14612
14613 show_name = 1;
14614
14615 /* The ARCH structure is used to hold information about this archive. */
14616 arch.file_name = NULL;
14617 arch.file = NULL;
14618 arch.index_array = NULL;
14619 arch.sym_table = NULL;
14620 arch.longnames = NULL;
14621
14622 /* The NESTED_ARCH structure is used as a single-item cache of information
14623 about a nested archive (when members of a thin archive reside within
14624 another regular archive file). */
14625 nested_arch.file_name = NULL;
14626 nested_arch.file = NULL;
14627 nested_arch.index_array = NULL;
14628 nested_arch.sym_table = NULL;
14629 nested_arch.longnames = NULL;
14630
14631 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
14632 {
14633 ret = 1;
14634 goto out;
4145f1d5 14635 }
fb52b2f4 14636
4145f1d5
NC		 14637 if (do_archive_index)
14638 {
2cf0635d 14639 if (arch.sym_table == NULL)
4145f1d5
NC		 14640 error (_("%s: unable to dump the index as none was found\n"), file_name);
14641 else
14642 {
2cf0635d 14643 unsigned int i, l;
4145f1d5
NC		 14644 unsigned long current_pos;
14645
14646 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
c2a7d3f5 14647 file_name, (long) arch.index_num, arch.sym_size);
4145f1d5
NC		 14648 current_pos = ftell (file);
14649
2cf0635d 14650 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 14651 {
2cf0635d
NC		 14652 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
14653 {
14654 char * member_name;
4145f1d5 14655
2cf0635d
NC		 14656 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
14657
14658 if (member_name != NULL)
14659 {
14660 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
14661
14662 if (qualified_name != NULL)
14663 {
c2a7d3f5
NC		 14664 printf (_("Contents of binary %s at offset "), qualified_name);
14665 (void) print_vma (arch.index_array[i], PREFIX_HEX);
14666 putchar ('\n');
2cf0635d
NC		 14667 free (qualified_name);
14668 }
4145f1d5
NC		 14669 }
14670 }
2cf0635d
NC		 14671
14672 if (l >= arch.sym_size)
4145f1d5
NC		 14673 {
14674 error (_("%s: end of the symbol table reached before the end of the index\n"),
14675 file_name);
cb8f3167 14676 break;
4145f1d5 14677 }
2cf0635d
NC		 14678 printf ("\t%s\n", arch.sym_table + l);
14679 l += strlen (arch.sym_table + l) + 1;
4145f1d5
NC		 14680 }
14681
c2a7d3f5
NC		 14682 if (arch.uses_64bit_indicies)
14683 l = (l + 7) & ~ 7;
14684 else
14685 l += l & 1;
14686
2cf0635d 14687 if (l < arch.sym_size)
c2a7d3f5
NC		 14688 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
14689 file_name, arch.sym_size - l);
4145f1d5 14690
4145f1d5
NC		 14691 if (fseek (file, current_pos, SEEK_SET) != 0)
14692 {
14693 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 14694 ret = 1;
14695 goto out;
4145f1d5 14696 }
fb52b2f4 14697 }
4145f1d5
NC		 14698
14699 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
14700 && !do_segments && !do_header && !do_dump && !do_version
14701 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 14702 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 14703 {
14704 ret = 0; /* Archive index only. */
14705 goto out;
14706 }
fb52b2f4
NC		 14707 }
14708
d989285c 14709 ret = 0;
fb52b2f4
NC		 14710
14711 while (1)
14712 {
2cf0635d
NC		 14713 char * name;
14714 size_t namelen;
14715 char * qualified_name;
14716
14717 /* Read the next archive header. */
14718 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
14719 {
14720 error (_("%s: failed to seek to next archive header\n"), file_name);
14721 return 1;
14722 }
14723 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
14724 if (got != sizeof arch.arhdr)
14725 {
14726 if (got == 0)
14727 break;
14728 error (_("%s: failed to read archive header\n"), file_name);
14729 ret = 1;
14730 break;
14731 }
14732 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
14733 {
14734 error (_("%s: did not find a valid archive header\n"), arch.file_name);
14735 ret = 1;
14736 break;
14737 }
14738
14739 arch.next_arhdr_offset += sizeof arch.arhdr;
14740
14741 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
14742 if (archive_file_size & 01)
14743 ++archive_file_size;
14744
14745 name = get_archive_member_name (&arch, &nested_arch);
14746 if (name == NULL)
fb52b2f4 14747 {
0fd3a477 14748 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 14749 ret = 1;
14750 break;
fb52b2f4 14751 }
2cf0635d 14752 namelen = strlen (name);
fb52b2f4 14753
2cf0635d
NC		 14754 qualified_name = make_qualified_name (&arch, &nested_arch, name);
14755 if (qualified_name == NULL)
fb52b2f4 14756 {
2cf0635d 14757 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 14758 ret = 1;
14759 break;
fb52b2f4
NC		 14760 }
14761
2cf0635d
NC		 14762 if (is_thin_archive && arch.nested_member_origin == 0)
14763 {
14764 /* This is a proxy for an external member of a thin archive. */
14765 FILE * member_file;
14766 char * member_file_name = adjust_relative_path (file_name, name, namelen);
14767 if (member_file_name == NULL)
14768 {
14769 ret = 1;
14770 break;
14771 }
14772
14773 member_file = fopen (member_file_name, "rb");
14774 if (member_file == NULL)
14775 {
14776 error (_("Input file '%s' is not readable.\n"), member_file_name);
14777 free (member_file_name);
14778 ret = 1;
14779 break;
14780 }
14781
14782 archive_file_offset = arch.nested_member_origin;
14783
14784 ret |= process_object (qualified_name, member_file);
14785
14786 fclose (member_file);
14787 free (member_file_name);
14788 }
14789 else if (is_thin_archive)
14790 {
a043396b
NC		 14791 /* PR 15140: Allow for corrupt thin archives. */
14792 if (nested_arch.file == NULL)
14793 {
14794 error (_("%s: contains corrupt thin archive: %s\n"),
14795 file_name, name);
14796 ret = 1;
14797 break;
14798 }
14799
2cf0635d
NC		 14800 /* This is a proxy for a member of a nested archive. */
14801 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
14802
14803 /* The nested archive file will have been opened and setup by
14804 get_archive_member_name. */
14805 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
14806 {
14807 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
14808 ret = 1;
14809 break;
14810 }
14811
14812 ret |= process_object (qualified_name, nested_arch.file);
14813 }
14814 else
14815 {
14816 archive_file_offset = arch.next_arhdr_offset;
14817 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 14818
2cf0635d
NC		 14819 ret |= process_object (qualified_name, file);
14820 }
fb52b2f4 14821
2b52916e
L		 14822 if (dump_sects != NULL)
14823 {
14824 free (dump_sects);
14825 dump_sects = NULL;
14826 num_dump_sects = 0;
14827 }
14828
2cf0635d 14829 free (qualified_name);
fb52b2f4
NC		 14830 }
14831
4145f1d5 14832 out:
2cf0635d
NC		 14833 if (nested_arch.file != NULL)
14834 fclose (nested_arch.file);
14835 release_archive (&nested_arch);
14836 release_archive (&arch);
fb52b2f4 14837
d989285c 14838 return ret;
fb52b2f4
NC		 14839}
14840
14841static int
2cf0635d 14842process_file (char * file_name)
fb52b2f4 14843{
2cf0635d 14844 FILE * file;
fb52b2f4
NC		 14845 struct stat statbuf;
14846 char armag[SARMAG];
14847 int ret;
14848
14849 if (stat (file_name, &statbuf) < 0)
14850 {
f24ddbdd
NC		 14851 if (errno == ENOENT)
14852 error (_("'%s': No such file\n"), file_name);
14853 else
14854 error (_("Could not locate '%s'. System error message: %s\n"),
14855 file_name, strerror (errno));
14856 return 1;
14857 }
14858
14859 if (! S_ISREG (statbuf.st_mode))
14860 {
14861 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 14862 return 1;
14863 }
14864
14865 file = fopen (file_name, "rb");
14866 if (file == NULL)
14867 {
f24ddbdd 14868 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 14869 return 1;
14870 }
14871
14872 if (fread (armag, SARMAG, 1, file) != 1)
14873 {
4145f1d5 14874 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 14875 fclose (file);
14876 return 1;
14877 }
14878
14879 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 14880 ret = process_archive (file_name, file, FALSE);
14881 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
14882 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 14883 else
14884 {
4145f1d5
NC		 14885 if (do_archive_index)
14886 error (_("File %s is not an archive so its index cannot be displayed.\n"),
14887 file_name);
14888
fb52b2f4
NC		 14889 rewind (file);
14890 archive_file_size = archive_file_offset = 0;
14891 ret = process_object (file_name, file);
14892 }
14893
14894 fclose (file);
14895
14896 return ret;
14897}
14898
252b5132
RH		 14899#ifdef SUPPORT_DISASSEMBLY
14900/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 14901 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 14902 symbols. */
252b5132
RH		 14903
14904void
2cf0635d 14905print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 14906{
14907 fprintf (outfile,"0x%8.8x", addr);
14908}
14909
e3c8793a 14910/* Needed by the i386 disassembler. */
252b5132
RH		 14911void
14912db_task_printsym (unsigned int addr)
14913{
14914 print_address (addr, stderr);
14915}
14916#endif
14917
14918int
2cf0635d 14919main (int argc, char ** argv)
252b5132 14920{
ff78d6d6
L		 14921 int err;
14922
252b5132
RH		 14923#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
14924 setlocale (LC_MESSAGES, "");
3882b010
L		 14925#endif
14926#if defined (HAVE_SETLOCALE)
14927 setlocale (LC_CTYPE, "");
252b5132
RH		 14928#endif
14929 bindtextdomain (PACKAGE, LOCALEDIR);
14930 textdomain (PACKAGE);
14931
869b9d07
MM		 14932 expandargv (&argc, &argv);
14933
252b5132
RH		 14934 parse_args (argc, argv);
14935
18bd398b 14936 if (num_dump_sects > 0)
59f14fc0 14937 {
18bd398b 14938 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 14939 cmdline_dump_sects = (dump_type *)
14940 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 14941 if (cmdline_dump_sects == NULL)
591a748a 14942 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 14943 else
14944 {
09c11c86
NC		 14945 memcpy (cmdline_dump_sects, dump_sects,
14946 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 14947 num_cmdline_dump_sects = num_dump_sects;
14948 }
14949 }
14950
18bd398b
NC		 14951 if (optind < (argc - 1))
14952 show_name = 1;
14953
ff78d6d6 14954 err = 0;
252b5132 14955 while (optind < argc)
18bd398b 14956 err |= process_file (argv[optind++]);
252b5132
RH		 14957
14958 if (dump_sects != NULL)
14959 free (dump_sects);
59f14fc0
AS		 14960 if (cmdline_dump_sects != NULL)
14961 free (cmdline_dump_sects);
252b5132 14962
ff78d6d6 14963 return err;
252b5132 14964}
GDB Binutils - Deliverables
This page took 1.981306 seconds and 4 git commands to generate.