ChangeLog entries for the previous commit.
[deliverable/binutils-gdb.git] / binutils / readelf.c
CommitLineData
252b5132 1/* readelf.c -- display contents of an ELF format file
7e26601c 2 Copyright 1998-2013 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"
13761a11 134#include "elf/nios2.h"
3b16e843 135#include "elf/or32.h"
7d466069 136#include "elf/pj.h"
3b16e843 137#include "elf/ppc.h"
c833c019 138#include "elf/ppc64.h"
99c513f6 139#include "elf/rl78.h"
c7927a3c 140#include "elf/rx.h"
a85d7ed0 141#include "elf/s390.h"
1c0d3aa6 142#include "elf/score.h"
3b16e843
NC
143#include "elf/sh.h"
144#include "elf/sparc.h"
e9f53129 145#include "elf/spu.h"
40b36596 146#include "elf/tic6x.h"
aa137e4d
NC
147#include "elf/tilegx.h"
148#include "elf/tilepro.h"
3b16e843 149#include "elf/v850.h"
179d3252 150#include "elf/vax.h"
3b16e843 151#include "elf/x86-64.h"
c29aca4a 152#include "elf/xc16x.h"
f6c1a2d5 153#include "elf/xgate.h"
93fbbb04 154#include "elf/xstormy16.h"
88da6820 155#include "elf/xtensa.h"
252b5132 156
252b5132 157#include "getopt.h"
566b0d53 158#include "libiberty.h"
09c11c86 159#include "safe-ctype.h"
2cf0635d 160#include "filenames.h"
252b5132 161
15b42fb0
AM
162#ifndef offsetof
163#define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
164#endif
165
2cf0635d 166char * program_name = "readelf";
85b1c36d
BE
167static long archive_file_offset;
168static unsigned long archive_file_size;
169static unsigned long dynamic_addr;
170static bfd_size_type dynamic_size;
171static unsigned int dynamic_nent;
2cf0635d 172static char * dynamic_strings;
85b1c36d 173static unsigned long dynamic_strings_length;
2cf0635d 174static char * string_table;
85b1c36d
BE
175static unsigned long string_table_length;
176static unsigned long num_dynamic_syms;
2cf0635d
NC
177static Elf_Internal_Sym * dynamic_symbols;
178static Elf_Internal_Syminfo * dynamic_syminfo;
85b1c36d
BE
179static unsigned long dynamic_syminfo_offset;
180static unsigned int dynamic_syminfo_nent;
f8eae8b2 181static char program_interpreter[PATH_MAX];
bb8a0291 182static bfd_vma dynamic_info[DT_ENCODING];
fdc90cb4 183static bfd_vma dynamic_info_DT_GNU_HASH;
85b1c36d
BE
184static bfd_vma version_info[16];
185static Elf_Internal_Ehdr elf_header;
2cf0635d
NC
186static Elf_Internal_Shdr * section_headers;
187static Elf_Internal_Phdr * program_headers;
188static Elf_Internal_Dyn * dynamic_section;
189static Elf_Internal_Shdr * symtab_shndx_hdr;
85b1c36d
BE
190static int show_name;
191static int do_dynamic;
192static int do_syms;
2c610e4b 193static int do_dyn_syms;
85b1c36d
BE
194static int do_reloc;
195static int do_sections;
196static int do_section_groups;
5477e8a0 197static int do_section_details;
85b1c36d
BE
198static int do_segments;
199static int do_unwind;
200static int do_using_dynamic;
201static int do_header;
202static int do_dump;
203static int do_version;
85b1c36d
BE
204static int do_histogram;
205static int do_debugging;
85b1c36d
BE
206static int do_arch;
207static int do_notes;
4145f1d5 208static int do_archive_index;
85b1c36d 209static int is_32bit_elf;
252b5132 210
e4b17d5c
L
211struct group_list
212{
2cf0635d 213 struct group_list * next;
e4b17d5c
L
214 unsigned int section_index;
215};
216
217struct group
218{
2cf0635d 219 struct group_list * root;
e4b17d5c
L
220 unsigned int group_index;
221};
222
85b1c36d 223static size_t group_count;
2cf0635d
NC
224static struct group * section_groups;
225static struct group ** section_headers_groups;
e4b17d5c 226
09c11c86
NC
227
228/* Flag bits indicating particular types of dump. */
229#define HEX_DUMP (1 << 0) /* The -x command line switch. */
230#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
231#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
232#define STRING_DUMP (1 << 3) /* The -p command line switch. */
cf13d699 233#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
09c11c86
NC
234
235typedef unsigned char dump_type;
236
237/* A linked list of the section names for which dumps were requested. */
aef1f6d0
DJ
238struct dump_list_entry
239{
2cf0635d 240 char * name;
09c11c86 241 dump_type type;
2cf0635d 242 struct dump_list_entry * next;
aef1f6d0 243};
2cf0635d 244static struct dump_list_entry * dump_sects_byname;
aef1f6d0 245
09c11c86
NC
246/* A dynamic array of flags indicating for which sections a dump
247 has been requested via command line switches. */
248static dump_type * cmdline_dump_sects = NULL;
249static unsigned int num_cmdline_dump_sects = 0;
18bd398b
NC
250
251/* A dynamic array of flags indicating for which sections a dump of
252 some kind has been requested. It is reset on a per-object file
aef1f6d0
DJ
253 basis and then initialised from the cmdline_dump_sects array,
254 the results of interpreting the -w switch, and the
255 dump_sects_byname list. */
09c11c86
NC
256static dump_type * dump_sects = NULL;
257static unsigned int num_dump_sects = 0;
252b5132 258
252b5132 259
c256ffe7 260/* How to print a vma value. */
843dd992
NC
261typedef enum print_mode
262{
263 HEX,
264 DEC,
265 DEC_5,
266 UNSIGNED,
267 PREFIX_HEX,
268 FULL_HEX,
269 LONG_HEX
270}
271print_mode;
272
9c19a809
NC
273#define UNKNOWN -1
274
2b692964
NC
275#define SECTION_NAME(X) \
276 ((X) == NULL ? _("<none>") \
277 : string_table == NULL ? _("<no-name>") \
278 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
0b49d371 279 : string_table + (X)->sh_name))
252b5132 280
ee42cf8c 281#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
252b5132 282
ba5cdace
NC
283#define GET_ELF_SYMBOLS(file, section, sym_count) \
284 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
285 : get_64bit_elf_symbols (file, section, sym_count))
9ea033b2 286
d79b3d50
NC
287#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
288/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
289 already been called and verified that the string exists. */
290#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
18bd398b 291
61865e30
NC
292#define REMOVE_ARCH_BITS(ADDR) \
293 do \
294 { \
295 if (elf_header.e_machine == EM_ARM) \
296 (ADDR) &= ~1; \
297 } \
298 while (0)
d79b3d50 299\f
59245841
NC
300/* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
301 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
302 using malloc and fill that. In either case return the pointer to the start of
303 the retrieved data or NULL if something went wrong. If something does go wrong
304 emit an error message using REASON as part of the context. */
305
c256ffe7 306static void *
2cf0635d
NC
307get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
308 const char * reason)
a6e9f9df 309{
2cf0635d 310 void * mvar;
a6e9f9df 311
c256ffe7 312 if (size == 0 || nmemb == 0)
a6e9f9df
AM
313 return NULL;
314
fb52b2f4 315 if (fseek (file, archive_file_offset + offset, SEEK_SET))
a6e9f9df 316 {
0fd3a477 317 error (_("Unable to seek to 0x%lx for %s\n"),
0af1713e 318 (unsigned long) archive_file_offset + offset, reason);
a6e9f9df
AM
319 return NULL;
320 }
321
322 mvar = var;
323 if (mvar == NULL)
324 {
c256ffe7
JJ
325 /* Check for overflow. */
326 if (nmemb < (~(size_t) 0 - 1) / size)
327 /* + 1 so that we can '\0' terminate invalid string table sections. */
328 mvar = malloc (size * nmemb + 1);
a6e9f9df
AM
329
330 if (mvar == NULL)
331 {
0fd3a477
JW
332 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
333 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM
334 return NULL;
335 }
c256ffe7
JJ
336
337 ((char *) mvar)[size * nmemb] = '\0';
a6e9f9df
AM
338 }
339
c256ffe7 340 if (fread (mvar, size, nmemb, file) != nmemb)
a6e9f9df 341 {
0fd3a477
JW
342 error (_("Unable to read in 0x%lx bytes of %s\n"),
343 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM
344 if (mvar != var)
345 free (mvar);
346 return NULL;
347 }
348
349 return mvar;
350}
351
14a91970 352/* Print a VMA value. */
cb8f3167 353
66543521 354static int
14a91970 355print_vma (bfd_vma vma, print_mode mode)
66543521 356{
66543521
AM
357 int nc = 0;
358
14a91970 359 switch (mode)
66543521 360 {
14a91970
AM
361 case FULL_HEX:
362 nc = printf ("0x");
363 /* Drop through. */
66543521 364
14a91970 365 case LONG_HEX:
f7a99963 366#ifdef BFD64
14a91970 367 if (is_32bit_elf)
437c2fb7 368 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
f7a99963 369#endif
14a91970
AM
370 printf_vma (vma);
371 return nc + 16;
b19aac67 372
14a91970
AM
373 case DEC_5:
374 if (vma <= 99999)
375 return printf ("%5" BFD_VMA_FMT "d", vma);
376 /* Drop through. */
66543521 377
14a91970
AM
378 case PREFIX_HEX:
379 nc = printf ("0x");
380 /* Drop through. */
66543521 381
14a91970
AM
382 case HEX:
383 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 384
14a91970
AM
385 case DEC:
386 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 387
14a91970
AM
388 case UNSIGNED:
389 return printf ("%" BFD_VMA_FMT "u", vma);
f7a99963 390 }
66543521 391 return 0;
f7a99963
NC
392}
393
7bfd842d 394/* Display a symbol on stdout. Handles the display of control characters and
3bfcb652 395 multibye characters (assuming the host environment supports them).
31104126 396
7bfd842d
NC
397 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
398
399 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
400 padding as necessary.
171191ba
NC
401
402 Returns the number of emitted characters. */
403
404static unsigned int
7a88bc9c 405print_symbol (int width, const char *symbol)
31104126 406{
171191ba 407 bfd_boolean extra_padding = FALSE;
7bfd842d 408 int num_printed = 0;
3bfcb652 409#ifdef HAVE_MBSTATE_T
7bfd842d 410 mbstate_t state;
3bfcb652 411#endif
7bfd842d 412 int width_remaining;
961c521f 413
7bfd842d 414 if (width < 0)
961c521f 415 {
961c521f
NC
416 /* Keep the width positive. This also helps. */
417 width = - width;
171191ba 418 extra_padding = TRUE;
7bfd842d 419 }
961c521f 420
7bfd842d
NC
421 if (do_wide)
422 /* Set the remaining width to a very large value.
423 This simplifies the code below. */
424 width_remaining = INT_MAX;
425 else
426 width_remaining = width;
cb8f3167 427
3bfcb652 428#ifdef HAVE_MBSTATE_T
7bfd842d
NC
429 /* Initialise the multibyte conversion state. */
430 memset (& state, 0, sizeof (state));
3bfcb652 431#endif
961c521f 432
7bfd842d
NC
433 while (width_remaining)
434 {
435 size_t n;
7bfd842d 436 const char c = *symbol++;
961c521f 437
7bfd842d 438 if (c == 0)
961c521f
NC
439 break;
440
7bfd842d
NC
441 /* Do not print control characters directly as they can affect terminal
442 settings. Such characters usually appear in the names generated
443 by the assembler for local labels. */
444 if (ISCNTRL (c))
961c521f 445 {
7bfd842d 446 if (width_remaining < 2)
961c521f
NC
447 break;
448
7bfd842d
NC
449 printf ("^%c", c + 0x40);
450 width_remaining -= 2;
171191ba 451 num_printed += 2;
961c521f 452 }
7bfd842d
NC
453 else if (ISPRINT (c))
454 {
455 putchar (c);
456 width_remaining --;
457 num_printed ++;
458 }
961c521f
NC
459 else
460 {
3bfcb652
NC
461#ifdef HAVE_MBSTATE_T
462 wchar_t w;
463#endif
7bfd842d
NC
464 /* Let printf do the hard work of displaying multibyte characters. */
465 printf ("%.1s", symbol - 1);
466 width_remaining --;
467 num_printed ++;
468
3bfcb652 469#ifdef HAVE_MBSTATE_T
7bfd842d
NC
470 /* Try to find out how many bytes made up the character that was
471 just printed. Advance the symbol pointer past the bytes that
472 were displayed. */
473 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
3bfcb652
NC
474#else
475 n = 1;
476#endif
7bfd842d
NC
477 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
478 symbol += (n - 1);
961c521f 479 }
961c521f 480 }
171191ba 481
7bfd842d 482 if (extra_padding && num_printed < width)
171191ba
NC
483 {
484 /* Fill in the remaining spaces. */
7bfd842d
NC
485 printf ("%-*s", width - num_printed, " ");
486 num_printed = width;
171191ba
NC
487 }
488
489 return num_printed;
31104126
NC
490}
491
89fac5e3
RS
492/* Return a pointer to section NAME, or NULL if no such section exists. */
493
494static Elf_Internal_Shdr *
2cf0635d 495find_section (const char * name)
89fac5e3
RS
496{
497 unsigned int i;
498
499 for (i = 0; i < elf_header.e_shnum; i++)
500 if (streq (SECTION_NAME (section_headers + i), name))
501 return section_headers + i;
502
503 return NULL;
504}
505
0b6ae522
DJ
506/* Return a pointer to a section containing ADDR, or NULL if no such
507 section exists. */
508
509static Elf_Internal_Shdr *
510find_section_by_address (bfd_vma addr)
511{
512 unsigned int i;
513
514 for (i = 0; i < elf_header.e_shnum; i++)
515 {
516 Elf_Internal_Shdr *sec = section_headers + i;
517 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
518 return sec;
519 }
520
521 return NULL;
522}
523
657d0d47
CC
524/* Return a pointer to section NAME, or NULL if no such section exists,
525 restricted to the list of sections given in SET. */
526
527static Elf_Internal_Shdr *
528find_section_in_set (const char * name, unsigned int * set)
529{
530 unsigned int i;
531
532 if (set != NULL)
533 {
534 while ((i = *set++) > 0)
535 if (streq (SECTION_NAME (section_headers + i), name))
536 return section_headers + i;
537 }
538
539 return find_section (name);
540}
541
0b6ae522
DJ
542/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
543 bytes read. */
544
f6f0e17b
NC
545static inline unsigned long
546read_uleb128 (unsigned char *data,
547 unsigned int *length_return,
548 const unsigned char * const end)
0b6ae522 549{
f6f0e17b 550 return read_leb128 (data, length_return, FALSE, end);
0b6ae522
DJ
551}
552
28f997cf
TG
553/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
554 This OS has so many departures from the ELF standard that we test it at
555 many places. */
556
557static inline int
558is_ia64_vms (void)
559{
560 return elf_header.e_machine == EM_IA_64
561 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
562}
563
bcedfee6 564/* Guess the relocation size commonly used by the specific machines. */
252b5132 565
252b5132 566static int
2dc4cec1 567guess_is_rela (unsigned int e_machine)
252b5132 568{
9c19a809 569 switch (e_machine)
252b5132
RH
570 {
571 /* Targets that use REL relocations. */
252b5132
RH
572 case EM_386:
573 case EM_486:
63fcb9e9 574 case EM_960:
e9f53129 575 case EM_ARM:
2b0337b0 576 case EM_D10V:
252b5132 577 case EM_CYGNUS_D10V:
e9f53129 578 case EM_DLX:
252b5132 579 case EM_MIPS:
4fe85591 580 case EM_MIPS_RS3_LE:
e9f53129
AM
581 case EM_CYGNUS_M32R:
582 case EM_OPENRISC:
583 case EM_OR32:
1c0d3aa6 584 case EM_SCORE:
f6c1a2d5 585 case EM_XGATE:
9c19a809 586 return FALSE;
103f02d3 587
252b5132
RH
588 /* Targets that use RELA relocations. */
589 case EM_68K:
e9f53129 590 case EM_860:
a06ea964 591 case EM_AARCH64:
cfb8c092 592 case EM_ADAPTEVA_EPIPHANY:
e9f53129
AM
593 case EM_ALPHA:
594 case EM_ALTERA_NIOS2:
595 case EM_AVR:
596 case EM_AVR_OLD:
597 case EM_BLACKFIN:
60bca95a 598 case EM_CR16:
e9f53129
AM
599 case EM_CRIS:
600 case EM_CRX:
2b0337b0 601 case EM_D30V:
252b5132 602 case EM_CYGNUS_D30V:
2b0337b0 603 case EM_FR30:
252b5132 604 case EM_CYGNUS_FR30:
5c70f934 605 case EM_CYGNUS_FRV:
e9f53129
AM
606 case EM_H8S:
607 case EM_H8_300:
608 case EM_H8_300H:
800eeca4 609 case EM_IA_64:
1e4cf259
NC
610 case EM_IP2K:
611 case EM_IP2K_OLD:
3b36097d 612 case EM_IQ2000:
84e94c90 613 case EM_LATTICEMICO32:
ff7eeb89 614 case EM_M32C_OLD:
49f58d10 615 case EM_M32C:
e9f53129
AM
616 case EM_M32R:
617 case EM_MCORE:
15ab5209 618 case EM_CYGNUS_MEP:
a3c62988 619 case EM_METAG:
e9f53129
AM
620 case EM_MMIX:
621 case EM_MN10200:
622 case EM_CYGNUS_MN10200:
623 case EM_MN10300:
624 case EM_CYGNUS_MN10300:
5506d11a 625 case EM_MOXIE:
e9f53129
AM
626 case EM_MSP430:
627 case EM_MSP430_OLD:
d031aafb 628 case EM_MT:
64fd6348 629 case EM_NIOS32:
e9f53129
AM
630 case EM_PPC64:
631 case EM_PPC:
99c513f6 632 case EM_RL78:
c7927a3c 633 case EM_RX:
e9f53129
AM
634 case EM_S390:
635 case EM_S390_OLD:
636 case EM_SH:
637 case EM_SPARC:
638 case EM_SPARC32PLUS:
639 case EM_SPARCV9:
640 case EM_SPU:
40b36596 641 case EM_TI_C6000:
aa137e4d
NC
642 case EM_TILEGX:
643 case EM_TILEPRO:
708e2187 644 case EM_V800:
e9f53129
AM
645 case EM_V850:
646 case EM_CYGNUS_V850:
647 case EM_VAX:
648 case EM_X86_64:
8a9036a4 649 case EM_L1OM:
7a9068fe 650 case EM_K1OM:
e9f53129
AM
651 case EM_XSTORMY16:
652 case EM_XTENSA:
653 case EM_XTENSA_OLD:
7ba29e2a
NC
654 case EM_MICROBLAZE:
655 case EM_MICROBLAZE_OLD:
9c19a809 656 return TRUE;
103f02d3 657
e9f53129
AM
658 case EM_68HC05:
659 case EM_68HC08:
660 case EM_68HC11:
661 case EM_68HC16:
662 case EM_FX66:
663 case EM_ME16:
d1133906 664 case EM_MMA:
d1133906
NC
665 case EM_NCPU:
666 case EM_NDR1:
e9f53129 667 case EM_PCP:
d1133906 668 case EM_ST100:
e9f53129 669 case EM_ST19:
d1133906 670 case EM_ST7:
e9f53129
AM
671 case EM_ST9PLUS:
672 case EM_STARCORE:
d1133906 673 case EM_SVX:
e9f53129 674 case EM_TINYJ:
9c19a809
NC
675 default:
676 warn (_("Don't know about relocations on this machine architecture\n"));
677 return FALSE;
678 }
679}
252b5132 680
9c19a809 681static int
2cf0635d 682slurp_rela_relocs (FILE * file,
d3ba0551
AM
683 unsigned long rel_offset,
684 unsigned long rel_size,
2cf0635d
NC
685 Elf_Internal_Rela ** relasp,
686 unsigned long * nrelasp)
9c19a809 687{
2cf0635d 688 Elf_Internal_Rela * relas;
4d6ed7c8
NC
689 unsigned long nrelas;
690 unsigned int i;
252b5132 691
4d6ed7c8
NC
692 if (is_32bit_elf)
693 {
2cf0635d 694 Elf32_External_Rela * erelas;
103f02d3 695
3f5e193b 696 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 697 rel_size, _("32-bit relocation data"));
a6e9f9df
AM
698 if (!erelas)
699 return 0;
252b5132 700
4d6ed7c8 701 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 702
3f5e193b
NC
703 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
704 sizeof (Elf_Internal_Rela));
103f02d3 705
4d6ed7c8
NC
706 if (relas == NULL)
707 {
c256ffe7 708 free (erelas);
591a748a 709 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC
710 return 0;
711 }
103f02d3 712
4d6ed7c8
NC
713 for (i = 0; i < nrelas; i++)
714 {
715 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
716 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 717 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 718 }
103f02d3 719
4d6ed7c8
NC
720 free (erelas);
721 }
722 else
723 {
2cf0635d 724 Elf64_External_Rela * erelas;
103f02d3 725
3f5e193b 726 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 727 rel_size, _("64-bit relocation data"));
a6e9f9df
AM
728 if (!erelas)
729 return 0;
4d6ed7c8
NC
730
731 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 732
3f5e193b
NC
733 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
734 sizeof (Elf_Internal_Rela));
103f02d3 735
4d6ed7c8
NC
736 if (relas == NULL)
737 {
c256ffe7 738 free (erelas);
591a748a 739 error (_("out of memory parsing relocs\n"));
4d6ed7c8 740 return 0;
9c19a809 741 }
4d6ed7c8
NC
742
743 for (i = 0; i < nrelas; i++)
9c19a809 744 {
66543521
AM
745 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
746 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 747 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ
748
749 /* The #ifdef BFD64 below is to prevent a compile time
750 warning. We know that if we do not have a 64 bit data
751 type that we will never execute this code anyway. */
752#ifdef BFD64
753 if (elf_header.e_machine == EM_MIPS
754 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
755 {
756 /* In little-endian objects, r_info isn't really a
757 64-bit little-endian value: it has a 32-bit
758 little-endian symbol index followed by four
759 individual byte fields. Reorder INFO
760 accordingly. */
91d6fa6a
NC
761 bfd_vma inf = relas[i].r_info;
762 inf = (((inf & 0xffffffff) << 32)
763 | ((inf >> 56) & 0xff)
764 | ((inf >> 40) & 0xff00)
765 | ((inf >> 24) & 0xff0000)
766 | ((inf >> 8) & 0xff000000));
767 relas[i].r_info = inf;
861fb55a
DJ
768 }
769#endif /* BFD64 */
4d6ed7c8 770 }
103f02d3 771
4d6ed7c8
NC
772 free (erelas);
773 }
774 *relasp = relas;
775 *nrelasp = nrelas;
776 return 1;
777}
103f02d3 778
4d6ed7c8 779static int
2cf0635d 780slurp_rel_relocs (FILE * file,
d3ba0551
AM
781 unsigned long rel_offset,
782 unsigned long rel_size,
2cf0635d
NC
783 Elf_Internal_Rela ** relsp,
784 unsigned long * nrelsp)
4d6ed7c8 785{
2cf0635d 786 Elf_Internal_Rela * rels;
4d6ed7c8
NC
787 unsigned long nrels;
788 unsigned int i;
103f02d3 789
4d6ed7c8
NC
790 if (is_32bit_elf)
791 {
2cf0635d 792 Elf32_External_Rel * erels;
103f02d3 793
3f5e193b 794 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 795 rel_size, _("32-bit relocation data"));
a6e9f9df
AM
796 if (!erels)
797 return 0;
103f02d3 798
4d6ed7c8 799 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 800
3f5e193b 801 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 802
4d6ed7c8
NC
803 if (rels == NULL)
804 {
c256ffe7 805 free (erels);
591a748a 806 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC
807 return 0;
808 }
809
810 for (i = 0; i < nrels; i++)
811 {
812 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
813 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 814 rels[i].r_addend = 0;
9ea033b2 815 }
4d6ed7c8
NC
816
817 free (erels);
9c19a809
NC
818 }
819 else
820 {
2cf0635d 821 Elf64_External_Rel * erels;
9ea033b2 822
3f5e193b 823 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 824 rel_size, _("64-bit relocation data"));
a6e9f9df
AM
825 if (!erels)
826 return 0;
103f02d3 827
4d6ed7c8 828 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 829
3f5e193b 830 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 831
4d6ed7c8 832 if (rels == NULL)
9c19a809 833 {
c256ffe7 834 free (erels);
591a748a 835 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC
836 return 0;
837 }
103f02d3 838
4d6ed7c8
NC
839 for (i = 0; i < nrels; i++)
840 {
66543521
AM
841 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
842 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 843 rels[i].r_addend = 0;
861fb55a
DJ
844
845 /* The #ifdef BFD64 below is to prevent a compile time
846 warning. We know that if we do not have a 64 bit data
847 type that we will never execute this code anyway. */
848#ifdef BFD64
849 if (elf_header.e_machine == EM_MIPS
850 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
851 {
852 /* In little-endian objects, r_info isn't really a
853 64-bit little-endian value: it has a 32-bit
854 little-endian symbol index followed by four
855 individual byte fields. Reorder INFO
856 accordingly. */
91d6fa6a
NC
857 bfd_vma inf = rels[i].r_info;
858 inf = (((inf & 0xffffffff) << 32)
859 | ((inf >> 56) & 0xff)
860 | ((inf >> 40) & 0xff00)
861 | ((inf >> 24) & 0xff0000)
862 | ((inf >> 8) & 0xff000000));
863 rels[i].r_info = inf;
861fb55a
DJ
864 }
865#endif /* BFD64 */
4d6ed7c8 866 }
103f02d3 867
4d6ed7c8
NC
868 free (erels);
869 }
870 *relsp = rels;
871 *nrelsp = nrels;
872 return 1;
873}
103f02d3 874
aca88567
NC
875/* Returns the reloc type extracted from the reloc info field. */
876
877static unsigned int
878get_reloc_type (bfd_vma reloc_info)
879{
880 if (is_32bit_elf)
881 return ELF32_R_TYPE (reloc_info);
882
883 switch (elf_header.e_machine)
884 {
885 case EM_MIPS:
886 /* Note: We assume that reloc_info has already been adjusted for us. */
887 return ELF64_MIPS_R_TYPE (reloc_info);
888
889 case EM_SPARCV9:
890 return ELF64_R_TYPE_ID (reloc_info);
891
892 default:
893 return ELF64_R_TYPE (reloc_info);
894 }
895}
896
897/* Return the symbol index extracted from the reloc info field. */
898
899static bfd_vma
900get_reloc_symindex (bfd_vma reloc_info)
901{
902 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
903}
904
13761a11
NC
905static inline bfd_boolean
906uses_msp430x_relocs (void)
907{
908 return
909 elf_header.e_machine == EM_MSP430 /* Paranoia. */
910 /* GCC uses osabi == ELFOSBI_STANDALONE. */
911 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
912 /* TI compiler uses ELFOSABI_NONE. */
913 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
914}
915
d3ba0551
AM
916/* Display the contents of the relocation data found at the specified
917 offset. */
ee42cf8c 918
41e92641 919static void
2cf0635d 920dump_relocations (FILE * file,
d3ba0551
AM
921 unsigned long rel_offset,
922 unsigned long rel_size,
2cf0635d 923 Elf_Internal_Sym * symtab,
d3ba0551 924 unsigned long nsyms,
2cf0635d 925 char * strtab,
d79b3d50 926 unsigned long strtablen,
d3ba0551 927 int is_rela)
4d6ed7c8 928{
b34976b6 929 unsigned int i;
2cf0635d 930 Elf_Internal_Rela * rels;
103f02d3 931
4d6ed7c8
NC
932 if (is_rela == UNKNOWN)
933 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 934
4d6ed7c8
NC
935 if (is_rela)
936 {
c8286bd1 937 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 938 return;
4d6ed7c8
NC
939 }
940 else
941 {
942 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 943 return;
252b5132
RH
944 }
945
410f7a12
L
946 if (is_32bit_elf)
947 {
948 if (is_rela)
2c71103e
NC
949 {
950 if (do_wide)
951 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
952 else
953 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
954 }
410f7a12 955 else
2c71103e
NC
956 {
957 if (do_wide)
958 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
959 else
960 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
961 }
410f7a12 962 }
252b5132 963 else
410f7a12
L
964 {
965 if (is_rela)
2c71103e
NC
966 {
967 if (do_wide)
8beeaeb7 968 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC
969 else
970 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
971 }
410f7a12 972 else
2c71103e
NC
973 {
974 if (do_wide)
8beeaeb7 975 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC
976 else
977 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
978 }
410f7a12 979 }
252b5132
RH
980
981 for (i = 0; i < rel_size; i++)
982 {
2cf0635d 983 const char * rtype;
b34976b6 984 bfd_vma offset;
91d6fa6a 985 bfd_vma inf;
b34976b6
AM
986 bfd_vma symtab_index;
987 bfd_vma type;
103f02d3 988
b34976b6 989 offset = rels[i].r_offset;
91d6fa6a 990 inf = rels[i].r_info;
103f02d3 991
91d6fa6a
NC
992 type = get_reloc_type (inf);
993 symtab_index = get_reloc_symindex (inf);
252b5132 994
410f7a12
L
995 if (is_32bit_elf)
996 {
39dbeff8
AM
997 printf ("%8.8lx %8.8lx ",
998 (unsigned long) offset & 0xffffffff,
91d6fa6a 999 (unsigned long) inf & 0xffffffff);
410f7a12
L
1000 }
1001 else
1002 {
39dbeff8
AM
1003#if BFD_HOST_64BIT_LONG
1004 printf (do_wide
1005 ? "%16.16lx %16.16lx "
1006 : "%12.12lx %12.12lx ",
91d6fa6a 1007 offset, inf);
39dbeff8 1008#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 1009#ifndef __MSVCRT__
39dbeff8
AM
1010 printf (do_wide
1011 ? "%16.16llx %16.16llx "
1012 : "%12.12llx %12.12llx ",
91d6fa6a 1013 offset, inf);
6e3d6dc1
NC
1014#else
1015 printf (do_wide
1016 ? "%16.16I64x %16.16I64x "
1017 : "%12.12I64x %12.12I64x ",
91d6fa6a 1018 offset, inf);
6e3d6dc1 1019#endif
39dbeff8 1020#else
2c71103e
NC
1021 printf (do_wide
1022 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1023 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L
1024 _bfd_int64_high (offset),
1025 _bfd_int64_low (offset),
91d6fa6a
NC
1026 _bfd_int64_high (inf),
1027 _bfd_int64_low (inf));
9ea033b2 1028#endif
410f7a12 1029 }
103f02d3 1030
252b5132
RH
1031 switch (elf_header.e_machine)
1032 {
1033 default:
1034 rtype = NULL;
1035 break;
1036
a06ea964
NC
1037 case EM_AARCH64:
1038 rtype = elf_aarch64_reloc_type (type);
1039 break;
1040
2b0337b0 1041 case EM_M32R:
252b5132 1042 case EM_CYGNUS_M32R:
9ea033b2 1043 rtype = elf_m32r_reloc_type (type);
252b5132
RH
1044 break;
1045
1046 case EM_386:
1047 case EM_486:
9ea033b2 1048 rtype = elf_i386_reloc_type (type);
252b5132
RH
1049 break;
1050
ba2685cc
AM
1051 case EM_68HC11:
1052 case EM_68HC12:
1053 rtype = elf_m68hc11_reloc_type (type);
1054 break;
75751cd9 1055
252b5132 1056 case EM_68K:
9ea033b2 1057 rtype = elf_m68k_reloc_type (type);
252b5132
RH
1058 break;
1059
63fcb9e9 1060 case EM_960:
9ea033b2 1061 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT
1062 break;
1063
adde6300 1064 case EM_AVR:
2b0337b0 1065 case EM_AVR_OLD:
adde6300
AM
1066 rtype = elf_avr_reloc_type (type);
1067 break;
1068
9ea033b2
NC
1069 case EM_OLD_SPARCV9:
1070 case EM_SPARC32PLUS:
1071 case EM_SPARCV9:
252b5132 1072 case EM_SPARC:
9ea033b2 1073 rtype = elf_sparc_reloc_type (type);
252b5132
RH
1074 break;
1075
e9f53129
AM
1076 case EM_SPU:
1077 rtype = elf_spu_reloc_type (type);
1078 break;
1079
708e2187
NC
1080 case EM_V800:
1081 rtype = v800_reloc_type (type);
1082 break;
2b0337b0 1083 case EM_V850:
252b5132 1084 case EM_CYGNUS_V850:
9ea033b2 1085 rtype = v850_reloc_type (type);
252b5132
RH
1086 break;
1087
2b0337b0 1088 case EM_D10V:
252b5132 1089 case EM_CYGNUS_D10V:
9ea033b2 1090 rtype = elf_d10v_reloc_type (type);
252b5132
RH
1091 break;
1092
2b0337b0 1093 case EM_D30V:
252b5132 1094 case EM_CYGNUS_D30V:
9ea033b2 1095 rtype = elf_d30v_reloc_type (type);
252b5132
RH
1096 break;
1097
d172d4ba
NC
1098 case EM_DLX:
1099 rtype = elf_dlx_reloc_type (type);
1100 break;
1101
252b5132 1102 case EM_SH:
9ea033b2 1103 rtype = elf_sh_reloc_type (type);
252b5132
RH
1104 break;
1105
2b0337b0 1106 case EM_MN10300:
252b5132 1107 case EM_CYGNUS_MN10300:
9ea033b2 1108 rtype = elf_mn10300_reloc_type (type);
252b5132
RH
1109 break;
1110
2b0337b0 1111 case EM_MN10200:
252b5132 1112 case EM_CYGNUS_MN10200:
9ea033b2 1113 rtype = elf_mn10200_reloc_type (type);
252b5132
RH
1114 break;
1115
2b0337b0 1116 case EM_FR30:
252b5132 1117 case EM_CYGNUS_FR30:
9ea033b2 1118 rtype = elf_fr30_reloc_type (type);
252b5132
RH
1119 break;
1120
ba2685cc
AM
1121 case EM_CYGNUS_FRV:
1122 rtype = elf_frv_reloc_type (type);
1123 break;
5c70f934 1124
252b5132 1125 case EM_MCORE:
9ea033b2 1126 rtype = elf_mcore_reloc_type (type);
252b5132
RH
1127 break;
1128
3c3bdf30
NC
1129 case EM_MMIX:
1130 rtype = elf_mmix_reloc_type (type);
1131 break;
1132
5506d11a
AM
1133 case EM_MOXIE:
1134 rtype = elf_moxie_reloc_type (type);
1135 break;
1136
2469cfa2 1137 case EM_MSP430:
13761a11
NC
1138 if (uses_msp430x_relocs ())
1139 {
1140 rtype = elf_msp430x_reloc_type (type);
1141 break;
1142 }
2469cfa2
NC
1143 case EM_MSP430_OLD:
1144 rtype = elf_msp430_reloc_type (type);
1145 break;
1146
252b5132 1147 case EM_PPC:
9ea033b2 1148 rtype = elf_ppc_reloc_type (type);
252b5132
RH
1149 break;
1150
c833c019
AM
1151 case EM_PPC64:
1152 rtype = elf_ppc64_reloc_type (type);
1153 break;
1154
252b5132 1155 case EM_MIPS:
4fe85591 1156 case EM_MIPS_RS3_LE:
9ea033b2 1157 rtype = elf_mips_reloc_type (type);
252b5132
RH
1158 break;
1159
1160 case EM_ALPHA:
9ea033b2 1161 rtype = elf_alpha_reloc_type (type);
252b5132
RH
1162 break;
1163
1164 case EM_ARM:
9ea033b2 1165 rtype = elf_arm_reloc_type (type);
252b5132
RH
1166 break;
1167
584da044 1168 case EM_ARC:
9ea033b2 1169 rtype = elf_arc_reloc_type (type);
252b5132
RH
1170 break;
1171
1172 case EM_PARISC:
69e617ca 1173 rtype = elf_hppa_reloc_type (type);
252b5132 1174 break;
7d466069 1175
b8720f9d
JL
1176 case EM_H8_300:
1177 case EM_H8_300H:
1178 case EM_H8S:
1179 rtype = elf_h8_reloc_type (type);
1180 break;
1181
3b16e843
NC
1182 case EM_OPENRISC:
1183 case EM_OR32:
1184 rtype = elf_or32_reloc_type (type);
1185 break;
1186
7d466069 1187 case EM_PJ:
2b0337b0 1188 case EM_PJ_OLD:
7d466069
ILT
1189 rtype = elf_pj_reloc_type (type);
1190 break;
800eeca4
JW
1191 case EM_IA_64:
1192 rtype = elf_ia64_reloc_type (type);
1193 break;
1b61cf92
HPN
1194
1195 case EM_CRIS:
1196 rtype = elf_cris_reloc_type (type);
1197 break;
535c37ff
JE
1198
1199 case EM_860:
1200 rtype = elf_i860_reloc_type (type);
1201 break;
bcedfee6
NC
1202
1203 case EM_X86_64:
8a9036a4 1204 case EM_L1OM:
7a9068fe 1205 case EM_K1OM:
bcedfee6
NC
1206 rtype = elf_x86_64_reloc_type (type);
1207 break;
a85d7ed0 1208
35b1837e
AM
1209 case EM_S370:
1210 rtype = i370_reloc_type (type);
1211 break;
1212
53c7db4b
KH
1213 case EM_S390_OLD:
1214 case EM_S390:
1215 rtype = elf_s390_reloc_type (type);
1216 break;
93fbbb04 1217
1c0d3aa6
NC
1218 case EM_SCORE:
1219 rtype = elf_score_reloc_type (type);
1220 break;
1221
93fbbb04
GK
1222 case EM_XSTORMY16:
1223 rtype = elf_xstormy16_reloc_type (type);
1224 break;
179d3252 1225
1fe1f39c
NC
1226 case EM_CRX:
1227 rtype = elf_crx_reloc_type (type);
1228 break;
1229
179d3252
JT
1230 case EM_VAX:
1231 rtype = elf_vax_reloc_type (type);
1232 break;
1e4cf259 1233
cfb8c092
NC
1234 case EM_ADAPTEVA_EPIPHANY:
1235 rtype = elf_epiphany_reloc_type (type);
1236 break;
1237
1e4cf259
NC
1238 case EM_IP2K:
1239 case EM_IP2K_OLD:
1240 rtype = elf_ip2k_reloc_type (type);
1241 break;
3b36097d
SC
1242
1243 case EM_IQ2000:
1244 rtype = elf_iq2000_reloc_type (type);
1245 break;
88da6820
NC
1246
1247 case EM_XTENSA_OLD:
1248 case EM_XTENSA:
1249 rtype = elf_xtensa_reloc_type (type);
1250 break;
a34e3ecb 1251
84e94c90
NC
1252 case EM_LATTICEMICO32:
1253 rtype = elf_lm32_reloc_type (type);
1254 break;
1255
ff7eeb89 1256 case EM_M32C_OLD:
49f58d10
JB
1257 case EM_M32C:
1258 rtype = elf_m32c_reloc_type (type);
1259 break;
1260
d031aafb
NS
1261 case EM_MT:
1262 rtype = elf_mt_reloc_type (type);
a34e3ecb 1263 break;
1d65ded4
CM
1264
1265 case EM_BLACKFIN:
1266 rtype = elf_bfin_reloc_type (type);
1267 break;
15ab5209
DB
1268
1269 case EM_CYGNUS_MEP:
1270 rtype = elf_mep_reloc_type (type);
1271 break;
60bca95a
NC
1272
1273 case EM_CR16:
1274 rtype = elf_cr16_reloc_type (type);
1275 break;
dd24e3da 1276
7ba29e2a
NC
1277 case EM_MICROBLAZE:
1278 case EM_MICROBLAZE_OLD:
1279 rtype = elf_microblaze_reloc_type (type);
1280 break;
c7927a3c 1281
99c513f6
DD
1282 case EM_RL78:
1283 rtype = elf_rl78_reloc_type (type);
1284 break;
1285
c7927a3c
NC
1286 case EM_RX:
1287 rtype = elf_rx_reloc_type (type);
1288 break;
c29aca4a 1289
a3c62988
NC
1290 case EM_METAG:
1291 rtype = elf_metag_reloc_type (type);
1292 break;
1293
c29aca4a
NC
1294 case EM_XC16X:
1295 case EM_C166:
1296 rtype = elf_xc16x_reloc_type (type);
1297 break;
40b36596
JM
1298
1299 case EM_TI_C6000:
1300 rtype = elf_tic6x_reloc_type (type);
1301 break;
aa137e4d
NC
1302
1303 case EM_TILEGX:
1304 rtype = elf_tilegx_reloc_type (type);
1305 break;
1306
1307 case EM_TILEPRO:
1308 rtype = elf_tilepro_reloc_type (type);
1309 break;
f6c1a2d5
NC
1310
1311 case EM_XGATE:
1312 rtype = elf_xgate_reloc_type (type);
1313 break;
36591ba1
SL
1314
1315 case EM_ALTERA_NIOS2:
1316 rtype = elf_nios2_reloc_type (type);
1317 break;
252b5132
RH
1318 }
1319
1320 if (rtype == NULL)
39dbeff8 1321 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1322 else
8beeaeb7 1323 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1324
7ace3541 1325 if (elf_header.e_machine == EM_ALPHA
157c2599 1326 && rtype != NULL
7ace3541
RH
1327 && streq (rtype, "R_ALPHA_LITUSE")
1328 && is_rela)
1329 {
1330 switch (rels[i].r_addend)
1331 {
1332 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1333 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1334 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1335 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1336 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1337 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1338 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1339 default: rtype = NULL;
1340 }
1341 if (rtype)
1342 printf (" (%s)", rtype);
1343 else
1344 {
1345 putchar (' ');
1346 printf (_("<unknown addend: %lx>"),
1347 (unsigned long) rels[i].r_addend);
1348 }
1349 }
1350 else if (symtab_index)
252b5132 1351 {
af3fc3bc 1352 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1353 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1354 else
19936277 1355 {
2cf0635d 1356 Elf_Internal_Sym * psym;
19936277 1357
af3fc3bc 1358 psym = symtab + symtab_index;
103f02d3 1359
af3fc3bc 1360 printf (" ");
171191ba 1361
d8045f23
NC
1362 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1363 {
1364 const char * name;
1365 unsigned int len;
1366 unsigned int width = is_32bit_elf ? 8 : 14;
1367
1368 /* Relocations against GNU_IFUNC symbols do not use the value
1369 of the symbol as the address to relocate against. Instead
1370 they invoke the function named by the symbol and use its
1371 result as the address for relocation.
1372
1373 To indicate this to the user, do not display the value of
1374 the symbol in the "Symbols's Value" field. Instead show
1375 its name followed by () as a hint that the symbol is
1376 invoked. */
1377
1378 if (strtab == NULL
1379 || psym->st_name == 0
1380 || psym->st_name >= strtablen)
1381 name = "??";
1382 else
1383 name = strtab + psym->st_name;
1384
1385 len = print_symbol (width, name);
1386 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1387 }
1388 else
1389 {
1390 print_vma (psym->st_value, LONG_HEX);
171191ba 1391
d8045f23
NC
1392 printf (is_32bit_elf ? " " : " ");
1393 }
103f02d3 1394
af3fc3bc 1395 if (psym->st_name == 0)
f1ef08cb 1396 {
2cf0635d 1397 const char * sec_name = "<null>";
f1ef08cb
AM
1398 char name_buf[40];
1399
1400 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1401 {
4fbb74a6
AM
1402 if (psym->st_shndx < elf_header.e_shnum)
1403 sec_name
1404 = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM
1405 else if (psym->st_shndx == SHN_ABS)
1406 sec_name = "ABS";
1407 else if (psym->st_shndx == SHN_COMMON)
1408 sec_name = "COMMON";
ac145307
BS
1409 else if ((elf_header.e_machine == EM_MIPS
1410 && psym->st_shndx == SHN_MIPS_SCOMMON)
1411 || (elf_header.e_machine == EM_TI_C6000
1412 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS
1413 sec_name = "SCOMMON";
1414 else if (elf_header.e_machine == EM_MIPS
1415 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1416 sec_name = "SUNDEF";
8a9036a4 1417 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L
1418 || elf_header.e_machine == EM_L1OM
1419 || elf_header.e_machine == EM_K1OM)
3b22753a
L
1420 && psym->st_shndx == SHN_X86_64_LCOMMON)
1421 sec_name = "LARGE_COMMON";
9ce701e2
L
1422 else if (elf_header.e_machine == EM_IA_64
1423 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1424 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1425 sec_name = "ANSI_COM";
28f997cf 1426 else if (is_ia64_vms ()
148b93f2
NC
1427 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1428 sec_name = "VMS_SYMVEC";
f1ef08cb
AM
1429 else
1430 {
1431 sprintf (name_buf, "<section 0x%x>",
1432 (unsigned int) psym->st_shndx);
1433 sec_name = name_buf;
1434 }
1435 }
1436 print_symbol (22, sec_name);
1437 }
af3fc3bc 1438 else if (strtab == NULL)
d79b3d50 1439 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1440 else if (psym->st_name >= strtablen)
d79b3d50 1441 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1442 else
2c71103e 1443 print_symbol (22, strtab + psym->st_name);
103f02d3 1444
af3fc3bc 1445 if (is_rela)
171191ba 1446 {
598aaa76 1447 bfd_signed_vma off = rels[i].r_addend;
171191ba 1448
91d6fa6a 1449 if (off < 0)
598aaa76 1450 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1451 else
598aaa76 1452 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1453 }
19936277 1454 }
252b5132 1455 }
1b228002 1456 else if (is_rela)
f7a99963 1457 {
e04d7088
L
1458 bfd_signed_vma off = rels[i].r_addend;
1459
1460 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1461 if (off < 0)
1462 printf ("-%" BFD_VMA_FMT "x", - off);
1463 else
1464 printf ("%" BFD_VMA_FMT "x", off);
f7a99963 1465 }
252b5132 1466
157c2599
NC
1467 if (elf_header.e_machine == EM_SPARCV9
1468 && rtype != NULL
1469 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1470 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1471
252b5132 1472 putchar ('\n');
2c71103e 1473
aca88567 1474#ifdef BFD64
53c7db4b 1475 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1476 {
91d6fa6a
NC
1477 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1478 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC
1479 const char * rtype2 = elf_mips_reloc_type (type2);
1480 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1481
2c71103e
NC
1482 printf (" Type2: ");
1483
1484 if (rtype2 == NULL)
39dbeff8
AM
1485 printf (_("unrecognized: %-7lx"),
1486 (unsigned long) type2 & 0xffffffff);
2c71103e
NC
1487 else
1488 printf ("%-17.17s", rtype2);
1489
18bd398b 1490 printf ("\n Type3: ");
2c71103e
NC
1491
1492 if (rtype3 == NULL)
39dbeff8
AM
1493 printf (_("unrecognized: %-7lx"),
1494 (unsigned long) type3 & 0xffffffff);
2c71103e
NC
1495 else
1496 printf ("%-17.17s", rtype3);
1497
53c7db4b 1498 putchar ('\n');
2c71103e 1499 }
aca88567 1500#endif /* BFD64 */
252b5132
RH
1501 }
1502
c8286bd1 1503 free (rels);
252b5132
RH
1504}
1505
1506static const char *
d3ba0551 1507get_mips_dynamic_type (unsigned long type)
252b5132
RH
1508{
1509 switch (type)
1510 {
1511 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1512 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1513 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1514 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1515 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1516 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1517 case DT_MIPS_MSYM: return "MIPS_MSYM";
1518 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1519 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1520 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1521 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1522 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1523 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1524 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1525 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1526 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1527 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1528 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1529 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1530 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1531 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1532 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1533 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1534 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1535 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1536 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1537 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1538 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1539 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1540 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1541 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1542 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1543 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1544 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1545 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1546 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1547 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1548 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1549 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1550 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1551 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1552 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1553 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ
1554 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1555 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH
1556 default:
1557 return NULL;
1558 }
1559}
1560
9a097730 1561static const char *
d3ba0551 1562get_sparc64_dynamic_type (unsigned long type)
9a097730
RH
1563{
1564 switch (type)
1565 {
1566 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1567 default:
1568 return NULL;
1569 }
103f02d3
UD
1570}
1571
7490d522
AM
1572static const char *
1573get_ppc_dynamic_type (unsigned long type)
1574{
1575 switch (type)
1576 {
a7f2871e
AM
1577 case DT_PPC_GOT: return "PPC_GOT";
1578 case DT_PPC_TLSOPT: return "PPC_TLSOPT";
7490d522
AM
1579 default:
1580 return NULL;
1581 }
1582}
1583
f1cb7e17 1584static const char *
d3ba0551 1585get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM
1586{
1587 switch (type)
1588 {
a7f2871e
AM
1589 case DT_PPC64_GLINK: return "PPC64_GLINK";
1590 case DT_PPC64_OPD: return "PPC64_OPD";
1591 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1592 case DT_PPC64_TLSOPT: return "PPC64_TLSOPT";
f1cb7e17
AM
1593 default:
1594 return NULL;
1595 }
1596}
1597
103f02d3 1598static const char *
d3ba0551 1599get_parisc_dynamic_type (unsigned long type)
103f02d3
UD
1600{
1601 switch (type)
1602 {
1603 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1604 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1605 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1606 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1607 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1608 case DT_HP_PREINIT: return "HP_PREINIT";
1609 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1610 case DT_HP_NEEDED: return "HP_NEEDED";
1611 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1612 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1613 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1614 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1615 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA
1616 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1617 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1618 case DT_HP_FILTERED: return "HP_FILTERED";
1619 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1620 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1621 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1622 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1623 case DT_PLT: return "PLT";
1624 case DT_PLT_SIZE: return "PLT_SIZE";
1625 case DT_DLT: return "DLT";
1626 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD
1627 default:
1628 return NULL;
1629 }
1630}
9a097730 1631
ecc51f48 1632static const char *
d3ba0551 1633get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC
1634{
1635 switch (type)
1636 {
148b93f2
NC
1637 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1638 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1639 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1640 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1641 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1642 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1643 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1644 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1645 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1646 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1647 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1648 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1649 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1650 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1651 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1652 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1653 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1654 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1655 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1656 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1657 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1658 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1659 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1660 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1661 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1662 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1663 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1664 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1665 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1666 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1667 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC
1668 default:
1669 return NULL;
1670 }
1671}
1672
fabcb361
RH
1673static const char *
1674get_alpha_dynamic_type (unsigned long type)
1675{
1676 switch (type)
1677 {
1678 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1679 default:
1680 return NULL;
1681 }
1682}
1683
1c0d3aa6
NC
1684static const char *
1685get_score_dynamic_type (unsigned long type)
1686{
1687 switch (type)
1688 {
1689 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1690 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1691 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1692 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1693 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1694 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1695 default:
1696 return NULL;
1697 }
1698}
1699
40b36596
JM
1700static const char *
1701get_tic6x_dynamic_type (unsigned long type)
1702{
1703 switch (type)
1704 {
1705 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1706 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1707 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1708 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1709 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1710 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1711 default:
1712 return NULL;
1713 }
1714}
1c0d3aa6 1715
36591ba1
SL
1716static const char *
1717get_nios2_dynamic_type (unsigned long type)
1718{
1719 switch (type)
1720 {
1721 case DT_NIOS2_GP: return "NIOS2_GP";
1722 default:
1723 return NULL;
1724 }
1725}
1726
252b5132 1727static const char *
d3ba0551 1728get_dynamic_type (unsigned long type)
252b5132 1729{
e9e44622 1730 static char buff[64];
252b5132
RH
1731
1732 switch (type)
1733 {
1734 case DT_NULL: return "NULL";
1735 case DT_NEEDED: return "NEEDED";
1736 case DT_PLTRELSZ: return "PLTRELSZ";
1737 case DT_PLTGOT: return "PLTGOT";
1738 case DT_HASH: return "HASH";
1739 case DT_STRTAB: return "STRTAB";
1740 case DT_SYMTAB: return "SYMTAB";
1741 case DT_RELA: return "RELA";
1742 case DT_RELASZ: return "RELASZ";
1743 case DT_RELAENT: return "RELAENT";
1744 case DT_STRSZ: return "STRSZ";
1745 case DT_SYMENT: return "SYMENT";
1746 case DT_INIT: return "INIT";
1747 case DT_FINI: return "FINI";
1748 case DT_SONAME: return "SONAME";
1749 case DT_RPATH: return "RPATH";
1750 case DT_SYMBOLIC: return "SYMBOLIC";
1751 case DT_REL: return "REL";
1752 case DT_RELSZ: return "RELSZ";
1753 case DT_RELENT: return "RELENT";
1754 case DT_PLTREL: return "PLTREL";
1755 case DT_DEBUG: return "DEBUG";
1756 case DT_TEXTREL: return "TEXTREL";
1757 case DT_JMPREL: return "JMPREL";
1758 case DT_BIND_NOW: return "BIND_NOW";
1759 case DT_INIT_ARRAY: return "INIT_ARRAY";
1760 case DT_FINI_ARRAY: return "FINI_ARRAY";
1761 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1762 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC
1763 case DT_RUNPATH: return "RUNPATH";
1764 case DT_FLAGS: return "FLAGS";
2d0e6f43 1765
d1133906
NC
1766 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1767 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1768
05107a46 1769 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH
1770 case DT_PLTPADSZ: return "PLTPADSZ";
1771 case DT_MOVEENT: return "MOVEENT";
1772 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1773 case DT_FEATURE: return "FEATURE";
252b5132
RH
1774 case DT_POSFLAG_1: return "POSFLAG_1";
1775 case DT_SYMINSZ: return "SYMINSZ";
1776 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1777
252b5132 1778 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L
1779 case DT_CONFIG: return "CONFIG";
1780 case DT_DEPAUDIT: return "DEPAUDIT";
1781 case DT_AUDIT: return "AUDIT";
1782 case DT_PLTPAD: return "PLTPAD";
1783 case DT_MOVETAB: return "MOVETAB";
252b5132 1784 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1785
252b5132 1786 case DT_VERSYM: return "VERSYM";
103f02d3 1787
67a4f2b7
AO
1788 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1789 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH
1790 case DT_RELACOUNT: return "RELACOUNT";
1791 case DT_RELCOUNT: return "RELCOUNT";
1792 case DT_FLAGS_1: return "FLAGS_1";
1793 case DT_VERDEF: return "VERDEF";
1794 case DT_VERDEFNUM: return "VERDEFNUM";
1795 case DT_VERNEED: return "VERNEED";
1796 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1797
019148e4 1798 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH
1799 case DT_USED: return "USED";
1800 case DT_FILTER: return "FILTER";
103f02d3 1801
047b2264
JJ
1802 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1803 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1804 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1805 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1806 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1807 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1808
252b5132
RH
1809 default:
1810 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1811 {
2cf0635d 1812 const char * result;
103f02d3 1813
252b5132
RH
1814 switch (elf_header.e_machine)
1815 {
1816 case EM_MIPS:
4fe85591 1817 case EM_MIPS_RS3_LE:
252b5132
RH
1818 result = get_mips_dynamic_type (type);
1819 break;
9a097730
RH
1820 case EM_SPARCV9:
1821 result = get_sparc64_dynamic_type (type);
1822 break;
7490d522
AM
1823 case EM_PPC:
1824 result = get_ppc_dynamic_type (type);
1825 break;
f1cb7e17
AM
1826 case EM_PPC64:
1827 result = get_ppc64_dynamic_type (type);
1828 break;
ecc51f48
NC
1829 case EM_IA_64:
1830 result = get_ia64_dynamic_type (type);
1831 break;
fabcb361
RH
1832 case EM_ALPHA:
1833 result = get_alpha_dynamic_type (type);
1834 break;
1c0d3aa6
NC
1835 case EM_SCORE:
1836 result = get_score_dynamic_type (type);
1837 break;
40b36596
JM
1838 case EM_TI_C6000:
1839 result = get_tic6x_dynamic_type (type);
1840 break;
36591ba1
SL
1841 case EM_ALTERA_NIOS2:
1842 result = get_nios2_dynamic_type (type);
1843 break;
252b5132
RH
1844 default:
1845 result = NULL;
1846 break;
1847 }
1848
1849 if (result != NULL)
1850 return result;
1851
e9e44622 1852 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 1853 }
eec8f817
DA
1854 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1855 || (elf_header.e_machine == EM_PARISC
1856 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 1857 {
2cf0635d 1858 const char * result;
103f02d3
UD
1859
1860 switch (elf_header.e_machine)
1861 {
1862 case EM_PARISC:
1863 result = get_parisc_dynamic_type (type);
1864 break;
148b93f2
NC
1865 case EM_IA_64:
1866 result = get_ia64_dynamic_type (type);
1867 break;
103f02d3
UD
1868 default:
1869 result = NULL;
1870 break;
1871 }
1872
1873 if (result != NULL)
1874 return result;
1875
e9e44622
JJ
1876 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1877 type);
103f02d3 1878 }
252b5132 1879 else
e9e44622 1880 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 1881
252b5132
RH
1882 return buff;
1883 }
1884}
1885
1886static char *
d3ba0551 1887get_file_type (unsigned e_type)
252b5132 1888{
b34976b6 1889 static char buff[32];
252b5132
RH
1890
1891 switch (e_type)
1892 {
1893 case ET_NONE: return _("NONE (None)");
1894 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM
1895 case ET_EXEC: return _("EXEC (Executable file)");
1896 case ET_DYN: return _("DYN (Shared object file)");
1897 case ET_CORE: return _("CORE (Core file)");
252b5132
RH
1898
1899 default:
1900 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 1901 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 1902 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 1903 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 1904 else
e9e44622 1905 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH
1906 return buff;
1907 }
1908}
1909
1910static char *
d3ba0551 1911get_machine_name (unsigned e_machine)
252b5132 1912{
b34976b6 1913 static char buff[64]; /* XXX */
252b5132
RH
1914
1915 switch (e_machine)
1916 {
c45021f2 1917 case EM_NONE: return _("None");
a06ea964 1918 case EM_AARCH64: return "AArch64";
c45021f2
NC
1919 case EM_M32: return "WE32100";
1920 case EM_SPARC: return "Sparc";
e9f53129 1921 case EM_SPU: return "SPU";
c45021f2
NC
1922 case EM_386: return "Intel 80386";
1923 case EM_68K: return "MC68000";
1924 case EM_88K: return "MC88000";
1925 case EM_486: return "Intel 80486";
1926 case EM_860: return "Intel 80860";
1927 case EM_MIPS: return "MIPS R3000";
1928 case EM_S370: return "IBM System/370";
7036c0e1 1929 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 1930 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 1931 case EM_PARISC: return "HPPA";
252b5132 1932 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 1933 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC
1934 case EM_960: return "Intel 90860";
1935 case EM_PPC: return "PowerPC";
285d1771 1936 case EM_PPC64: return "PowerPC64";
c45021f2
NC
1937 case EM_FR20: return "Fujitsu FR20";
1938 case EM_RH32: return "TRW RH32";
b34976b6 1939 case EM_MCORE: return "MCORE";
7036c0e1
AJ
1940 case EM_ARM: return "ARM";
1941 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 1942 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC
1943 case EM_SPARCV9: return "Sparc v9";
1944 case EM_TRICORE: return "Siemens Tricore";
584da044 1945 case EM_ARC: return "ARC";
c2dcd04e
NC
1946 case EM_H8_300: return "Renesas H8/300";
1947 case EM_H8_300H: return "Renesas H8/300H";
1948 case EM_H8S: return "Renesas H8S";
1949 case EM_H8_500: return "Renesas H8/500";
30800947 1950 case EM_IA_64: return "Intel IA-64";
252b5132
RH
1951 case EM_MIPS_X: return "Stanford MIPS-X";
1952 case EM_COLDFIRE: return "Motorola Coldfire";
c45021f2 1953 case EM_ALPHA: return "Alpha";
2b0337b0
AO
1954 case EM_CYGNUS_D10V:
1955 case EM_D10V: return "d10v";
1956 case EM_CYGNUS_D30V:
b34976b6 1957 case EM_D30V: return "d30v";
2b0337b0 1958 case EM_CYGNUS_M32R:
26597c86 1959 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 1960 case EM_CYGNUS_V850:
708e2187 1961 case EM_V800: return "Renesas V850 (using RH850 ABI)";
f6c1a2d5 1962 case EM_V850: return "Renesas V850";
2b0337b0
AO
1963 case EM_CYGNUS_MN10300:
1964 case EM_MN10300: return "mn10300";
1965 case EM_CYGNUS_MN10200:
1966 case EM_MN10200: return "mn10200";
5506d11a 1967 case EM_MOXIE: return "Moxie";
2b0337b0
AO
1968 case EM_CYGNUS_FR30:
1969 case EM_FR30: return "Fujitsu FR30";
b34976b6 1970 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 1971 case EM_PJ_OLD:
b34976b6 1972 case EM_PJ: return "picoJava";
7036c0e1
AJ
1973 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1974 case EM_PCP: return "Siemens PCP";
1975 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1976 case EM_NDR1: return "Denso NDR1 microprocesspr";
1977 case EM_STARCORE: return "Motorola Star*Core processor";
1978 case EM_ME16: return "Toyota ME16 processor";
1979 case EM_ST100: return "STMicroelectronics ST100 processor";
1980 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM
1981 case EM_PDSP: return "Sony DSP processor";
1982 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
1983 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ
1984 case EM_FX66: return "Siemens FX66 microcontroller";
1985 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1986 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1987 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
6927f982 1988 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ
1989 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1990 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1991 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1992 case EM_SVX: return "Silicon Graphics SVx";
1993 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1994 case EM_VAX: return "Digital VAX";
2b0337b0 1995 case EM_AVR_OLD:
b34976b6 1996 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 1997 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC
1998 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1999 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2000 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 2001 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 2002 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 2003 case EM_PRISM: return "Vitesse Prism";
bcedfee6 2004 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 2005 case EM_L1OM: return "Intel L1OM";
7a9068fe 2006 case EM_K1OM: return "Intel K1OM";
b7498e0e 2007 case EM_S390_OLD:
b34976b6 2008 case EM_S390: return "IBM S/390";
1c0d3aa6 2009 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 2010 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
3b16e843
NC
2011 case EM_OPENRISC:
2012 case EM_OR32: return "OpenRISC";
11636f9e 2013 case EM_ARC_A5: return "ARC International ARCompact processor";
1fe1f39c 2014 case EM_CRX: return "National Semiconductor CRX microprocessor";
cfb8c092 2015 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
d172d4ba 2016 case EM_DLX: return "OpenDLX";
1e4cf259 2017 case EM_IP2K_OLD:
b34976b6 2018 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 2019 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC
2020 case EM_XTENSA_OLD:
2021 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM
2022 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2023 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2024 case EM_NS32K: return "National Semiconductor 32000 series";
2025 case EM_TPC: return "Tenor Network TPC processor";
2026 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2027 case EM_MAX: return "MAX Processor";
2028 case EM_CR: return "National Semiconductor CompactRISC";
2029 case EM_F2MC16: return "Fujitsu F2MC16";
2030 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 2031 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 2032 case EM_M32C_OLD:
49f58d10 2033 case EM_M32C: return "Renesas M32c";
d031aafb 2034 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 2035 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM
2036 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2037 case EM_SEP: return "Sharp embedded microprocessor";
2038 case EM_ARCA: return "Arca RISC microprocessor";
2039 case EM_UNICORE: return "Unicore";
2040 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2041 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC
2042 case EM_NIOS32: return "Altera Nios";
2043 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 2044 case EM_C166:
d70c5fc7 2045 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM
2046 case EM_M16C: return "Renesas M16C series microprocessors";
2047 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2048 case EM_CE: return "Freescale Communication Engine RISC core";
2049 case EM_TSK3000: return "Altium TSK3000 core";
2050 case EM_RS08: return "Freescale RS08 embedded processor";
2051 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2052 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2053 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2054 case EM_SE_C17: return "Seiko Epson C17 family";
2055 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2056 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2057 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2058 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2059 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2060 case EM_R32C: return "Renesas R32C series microprocessors";
2061 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2062 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2063 case EM_8051: return "Intel 8051 and variants";
2064 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2065 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2066 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2067 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2068 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2069 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2070 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 2071 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 2072 case EM_CR16:
f6c1a2d5 2073 case EM_MICROBLAZE:
7ba29e2a 2074 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
99c513f6 2075 case EM_RL78: return "Renesas RL78";
c7927a3c 2076 case EM_RX: return "Renesas RX";
a3c62988 2077 case EM_METAG: return "Imagination Technologies Meta processor architecture";
11636f9e
JM
2078 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2079 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2080 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2081 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2082 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2083 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2084 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2085 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 2086 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 2087 case EM_CUDA: return "NVIDIA CUDA architecture";
f6c1a2d5 2088 case EM_XGATE: return "Motorola XGATE embedded processor";
252b5132 2089 default:
35d9dd2f 2090 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH
2091 return buff;
2092 }
2093}
2094
f3485b74 2095static void
d3ba0551 2096decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC
2097{
2098 unsigned eabi;
2099 int unknown = 0;
2100
2101 eabi = EF_ARM_EABI_VERSION (e_flags);
2102 e_flags &= ~ EF_ARM_EABIMASK;
2103
2104 /* Handle "generic" ARM flags. */
2105 if (e_flags & EF_ARM_RELEXEC)
2106 {
2107 strcat (buf, ", relocatable executable");
2108 e_flags &= ~ EF_ARM_RELEXEC;
2109 }
76da6bbe 2110
f3485b74
NC
2111 if (e_flags & EF_ARM_HASENTRY)
2112 {
2113 strcat (buf, ", has entry point");
2114 e_flags &= ~ EF_ARM_HASENTRY;
2115 }
76da6bbe 2116
f3485b74
NC
2117 /* Now handle EABI specific flags. */
2118 switch (eabi)
2119 {
2120 default:
2c71103e 2121 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC
2122 if (e_flags)
2123 unknown = 1;
2124 break;
2125
2126 case EF_ARM_EABI_VER1:
a5bcd848 2127 strcat (buf, ", Version1 EABI");
f3485b74
NC
2128 while (e_flags)
2129 {
2130 unsigned flag;
76da6bbe 2131
f3485b74
NC
2132 /* Process flags one bit at a time. */
2133 flag = e_flags & - e_flags;
2134 e_flags &= ~ flag;
76da6bbe 2135
f3485b74
NC
2136 switch (flag)
2137 {
a5bcd848 2138 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC
2139 strcat (buf, ", sorted symbol tables");
2140 break;
76da6bbe 2141
f3485b74
NC
2142 default:
2143 unknown = 1;
2144 break;
2145 }
2146 }
2147 break;
76da6bbe 2148
a5bcd848
PB
2149 case EF_ARM_EABI_VER2:
2150 strcat (buf, ", Version2 EABI");
2151 while (e_flags)
2152 {
2153 unsigned flag;
2154
2155 /* Process flags one bit at a time. */
2156 flag = e_flags & - e_flags;
2157 e_flags &= ~ flag;
2158
2159 switch (flag)
2160 {
2161 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2162 strcat (buf, ", sorted symbol tables");
2163 break;
2164
2165 case EF_ARM_DYNSYMSUSESEGIDX:
2166 strcat (buf, ", dynamic symbols use segment index");
2167 break;
2168
2169 case EF_ARM_MAPSYMSFIRST:
2170 strcat (buf, ", mapping symbols precede others");
2171 break;
2172
2173 default:
2174 unknown = 1;
2175 break;
2176 }
2177 }
2178 break;
2179
d507cf36
PB
2180 case EF_ARM_EABI_VER3:
2181 strcat (buf, ", Version3 EABI");
8cb51566
PB
2182 break;
2183
2184 case EF_ARM_EABI_VER4:
2185 strcat (buf, ", Version4 EABI");
3bfcb652
NC
2186 while (e_flags)
2187 {
2188 unsigned flag;
2189
2190 /* Process flags one bit at a time. */
2191 flag = e_flags & - e_flags;
2192 e_flags &= ~ flag;
2193
2194 switch (flag)
2195 {
2196 case EF_ARM_BE8:
2197 strcat (buf, ", BE8");
2198 break;
2199
2200 case EF_ARM_LE8:
2201 strcat (buf, ", LE8");
2202 break;
2203
2204 default:
2205 unknown = 1;
2206 break;
2207 }
2208 break;
2209 }
2210 break;
3a4a14e9
PB
2211
2212 case EF_ARM_EABI_VER5:
2213 strcat (buf, ", Version5 EABI");
d507cf36
PB
2214 while (e_flags)
2215 {
2216 unsigned flag;
2217
2218 /* Process flags one bit at a time. */
2219 flag = e_flags & - e_flags;
2220 e_flags &= ~ flag;
2221
2222 switch (flag)
2223 {
2224 case EF_ARM_BE8:
2225 strcat (buf, ", BE8");
2226 break;
2227
2228 case EF_ARM_LE8:
2229 strcat (buf, ", LE8");
2230 break;
2231
3bfcb652
NC
2232 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2233 strcat (buf, ", soft-float ABI");
2234 break;
2235
2236 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2237 strcat (buf, ", hard-float ABI");
2238 break;
2239
d507cf36
PB
2240 default:
2241 unknown = 1;
2242 break;
2243 }
2244 }
2245 break;
2246
f3485b74 2247 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2248 strcat (buf, ", GNU EABI");
f3485b74
NC
2249 while (e_flags)
2250 {
2251 unsigned flag;
76da6bbe 2252
f3485b74
NC
2253 /* Process flags one bit at a time. */
2254 flag = e_flags & - e_flags;
2255 e_flags &= ~ flag;
76da6bbe 2256
f3485b74
NC
2257 switch (flag)
2258 {
a5bcd848 2259 case EF_ARM_INTERWORK:
f3485b74
NC
2260 strcat (buf, ", interworking enabled");
2261 break;
76da6bbe 2262
a5bcd848 2263 case EF_ARM_APCS_26:
f3485b74
NC
2264 strcat (buf, ", uses APCS/26");
2265 break;
76da6bbe 2266
a5bcd848 2267 case EF_ARM_APCS_FLOAT:
f3485b74
NC
2268 strcat (buf, ", uses APCS/float");
2269 break;
76da6bbe 2270
a5bcd848 2271 case EF_ARM_PIC:
f3485b74
NC
2272 strcat (buf, ", position independent");
2273 break;
76da6bbe 2274
a5bcd848 2275 case EF_ARM_ALIGN8:
f3485b74
NC
2276 strcat (buf, ", 8 bit structure alignment");
2277 break;
76da6bbe 2278
a5bcd848 2279 case EF_ARM_NEW_ABI:
f3485b74
NC
2280 strcat (buf, ", uses new ABI");
2281 break;
76da6bbe 2282
a5bcd848 2283 case EF_ARM_OLD_ABI:
f3485b74
NC
2284 strcat (buf, ", uses old ABI");
2285 break;
76da6bbe 2286
a5bcd848 2287 case EF_ARM_SOFT_FLOAT:
f3485b74
NC
2288 strcat (buf, ", software FP");
2289 break;
76da6bbe 2290
90e01f86
ILT
2291 case EF_ARM_VFP_FLOAT:
2292 strcat (buf, ", VFP");
2293 break;
2294
fde78edd
NC
2295 case EF_ARM_MAVERICK_FLOAT:
2296 strcat (buf, ", Maverick FP");
2297 break;
2298
f3485b74
NC
2299 default:
2300 unknown = 1;
2301 break;
2302 }
2303 }
2304 }
f3485b74
NC
2305
2306 if (unknown)
2b692964 2307 strcat (buf,_(", <unknown>"));
f3485b74
NC
2308}
2309
252b5132 2310static char *
d3ba0551 2311get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2312{
b34976b6 2313 static char buf[1024];
252b5132
RH
2314
2315 buf[0] = '\0';
76da6bbe 2316
252b5132
RH
2317 if (e_flags)
2318 {
2319 switch (e_machine)
2320 {
2321 default:
2322 break;
2323
f3485b74
NC
2324 case EM_ARM:
2325 decode_ARM_machine_flags (e_flags, buf);
2326 break;
76da6bbe 2327
781303ce
MF
2328 case EM_BLACKFIN:
2329 if (e_flags & EF_BFIN_PIC)
2330 strcat (buf, ", PIC");
2331
2332 if (e_flags & EF_BFIN_FDPIC)
2333 strcat (buf, ", FDPIC");
2334
2335 if (e_flags & EF_BFIN_CODE_IN_L1)
2336 strcat (buf, ", code in L1");
2337
2338 if (e_flags & EF_BFIN_DATA_IN_L1)
2339 strcat (buf, ", data in L1");
2340
2341 break;
2342
ec2dfb42
AO
2343 case EM_CYGNUS_FRV:
2344 switch (e_flags & EF_FRV_CPU_MASK)
2345 {
2346 case EF_FRV_CPU_GENERIC:
2347 break;
2348
2349 default:
2350 strcat (buf, ", fr???");
2351 break;
57346661 2352
ec2dfb42
AO
2353 case EF_FRV_CPU_FR300:
2354 strcat (buf, ", fr300");
2355 break;
2356
2357 case EF_FRV_CPU_FR400:
2358 strcat (buf, ", fr400");
2359 break;
2360 case EF_FRV_CPU_FR405:
2361 strcat (buf, ", fr405");
2362 break;
2363
2364 case EF_FRV_CPU_FR450:
2365 strcat (buf, ", fr450");
2366 break;
2367
2368 case EF_FRV_CPU_FR500:
2369 strcat (buf, ", fr500");
2370 break;
2371 case EF_FRV_CPU_FR550:
2372 strcat (buf, ", fr550");
2373 break;
2374
2375 case EF_FRV_CPU_SIMPLE:
2376 strcat (buf, ", simple");
2377 break;
2378 case EF_FRV_CPU_TOMCAT:
2379 strcat (buf, ", tomcat");
2380 break;
2381 }
1c877e87 2382 break;
ec2dfb42 2383
53c7db4b 2384 case EM_68K:
425c6cb0 2385 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2386 strcat (buf, ", m68000");
425c6cb0 2387 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH
2388 strcat (buf, ", cpu32");
2389 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2390 strcat (buf, ", fido_a");
425c6cb0 2391 else
266abb8f 2392 {
2cf0635d
NC
2393 char const * isa = _("unknown");
2394 char const * mac = _("unknown mac");
2395 char const * additional = NULL;
0112cd26 2396
c694fd50 2397 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2398 {
c694fd50 2399 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS
2400 isa = "A";
2401 additional = ", nodiv";
2402 break;
c694fd50 2403 case EF_M68K_CF_ISA_A:
266abb8f
NS
2404 isa = "A";
2405 break;
c694fd50 2406 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS
2407 isa = "A+";
2408 break;
c694fd50 2409 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS
2410 isa = "B";
2411 additional = ", nousp";
2412 break;
c694fd50 2413 case EF_M68K_CF_ISA_B:
266abb8f
NS
2414 isa = "B";
2415 break;
f608cd77
NS
2416 case EF_M68K_CF_ISA_C:
2417 isa = "C";
2418 break;
2419 case EF_M68K_CF_ISA_C_NODIV:
2420 isa = "C";
2421 additional = ", nodiv";
2422 break;
266abb8f
NS
2423 }
2424 strcat (buf, ", cf, isa ");
2425 strcat (buf, isa);
0b2e31dc
NS
2426 if (additional)
2427 strcat (buf, additional);
c694fd50 2428 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2429 strcat (buf, ", float");
c694fd50 2430 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS
2431 {
2432 case 0:
2433 mac = NULL;
2434 break;
c694fd50 2435 case EF_M68K_CF_MAC:
266abb8f
NS
2436 mac = "mac";
2437 break;
c694fd50 2438 case EF_M68K_CF_EMAC:
266abb8f
NS
2439 mac = "emac";
2440 break;
f608cd77
NS
2441 case EF_M68K_CF_EMAC_B:
2442 mac = "emac_b";
2443 break;
266abb8f
NS
2444 }
2445 if (mac)
2446 {
2447 strcat (buf, ", ");
2448 strcat (buf, mac);
2449 }
266abb8f 2450 }
53c7db4b 2451 break;
33c63f9d 2452
252b5132
RH
2453 case EM_PPC:
2454 if (e_flags & EF_PPC_EMB)
2455 strcat (buf, ", emb");
2456
2457 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2458 strcat (buf, _(", relocatable"));
252b5132
RH
2459
2460 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 2461 strcat (buf, _(", relocatable-lib"));
252b5132
RH
2462 break;
2463
708e2187
NC
2464 case EM_V800:
2465 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2466 strcat (buf, ", RH850 ABI");
2467
2468 if (e_flags & EF_V800_850E3)
2469 strcat (buf, ", V3 architecture");
2470
2471 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2472 strcat (buf, ", FPU not used");
2473
2474 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2475 strcat (buf, ", regmode: COMMON");
2476
2477 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2478 strcat (buf, ", r4 not used");
2479
2480 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2481 strcat (buf, ", r30 not used");
2482
2483 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2484 strcat (buf, ", r5 not used");
2485
2486 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2487 strcat (buf, ", r2 not used");
2488
2489 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2490 {
2491 switch (e_flags & - e_flags)
2492 {
2493 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2494 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2495 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2496 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2497 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2498 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2499 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2500 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2501 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2502 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2503 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2504 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2505 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2506 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2507 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2508 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2509 default: break;
2510 }
2511 }
2512 break;
2513
2b0337b0 2514 case EM_V850:
252b5132
RH
2515 case EM_CYGNUS_V850:
2516 switch (e_flags & EF_V850_ARCH)
2517 {
78c8d46c
NC
2518 case E_V850E3V5_ARCH:
2519 strcat (buf, ", v850e3v5");
2520 break;
1cd986c5
NC
2521 case E_V850E2V3_ARCH:
2522 strcat (buf, ", v850e2v3");
2523 break;
2524 case E_V850E2_ARCH:
2525 strcat (buf, ", v850e2");
2526 break;
2527 case E_V850E1_ARCH:
2528 strcat (buf, ", v850e1");
8ad30312 2529 break;
252b5132
RH
2530 case E_V850E_ARCH:
2531 strcat (buf, ", v850e");
2532 break;
252b5132
RH
2533 case E_V850_ARCH:
2534 strcat (buf, ", v850");
2535 break;
2536 default:
2b692964 2537 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH
2538 break;
2539 }
2540 break;
2541
2b0337b0 2542 case EM_M32R:
252b5132
RH
2543 case EM_CYGNUS_M32R:
2544 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2545 strcat (buf, ", m32r");
252b5132
RH
2546 break;
2547
2548 case EM_MIPS:
4fe85591 2549 case EM_MIPS_RS3_LE:
252b5132
RH
2550 if (e_flags & EF_MIPS_NOREORDER)
2551 strcat (buf, ", noreorder");
2552
2553 if (e_flags & EF_MIPS_PIC)
2554 strcat (buf, ", pic");
2555
2556 if (e_flags & EF_MIPS_CPIC)
2557 strcat (buf, ", cpic");
2558
d1bdd336
TS
2559 if (e_flags & EF_MIPS_UCODE)
2560 strcat (buf, ", ugen_reserved");
2561
252b5132
RH
2562 if (e_flags & EF_MIPS_ABI2)
2563 strcat (buf, ", abi2");
2564
43521d43
TS
2565 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2566 strcat (buf, ", odk first");
2567
a5d22d2a
TS
2568 if (e_flags & EF_MIPS_32BITMODE)
2569 strcat (buf, ", 32bitmode");
2570
ba92f887
MR
2571 if (e_flags & EF_MIPS_NAN2008)
2572 strcat (buf, ", nan2008");
2573
fef1b0b3
SE
2574 if (e_flags & EF_MIPS_FP64)
2575 strcat (buf, ", fp64");
2576
156c2f8b
NC
2577 switch ((e_flags & EF_MIPS_MACH))
2578 {
2579 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2580 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2581 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 2582 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L
2583 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2584 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2585 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2586 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 2587 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 2588 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS
2589 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2590 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 2591 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 2592 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 2593 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
52b6b6b9 2594 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS
2595 case 0:
2596 /* We simply ignore the field in this case to avoid confusion:
2597 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2598 extension. */
2599 break;
2b692964 2600 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 2601 }
43521d43
TS
2602
2603 switch ((e_flags & EF_MIPS_ABI))
2604 {
2605 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2606 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2607 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2608 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2609 case 0:
2610 /* We simply ignore the field in this case to avoid confusion:
2611 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2612 This means it is likely to be an o32 file, but not for
2613 sure. */
2614 break;
2b692964 2615 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS
2616 }
2617
2618 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2619 strcat (buf, ", mdmx");
2620
2621 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2622 strcat (buf, ", mips16");
2623
df58fc94
RS
2624 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2625 strcat (buf, ", micromips");
2626
43521d43
TS
2627 switch ((e_flags & EF_MIPS_ARCH))
2628 {
2629 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2630 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2631 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2632 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2633 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2634 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 2635 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
43521d43 2636 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 2637 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2b692964 2638 default: strcat (buf, _(", unknown ISA")); break;
43521d43 2639 }
252b5132 2640 break;
351b4b40 2641
ccde1100
AO
2642 case EM_SH:
2643 switch ((e_flags & EF_SH_MACH_MASK))
2644 {
2645 case EF_SH1: strcat (buf, ", sh1"); break;
2646 case EF_SH2: strcat (buf, ", sh2"); break;
2647 case EF_SH3: strcat (buf, ", sh3"); break;
2648 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2649 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2650 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2651 case EF_SH3E: strcat (buf, ", sh3e"); break;
2652 case EF_SH4: strcat (buf, ", sh4"); break;
2653 case EF_SH5: strcat (buf, ", sh5"); break;
2654 case EF_SH2E: strcat (buf, ", sh2e"); break;
2655 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 2656 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO
2657 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2658 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 2659 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH
2660 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2661 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2662 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2663 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2664 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2665 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 2666 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO
2667 }
2668
cec6a5b8
MR
2669 if (e_flags & EF_SH_PIC)
2670 strcat (buf, ", pic");
2671
2672 if (e_flags & EF_SH_FDPIC)
2673 strcat (buf, ", fdpic");
ccde1100 2674 break;
57346661 2675
351b4b40
RH
2676 case EM_SPARCV9:
2677 if (e_flags & EF_SPARC_32PLUS)
2678 strcat (buf, ", v8+");
2679
2680 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH
2681 strcat (buf, ", ultrasparcI");
2682
2683 if (e_flags & EF_SPARC_SUN_US3)
2684 strcat (buf, ", ultrasparcIII");
351b4b40
RH
2685
2686 if (e_flags & EF_SPARC_HAL_R1)
2687 strcat (buf, ", halr1");
2688
2689 if (e_flags & EF_SPARC_LEDATA)
2690 strcat (buf, ", ledata");
2691
2692 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2693 strcat (buf, ", tso");
2694
2695 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2696 strcat (buf, ", pso");
2697
2698 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2699 strcat (buf, ", rmo");
2700 break;
7d466069 2701
103f02d3
UD
2702 case EM_PARISC:
2703 switch (e_flags & EF_PARISC_ARCH)
2704 {
2705 case EFA_PARISC_1_0:
2706 strcpy (buf, ", PA-RISC 1.0");
2707 break;
2708 case EFA_PARISC_1_1:
2709 strcpy (buf, ", PA-RISC 1.1");
2710 break;
2711 case EFA_PARISC_2_0:
2712 strcpy (buf, ", PA-RISC 2.0");
2713 break;
2714 default:
2715 break;
2716 }
2717 if (e_flags & EF_PARISC_TRAPNIL)
2718 strcat (buf, ", trapnil");
2719 if (e_flags & EF_PARISC_EXT)
2720 strcat (buf, ", ext");
2721 if (e_flags & EF_PARISC_LSB)
2722 strcat (buf, ", lsb");
2723 if (e_flags & EF_PARISC_WIDE)
2724 strcat (buf, ", wide");
2725 if (e_flags & EF_PARISC_NO_KABP)
2726 strcat (buf, ", no kabp");
2727 if (e_flags & EF_PARISC_LAZYSWAP)
2728 strcat (buf, ", lazyswap");
30800947 2729 break;
76da6bbe 2730
7d466069 2731 case EM_PJ:
2b0337b0 2732 case EM_PJ_OLD:
7d466069
ILT
2733 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2734 strcat (buf, ", new calling convention");
2735
2736 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2737 strcat (buf, ", gnu calling convention");
2738 break;
4d6ed7c8
NC
2739
2740 case EM_IA_64:
2741 if ((e_flags & EF_IA_64_ABI64))
2742 strcat (buf, ", 64-bit");
2743 else
2744 strcat (buf, ", 32-bit");
2745 if ((e_flags & EF_IA_64_REDUCEDFP))
2746 strcat (buf, ", reduced fp model");
2747 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2748 strcat (buf, ", no function descriptors, constant gp");
2749 else if ((e_flags & EF_IA_64_CONS_GP))
2750 strcat (buf, ", constant gp");
2751 if ((e_flags & EF_IA_64_ABSOLUTE))
2752 strcat (buf, ", absolute");
28f997cf
TG
2753 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2754 {
2755 if ((e_flags & EF_IA_64_VMS_LINKAGES))
2756 strcat (buf, ", vms_linkages");
2757 switch ((e_flags & EF_IA_64_VMS_COMCOD))
2758 {
2759 case EF_IA_64_VMS_COMCOD_SUCCESS:
2760 break;
2761 case EF_IA_64_VMS_COMCOD_WARNING:
2762 strcat (buf, ", warning");
2763 break;
2764 case EF_IA_64_VMS_COMCOD_ERROR:
2765 strcat (buf, ", error");
2766 break;
2767 case EF_IA_64_VMS_COMCOD_ABORT:
2768 strcat (buf, ", abort");
2769 break;
2770 default:
2771 abort ();
2772 }
2773 }
4d6ed7c8 2774 break;
179d3252
JT
2775
2776 case EM_VAX:
2777 if ((e_flags & EF_VAX_NONPIC))
2778 strcat (buf, ", non-PIC");
2779 if ((e_flags & EF_VAX_DFLOAT))
2780 strcat (buf, ", D-Float");
2781 if ((e_flags & EF_VAX_GFLOAT))
2782 strcat (buf, ", G-Float");
2783 break;
c7927a3c 2784
4046d87a
NC
2785 case EM_RL78:
2786 if (e_flags & E_FLAG_RL78_G10)
2787 strcat (buf, ", G10");
2788 break;
2789
c7927a3c
NC
2790 case EM_RX:
2791 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2792 strcat (buf, ", 64-bit doubles");
2793 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 2794 strcat (buf, ", dsp");
d4cb0ea0
NC
2795 if (e_flags & E_FLAG_RX_PID)
2796 strcat (buf, ", pid");
708e2187
NC
2797 if (e_flags & E_FLAG_RX_ABI)
2798 strcat (buf, ", RX ABI");
d4cb0ea0 2799 break;
55786da2
AK
2800
2801 case EM_S390:
2802 if (e_flags & EF_S390_HIGH_GPRS)
2803 strcat (buf, ", highgprs");
d4cb0ea0 2804 break;
40b36596
JM
2805
2806 case EM_TI_C6000:
2807 if ((e_flags & EF_C6000_REL))
2808 strcat (buf, ", relocatable module");
d4cb0ea0 2809 break;
13761a11
NC
2810
2811 case EM_MSP430:
2812 strcat (buf, _(": architecture variant: "));
2813 switch (e_flags & EF_MSP430_MACH)
2814 {
2815 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
2816 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
2817 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
2818 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
2819 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
2820 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
2821 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
2822 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
2823 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
2824 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
2825 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
2826 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
2827 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
2828 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
2829 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
2830 default:
2831 strcat (buf, _(": unknown")); break;
2832 }
2833
2834 if (e_flags & ~ EF_MSP430_MACH)
2835 strcat (buf, _(": unknown extra flag bits also present"));
252b5132
RH
2836 }
2837 }
2838
2839 return buf;
2840}
2841
252b5132 2842static const char *
d3ba0551
AM
2843get_osabi_name (unsigned int osabi)
2844{
2845 static char buff[32];
2846
2847 switch (osabi)
2848 {
2849 case ELFOSABI_NONE: return "UNIX - System V";
2850 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2851 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 2852 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM
2853 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2854 case ELFOSABI_AIX: return "UNIX - AIX";
2855 case ELFOSABI_IRIX: return "UNIX - IRIX";
2856 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2857 case ELFOSABI_TRU64: return "UNIX - TRU64";
2858 case ELFOSABI_MODESTO: return "Novell - Modesto";
2859 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2860 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2861 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 2862 case ELFOSABI_AROS: return "AROS";
11636f9e 2863 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 2864 default:
40b36596
JM
2865 if (osabi >= 64)
2866 switch (elf_header.e_machine)
2867 {
2868 case EM_ARM:
2869 switch (osabi)
2870 {
2871 case ELFOSABI_ARM: return "ARM";
2872 default:
2873 break;
2874 }
2875 break;
2876
2877 case EM_MSP430:
2878 case EM_MSP430_OLD:
2879 switch (osabi)
2880 {
2881 case ELFOSABI_STANDALONE: return _("Standalone App");
2882 default:
2883 break;
2884 }
2885 break;
2886
2887 case EM_TI_C6000:
2888 switch (osabi)
2889 {
2890 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
2891 case ELFOSABI_C6000_LINUX: return "Linux C6000";
2892 default:
2893 break;
2894 }
2895 break;
2896
2897 default:
2898 break;
2899 }
e9e44622 2900 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM
2901 return buff;
2902 }
2903}
2904
a06ea964
NC
2905static const char *
2906get_aarch64_segment_type (unsigned long type)
2907{
2908 switch (type)
2909 {
2910 case PT_AARCH64_ARCHEXT:
2911 return "AARCH64_ARCHEXT";
2912 default:
2913 break;
2914 }
2915
2916 return NULL;
2917}
2918
b294bdf8
MM
2919static const char *
2920get_arm_segment_type (unsigned long type)
2921{
2922 switch (type)
2923 {
2924 case PT_ARM_EXIDX:
2925 return "EXIDX";
2926 default:
2927 break;
2928 }
2929
2930 return NULL;
2931}
2932
d3ba0551
AM
2933static const char *
2934get_mips_segment_type (unsigned long type)
252b5132
RH
2935{
2936 switch (type)
2937 {
2938 case PT_MIPS_REGINFO:
2939 return "REGINFO";
2940 case PT_MIPS_RTPROC:
2941 return "RTPROC";
2942 case PT_MIPS_OPTIONS:
2943 return "OPTIONS";
2944 default:
2945 break;
2946 }
2947
2948 return NULL;
2949}
2950
103f02d3 2951static const char *
d3ba0551 2952get_parisc_segment_type (unsigned long type)
103f02d3
UD
2953{
2954 switch (type)
2955 {
2956 case PT_HP_TLS: return "HP_TLS";
2957 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2958 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2959 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2960 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2961 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2962 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2963 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2964 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2965 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2966 case PT_HP_PARALLEL: return "HP_PARALLEL";
2967 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA
2968 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
2969 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
2970 case PT_HP_STACK: return "HP_STACK";
2971 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD
2972 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2973 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 2974 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD
2975 default:
2976 break;
2977 }
2978
2979 return NULL;
2980}
2981
4d6ed7c8 2982static const char *
d3ba0551 2983get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC
2984{
2985 switch (type)
2986 {
2987 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2988 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM
2989 case PT_HP_TLS: return "HP_TLS";
2990 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2991 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2992 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC
2993 default:
2994 break;
2995 }
2996
2997 return NULL;
2998}
2999
40b36596
JM
3000static const char *
3001get_tic6x_segment_type (unsigned long type)
3002{
3003 switch (type)
3004 {
3005 case PT_C6000_PHATTR: return "C6000_PHATTR";
3006 default:
3007 break;
3008 }
3009
3010 return NULL;
3011}
3012
252b5132 3013static const char *
d3ba0551 3014get_segment_type (unsigned long p_type)
252b5132 3015{
b34976b6 3016 static char buff[32];
252b5132
RH
3017
3018 switch (p_type)
3019 {
b34976b6
AM
3020 case PT_NULL: return "NULL";
3021 case PT_LOAD: return "LOAD";
252b5132 3022 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM
3023 case PT_INTERP: return "INTERP";
3024 case PT_NOTE: return "NOTE";
3025 case PT_SHLIB: return "SHLIB";
3026 case PT_PHDR: return "PHDR";
13ae64f3 3027 case PT_TLS: return "TLS";
252b5132 3028
65765700
JJ
3029 case PT_GNU_EH_FRAME:
3030 return "GNU_EH_FRAME";
2b05f1b7 3031 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 3032 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 3033
252b5132
RH
3034 default:
3035 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3036 {
2cf0635d 3037 const char * result;
103f02d3 3038
252b5132
RH
3039 switch (elf_header.e_machine)
3040 {
a06ea964
NC
3041 case EM_AARCH64:
3042 result = get_aarch64_segment_type (p_type);
3043 break;
b294bdf8
MM
3044 case EM_ARM:
3045 result = get_arm_segment_type (p_type);
3046 break;
252b5132 3047 case EM_MIPS:
4fe85591 3048 case EM_MIPS_RS3_LE:
252b5132
RH
3049 result = get_mips_segment_type (p_type);
3050 break;
103f02d3
UD
3051 case EM_PARISC:
3052 result = get_parisc_segment_type (p_type);
3053 break;
4d6ed7c8
NC
3054 case EM_IA_64:
3055 result = get_ia64_segment_type (p_type);
3056 break;
40b36596
JM
3057 case EM_TI_C6000:
3058 result = get_tic6x_segment_type (p_type);
3059 break;
252b5132
RH
3060 default:
3061 result = NULL;
3062 break;
3063 }
103f02d3 3064
252b5132
RH
3065 if (result != NULL)
3066 return result;
103f02d3 3067
252b5132
RH
3068 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3069 }
3070 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3071 {
2cf0635d 3072 const char * result;
103f02d3
UD
3073
3074 switch (elf_header.e_machine)
3075 {
3076 case EM_PARISC:
3077 result = get_parisc_segment_type (p_type);
3078 break;
00428cca
AM
3079 case EM_IA_64:
3080 result = get_ia64_segment_type (p_type);
3081 break;
103f02d3
UD
3082 default:
3083 result = NULL;
3084 break;
3085 }
3086
3087 if (result != NULL)
3088 return result;
3089
3090 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3091 }
252b5132 3092 else
e9e44622 3093 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH
3094
3095 return buff;
3096 }
3097}
3098
3099static const char *
d3ba0551 3100get_mips_section_type_name (unsigned int sh_type)
252b5132
RH
3101{
3102 switch (sh_type)
3103 {
b34976b6
AM
3104 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3105 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3106 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3107 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3108 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3109 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3110 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3111 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3112 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3113 case SHT_MIPS_RELD: return "MIPS_RELD";
3114 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3115 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3116 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3117 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3118 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3119 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3120 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3121 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3122 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3123 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3124 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3125 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3126 case SHT_MIPS_LINE: return "MIPS_LINE";
3127 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3128 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3129 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3130 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3131 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3132 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3133 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3134 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3135 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3136 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3137 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3138 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3139 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3140 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3141 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132
RH
3142 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3143 default:
3144 break;
3145 }
3146 return NULL;
3147}
3148
103f02d3 3149static const char *
d3ba0551 3150get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD
3151{
3152 switch (sh_type)
3153 {
3154 case SHT_PARISC_EXT: return "PARISC_EXT";
3155 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3156 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA
3157 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3158 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3159 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3160 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD
3161 default:
3162 break;
3163 }
3164 return NULL;
3165}
3166
4d6ed7c8 3167static const char *
d3ba0551 3168get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3169{
18bd398b 3170 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC
3171 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3172 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3173
4d6ed7c8
NC
3174 switch (sh_type)
3175 {
148b93f2
NC
3176 case SHT_IA_64_EXT: return "IA_64_EXT";
3177 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3178 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3179 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3180 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3181 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3182 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3183 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3184 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3185 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC
3186 default:
3187 break;
3188 }
3189 return NULL;
3190}
3191
d2b2c203
DJ
3192static const char *
3193get_x86_64_section_type_name (unsigned int sh_type)
3194{
3195 switch (sh_type)
3196 {
3197 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3198 default:
3199 break;
3200 }
3201 return NULL;
3202}
3203
a06ea964
NC
3204static const char *
3205get_aarch64_section_type_name (unsigned int sh_type)
3206{
3207 switch (sh_type)
3208 {
3209 case SHT_AARCH64_ATTRIBUTES:
3210 return "AARCH64_ATTRIBUTES";
3211 default:
3212 break;
3213 }
3214 return NULL;
3215}
3216
40a18ebd
NC
3217static const char *
3218get_arm_section_type_name (unsigned int sh_type)
3219{
3220 switch (sh_type)
3221 {
7f6fed87
NC
3222 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3223 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3224 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3225 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3226 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC
3227 default:
3228 break;
3229 }
3230 return NULL;
3231}
3232
40b36596
JM
3233static const char *
3234get_tic6x_section_type_name (unsigned int sh_type)
3235{
3236 switch (sh_type)
3237 {
3238 case SHT_C6000_UNWIND:
3239 return "C6000_UNWIND";
3240 case SHT_C6000_PREEMPTMAP:
3241 return "C6000_PREEMPTMAP";
3242 case SHT_C6000_ATTRIBUTES:
3243 return "C6000_ATTRIBUTES";
3244 case SHT_TI_ICODE:
3245 return "TI_ICODE";
3246 case SHT_TI_XREF:
3247 return "TI_XREF";
3248 case SHT_TI_HANDLER:
3249 return "TI_HANDLER";
3250 case SHT_TI_INITINFO:
3251 return "TI_INITINFO";
3252 case SHT_TI_PHATTRS:
3253 return "TI_PHATTRS";
3254 default:
3255 break;
3256 }
3257 return NULL;
3258}
3259
13761a11
NC
3260static const char *
3261get_msp430x_section_type_name (unsigned int sh_type)
3262{
3263 switch (sh_type)
3264 {
3265 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3266 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3267 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3268 default: return NULL;
3269 }
3270}
3271
252b5132 3272static const char *
d3ba0551 3273get_section_type_name (unsigned int sh_type)
252b5132 3274{
b34976b6 3275 static char buff[32];
252b5132
RH
3276
3277 switch (sh_type)
3278 {
3279 case SHT_NULL: return "NULL";
3280 case SHT_PROGBITS: return "PROGBITS";
3281 case SHT_SYMTAB: return "SYMTAB";
3282 case SHT_STRTAB: return "STRTAB";
3283 case SHT_RELA: return "RELA";
3284 case SHT_HASH: return "HASH";
3285 case SHT_DYNAMIC: return "DYNAMIC";
3286 case SHT_NOTE: return "NOTE";
3287 case SHT_NOBITS: return "NOBITS";
3288 case SHT_REL: return "REL";
3289 case SHT_SHLIB: return "SHLIB";
3290 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC
3291 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3292 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3293 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3294 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC
3295 case SHT_GROUP: return "GROUP";
3296 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH
3297 case SHT_GNU_verdef: return "VERDEF";
3298 case SHT_GNU_verneed: return "VERNEED";
3299 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM
3300 case 0x6ffffff0: return "VERSYM";
3301 case 0x6ffffffc: return "VERDEF";
252b5132
RH
3302 case 0x7ffffffd: return "AUXILIARY";
3303 case 0x7fffffff: return "FILTER";
047b2264 3304 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH
3305
3306 default:
3307 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3308 {
2cf0635d 3309 const char * result;
252b5132
RH
3310
3311 switch (elf_header.e_machine)
3312 {
3313 case EM_MIPS:
4fe85591 3314 case EM_MIPS_RS3_LE:
252b5132
RH
3315 result = get_mips_section_type_name (sh_type);
3316 break;
103f02d3
UD
3317 case EM_PARISC:
3318 result = get_parisc_section_type_name (sh_type);
3319 break;
4d6ed7c8
NC
3320 case EM_IA_64:
3321 result = get_ia64_section_type_name (sh_type);
3322 break;
d2b2c203 3323 case EM_X86_64:
8a9036a4 3324 case EM_L1OM:
7a9068fe 3325 case EM_K1OM:
d2b2c203
DJ
3326 result = get_x86_64_section_type_name (sh_type);
3327 break;
a06ea964
NC
3328 case EM_AARCH64:
3329 result = get_aarch64_section_type_name (sh_type);
3330 break;
40a18ebd
NC
3331 case EM_ARM:
3332 result = get_arm_section_type_name (sh_type);
3333 break;
40b36596
JM
3334 case EM_TI_C6000:
3335 result = get_tic6x_section_type_name (sh_type);
3336 break;
13761a11
NC
3337 case EM_MSP430:
3338 result = get_msp430x_section_type_name (sh_type);
3339 break;
252b5132
RH
3340 default:
3341 result = NULL;
3342 break;
3343 }
3344
3345 if (result != NULL)
3346 return result;
3347
c91d0dfb 3348 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH
3349 }
3350 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3351 {
2cf0635d 3352 const char * result;
148b93f2
NC
3353
3354 switch (elf_header.e_machine)
3355 {
3356 case EM_IA_64:
3357 result = get_ia64_section_type_name (sh_type);
3358 break;
3359 default:
3360 result = NULL;
3361 break;
3362 }
3363
3364 if (result != NULL)
3365 return result;
3366
3367 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3368 }
252b5132 3369 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
c91d0dfb 3370 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
252b5132 3371 else
a7dbfd1c
NC
3372 /* This message is probably going to be displayed in a 15
3373 character wide field, so put the hex value first. */
3374 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3375
252b5132
RH
3376 return buff;
3377 }
3378}
3379
2979dc34 3380#define OPTION_DEBUG_DUMP 512
2c610e4b 3381#define OPTION_DYN_SYMS 513
fd2f0033
TT
3382#define OPTION_DWARF_DEPTH 514
3383#define OPTION_DWARF_START 515
4723351a 3384#define OPTION_DWARF_CHECK 516
2979dc34 3385
85b1c36d 3386static struct option options[] =
252b5132 3387{
b34976b6 3388 {"all", no_argument, 0, 'a'},
252b5132
RH
3389 {"file-header", no_argument, 0, 'h'},
3390 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM
3391 {"headers", no_argument, 0, 'e'},
3392 {"histogram", no_argument, 0, 'I'},
3393 {"segments", no_argument, 0, 'l'},
3394 {"sections", no_argument, 0, 'S'},
252b5132 3395 {"section-headers", no_argument, 0, 'S'},
f5842774 3396 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3397 {"section-details", no_argument, 0, 't'},
595cf52e 3398 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM
3399 {"symbols", no_argument, 0, 's'},
3400 {"syms", no_argument, 0, 's'},
2c610e4b 3401 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM
3402 {"relocs", no_argument, 0, 'r'},
3403 {"notes", no_argument, 0, 'n'},
3404 {"dynamic", no_argument, 0, 'd'},
a952a375 3405 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH
3406 {"version-info", no_argument, 0, 'V'},
3407 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3408 {"unwind", no_argument, 0, 'u'},
4145f1d5 3409 {"archive-index", no_argument, 0, 'c'},
b34976b6 3410 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3411 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3412 {"string-dump", required_argument, 0, 'p'},
252b5132
RH
3413#ifdef SUPPORT_DISASSEMBLY
3414 {"instruction-dump", required_argument, 0, 'i'},
3415#endif
cf13d699 3416 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3417
fd2f0033
TT
3418 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3419 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 3420 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 3421
b34976b6
AM
3422 {"version", no_argument, 0, 'v'},
3423 {"wide", no_argument, 0, 'W'},
3424 {"help", no_argument, 0, 'H'},
3425 {0, no_argument, 0, 0}
252b5132
RH
3426};
3427
3428static void
2cf0635d 3429usage (FILE * stream)
252b5132 3430{
92f01d61
JM
3431 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3432 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3433 fprintf (stream, _(" Options are:\n\
8b53311e
NC
3434 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3435 -h --file-header Display the ELF file header\n\
3436 -l --program-headers Display the program headers\n\
3437 --segments An alias for --program-headers\n\
3438 -S --section-headers Display the sections' header\n\
3439 --sections An alias for --section-headers\n\
f5842774 3440 -g --section-groups Display the section groups\n\
5477e8a0 3441 -t --section-details Display the section details\n\
8b53311e
NC
3442 -e --headers Equivalent to: -h -l -S\n\
3443 -s --syms Display the symbol table\n\
3f08eb35 3444 --symbols An alias for --syms\n\
2c610e4b 3445 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC
3446 -n --notes Display the core notes (if present)\n\
3447 -r --relocs Display the relocations (if present)\n\
3448 -u --unwind Display the unwind info (if present)\n\
b2d38a17 3449 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 3450 -V --version-info Display the version sections (if present)\n\
1b31d05e 3451 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 3452 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 3453 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC
3454 -x --hex-dump=<number|name>\n\
3455 Dump the contents of section <number|name> as bytes\n\
3456 -p --string-dump=<number|name>\n\
3457 Dump the contents of section <number|name> as strings\n\
cf13d699
NC
3458 -R --relocated-dump=<number|name>\n\
3459 Dump the contents of section <number|name> as relocated bytes\n\
f9f0e732 3460 -w[lLiaprmfFsoRt] or\n\
1ed06042 3461 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 3462 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC
3463 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3464 =addr,=cu_index]\n\
8b53311e 3465 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT
3466 fprintf (stream, _("\
3467 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3468 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3469 or deeper\n"));
252b5132 3470#ifdef SUPPORT_DISASSEMBLY
92f01d61 3471 fprintf (stream, _("\
09c11c86
NC
3472 -i --instruction-dump=<number|name>\n\
3473 Disassemble the contents of section <number|name>\n"));
252b5132 3474#endif
92f01d61 3475 fprintf (stream, _("\
8b53311e
NC
3476 -I --histogram Display histogram of bucket list lengths\n\
3477 -W --wide Allow output width to exceed 80 characters\n\
07012eee 3478 @<file> Read options from <file>\n\
8b53311e
NC
3479 -H --help Display this information\n\
3480 -v --version Display the version number of readelf\n"));
1118d252 3481
92f01d61
JM
3482 if (REPORT_BUGS_TO[0] && stream == stdout)
3483 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 3484
92f01d61 3485 exit (stream == stdout ? 0 : 1);
252b5132
RH
3486}
3487
18bd398b
NC
3488/* Record the fact that the user wants the contents of section number
3489 SECTION to be displayed using the method(s) encoded as flags bits
3490 in TYPE. Note, TYPE can be zero if we are creating the array for
3491 the first time. */
3492
252b5132 3493static void
09c11c86 3494request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH
3495{
3496 if (section >= num_dump_sects)
3497 {
2cf0635d 3498 dump_type * new_dump_sects;
252b5132 3499
3f5e193b
NC
3500 new_dump_sects = (dump_type *) calloc (section + 1,
3501 sizeof (* dump_sects));
252b5132
RH
3502
3503 if (new_dump_sects == NULL)
591a748a 3504 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH
3505 else
3506 {
3507 /* Copy current flag settings. */
09c11c86 3508 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH
3509
3510 free (dump_sects);
3511
3512 dump_sects = new_dump_sects;
3513 num_dump_sects = section + 1;
3514 }
3515 }
3516
3517 if (dump_sects)
b34976b6 3518 dump_sects[section] |= type;
252b5132
RH
3519
3520 return;
3521}
3522
aef1f6d0
DJ
3523/* Request a dump by section name. */
3524
3525static void
2cf0635d 3526request_dump_byname (const char * section, dump_type type)
aef1f6d0 3527{
2cf0635d 3528 struct dump_list_entry * new_request;
aef1f6d0 3529
3f5e193b
NC
3530 new_request = (struct dump_list_entry *)
3531 malloc (sizeof (struct dump_list_entry));
aef1f6d0 3532 if (!new_request)
591a748a 3533 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ
3534
3535 new_request->name = strdup (section);
3536 if (!new_request->name)
591a748a 3537 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ
3538
3539 new_request->type = type;
3540
3541 new_request->next = dump_sects_byname;
3542 dump_sects_byname = new_request;
3543}
3544
cf13d699
NC
3545static inline void
3546request_dump (dump_type type)
3547{
3548 int section;
3549 char * cp;
3550
3551 do_dump++;
3552 section = strtoul (optarg, & cp, 0);
3553
3554 if (! *cp && section >= 0)
3555 request_dump_bynumber (section, type);
3556 else
3557 request_dump_byname (optarg, type);
3558}
3559
3560
252b5132 3561static void
2cf0635d 3562parse_args (int argc, char ** argv)
252b5132
RH
3563{
3564 int c;
3565
3566 if (argc < 2)
92f01d61 3567 usage (stderr);
252b5132
RH
3568
3569 while ((c = getopt_long
cf13d699 3570 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
252b5132 3571 {
252b5132
RH
3572 switch (c)
3573 {
3574 case 0:
3575 /* Long options. */
3576 break;
3577 case 'H':
92f01d61 3578 usage (stdout);
252b5132
RH
3579 break;
3580
3581 case 'a':
b34976b6
AM
3582 do_syms++;
3583 do_reloc++;
3584 do_unwind++;
3585 do_dynamic++;
3586 do_header++;
3587 do_sections++;
f5842774 3588 do_section_groups++;
b34976b6
AM
3589 do_segments++;
3590 do_version++;
3591 do_histogram++;
3592 do_arch++;
3593 do_notes++;
252b5132 3594 break;
f5842774
L
3595 case 'g':
3596 do_section_groups++;
3597 break;
5477e8a0 3598 case 't':
595cf52e 3599 case 'N':
5477e8a0
L
3600 do_sections++;
3601 do_section_details++;
595cf52e 3602 break;
252b5132 3603 case 'e':
b34976b6
AM
3604 do_header++;
3605 do_sections++;
3606 do_segments++;
252b5132 3607 break;
a952a375 3608 case 'A':
b34976b6 3609 do_arch++;
a952a375 3610 break;
252b5132 3611 case 'D':
b34976b6 3612 do_using_dynamic++;
252b5132
RH
3613 break;
3614 case 'r':
b34976b6 3615 do_reloc++;
252b5132 3616 break;
4d6ed7c8 3617 case 'u':
b34976b6 3618 do_unwind++;
4d6ed7c8 3619 break;
252b5132 3620 case 'h':
b34976b6 3621 do_header++;
252b5132
RH
3622 break;
3623 case 'l':
b34976b6 3624 do_segments++;
252b5132
RH
3625 break;
3626 case 's':
b34976b6 3627 do_syms++;
252b5132
RH
3628 break;
3629 case 'S':
b34976b6 3630 do_sections++;
252b5132
RH
3631 break;
3632 case 'd':
b34976b6 3633 do_dynamic++;
252b5132 3634 break;
a952a375 3635 case 'I':
b34976b6 3636 do_histogram++;
a952a375 3637 break;
779fe533 3638 case 'n':
b34976b6 3639 do_notes++;
779fe533 3640 break;
4145f1d5
NC
3641 case 'c':
3642 do_archive_index++;
3643 break;
252b5132 3644 case 'x':
cf13d699 3645 request_dump (HEX_DUMP);
aef1f6d0 3646 break;
09c11c86 3647 case 'p':
cf13d699
NC
3648 request_dump (STRING_DUMP);
3649 break;
3650 case 'R':
3651 request_dump (RELOC_DUMP);
09c11c86 3652 break;
252b5132 3653 case 'w':
b34976b6 3654 do_dump++;
252b5132 3655 if (optarg == 0)
613ff48b
CC
3656 {
3657 do_debugging = 1;
3658 dwarf_select_sections_all ();
3659 }
252b5132
RH
3660 else
3661 {
3662 do_debugging = 0;
4cb93e3b 3663 dwarf_select_sections_by_letters (optarg);
252b5132
RH
3664 }
3665 break;
2979dc34 3666 case OPTION_DEBUG_DUMP:
b34976b6 3667 do_dump++;
2979dc34
JJ
3668 if (optarg == 0)
3669 do_debugging = 1;
3670 else
3671 {
2979dc34 3672 do_debugging = 0;
4cb93e3b 3673 dwarf_select_sections_by_names (optarg);
2979dc34
JJ
3674 }
3675 break;
fd2f0033
TT
3676 case OPTION_DWARF_DEPTH:
3677 {
3678 char *cp;
3679
3680 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3681 }
3682 break;
3683 case OPTION_DWARF_START:
3684 {
3685 char *cp;
3686
3687 dwarf_start_die = strtoul (optarg, & cp, 0);
3688 }
3689 break;
4723351a
CC
3690 case OPTION_DWARF_CHECK:
3691 dwarf_check = 1;
3692 break;
2c610e4b
L
3693 case OPTION_DYN_SYMS:
3694 do_dyn_syms++;
3695 break;
252b5132
RH
3696#ifdef SUPPORT_DISASSEMBLY
3697 case 'i':
cf13d699
NC
3698 request_dump (DISASS_DUMP);
3699 break;
252b5132
RH
3700#endif
3701 case 'v':
3702 print_version (program_name);
3703 break;
3704 case 'V':
b34976b6 3705 do_version++;
252b5132 3706 break;
d974e256 3707 case 'W':
b34976b6 3708 do_wide++;
d974e256 3709 break;
252b5132 3710 default:
252b5132
RH
3711 /* xgettext:c-format */
3712 error (_("Invalid option '-%c'\n"), c);
3713 /* Drop through. */
3714 case '?':
92f01d61 3715 usage (stderr);
252b5132
RH
3716 }
3717 }
3718
4d6ed7c8 3719 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 3720 && !do_segments && !do_header && !do_dump && !do_version
f5842774 3721 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L
3722 && !do_section_groups && !do_archive_index
3723 && !do_dyn_syms)
92f01d61 3724 usage (stderr);
252b5132
RH
3725 else if (argc < 3)
3726 {
3727 warn (_("Nothing to do.\n"));
92f01d61 3728 usage (stderr);
252b5132
RH
3729 }
3730}
3731
3732static const char *
d3ba0551 3733get_elf_class (unsigned int elf_class)
252b5132 3734{
b34976b6 3735 static char buff[32];
103f02d3 3736
252b5132
RH
3737 switch (elf_class)
3738 {
3739 case ELFCLASSNONE: return _("none");
e3c8793a
NC
3740 case ELFCLASS32: return "ELF32";
3741 case ELFCLASS64: return "ELF64";
ab5e7794 3742 default:
e9e44622 3743 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 3744 return buff;
252b5132
RH
3745 }
3746}
3747
3748static const char *
d3ba0551 3749get_data_encoding (unsigned int encoding)
252b5132 3750{
b34976b6 3751 static char buff[32];
103f02d3 3752
252b5132
RH
3753 switch (encoding)
3754 {
3755 case ELFDATANONE: return _("none");
33c63f9d
CM
3756 case ELFDATA2LSB: return _("2's complement, little endian");
3757 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 3758 default:
e9e44622 3759 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 3760 return buff;
252b5132
RH
3761 }
3762}
3763
252b5132 3764/* Decode the data held in 'elf_header'. */
ee42cf8c 3765
252b5132 3766static int
d3ba0551 3767process_file_header (void)
252b5132 3768{
b34976b6
AM
3769 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3770 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3771 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3772 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH
3773 {
3774 error
3775 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3776 return 0;
3777 }
3778
2dc4cec1
L
3779 init_dwarf_regnames (elf_header.e_machine);
3780
252b5132
RH
3781 if (do_header)
3782 {
3783 int i;
3784
3785 printf (_("ELF Header:\n"));
3786 printf (_(" Magic: "));
b34976b6
AM
3787 for (i = 0; i < EI_NIDENT; i++)
3788 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH
3789 printf ("\n");
3790 printf (_(" Class: %s\n"),
b34976b6 3791 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 3792 printf (_(" Data: %s\n"),
b34976b6 3793 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 3794 printf (_(" Version: %d %s\n"),
b34976b6
AM
3795 elf_header.e_ident[EI_VERSION],
3796 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 3797 ? "(current)"
b34976b6 3798 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 3799 ? _("<unknown: %lx>")
789be9f7 3800 : "")));
252b5132 3801 printf (_(" OS/ABI: %s\n"),
b34976b6 3802 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 3803 printf (_(" ABI Version: %d\n"),
b34976b6 3804 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH
3805 printf (_(" Type: %s\n"),
3806 get_file_type (elf_header.e_type));
3807 printf (_(" Machine: %s\n"),
3808 get_machine_name (elf_header.e_machine));
3809 printf (_(" Version: 0x%lx\n"),
3810 (unsigned long) elf_header.e_version);
76da6bbe 3811
f7a99963
NC
3812 printf (_(" Entry point address: "));
3813 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3814 printf (_("\n Start of program headers: "));
3815 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3816 printf (_(" (bytes into file)\n Start of section headers: "));
3817 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3818 printf (_(" (bytes into file)\n"));
76da6bbe 3819
252b5132
RH
3820 printf (_(" Flags: 0x%lx%s\n"),
3821 (unsigned long) elf_header.e_flags,
3822 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3823 printf (_(" Size of this header: %ld (bytes)\n"),
3824 (long) elf_header.e_ehsize);
3825 printf (_(" Size of program headers: %ld (bytes)\n"),
3826 (long) elf_header.e_phentsize);
2046a35d 3827 printf (_(" Number of program headers: %ld"),
252b5132 3828 (long) elf_header.e_phnum);
2046a35d
AM
3829 if (section_headers != NULL
3830 && elf_header.e_phnum == PN_XNUM
3831 && section_headers[0].sh_info != 0)
cc5914eb 3832 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 3833 putc ('\n', stdout);
252b5132
RH
3834 printf (_(" Size of section headers: %ld (bytes)\n"),
3835 (long) elf_header.e_shentsize);
560f3c1c 3836 printf (_(" Number of section headers: %ld"),
252b5132 3837 (long) elf_header.e_shnum);
4fbb74a6 3838 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM
3839 printf (" (%ld)", (long) section_headers[0].sh_size);
3840 putc ('\n', stdout);
3841 printf (_(" Section header string table index: %ld"),
252b5132 3842 (long) elf_header.e_shstrndx);
4fbb74a6
AM
3843 if (section_headers != NULL
3844 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 3845 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM
3846 else if (elf_header.e_shstrndx != SHN_UNDEF
3847 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 3848 printf (_(" <corrupt: out of range>"));
560f3c1c
AM
3849 putc ('\n', stdout);
3850 }
3851
3852 if (section_headers != NULL)
3853 {
2046a35d
AM
3854 if (elf_header.e_phnum == PN_XNUM
3855 && section_headers[0].sh_info != 0)
3856 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 3857 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 3858 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 3859 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 3860 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 3861 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 3862 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM
3863 free (section_headers);
3864 section_headers = NULL;
252b5132 3865 }
103f02d3 3866
9ea033b2
NC
3867 return 1;
3868}
3869
252b5132 3870
9ea033b2 3871static int
91d6fa6a 3872get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3873{
2cf0635d
NC
3874 Elf32_External_Phdr * phdrs;
3875 Elf32_External_Phdr * external;
3876 Elf_Internal_Phdr * internal;
b34976b6 3877 unsigned int i;
103f02d3 3878
3f5e193b
NC
3879 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3880 elf_header.e_phentsize,
3881 elf_header.e_phnum,
3882 _("program headers"));
a6e9f9df
AM
3883 if (!phdrs)
3884 return 0;
9ea033b2 3885
91d6fa6a 3886 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3887 i < elf_header.e_phnum;
b34976b6 3888 i++, internal++, external++)
252b5132 3889 {
9ea033b2
NC
3890 internal->p_type = BYTE_GET (external->p_type);
3891 internal->p_offset = BYTE_GET (external->p_offset);
3892 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3893 internal->p_paddr = BYTE_GET (external->p_paddr);
3894 internal->p_filesz = BYTE_GET (external->p_filesz);
3895 internal->p_memsz = BYTE_GET (external->p_memsz);
3896 internal->p_flags = BYTE_GET (external->p_flags);
3897 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH
3898 }
3899
9ea033b2
NC
3900 free (phdrs);
3901
252b5132
RH
3902 return 1;
3903}
3904
9ea033b2 3905static int
91d6fa6a 3906get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3907{
2cf0635d
NC
3908 Elf64_External_Phdr * phdrs;
3909 Elf64_External_Phdr * external;
3910 Elf_Internal_Phdr * internal;
b34976b6 3911 unsigned int i;
103f02d3 3912
3f5e193b
NC
3913 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3914 elf_header.e_phentsize,
3915 elf_header.e_phnum,
3916 _("program headers"));
a6e9f9df
AM
3917 if (!phdrs)
3918 return 0;
9ea033b2 3919
91d6fa6a 3920 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3921 i < elf_header.e_phnum;
b34976b6 3922 i++, internal++, external++)
9ea033b2
NC
3923 {
3924 internal->p_type = BYTE_GET (external->p_type);
3925 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM
3926 internal->p_offset = BYTE_GET (external->p_offset);
3927 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3928 internal->p_paddr = BYTE_GET (external->p_paddr);
3929 internal->p_filesz = BYTE_GET (external->p_filesz);
3930 internal->p_memsz = BYTE_GET (external->p_memsz);
3931 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC
3932 }
3933
3934 free (phdrs);
3935
3936 return 1;
3937}
252b5132 3938
d93f0186
NC
3939/* Returns 1 if the program headers were read into `program_headers'. */
3940
3941static int
2cf0635d 3942get_program_headers (FILE * file)
d93f0186 3943{
2cf0635d 3944 Elf_Internal_Phdr * phdrs;
d93f0186
NC
3945
3946 /* Check cache of prior read. */
3947 if (program_headers != NULL)
3948 return 1;
3949
3f5e193b
NC
3950 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3951 sizeof (Elf_Internal_Phdr));
d93f0186
NC
3952
3953 if (phdrs == NULL)
3954 {
3955 error (_("Out of memory\n"));
3956 return 0;
3957 }
3958
3959 if (is_32bit_elf
3960 ? get_32bit_program_headers (file, phdrs)
3961 : get_64bit_program_headers (file, phdrs))
3962 {
3963 program_headers = phdrs;
3964 return 1;
3965 }
3966
3967 free (phdrs);
3968 return 0;
3969}
3970
2f62977e
NC
3971/* Returns 1 if the program headers were loaded. */
3972
252b5132 3973static int
2cf0635d 3974process_program_headers (FILE * file)
252b5132 3975{
2cf0635d 3976 Elf_Internal_Phdr * segment;
b34976b6 3977 unsigned int i;
252b5132
RH
3978
3979 if (elf_header.e_phnum == 0)
3980 {
82f2dbf7
NC
3981 /* PR binutils/12467. */
3982 if (elf_header.e_phoff != 0)
3983 warn (_("possibly corrupt ELF header - it has a non-zero program"
3984 " header offset, but no program headers"));
3985 else if (do_segments)
252b5132 3986 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 3987 return 0;
252b5132
RH
3988 }
3989
3990 if (do_segments && !do_header)
3991 {
f7a99963
NC
3992 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3993 printf (_("Entry point "));
3994 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3995 printf (_("\nThere are %d program headers, starting at offset "),
3996 elf_header.e_phnum);
3997 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3998 printf ("\n");
252b5132
RH
3999 }
4000
d93f0186 4001 if (! get_program_headers (file))
252b5132 4002 return 0;
103f02d3 4003
252b5132
RH
4004 if (do_segments)
4005 {
3a1a2036
NC
4006 if (elf_header.e_phnum > 1)
4007 printf (_("\nProgram Headers:\n"));
4008 else
4009 printf (_("\nProgram Headers:\n"));
76da6bbe 4010
f7a99963
NC
4011 if (is_32bit_elf)
4012 printf
4013 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ
4014 else if (do_wide)
4015 printf
4016 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC
4017 else
4018 {
4019 printf
4020 (_(" Type Offset VirtAddr PhysAddr\n"));
4021 printf
4022 (_(" FileSiz MemSiz Flags Align\n"));
4023 }
252b5132
RH
4024 }
4025
252b5132 4026 dynamic_addr = 0;
1b228002 4027 dynamic_size = 0;
252b5132
RH
4028
4029 for (i = 0, segment = program_headers;
4030 i < elf_header.e_phnum;
b34976b6 4031 i++, segment++)
252b5132
RH
4032 {
4033 if (do_segments)
4034 {
103f02d3 4035 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC
4036
4037 if (is_32bit_elf)
4038 {
4039 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4040 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4041 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4042 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4043 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4044 printf ("%c%c%c ",
4045 (segment->p_flags & PF_R ? 'R' : ' '),
4046 (segment->p_flags & PF_W ? 'W' : ' '),
4047 (segment->p_flags & PF_X ? 'E' : ' '));
4048 printf ("%#lx", (unsigned long) segment->p_align);
4049 }
d974e256
JJ
4050 else if (do_wide)
4051 {
4052 if ((unsigned long) segment->p_offset == segment->p_offset)
4053 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4054 else
4055 {
4056 print_vma (segment->p_offset, FULL_HEX);
4057 putchar (' ');
4058 }
4059
4060 print_vma (segment->p_vaddr, FULL_HEX);
4061 putchar (' ');
4062 print_vma (segment->p_paddr, FULL_HEX);
4063 putchar (' ');
4064
4065 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4066 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4067 else
4068 {
4069 print_vma (segment->p_filesz, FULL_HEX);
4070 putchar (' ');
4071 }
4072
4073 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4074 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4075 else
4076 {
f48e6c45 4077 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ
4078 }
4079
4080 printf (" %c%c%c ",
4081 (segment->p_flags & PF_R ? 'R' : ' '),
4082 (segment->p_flags & PF_W ? 'W' : ' '),
4083 (segment->p_flags & PF_X ? 'E' : ' '));
4084
4085 if ((unsigned long) segment->p_align == segment->p_align)
4086 printf ("%#lx", (unsigned long) segment->p_align);
4087 else
4088 {
4089 print_vma (segment->p_align, PREFIX_HEX);
4090 }
4091 }
f7a99963
NC
4092 else
4093 {
4094 print_vma (segment->p_offset, FULL_HEX);
4095 putchar (' ');
4096 print_vma (segment->p_vaddr, FULL_HEX);
4097 putchar (' ');
4098 print_vma (segment->p_paddr, FULL_HEX);
4099 printf ("\n ");
4100 print_vma (segment->p_filesz, FULL_HEX);
4101 putchar (' ');
4102 print_vma (segment->p_memsz, FULL_HEX);
4103 printf (" %c%c%c ",
4104 (segment->p_flags & PF_R ? 'R' : ' '),
4105 (segment->p_flags & PF_W ? 'W' : ' '),
4106 (segment->p_flags & PF_X ? 'E' : ' '));
4107 print_vma (segment->p_align, HEX);
4108 }
252b5132
RH
4109 }
4110
4111 switch (segment->p_type)
4112 {
252b5132
RH
4113 case PT_DYNAMIC:
4114 if (dynamic_addr)
4115 error (_("more than one dynamic segment\n"));
4116
20737c13
AM
4117 /* By default, assume that the .dynamic section is the first
4118 section in the DYNAMIC segment. */
4119 dynamic_addr = segment->p_offset;
4120 dynamic_size = segment->p_filesz;
4121
b2d38a17
NC
4122 /* Try to locate the .dynamic section. If there is
4123 a section header table, we can easily locate it. */
4124 if (section_headers != NULL)
4125 {
2cf0635d 4126 Elf_Internal_Shdr * sec;
b2d38a17 4127
89fac5e3
RS
4128 sec = find_section (".dynamic");
4129 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4130 {
28f997cf
TG
4131 /* A corresponding .dynamic section is expected, but on
4132 IA-64/OpenVMS it is OK for it to be missing. */
4133 if (!is_ia64_vms ())
4134 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC
4135 break;
4136 }
4137
42bb2e33 4138 if (sec->sh_type == SHT_NOBITS)
20737c13
AM
4139 {
4140 dynamic_size = 0;
4141 break;
4142 }
42bb2e33 4143
b2d38a17
NC
4144 dynamic_addr = sec->sh_offset;
4145 dynamic_size = sec->sh_size;
4146
4147 if (dynamic_addr < segment->p_offset
4148 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM
4149 warn (_("the .dynamic section is not contained"
4150 " within the dynamic segment\n"));
b2d38a17 4151 else if (dynamic_addr > segment->p_offset)
20737c13
AM
4152 warn (_("the .dynamic section is not the first section"
4153 " in the dynamic segment.\n"));
b2d38a17 4154 }
252b5132
RH
4155 break;
4156
4157 case PT_INTERP:
fb52b2f4
NC
4158 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4159 SEEK_SET))
252b5132
RH
4160 error (_("Unable to find program interpreter name\n"));
4161 else
4162 {
f8eae8b2
L
4163 char fmt [32];
4164 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
4165
4166 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4167 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4168
252b5132 4169 program_interpreter[0] = 0;
7bd7b3ef
AM
4170 if (fscanf (file, fmt, program_interpreter) <= 0)
4171 error (_("Unable to read program interpreter name\n"));
252b5132
RH
4172
4173 if (do_segments)
4174 printf (_("\n [Requesting program interpreter: %s]"),
4175 program_interpreter);
4176 }
4177 break;
4178 }
4179
4180 if (do_segments)
4181 putc ('\n', stdout);
4182 }
4183
c256ffe7 4184 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH
4185 {
4186 printf (_("\n Section to Segment mapping:\n"));
4187 printf (_(" Segment Sections...\n"));
4188
252b5132
RH
4189 for (i = 0; i < elf_header.e_phnum; i++)
4190 {
9ad5cbcf 4191 unsigned int j;
2cf0635d 4192 Elf_Internal_Shdr * section;
252b5132
RH
4193
4194 segment = program_headers + i;
b391a3e3 4195 section = section_headers + 1;
252b5132
RH
4196
4197 printf (" %2.2d ", i);
4198
b34976b6 4199 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4200 {
f4638467
AM
4201 if (!ELF_TBSS_SPECIAL (section, segment)
4202 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
252b5132
RH
4203 printf ("%s ", SECTION_NAME (section));
4204 }
4205
4206 putc ('\n',stdout);
4207 }
4208 }
4209
252b5132
RH
4210 return 1;
4211}
4212
4213
d93f0186
NC
4214/* Find the file offset corresponding to VMA by using the program headers. */
4215
4216static long
2cf0635d 4217offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4218{
2cf0635d 4219 Elf_Internal_Phdr * seg;
d93f0186
NC
4220
4221 if (! get_program_headers (file))
4222 {
4223 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4224 return (long) vma;
4225 }
4226
4227 for (seg = program_headers;
4228 seg < program_headers + elf_header.e_phnum;
4229 ++seg)
4230 {
4231 if (seg->p_type != PT_LOAD)
4232 continue;
4233
4234 if (vma >= (seg->p_vaddr & -seg->p_align)
4235 && vma + size <= seg->p_vaddr + seg->p_filesz)
4236 return vma - seg->p_vaddr + seg->p_offset;
4237 }
4238
4239 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4240 (unsigned long) vma);
d93f0186
NC
4241 return (long) vma;
4242}
4243
4244
252b5132 4245static int
2cf0635d 4246get_32bit_section_headers (FILE * file, unsigned int num)
252b5132 4247{
2cf0635d
NC
4248 Elf32_External_Shdr * shdrs;
4249 Elf_Internal_Shdr * internal;
b34976b6 4250 unsigned int i;
252b5132 4251
3f5e193b
NC
4252 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4253 elf_header.e_shentsize, num,
4254 _("section headers"));
a6e9f9df
AM
4255 if (!shdrs)
4256 return 0;
252b5132 4257
3f5e193b
NC
4258 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4259 sizeof (Elf_Internal_Shdr));
252b5132
RH
4260
4261 if (section_headers == NULL)
4262 {
4263 error (_("Out of memory\n"));
4264 return 0;
4265 }
4266
4267 for (i = 0, internal = section_headers;
560f3c1c 4268 i < num;
b34976b6 4269 i++, internal++)
252b5132
RH
4270 {
4271 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4272 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4273 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4274 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4275 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4276 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4277 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4278 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4279 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4280 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4281 }
4282
4283 free (shdrs);
4284
4285 return 1;
4286}
4287
9ea033b2 4288static int
2cf0635d 4289get_64bit_section_headers (FILE * file, unsigned int num)
9ea033b2 4290{
2cf0635d
NC
4291 Elf64_External_Shdr * shdrs;
4292 Elf_Internal_Shdr * internal;
b34976b6 4293 unsigned int i;
9ea033b2 4294
3f5e193b
NC
4295 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4296 elf_header.e_shentsize, num,
4297 _("section headers"));
a6e9f9df
AM
4298 if (!shdrs)
4299 return 0;
9ea033b2 4300
3f5e193b
NC
4301 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4302 sizeof (Elf_Internal_Shdr));
9ea033b2
NC
4303
4304 if (section_headers == NULL)
4305 {
4306 error (_("Out of memory\n"));
4307 return 0;
4308 }
4309
4310 for (i = 0, internal = section_headers;
560f3c1c 4311 i < num;
b34976b6 4312 i++, internal++)
9ea033b2
NC
4313 {
4314 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4315 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM
4316 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4317 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4318 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4319 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC
4320 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4321 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4322 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4323 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4324 }
4325
4326 free (shdrs);
4327
4328 return 1;
4329}
4330
252b5132 4331static Elf_Internal_Sym *
ba5cdace
NC
4332get_32bit_elf_symbols (FILE * file,
4333 Elf_Internal_Shdr * section,
4334 unsigned long * num_syms_return)
252b5132 4335{
ba5cdace 4336 unsigned long number = 0;
dd24e3da 4337 Elf32_External_Sym * esyms = NULL;
ba5cdace 4338 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 4339 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4340 Elf_Internal_Sym * psym;
b34976b6 4341 unsigned int j;
252b5132 4342
dd24e3da
NC
4343 /* Run some sanity checks first. */
4344 if (section->sh_entsize == 0)
4345 {
4346 error (_("sh_entsize is zero\n"));
ba5cdace 4347 goto exit_point;
dd24e3da
NC
4348 }
4349
4350 number = section->sh_size / section->sh_entsize;
4351
4352 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4353 {
4354 error (_("Invalid sh_entsize\n"));
ba5cdace 4355 goto exit_point;
dd24e3da
NC
4356 }
4357
3f5e193b
NC
4358 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4359 section->sh_size, _("symbols"));
dd24e3da 4360 if (esyms == NULL)
ba5cdace 4361 goto exit_point;
252b5132 4362
9ad5cbcf
AM
4363 shndx = NULL;
4364 if (symtab_shndx_hdr != NULL
4365 && (symtab_shndx_hdr->sh_link
4fbb74a6 4366 == (unsigned long) (section - section_headers)))
9ad5cbcf 4367 {
3f5e193b
NC
4368 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4369 symtab_shndx_hdr->sh_offset,
4370 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4371 _("symbol table section indicies"));
dd24e3da
NC
4372 if (shndx == NULL)
4373 goto exit_point;
9ad5cbcf
AM
4374 }
4375
3f5e193b 4376 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH
4377
4378 if (isyms == NULL)
4379 {
4380 error (_("Out of memory\n"));
dd24e3da 4381 goto exit_point;
252b5132
RH
4382 }
4383
dd24e3da 4384 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH
4385 {
4386 psym->st_name = BYTE_GET (esyms[j].st_name);
4387 psym->st_value = BYTE_GET (esyms[j].st_value);
4388 psym->st_size = BYTE_GET (esyms[j].st_size);
4389 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4390 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM
4391 psym->st_shndx
4392 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM
4393 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4394 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH
4395 psym->st_info = BYTE_GET (esyms[j].st_info);
4396 psym->st_other = BYTE_GET (esyms[j].st_other);
4397 }
4398
dd24e3da 4399 exit_point:
ba5cdace 4400 if (shndx != NULL)
9ad5cbcf 4401 free (shndx);
ba5cdace 4402 if (esyms != NULL)
dd24e3da 4403 free (esyms);
252b5132 4404
ba5cdace
NC
4405 if (num_syms_return != NULL)
4406 * num_syms_return = isyms == NULL ? 0 : number;
4407
252b5132
RH
4408 return isyms;
4409}
4410
9ea033b2 4411static Elf_Internal_Sym *
ba5cdace
NC
4412get_64bit_elf_symbols (FILE * file,
4413 Elf_Internal_Shdr * section,
4414 unsigned long * num_syms_return)
9ea033b2 4415{
ba5cdace
NC
4416 unsigned long number = 0;
4417 Elf64_External_Sym * esyms = NULL;
4418 Elf_External_Sym_Shndx * shndx = NULL;
4419 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4420 Elf_Internal_Sym * psym;
b34976b6 4421 unsigned int j;
9ea033b2 4422
dd24e3da
NC
4423 /* Run some sanity checks first. */
4424 if (section->sh_entsize == 0)
4425 {
4426 error (_("sh_entsize is zero\n"));
ba5cdace 4427 goto exit_point;
dd24e3da
NC
4428 }
4429
4430 number = section->sh_size / section->sh_entsize;
4431
4432 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4433 {
4434 error (_("Invalid sh_entsize\n"));
ba5cdace 4435 goto exit_point;
dd24e3da
NC
4436 }
4437
3f5e193b
NC
4438 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4439 section->sh_size, _("symbols"));
a6e9f9df 4440 if (!esyms)
ba5cdace 4441 goto exit_point;
9ea033b2 4442
9ad5cbcf
AM
4443 if (symtab_shndx_hdr != NULL
4444 && (symtab_shndx_hdr->sh_link
4fbb74a6 4445 == (unsigned long) (section - section_headers)))
9ad5cbcf 4446 {
3f5e193b
NC
4447 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4448 symtab_shndx_hdr->sh_offset,
4449 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4450 _("symbol table section indicies"));
ba5cdace
NC
4451 if (shndx == NULL)
4452 goto exit_point;
9ad5cbcf
AM
4453 }
4454
3f5e193b 4455 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC
4456
4457 if (isyms == NULL)
4458 {
4459 error (_("Out of memory\n"));
ba5cdace 4460 goto exit_point;
9ea033b2
NC
4461 }
4462
ba5cdace 4463 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC
4464 {
4465 psym->st_name = BYTE_GET (esyms[j].st_name);
4466 psym->st_info = BYTE_GET (esyms[j].st_info);
4467 psym->st_other = BYTE_GET (esyms[j].st_other);
4468 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 4469
4fbb74a6 4470 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM
4471 psym->st_shndx
4472 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM
4473 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4474 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 4475
66543521
AM
4476 psym->st_value = BYTE_GET (esyms[j].st_value);
4477 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC
4478 }
4479
ba5cdace
NC
4480 exit_point:
4481 if (shndx != NULL)
9ad5cbcf 4482 free (shndx);
ba5cdace
NC
4483 if (esyms != NULL)
4484 free (esyms);
4485
4486 if (num_syms_return != NULL)
4487 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC
4488
4489 return isyms;
4490}
4491
d1133906 4492static const char *
d3ba0551 4493get_elf_section_flags (bfd_vma sh_flags)
d1133906 4494{
5477e8a0 4495 static char buff[1024];
2cf0635d 4496 char * p = buff;
8d5ff12c 4497 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC
4498 int sindex;
4499 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L
4500 bfd_vma os_flags = 0;
4501 bfd_vma proc_flags = 0;
4502 bfd_vma unknown_flags = 0;
148b93f2 4503 static const struct
5477e8a0 4504 {
2cf0635d 4505 const char * str;
5477e8a0
L
4506 int len;
4507 }
4508 flags [] =
4509 {
cfcac11d
NC
4510 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4511 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4512 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4513 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4514 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4515 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4516 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4517 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4518 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4519 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4520 /* IA-64 specific. */
4521 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4522 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4523 /* IA-64 OpenVMS specific. */
4524 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4525 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4526 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4527 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4528 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4529 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 4530 /* Generic. */
cfcac11d 4531 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 4532 /* SPARC specific. */
cfcac11d 4533 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5477e8a0
L
4534 };
4535
4536 if (do_section_details)
4537 {
8d5ff12c
L
4538 sprintf (buff, "[%*.*lx]: ",
4539 field_size, field_size, (unsigned long) sh_flags);
4540 p += field_size + 4;
5477e8a0 4541 }
76da6bbe 4542
d1133906
NC
4543 while (sh_flags)
4544 {
4545 bfd_vma flag;
4546
4547 flag = sh_flags & - sh_flags;
4548 sh_flags &= ~ flag;
76da6bbe 4549
5477e8a0 4550 if (do_section_details)
d1133906 4551 {
5477e8a0
L
4552 switch (flag)
4553 {
91d6fa6a
NC
4554 case SHF_WRITE: sindex = 0; break;
4555 case SHF_ALLOC: sindex = 1; break;
4556 case SHF_EXECINSTR: sindex = 2; break;
4557 case SHF_MERGE: sindex = 3; break;
4558 case SHF_STRINGS: sindex = 4; break;
4559 case SHF_INFO_LINK: sindex = 5; break;
4560 case SHF_LINK_ORDER: sindex = 6; break;
4561 case SHF_OS_NONCONFORMING: sindex = 7; break;
4562 case SHF_GROUP: sindex = 8; break;
4563 case SHF_TLS: sindex = 9; break;
18ae9cc1 4564 case SHF_EXCLUDE: sindex = 18; break;
76da6bbe 4565
5477e8a0 4566 default:
91d6fa6a 4567 sindex = -1;
cfcac11d 4568 switch (elf_header.e_machine)
148b93f2 4569 {
cfcac11d 4570 case EM_IA_64:
148b93f2 4571 if (flag == SHF_IA_64_SHORT)
91d6fa6a 4572 sindex = 10;
148b93f2 4573 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 4574 sindex = 11;
148b93f2
NC
4575#ifdef BFD64
4576 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4577 switch (flag)
4578 {
91d6fa6a
NC
4579 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4580 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4581 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4582 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4583 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4584 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC
4585 default: break;
4586 }
4587#endif
cfcac11d
NC
4588 break;
4589
caa83f8b
NC
4590 case EM_386:
4591 case EM_486:
4592 case EM_X86_64:
7f502d6c 4593 case EM_L1OM:
7a9068fe 4594 case EM_K1OM:
cfcac11d
NC
4595 case EM_OLD_SPARCV9:
4596 case EM_SPARC32PLUS:
4597 case EM_SPARCV9:
4598 case EM_SPARC:
18ae9cc1 4599 if (flag == SHF_ORDERED)
91d6fa6a 4600 sindex = 19;
cfcac11d
NC
4601 break;
4602 default:
4603 break;
148b93f2 4604 }
5477e8a0
L
4605 }
4606
91d6fa6a 4607 if (sindex != -1)
5477e8a0 4608 {
8d5ff12c
L
4609 if (p != buff + field_size + 4)
4610 {
4611 if (size < (10 + 2))
4612 abort ();
4613 size -= 2;
4614 *p++ = ',';
4615 *p++ = ' ';
4616 }
4617
91d6fa6a
NC
4618 size -= flags [sindex].len;
4619 p = stpcpy (p, flags [sindex].str);
5477e8a0 4620 }
3b22753a 4621 else if (flag & SHF_MASKOS)
8d5ff12c 4622 os_flags |= flag;
d1133906 4623 else if (flag & SHF_MASKPROC)
8d5ff12c 4624 proc_flags |= flag;
d1133906 4625 else
8d5ff12c 4626 unknown_flags |= flag;
5477e8a0
L
4627 }
4628 else
4629 {
4630 switch (flag)
4631 {
4632 case SHF_WRITE: *p = 'W'; break;
4633 case SHF_ALLOC: *p = 'A'; break;
4634 case SHF_EXECINSTR: *p = 'X'; break;
4635 case SHF_MERGE: *p = 'M'; break;
4636 case SHF_STRINGS: *p = 'S'; break;
4637 case SHF_INFO_LINK: *p = 'I'; break;
4638 case SHF_LINK_ORDER: *p = 'L'; break;
4639 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4640 case SHF_GROUP: *p = 'G'; break;
4641 case SHF_TLS: *p = 'T'; break;
18ae9cc1 4642 case SHF_EXCLUDE: *p = 'E'; break;
5477e8a0
L
4643
4644 default:
8a9036a4 4645 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L
4646 || elf_header.e_machine == EM_L1OM
4647 || elf_header.e_machine == EM_K1OM)
5477e8a0
L
4648 && flag == SHF_X86_64_LARGE)
4649 *p = 'l';
4650 else if (flag & SHF_MASKOS)
4651 {
4652 *p = 'o';
4653 sh_flags &= ~ SHF_MASKOS;
4654 }
4655 else if (flag & SHF_MASKPROC)
4656 {
4657 *p = 'p';
4658 sh_flags &= ~ SHF_MASKPROC;
4659 }
4660 else
4661 *p = 'x';
4662 break;
4663 }
4664 p++;
d1133906
NC
4665 }
4666 }
76da6bbe 4667
8d5ff12c
L
4668 if (do_section_details)
4669 {
4670 if (os_flags)
4671 {
4672 size -= 5 + field_size;
4673 if (p != buff + field_size + 4)
4674 {
4675 if (size < (2 + 1))
4676 abort ();
4677 size -= 2;
4678 *p++ = ',';
4679 *p++ = ' ';
4680 }
4681 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4682 (unsigned long) os_flags);
4683 p += 5 + field_size;
4684 }
4685 if (proc_flags)
4686 {
4687 size -= 7 + field_size;
4688 if (p != buff + field_size + 4)
4689 {
4690 if (size < (2 + 1))
4691 abort ();
4692 size -= 2;
4693 *p++ = ',';
4694 *p++ = ' ';
4695 }
4696 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4697 (unsigned long) proc_flags);
4698 p += 7 + field_size;
4699 }
4700 if (unknown_flags)
4701 {
4702 size -= 10 + field_size;
4703 if (p != buff + field_size + 4)
4704 {
4705 if (size < (2 + 1))
4706 abort ();
4707 size -= 2;
4708 *p++ = ',';
4709 *p++ = ' ';
4710 }
2b692964 4711 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L
4712 (unsigned long) unknown_flags);
4713 p += 10 + field_size;
4714 }
4715 }
4716
e9e44622 4717 *p = '\0';
d1133906
NC
4718 return buff;
4719}
4720
252b5132 4721static int
2cf0635d 4722process_section_headers (FILE * file)
252b5132 4723{
2cf0635d 4724 Elf_Internal_Shdr * section;
b34976b6 4725 unsigned int i;
252b5132
RH
4726
4727 section_headers = NULL;
4728
4729 if (elf_header.e_shnum == 0)
4730 {
82f2dbf7
NC
4731 /* PR binutils/12467. */
4732 if (elf_header.e_shoff != 0)
4733 warn (_("possibly corrupt ELF file header - it has a non-zero"
4734 " section header offset, but no section headers\n"));
4735 else if (do_sections)
252b5132
RH
4736 printf (_("\nThere are no sections in this file.\n"));
4737
4738 return 1;
4739 }
4740
4741 if (do_sections && !do_header)
9ea033b2 4742 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH
4743 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4744
9ea033b2
NC
4745 if (is_32bit_elf)
4746 {
560f3c1c 4747 if (! get_32bit_section_headers (file, elf_header.e_shnum))
9ea033b2
NC
4748 return 0;
4749 }
560f3c1c 4750 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
252b5132
RH
4751 return 0;
4752
4753 /* Read in the string table, so that we have names to display. */
0b49d371 4754 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 4755 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 4756 {
4fbb74a6 4757 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 4758
c256ffe7
JJ
4759 if (section->sh_size != 0)
4760 {
3f5e193b
NC
4761 string_table = (char *) get_data (NULL, file, section->sh_offset,
4762 1, section->sh_size,
4763 _("string table"));
0de14b54 4764
c256ffe7
JJ
4765 string_table_length = string_table != NULL ? section->sh_size : 0;
4766 }
252b5132
RH
4767 }
4768
4769 /* Scan the sections for the dynamic symbol table
e3c8793a 4770 and dynamic string table and debug sections. */
252b5132
RH
4771 dynamic_symbols = NULL;
4772 dynamic_strings = NULL;
4773 dynamic_syminfo = NULL;
f1ef08cb 4774 symtab_shndx_hdr = NULL;
103f02d3 4775
89fac5e3
RS
4776 eh_addr_size = is_32bit_elf ? 4 : 8;
4777 switch (elf_header.e_machine)
4778 {
4779 case EM_MIPS:
4780 case EM_MIPS_RS3_LE:
4781 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4782 FDE addresses. However, the ABI also has a semi-official ILP32
4783 variant for which the normal FDE address size rules apply.
4784
4785 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4786 section, where XX is the size of longs in bits. Unfortunately,
4787 earlier compilers provided no way of distinguishing ILP32 objects
4788 from LP64 objects, so if there's any doubt, we should assume that
4789 the official LP64 form is being used. */
4790 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4791 && find_section (".gcc_compiled_long32") == NULL)
4792 eh_addr_size = 8;
4793 break;
0f56a26a
DD
4794
4795 case EM_H8_300:
4796 case EM_H8_300H:
4797 switch (elf_header.e_flags & EF_H8_MACH)
4798 {
4799 case E_H8_MACH_H8300:
4800 case E_H8_MACH_H8300HN:
4801 case E_H8_MACH_H8300SN:
4802 case E_H8_MACH_H8300SXN:
4803 eh_addr_size = 2;
4804 break;
4805 case E_H8_MACH_H8300H:
4806 case E_H8_MACH_H8300S:
4807 case E_H8_MACH_H8300SX:
4808 eh_addr_size = 4;
4809 break;
4810 }
f4236fe4
DD
4811 break;
4812
ff7eeb89 4813 case EM_M32C_OLD:
f4236fe4
DD
4814 case EM_M32C:
4815 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4816 {
4817 case EF_M32C_CPU_M16C:
4818 eh_addr_size = 2;
4819 break;
4820 }
4821 break;
89fac5e3
RS
4822 }
4823
08d8fa11
JJ
4824#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4825 do \
4826 { \
9dd3a467 4827 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
08d8fa11 4828 if (section->sh_entsize != expected_entsize) \
9dd3a467 4829 { \
15b42fb0 4830 error (_("Section %d has invalid sh_entsize of %" BFD_VMA_FMT "x\n"), \
9dd3a467
NC
4831 i, section->sh_entsize); \
4832 error (_("(Using the expected size of %d for the rest of this dump)\n"), \
4833 (int) expected_entsize); \
4834 section->sh_entsize = expected_entsize; \
4835 } \
08d8fa11
JJ
4836 } \
4837 while (0)
9dd3a467
NC
4838
4839#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ
4840 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4841 sizeof (Elf64_External_##type))
4842
252b5132
RH
4843 for (i = 0, section = section_headers;
4844 i < elf_header.e_shnum;
b34976b6 4845 i++, section++)
252b5132 4846 {
2cf0635d 4847 char * name = SECTION_NAME (section);
252b5132
RH
4848
4849 if (section->sh_type == SHT_DYNSYM)
4850 {
4851 if (dynamic_symbols != NULL)
4852 {
4853 error (_("File contains multiple dynamic symbol tables\n"));
4854 continue;
4855 }
4856
08d8fa11 4857 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 4858 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH
4859 }
4860 else if (section->sh_type == SHT_STRTAB
18bd398b 4861 && streq (name, ".dynstr"))
252b5132
RH
4862 {
4863 if (dynamic_strings != NULL)
4864 {
4865 error (_("File contains multiple dynamic string tables\n"));
4866 continue;
4867 }
4868
3f5e193b
NC
4869 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4870 1, section->sh_size,
4871 _("dynamic strings"));
59245841 4872 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 4873 }
9ad5cbcf
AM
4874 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4875 {
4876 if (symtab_shndx_hdr != NULL)
4877 {
4878 error (_("File contains multiple symtab shndx tables\n"));
4879 continue;
4880 }
4881 symtab_shndx_hdr = section;
4882 }
08d8fa11
JJ
4883 else if (section->sh_type == SHT_SYMTAB)
4884 CHECK_ENTSIZE (section, i, Sym);
4885 else if (section->sh_type == SHT_GROUP)
4886 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4887 else if (section->sh_type == SHT_REL)
4888 CHECK_ENTSIZE (section, i, Rel);
4889 else if (section->sh_type == SHT_RELA)
4890 CHECK_ENTSIZE (section, i, Rela);
252b5132 4891 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 4892 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 4893 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC
4894 || do_debug_str || do_debug_loc || do_debug_ranges
4895 || do_debug_addr || do_debug_cu_index)
1b315056
CS
4896 && (const_strneq (name, ".debug_")
4897 || const_strneq (name, ".zdebug_")))
252b5132 4898 {
1b315056
CS
4899 if (name[1] == 'z')
4900 name += sizeof (".zdebug_") - 1;
4901 else
4902 name += sizeof (".debug_") - 1;
252b5132
RH
4903
4904 if (do_debugging
4723351a
CC
4905 || (do_debug_info && const_strneq (name, "info"))
4906 || (do_debug_info && const_strneq (name, "types"))
4907 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC
4908 || (do_debug_lines && strcmp (name, "line") == 0)
4909 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC
4910 || (do_debug_pubnames && const_strneq (name, "pubnames"))
4911 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
4912 || (do_debug_aranges && const_strneq (name, "aranges"))
4913 || (do_debug_ranges && const_strneq (name, "ranges"))
4914 || (do_debug_frames && const_strneq (name, "frame"))
4915 || (do_debug_macinfo && const_strneq (name, "macinfo"))
4916 || (do_debug_macinfo && const_strneq (name, "macro"))
4917 || (do_debug_str && const_strneq (name, "str"))
4918 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC
4919 || (do_debug_addr && const_strneq (name, "addr"))
4920 || (do_debug_cu_index && const_strneq (name, "cu_index"))
4921 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 4922 )
09c11c86 4923 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 4924 }
a262ae96 4925 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 4926 else if ((do_debugging || do_debug_info)
0112cd26 4927 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 4928 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 4929 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 4930 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE
4931 else if (do_gdb_index && streq (name, ".gdb_index"))
4932 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG
4933 /* Trace sections for Itanium VMS. */
4934 else if ((do_debugging || do_trace_info || do_trace_abbrevs
4935 || do_trace_aranges)
4936 && const_strneq (name, ".trace_"))
4937 {
4938 name += sizeof (".trace_") - 1;
4939
4940 if (do_debugging
4941 || (do_trace_info && streq (name, "info"))
4942 || (do_trace_abbrevs && streq (name, "abbrev"))
4943 || (do_trace_aranges && streq (name, "aranges"))
4944 )
4945 request_dump_bynumber (i, DEBUG_DUMP);
4946 }
4947
252b5132
RH
4948 }
4949
4950 if (! do_sections)
4951 return 1;
4952
3a1a2036
NC
4953 if (elf_header.e_shnum > 1)
4954 printf (_("\nSection Headers:\n"));
4955 else
4956 printf (_("\nSection Header:\n"));
76da6bbe 4957
f7a99963 4958 if (is_32bit_elf)
595cf52e 4959 {
5477e8a0 4960 if (do_section_details)
595cf52e
L
4961 {
4962 printf (_(" [Nr] Name\n"));
5477e8a0 4963 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L
4964 }
4965 else
4966 printf
4967 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4968 }
d974e256 4969 else if (do_wide)
595cf52e 4970 {
5477e8a0 4971 if (do_section_details)
595cf52e
L
4972 {
4973 printf (_(" [Nr] Name\n"));
5477e8a0 4974 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L
4975 }
4976 else
4977 printf
4978 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4979 }
f7a99963
NC
4980 else
4981 {
5477e8a0 4982 if (do_section_details)
595cf52e
L
4983 {
4984 printf (_(" [Nr] Name\n"));
5477e8a0
L
4985 printf (_(" Type Address Offset Link\n"));
4986 printf (_(" Size EntSize Info Align\n"));
595cf52e
L
4987 }
4988 else
4989 {
4990 printf (_(" [Nr] Name Type Address Offset\n"));
4991 printf (_(" Size EntSize Flags Link Info Align\n"));
4992 }
f7a99963 4993 }
252b5132 4994
5477e8a0
L
4995 if (do_section_details)
4996 printf (_(" Flags\n"));
4997
252b5132
RH
4998 for (i = 0, section = section_headers;
4999 i < elf_header.e_shnum;
b34976b6 5000 i++, section++)
252b5132 5001 {
7bfd842d 5002 printf (" [%2u] ", i);
5477e8a0 5003 if (do_section_details)
595cf52e 5004 {
7bfd842d 5005 print_symbol (INT_MAX, SECTION_NAME (section));
ea52a088 5006 printf ("\n ");
595cf52e
L
5007 }
5008 else
7bfd842d
NC
5009 {
5010 print_symbol (-17, SECTION_NAME (section));
7bfd842d 5011 }
ea52a088
NC
5012
5013 printf (do_wide ? " %-15s " : " %-15.15s ",
5014 get_section_type_name (section->sh_type));
5015
f7a99963
NC
5016 if (is_32bit_elf)
5017 {
cfcac11d
NC
5018 const char * link_too_big = NULL;
5019
f7a99963 5020 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 5021
f7a99963
NC
5022 printf ( " %6.6lx %6.6lx %2.2lx",
5023 (unsigned long) section->sh_offset,
5024 (unsigned long) section->sh_size,
5025 (unsigned long) section->sh_entsize);
d1133906 5026
5477e8a0
L
5027 if (do_section_details)
5028 fputs (" ", stdout);
5029 else
5030 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5031
cfcac11d
NC
5032 if (section->sh_link >= elf_header.e_shnum)
5033 {
5034 link_too_big = "";
5035 /* The sh_link value is out of range. Normally this indicates
caa83f8b 5036 an error but it can have special values in Solaris binaries. */
cfcac11d
NC
5037 switch (elf_header.e_machine)
5038 {
caa83f8b
NC
5039 case EM_386:
5040 case EM_486:
5041 case EM_X86_64:
7f502d6c 5042 case EM_L1OM:
7a9068fe 5043 case EM_K1OM:
cfcac11d
NC
5044 case EM_OLD_SPARCV9:
5045 case EM_SPARC32PLUS:
5046 case EM_SPARCV9:
5047 case EM_SPARC:
5048 if (section->sh_link == (SHN_BEFORE & 0xffff))
5049 link_too_big = "BEFORE";
5050 else if (section->sh_link == (SHN_AFTER & 0xffff))
5051 link_too_big = "AFTER";
5052 break;
5053 default:
5054 break;
5055 }
5056 }
5057
5058 if (do_section_details)
5059 {
5060 if (link_too_big != NULL && * link_too_big)
5061 printf ("<%s> ", link_too_big);
5062 else
5063 printf ("%2u ", section->sh_link);
5064 printf ("%3u %2lu\n", section->sh_info,
5065 (unsigned long) section->sh_addralign);
5066 }
5067 else
5068 printf ("%2u %3u %2lu\n",
5069 section->sh_link,
5070 section->sh_info,
5071 (unsigned long) section->sh_addralign);
5072
5073 if (link_too_big && ! * link_too_big)
5074 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5075 i, section->sh_link);
f7a99963 5076 }
d974e256
JJ
5077 else if (do_wide)
5078 {
5079 print_vma (section->sh_addr, LONG_HEX);
5080
5081 if ((long) section->sh_offset == section->sh_offset)
5082 printf (" %6.6lx", (unsigned long) section->sh_offset);
5083 else
5084 {
5085 putchar (' ');
5086 print_vma (section->sh_offset, LONG_HEX);
5087 }
5088
5089 if ((unsigned long) section->sh_size == section->sh_size)
5090 printf (" %6.6lx", (unsigned long) section->sh_size);
5091 else
5092 {
5093 putchar (' ');
5094 print_vma (section->sh_size, LONG_HEX);
5095 }
5096
5097 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5098 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5099 else
5100 {
5101 putchar (' ');
5102 print_vma (section->sh_entsize, LONG_HEX);
5103 }
5104
5477e8a0
L
5105 if (do_section_details)
5106 fputs (" ", stdout);
5107 else
5108 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 5109
72de5009 5110 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ
5111
5112 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 5113 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ
5114 else
5115 {
5116 print_vma (section->sh_addralign, DEC);
5117 putchar ('\n');
5118 }
5119 }
5477e8a0 5120 else if (do_section_details)
595cf52e 5121 {
5477e8a0 5122 printf (" %-15.15s ",
595cf52e 5123 get_section_type_name (section->sh_type));
595cf52e
L
5124 print_vma (section->sh_addr, LONG_HEX);
5125 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 5126 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L
5127 else
5128 {
5129 printf (" ");
5130 print_vma (section->sh_offset, LONG_HEX);
5131 }
72de5009 5132 printf (" %u\n ", section->sh_link);
595cf52e 5133 print_vma (section->sh_size, LONG_HEX);
5477e8a0 5134 putchar (' ');
595cf52e
L
5135 print_vma (section->sh_entsize, LONG_HEX);
5136
72de5009
AM
5137 printf (" %-16u %lu\n",
5138 section->sh_info,
595cf52e
L
5139 (unsigned long) section->sh_addralign);
5140 }
f7a99963
NC
5141 else
5142 {
5143 putchar (' ');
5144 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH
5145 if ((long) section->sh_offset == section->sh_offset)
5146 printf (" %8.8lx", (unsigned long) section->sh_offset);
5147 else
5148 {
5149 printf (" ");
5150 print_vma (section->sh_offset, LONG_HEX);
5151 }
f7a99963
NC
5152 printf ("\n ");
5153 print_vma (section->sh_size, LONG_HEX);
5154 printf (" ");
5155 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 5156
d1133906 5157 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5158
72de5009
AM
5159 printf (" %2u %3u %lu\n",
5160 section->sh_link,
5161 section->sh_info,
f7a99963
NC
5162 (unsigned long) section->sh_addralign);
5163 }
5477e8a0
L
5164
5165 if (do_section_details)
5166 printf (" %s\n", get_elf_section_flags (section->sh_flags));
252b5132
RH
5167 }
5168
5477e8a0 5169 if (!do_section_details)
3dbcc61d
NC
5170 {
5171 if (elf_header.e_machine == EM_X86_64
7a9068fe
L
5172 || elf_header.e_machine == EM_L1OM
5173 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC
5174 printf (_("Key to Flags:\n\
5175 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5176 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5177 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5178 else
5179 printf (_("Key to Flags:\n\
e3c8793a 5180 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 5181 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 5182 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3dbcc61d 5183 }
d1133906 5184
252b5132
RH
5185 return 1;
5186}
5187
f5842774
L
5188static const char *
5189get_group_flags (unsigned int flags)
5190{
5191 static char buff[32];
5192 switch (flags)
5193 {
220453ec
AM
5194 case 0:
5195 return "";
5196
f5842774 5197 case GRP_COMDAT:
220453ec 5198 return "COMDAT ";
f5842774
L
5199
5200 default:
220453ec 5201 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L
5202 break;
5203 }
5204 return buff;
5205}
5206
5207static int
2cf0635d 5208process_section_groups (FILE * file)
f5842774 5209{
2cf0635d 5210 Elf_Internal_Shdr * section;
f5842774 5211 unsigned int i;
2cf0635d
NC
5212 struct group * group;
5213 Elf_Internal_Shdr * symtab_sec;
5214 Elf_Internal_Shdr * strtab_sec;
5215 Elf_Internal_Sym * symtab;
ba5cdace 5216 unsigned long num_syms;
2cf0635d 5217 char * strtab;
c256ffe7 5218 size_t strtab_size;
d1f5c6e3
L
5219
5220 /* Don't process section groups unless needed. */
5221 if (!do_unwind && !do_section_groups)
5222 return 1;
f5842774
L
5223
5224 if (elf_header.e_shnum == 0)
5225 {
5226 if (do_section_groups)
82f2dbf7 5227 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L
5228
5229 return 1;
5230 }
5231
5232 if (section_headers == NULL)
5233 {
5234 error (_("Section headers are not available!\n"));
fa1908fd
NC
5235 /* PR 13622: This can happen with a corrupt ELF header. */
5236 return 0;
f5842774
L
5237 }
5238
3f5e193b
NC
5239 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5240 sizeof (struct group *));
e4b17d5c
L
5241
5242 if (section_headers_groups == NULL)
5243 {
5244 error (_("Out of memory\n"));
5245 return 0;
5246 }
5247
f5842774 5248 /* Scan the sections for the group section. */
d1f5c6e3 5249 group_count = 0;
f5842774
L
5250 for (i = 0, section = section_headers;
5251 i < elf_header.e_shnum;
5252 i++, section++)
e4b17d5c
L
5253 if (section->sh_type == SHT_GROUP)
5254 group_count++;
5255
d1f5c6e3
L
5256 if (group_count == 0)
5257 {
5258 if (do_section_groups)
5259 printf (_("\nThere are no section groups in this file.\n"));
5260
5261 return 1;
5262 }
5263
3f5e193b 5264 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L
5265
5266 if (section_groups == NULL)
5267 {
5268 error (_("Out of memory\n"));
5269 return 0;
5270 }
5271
d1f5c6e3
L
5272 symtab_sec = NULL;
5273 strtab_sec = NULL;
5274 symtab = NULL;
ba5cdace 5275 num_syms = 0;
d1f5c6e3 5276 strtab = NULL;
c256ffe7 5277 strtab_size = 0;
e4b17d5c
L
5278 for (i = 0, section = section_headers, group = section_groups;
5279 i < elf_header.e_shnum;
5280 i++, section++)
f5842774
L
5281 {
5282 if (section->sh_type == SHT_GROUP)
5283 {
2cf0635d
NC
5284 char * name = SECTION_NAME (section);
5285 char * group_name;
5286 unsigned char * start;
5287 unsigned char * indices;
f5842774 5288 unsigned int entry, j, size;
2cf0635d
NC
5289 Elf_Internal_Shdr * sec;
5290 Elf_Internal_Sym * sym;
f5842774
L
5291
5292 /* Get the symbol table. */
4fbb74a6
AM
5293 if (section->sh_link >= elf_header.e_shnum
5294 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 5295 != SHT_SYMTAB))
f5842774
L
5296 {
5297 error (_("Bad sh_link in group section `%s'\n"), name);
5298 continue;
5299 }
d1f5c6e3
L
5300
5301 if (symtab_sec != sec)
5302 {
5303 symtab_sec = sec;
5304 if (symtab)
5305 free (symtab);
ba5cdace 5306 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 5307 }
f5842774 5308
dd24e3da
NC
5309 if (symtab == NULL)
5310 {
5311 error (_("Corrupt header in group section `%s'\n"), name);
5312 continue;
5313 }
5314
ba5cdace
NC
5315 if (section->sh_info >= num_syms)
5316 {
5317 error (_("Bad sh_info in group section `%s'\n"), name);
5318 continue;
5319 }
5320
f5842774
L
5321 sym = symtab + section->sh_info;
5322
5323 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5324 {
4fbb74a6
AM
5325 if (sym->st_shndx == 0
5326 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L
5327 {
5328 error (_("Bad sh_info in group section `%s'\n"), name);
5329 continue;
5330 }
ba2685cc 5331
4fbb74a6 5332 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ
5333 strtab_sec = NULL;
5334 if (strtab)
5335 free (strtab);
f5842774 5336 strtab = NULL;
c256ffe7 5337 strtab_size = 0;
f5842774
L
5338 }
5339 else
5340 {
5341 /* Get the string table. */
4fbb74a6 5342 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ
5343 {
5344 strtab_sec = NULL;
5345 if (strtab)
5346 free (strtab);
5347 strtab = NULL;
5348 strtab_size = 0;
5349 }
5350 else if (strtab_sec
4fbb74a6 5351 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L
5352 {
5353 strtab_sec = sec;
5354 if (strtab)
5355 free (strtab);
3f5e193b
NC
5356 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5357 1, strtab_sec->sh_size,
5358 _("string table"));
c256ffe7 5359 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 5360 }
c256ffe7 5361 group_name = sym->st_name < strtab_size
2b692964 5362 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L
5363 }
5364
3f5e193b
NC
5365 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5366 1, section->sh_size,
5367 _("section data"));
59245841
NC
5368 if (start == NULL)
5369 continue;
f5842774
L
5370
5371 indices = start;
5372 size = (section->sh_size / section->sh_entsize) - 1;
5373 entry = byte_get (indices, 4);
5374 indices += 4;
e4b17d5c
L
5375
5376 if (do_section_groups)
5377 {
2b692964 5378 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 5379 get_group_flags (entry), i, name, group_name, size);
ba2685cc 5380
e4b17d5c
L
5381 printf (_(" [Index] Name\n"));
5382 }
5383
5384 group->group_index = i;
5385
f5842774
L
5386 for (j = 0; j < size; j++)
5387 {
2cf0635d 5388 struct group_list * g;
e4b17d5c 5389
f5842774
L
5390 entry = byte_get (indices, 4);
5391 indices += 4;
5392
4fbb74a6 5393 if (entry >= elf_header.e_shnum)
391cb864
L
5394 {
5395 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5396 entry, i, elf_header.e_shnum - 1);
5397 continue;
5398 }
391cb864 5399
4fbb74a6 5400 if (section_headers_groups [entry] != NULL)
e4b17d5c 5401 {
d1f5c6e3
L
5402 if (entry)
5403 {
391cb864
L
5404 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5405 entry, i,
4fbb74a6 5406 section_headers_groups [entry]->group_index);
d1f5c6e3
L
5407 continue;
5408 }
5409 else
5410 {
5411 /* Intel C/C++ compiler may put section 0 in a
5412 section group. We just warn it the first time
5413 and ignore it afterwards. */
5414 static int warned = 0;
5415 if (!warned)
5416 {
5417 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 5418 section_headers_groups [entry]->group_index);
d1f5c6e3
L
5419 warned++;
5420 }
5421 }
e4b17d5c
L
5422 }
5423
4fbb74a6 5424 section_headers_groups [entry] = group;
e4b17d5c
L
5425
5426 if (do_section_groups)
5427 {
4fbb74a6 5428 sec = section_headers + entry;
c256ffe7 5429 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
ba2685cc
AM
5430 }
5431
3f5e193b 5432 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L
5433 g->section_index = entry;
5434 g->next = group->root;
5435 group->root = g;
f5842774
L
5436 }
5437
f5842774
L
5438 if (start)
5439 free (start);
e4b17d5c
L
5440
5441 group++;
f5842774
L
5442 }
5443 }
5444
d1f5c6e3
L
5445 if (symtab)
5446 free (symtab);
5447 if (strtab)
5448 free (strtab);
f5842774
L
5449 return 1;
5450}
5451
28f997cf
TG
5452/* Data used to display dynamic fixups. */
5453
5454struct ia64_vms_dynfixup
5455{
5456 bfd_vma needed_ident; /* Library ident number. */
5457 bfd_vma needed; /* Index in the dstrtab of the library name. */
5458 bfd_vma fixup_needed; /* Index of the library. */
5459 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5460 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5461};
5462
5463/* Data used to display dynamic relocations. */
5464
5465struct ia64_vms_dynimgrela
5466{
5467 bfd_vma img_rela_cnt; /* Number of relocations. */
5468 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5469};
5470
5471/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5472 library). */
5473
5474static void
5475dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5476 const char *strtab, unsigned int strtab_sz)
5477{
5478 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5479 long i;
5480 const char *lib_name;
5481
5482 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5483 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5484 _("dynamic section image fixups"));
5485 if (!imfs)
5486 return;
5487
5488 if (fixup->needed < strtab_sz)
5489 lib_name = strtab + fixup->needed;
5490 else
5491 {
5492 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 5493 (unsigned long) fixup->needed);
28f997cf
TG
5494 lib_name = "???";
5495 }
5496 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5497 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5498 printf
5499 (_("Seg Offset Type SymVec DataType\n"));
5500
5501 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5502 {
5503 unsigned int type;
5504 const char *rtype;
5505
5506 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5507 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5508 type = BYTE_GET (imfs [i].type);
5509 rtype = elf_ia64_reloc_type (type);
5510 if (rtype == NULL)
5511 printf (" 0x%08x ", type);
5512 else
5513 printf (" %-32s ", rtype);
5514 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5515 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5516 }
5517
5518 free (imfs);
5519}
5520
5521/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5522
5523static void
5524dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5525{
5526 Elf64_External_VMS_IMAGE_RELA *imrs;
5527 long i;
5528
5529 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5530 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 5531 _("dynamic section image relocations"));
28f997cf
TG
5532 if (!imrs)
5533 return;
5534
5535 printf (_("\nImage relocs\n"));
5536 printf
5537 (_("Seg Offset Type Addend Seg Sym Off\n"));
5538
5539 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5540 {
5541 unsigned int type;
5542 const char *rtype;
5543
5544 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5545 printf ("%08" BFD_VMA_FMT "x ",
5546 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5547 type = BYTE_GET (imrs [i].type);
5548 rtype = elf_ia64_reloc_type (type);
5549 if (rtype == NULL)
5550 printf ("0x%08x ", type);
5551 else
5552 printf ("%-31s ", rtype);
5553 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5554 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5555 printf ("%08" BFD_VMA_FMT "x\n",
5556 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5557 }
5558
5559 free (imrs);
5560}
5561
5562/* Display IA-64 OpenVMS dynamic relocations and fixups. */
5563
5564static int
5565process_ia64_vms_dynamic_relocs (FILE *file)
5566{
5567 struct ia64_vms_dynfixup fixup;
5568 struct ia64_vms_dynimgrela imgrela;
5569 Elf_Internal_Dyn *entry;
5570 int res = 0;
5571 bfd_vma strtab_off = 0;
5572 bfd_vma strtab_sz = 0;
5573 char *strtab = NULL;
5574
5575 memset (&fixup, 0, sizeof (fixup));
5576 memset (&imgrela, 0, sizeof (imgrela));
5577
5578 /* Note: the order of the entries is specified by the OpenVMS specs. */
5579 for (entry = dynamic_section;
5580 entry < dynamic_section + dynamic_nent;
5581 entry++)
5582 {
5583 switch (entry->d_tag)
5584 {
5585 case DT_IA_64_VMS_STRTAB_OFFSET:
5586 strtab_off = entry->d_un.d_val;
5587 break;
5588 case DT_STRSZ:
5589 strtab_sz = entry->d_un.d_val;
5590 if (strtab == NULL)
5591 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5592 1, strtab_sz, _("dynamic string section"));
5593 break;
5594
5595 case DT_IA_64_VMS_NEEDED_IDENT:
5596 fixup.needed_ident = entry->d_un.d_val;
5597 break;
5598 case DT_NEEDED:
5599 fixup.needed = entry->d_un.d_val;
5600 break;
5601 case DT_IA_64_VMS_FIXUP_NEEDED:
5602 fixup.fixup_needed = entry->d_un.d_val;
5603 break;
5604 case DT_IA_64_VMS_FIXUP_RELA_CNT:
5605 fixup.fixup_rela_cnt = entry->d_un.d_val;
5606 break;
5607 case DT_IA_64_VMS_FIXUP_RELA_OFF:
5608 fixup.fixup_rela_off = entry->d_un.d_val;
5609 res++;
5610 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5611 break;
5612
5613 case DT_IA_64_VMS_IMG_RELA_CNT:
5614 imgrela.img_rela_cnt = entry->d_un.d_val;
5615 break;
5616 case DT_IA_64_VMS_IMG_RELA_OFF:
5617 imgrela.img_rela_off = entry->d_un.d_val;
5618 res++;
5619 dump_ia64_vms_dynamic_relocs (file, &imgrela);
5620 break;
5621
5622 default:
5623 break;
5624 }
5625 }
5626
5627 if (strtab != NULL)
5628 free (strtab);
5629
5630 return res;
5631}
5632
85b1c36d 5633static struct
566b0d53 5634{
2cf0635d 5635 const char * name;
566b0d53
L
5636 int reloc;
5637 int size;
5638 int rela;
5639} dynamic_relocations [] =
5640{
5641 { "REL", DT_REL, DT_RELSZ, FALSE },
5642 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5643 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5644};
5645
252b5132 5646/* Process the reloc section. */
18bd398b 5647
252b5132 5648static int
2cf0635d 5649process_relocs (FILE * file)
252b5132 5650{
b34976b6
AM
5651 unsigned long rel_size;
5652 unsigned long rel_offset;
252b5132
RH
5653
5654
5655 if (!do_reloc)
5656 return 1;
5657
5658 if (do_using_dynamic)
5659 {
566b0d53 5660 int is_rela;
2cf0635d 5661 const char * name;
566b0d53
L
5662 int has_dynamic_reloc;
5663 unsigned int i;
0de14b54 5664
566b0d53 5665 has_dynamic_reloc = 0;
252b5132 5666
566b0d53 5667 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 5668 {
566b0d53
L
5669 is_rela = dynamic_relocations [i].rela;
5670 name = dynamic_relocations [i].name;
5671 rel_size = dynamic_info [dynamic_relocations [i].size];
5672 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 5673
566b0d53
L
5674 has_dynamic_reloc |= rel_size;
5675
5676 if (is_rela == UNKNOWN)
aa903cfb 5677 {
566b0d53
L
5678 if (dynamic_relocations [i].reloc == DT_JMPREL)
5679 switch (dynamic_info[DT_PLTREL])
5680 {
5681 case DT_REL:
5682 is_rela = FALSE;
5683 break;
5684 case DT_RELA:
5685 is_rela = TRUE;
5686 break;
5687 }
aa903cfb 5688 }
252b5132 5689
566b0d53
L
5690 if (rel_size)
5691 {
5692 printf
5693 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5694 name, rel_offset, rel_size);
252b5132 5695
d93f0186
NC
5696 dump_relocations (file,
5697 offset_from_vma (file, rel_offset, rel_size),
5698 rel_size,
566b0d53 5699 dynamic_symbols, num_dynamic_syms,
d79b3d50 5700 dynamic_strings, dynamic_strings_length, is_rela);
566b0d53 5701 }
252b5132 5702 }
566b0d53 5703
28f997cf
TG
5704 if (is_ia64_vms ())
5705 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5706
566b0d53 5707 if (! has_dynamic_reloc)
252b5132
RH
5708 printf (_("\nThere are no dynamic relocations in this file.\n"));
5709 }
5710 else
5711 {
2cf0635d 5712 Elf_Internal_Shdr * section;
b34976b6
AM
5713 unsigned long i;
5714 int found = 0;
252b5132
RH
5715
5716 for (i = 0, section = section_headers;
5717 i < elf_header.e_shnum;
b34976b6 5718 i++, section++)
252b5132
RH
5719 {
5720 if ( section->sh_type != SHT_RELA
5721 && section->sh_type != SHT_REL)
5722 continue;
5723
5724 rel_offset = section->sh_offset;
5725 rel_size = section->sh_size;
5726
5727 if (rel_size)
5728 {
2cf0635d 5729 Elf_Internal_Shdr * strsec;
b34976b6 5730 int is_rela;
103f02d3 5731
252b5132
RH
5732 printf (_("\nRelocation section "));
5733
5734 if (string_table == NULL)
19936277 5735 printf ("%d", section->sh_name);
252b5132 5736 else
9cf03b7e 5737 printf ("'%s'", SECTION_NAME (section));
252b5132
RH
5738
5739 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5740 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5741
d79b3d50
NC
5742 is_rela = section->sh_type == SHT_RELA;
5743
4fbb74a6
AM
5744 if (section->sh_link != 0
5745 && section->sh_link < elf_header.e_shnum)
af3fc3bc 5746 {
2cf0635d
NC
5747 Elf_Internal_Shdr * symsec;
5748 Elf_Internal_Sym * symtab;
d79b3d50 5749 unsigned long nsyms;
c256ffe7 5750 unsigned long strtablen = 0;
2cf0635d 5751 char * strtab = NULL;
57346661 5752
4fbb74a6 5753 symsec = section_headers + section->sh_link;
08d8fa11
JJ
5754 if (symsec->sh_type != SHT_SYMTAB
5755 && symsec->sh_type != SHT_DYNSYM)
5756 continue;
5757
ba5cdace 5758 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 5759
af3fc3bc
AM
5760 if (symtab == NULL)
5761 continue;
252b5132 5762
4fbb74a6
AM
5763 if (symsec->sh_link != 0
5764 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 5765 {
4fbb74a6 5766 strsec = section_headers + symsec->sh_link;
103f02d3 5767
3f5e193b
NC
5768 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5769 1, strsec->sh_size,
5770 _("string table"));
c256ffe7
JJ
5771 strtablen = strtab == NULL ? 0 : strsec->sh_size;
5772 }
252b5132 5773
d79b3d50
NC
5774 dump_relocations (file, rel_offset, rel_size,
5775 symtab, nsyms, strtab, strtablen, is_rela);
5776 if (strtab)
5777 free (strtab);
5778 free (symtab);
5779 }
5780 else
5781 dump_relocations (file, rel_offset, rel_size,
5782 NULL, 0, NULL, 0, is_rela);
252b5132
RH
5783
5784 found = 1;
5785 }
5786 }
5787
5788 if (! found)
5789 printf (_("\nThere are no relocations in this file.\n"));
5790 }
5791
5792 return 1;
5793}
5794
57346661
AM
5795/* Process the unwind section. */
5796
4d6ed7c8
NC
5797#include "unwind-ia64.h"
5798
5799/* An absolute address consists of a section and an offset. If the
5800 section is NULL, the offset itself is the address, otherwise, the
5801 address equals to LOAD_ADDRESS(section) + offset. */
5802
5803struct absaddr
5804 {
5805 unsigned short section;
5806 bfd_vma offset;
5807 };
5808
1949de15
L
5809#define ABSADDR(a) \
5810 ((a).section \
5811 ? section_headers [(a).section].sh_addr + (a).offset \
5812 : (a).offset)
5813
3f5e193b
NC
5814struct ia64_unw_table_entry
5815 {
5816 struct absaddr start;
5817 struct absaddr end;
5818 struct absaddr info;
5819 };
5820
57346661 5821struct ia64_unw_aux_info
4d6ed7c8 5822 {
3f5e193b
NC
5823
5824 struct ia64_unw_table_entry *table; /* Unwind table. */
b34976b6 5825 unsigned long table_len; /* Length of unwind table. */
2cf0635d 5826 unsigned char * info; /* Unwind info. */
b34976b6
AM
5827 unsigned long info_size; /* Size of unwind info. */
5828 bfd_vma info_addr; /* starting address of unwind info. */
5829 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 5830 Elf_Internal_Sym * symtab; /* The symbol table. */
b34976b6 5831 unsigned long nsyms; /* Number of symbols. */
2cf0635d 5832 char * strtab; /* The string table. */
b34976b6 5833 unsigned long strtab_size; /* Size of string table. */
4d6ed7c8
NC
5834 };
5835
4d6ed7c8 5836static void
2cf0635d 5837find_symbol_for_address (Elf_Internal_Sym * symtab,
57346661 5838 unsigned long nsyms,
2cf0635d 5839 const char * strtab,
57346661 5840 unsigned long strtab_size,
d3ba0551 5841 struct absaddr addr,
2cf0635d
NC
5842 const char ** symname,
5843 bfd_vma * offset)
4d6ed7c8 5844{
d3ba0551 5845 bfd_vma dist = 0x100000;
2cf0635d
NC
5846 Elf_Internal_Sym * sym;
5847 Elf_Internal_Sym * best = NULL;
4d6ed7c8
NC
5848 unsigned long i;
5849
0b6ae522
DJ
5850 REMOVE_ARCH_BITS (addr.offset);
5851
57346661 5852 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4d6ed7c8 5853 {
0b6ae522
DJ
5854 bfd_vma value = sym->st_value;
5855
5856 REMOVE_ARCH_BITS (value);
5857
4d6ed7c8
NC
5858 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5859 && sym->st_name != 0
5860 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ
5861 && addr.offset >= value
5862 && addr.offset - value < dist)
4d6ed7c8
NC
5863 {
5864 best = sym;
0b6ae522 5865 dist = addr.offset - value;
4d6ed7c8
NC
5866 if (!dist)
5867 break;
5868 }
5869 }
1b31d05e 5870
4d6ed7c8
NC
5871 if (best)
5872 {
57346661 5873 *symname = (best->st_name >= strtab_size
2b692964 5874 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC
5875 *offset = dist;
5876 return;
5877 }
1b31d05e 5878
4d6ed7c8
NC
5879 *symname = NULL;
5880 *offset = addr.offset;
5881}
5882
5883static void
2cf0635d 5884dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 5885{
2cf0635d 5886 struct ia64_unw_table_entry * tp;
4d6ed7c8 5887 int in_body;
7036c0e1 5888
4d6ed7c8
NC
5889 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5890 {
5891 bfd_vma stamp;
5892 bfd_vma offset;
2cf0635d
NC
5893 const unsigned char * dp;
5894 const unsigned char * head;
5895 const char * procname;
4d6ed7c8 5896
57346661
AM
5897 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5898 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC
5899
5900 fputs ("\n<", stdout);
5901
5902 if (procname)
5903 {
5904 fputs (procname, stdout);
5905
5906 if (offset)
5907 printf ("+%lx", (unsigned long) offset);
5908 }
5909
5910 fputs (">: [", stdout);
5911 print_vma (tp->start.offset, PREFIX_HEX);
5912 fputc ('-', stdout);
5913 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 5914 printf ("], info at +0x%lx\n",
4d6ed7c8
NC
5915 (unsigned long) (tp->info.offset - aux->seg_base));
5916
1949de15 5917 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 5918 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 5919
86f55779 5920 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC
5921 (unsigned) UNW_VER (stamp),
5922 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5923 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5924 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 5925 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC
5926
5927 if (UNW_VER (stamp) != 1)
5928 {
2b692964 5929 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC
5930 continue;
5931 }
5932
5933 in_body = 0;
89fac5e3 5934 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
4d6ed7c8
NC
5935 dp = unw_decode (dp, in_body, & in_body);
5936 }
5937}
5938
5939static int
2cf0635d
NC
5940slurp_ia64_unwind_table (FILE * file,
5941 struct ia64_unw_aux_info * aux,
5942 Elf_Internal_Shdr * sec)
4d6ed7c8 5943{
89fac5e3 5944 unsigned long size, nrelas, i;
2cf0635d
NC
5945 Elf_Internal_Phdr * seg;
5946 struct ia64_unw_table_entry * tep;
5947 Elf_Internal_Shdr * relsec;
5948 Elf_Internal_Rela * rela;
5949 Elf_Internal_Rela * rp;
5950 unsigned char * table;
5951 unsigned char * tp;
5952 Elf_Internal_Sym * sym;
5953 const char * relname;
4d6ed7c8 5954
4d6ed7c8
NC
5955 /* First, find the starting address of the segment that includes
5956 this section: */
5957
5958 if (elf_header.e_phnum)
5959 {
d93f0186 5960 if (! get_program_headers (file))
4d6ed7c8 5961 return 0;
4d6ed7c8 5962
d93f0186
NC
5963 for (seg = program_headers;
5964 seg < program_headers + elf_header.e_phnum;
5965 ++seg)
4d6ed7c8
NC
5966 {
5967 if (seg->p_type != PT_LOAD)
5968 continue;
5969
5970 if (sec->sh_addr >= seg->p_vaddr
5971 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5972 {
5973 aux->seg_base = seg->p_vaddr;
5974 break;
5975 }
5976 }
4d6ed7c8
NC
5977 }
5978
5979 /* Second, build the unwind table from the contents of the unwind section: */
5980 size = sec->sh_size;
3f5e193b
NC
5981 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5982 _("unwind table"));
a6e9f9df
AM
5983 if (!table)
5984 return 0;
4d6ed7c8 5985
3f5e193b
NC
5986 aux->table = (struct ia64_unw_table_entry *)
5987 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
89fac5e3 5988 tep = aux->table;
c6a0c689 5989 for (tp = table; tp < table + size; ++tep)
4d6ed7c8
NC
5990 {
5991 tep->start.section = SHN_UNDEF;
5992 tep->end.section = SHN_UNDEF;
5993 tep->info.section = SHN_UNDEF;
c6a0c689
AM
5994 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5995 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5996 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC
5997 tep->start.offset += aux->seg_base;
5998 tep->end.offset += aux->seg_base;
5999 tep->info.offset += aux->seg_base;
6000 }
6001 free (table);
6002
41e92641 6003 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC
6004 for (relsec = section_headers;
6005 relsec < section_headers + elf_header.e_shnum;
6006 ++relsec)
6007 {
6008 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM
6009 || relsec->sh_info >= elf_header.e_shnum
6010 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC
6011 continue;
6012
6013 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6014 & rela, & nrelas))
6015 return 0;
6016
6017 for (rp = rela; rp < rela + nrelas; ++rp)
6018 {
aca88567
NC
6019 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6020 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 6021
0112cd26 6022 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 6023 {
e5fb9629 6024 warn (_("Skipping unexpected relocation type %s\n"), relname);
4d6ed7c8
NC
6025 continue;
6026 }
6027
89fac5e3 6028 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 6029
89fac5e3 6030 switch (rp->r_offset/eh_addr_size % 3)
4d6ed7c8
NC
6031 {
6032 case 0:
6033 aux->table[i].start.section = sym->st_shndx;
e466bc6e 6034 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC
6035 break;
6036 case 1:
6037 aux->table[i].end.section = sym->st_shndx;
e466bc6e 6038 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC
6039 break;
6040 case 2:
6041 aux->table[i].info.section = sym->st_shndx;
e466bc6e 6042 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC
6043 break;
6044 default:
6045 break;
6046 }
6047 }
6048
6049 free (rela);
6050 }
6051
89fac5e3 6052 aux->table_len = size / (3 * eh_addr_size);
4d6ed7c8
NC
6053 return 1;
6054}
6055
1b31d05e 6056static void
2cf0635d 6057ia64_process_unwind (FILE * file)
4d6ed7c8 6058{
2cf0635d
NC
6059 Elf_Internal_Shdr * sec;
6060 Elf_Internal_Shdr * unwsec = NULL;
6061 Elf_Internal_Shdr * strsec;
89fac5e3 6062 unsigned long i, unwcount = 0, unwstart = 0;
57346661 6063 struct ia64_unw_aux_info aux;
f1467e33 6064
4d6ed7c8
NC
6065 memset (& aux, 0, sizeof (aux));
6066
4d6ed7c8
NC
6067 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6068 {
c256ffe7 6069 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6070 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 6071 {
ba5cdace 6072 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 6073
4fbb74a6 6074 strsec = section_headers + sec->sh_link;
59245841 6075 assert (aux.strtab == NULL);
3f5e193b
NC
6076 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6077 1, strsec->sh_size,
6078 _("string table"));
c256ffe7 6079 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC
6080 }
6081 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ
6082 unwcount++;
6083 }
6084
6085 if (!unwcount)
6086 printf (_("\nThere are no unwind sections in this file.\n"));
6087
6088 while (unwcount-- > 0)
6089 {
2cf0635d 6090 char * suffix;
579f31ac
JJ
6091 size_t len, len2;
6092
6093 for (i = unwstart, sec = section_headers + unwstart;
6094 i < elf_header.e_shnum; ++i, ++sec)
6095 if (sec->sh_type == SHT_IA_64_UNWIND)
6096 {
6097 unwsec = sec;
6098 break;
6099 }
6100
6101 unwstart = i + 1;
6102 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6103
e4b17d5c
L
6104 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6105 {
6106 /* We need to find which section group it is in. */
2cf0635d 6107 struct group_list * g = section_headers_groups [i]->root;
e4b17d5c
L
6108
6109 for (; g != NULL; g = g->next)
6110 {
4fbb74a6 6111 sec = section_headers + g->section_index;
18bd398b
NC
6112
6113 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
57346661 6114 break;
e4b17d5c
L
6115 }
6116
6117 if (g == NULL)
6118 i = elf_header.e_shnum;
6119 }
18bd398b 6120 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 6121 {
18bd398b 6122 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ
6123 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6124 suffix = SECTION_NAME (unwsec) + len;
6125 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6126 ++i, ++sec)
18bd398b
NC
6127 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6128 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ
6129 break;
6130 }
6131 else
6132 {
6133 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 6134 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ
6135 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6136 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6137 suffix = "";
18bd398b 6138 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ
6139 suffix = SECTION_NAME (unwsec) + len;
6140 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6141 ++i, ++sec)
18bd398b
NC
6142 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6143 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ
6144 break;
6145 }
6146
6147 if (i == elf_header.e_shnum)
6148 {
6149 printf (_("\nCould not find unwind info section for "));
6150
6151 if (string_table == NULL)
6152 printf ("%d", unwsec->sh_name);
6153 else
3a1a2036 6154 printf (_("'%s'"), SECTION_NAME (unwsec));
579f31ac
JJ
6155 }
6156 else
4d6ed7c8 6157 {
4d6ed7c8 6158 aux.info_addr = sec->sh_addr;
3f5e193b 6159 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
59245841 6160 sec->sh_size,
3f5e193b 6161 _("unwind info"));
59245841 6162 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 6163
579f31ac 6164 printf (_("\nUnwind section "));
4d6ed7c8 6165
579f31ac
JJ
6166 if (string_table == NULL)
6167 printf ("%d", unwsec->sh_name);
6168 else
3a1a2036 6169 printf (_("'%s'"), SECTION_NAME (unwsec));
4d6ed7c8 6170
579f31ac 6171 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 6172 (unsigned long) unwsec->sh_offset,
89fac5e3 6173 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 6174
579f31ac 6175 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4d6ed7c8 6176
579f31ac
JJ
6177 if (aux.table_len > 0)
6178 dump_ia64_unwind (& aux);
6179
6180 if (aux.table)
6181 free ((char *) aux.table);
6182 if (aux.info)
6183 free ((char *) aux.info);
6184 aux.table = NULL;
6185 aux.info = NULL;
6186 }
4d6ed7c8 6187 }
4d6ed7c8 6188
4d6ed7c8
NC
6189 if (aux.symtab)
6190 free (aux.symtab);
6191 if (aux.strtab)
6192 free ((char *) aux.strtab);
4d6ed7c8
NC
6193}
6194
3f5e193b
NC
6195struct hppa_unw_table_entry
6196 {
6197 struct absaddr start;
6198 struct absaddr end;
6199 unsigned int Cannot_unwind:1; /* 0 */
6200 unsigned int Millicode:1; /* 1 */
6201 unsigned int Millicode_save_sr0:1; /* 2 */
6202 unsigned int Region_description:2; /* 3..4 */
6203 unsigned int reserved1:1; /* 5 */
6204 unsigned int Entry_SR:1; /* 6 */
6205 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
6206 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
6207 unsigned int Args_stored:1; /* 16 */
6208 unsigned int Variable_Frame:1; /* 17 */
6209 unsigned int Separate_Package_Body:1; /* 18 */
6210 unsigned int Frame_Extension_Millicode:1; /* 19 */
6211 unsigned int Stack_Overflow_Check:1; /* 20 */
6212 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
6213 unsigned int Ada_Region:1; /* 22 */
6214 unsigned int cxx_info:1; /* 23 */
6215 unsigned int cxx_try_catch:1; /* 24 */
6216 unsigned int sched_entry_seq:1; /* 25 */
6217 unsigned int reserved2:1; /* 26 */
6218 unsigned int Save_SP:1; /* 27 */
6219 unsigned int Save_RP:1; /* 28 */
6220 unsigned int Save_MRP_in_frame:1; /* 29 */
6221 unsigned int extn_ptr_defined:1; /* 30 */
6222 unsigned int Cleanup_defined:1; /* 31 */
6223
6224 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
6225 unsigned int HP_UX_interrupt_marker:1; /* 1 */
6226 unsigned int Large_frame:1; /* 2 */
6227 unsigned int Pseudo_SP_Set:1; /* 3 */
6228 unsigned int reserved4:1; /* 4 */
6229 unsigned int Total_frame_size:27; /* 5..31 */
6230 };
6231
57346661
AM
6232struct hppa_unw_aux_info
6233 {
3f5e193b 6234 struct hppa_unw_table_entry *table; /* Unwind table. */
57346661
AM
6235 unsigned long table_len; /* Length of unwind table. */
6236 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 6237 Elf_Internal_Sym * symtab; /* The symbol table. */
57346661 6238 unsigned long nsyms; /* Number of symbols. */
2cf0635d 6239 char * strtab; /* The string table. */
57346661
AM
6240 unsigned long strtab_size; /* Size of string table. */
6241 };
6242
6243static void
2cf0635d 6244dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 6245{
2cf0635d 6246 struct hppa_unw_table_entry * tp;
57346661 6247
57346661
AM
6248 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6249 {
6250 bfd_vma offset;
2cf0635d 6251 const char * procname;
57346661
AM
6252
6253 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6254 aux->strtab_size, tp->start, &procname,
6255 &offset);
6256
6257 fputs ("\n<", stdout);
6258
6259 if (procname)
6260 {
6261 fputs (procname, stdout);
6262
6263 if (offset)
6264 printf ("+%lx", (unsigned long) offset);
6265 }
6266
6267 fputs (">: [", stdout);
6268 print_vma (tp->start.offset, PREFIX_HEX);
6269 fputc ('-', stdout);
6270 print_vma (tp->end.offset, PREFIX_HEX);
6271 printf ("]\n\t");
6272
18bd398b
NC
6273#define PF(_m) if (tp->_m) printf (#_m " ");
6274#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM
6275 PF(Cannot_unwind);
6276 PF(Millicode);
6277 PF(Millicode_save_sr0);
18bd398b 6278 /* PV(Region_description); */
57346661
AM
6279 PF(Entry_SR);
6280 PV(Entry_FR);
6281 PV(Entry_GR);
6282 PF(Args_stored);
6283 PF(Variable_Frame);
6284 PF(Separate_Package_Body);
6285 PF(Frame_Extension_Millicode);
6286 PF(Stack_Overflow_Check);
6287 PF(Two_Instruction_SP_Increment);
6288 PF(Ada_Region);
6289 PF(cxx_info);
6290 PF(cxx_try_catch);
6291 PF(sched_entry_seq);
6292 PF(Save_SP);
6293 PF(Save_RP);
6294 PF(Save_MRP_in_frame);
6295 PF(extn_ptr_defined);
6296 PF(Cleanup_defined);
6297 PF(MPE_XL_interrupt_marker);
6298 PF(HP_UX_interrupt_marker);
6299 PF(Large_frame);
6300 PF(Pseudo_SP_Set);
6301 PV(Total_frame_size);
6302#undef PF
6303#undef PV
6304 }
6305
18bd398b 6306 printf ("\n");
57346661
AM
6307}
6308
6309static int
2cf0635d
NC
6310slurp_hppa_unwind_table (FILE * file,
6311 struct hppa_unw_aux_info * aux,
6312 Elf_Internal_Shdr * sec)
57346661 6313{
1c0751b2 6314 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC
6315 Elf_Internal_Phdr * seg;
6316 struct hppa_unw_table_entry * tep;
6317 Elf_Internal_Shdr * relsec;
6318 Elf_Internal_Rela * rela;
6319 Elf_Internal_Rela * rp;
6320 unsigned char * table;
6321 unsigned char * tp;
6322 Elf_Internal_Sym * sym;
6323 const char * relname;
57346661 6324
57346661
AM
6325 /* First, find the starting address of the segment that includes
6326 this section. */
6327
6328 if (elf_header.e_phnum)
6329 {
6330 if (! get_program_headers (file))
6331 return 0;
6332
6333 for (seg = program_headers;
6334 seg < program_headers + elf_header.e_phnum;
6335 ++seg)
6336 {
6337 if (seg->p_type != PT_LOAD)
6338 continue;
6339
6340 if (sec->sh_addr >= seg->p_vaddr
6341 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6342 {
6343 aux->seg_base = seg->p_vaddr;
6344 break;
6345 }
6346 }
6347 }
6348
6349 /* Second, build the unwind table from the contents of the unwind
6350 section. */
6351 size = sec->sh_size;
3f5e193b
NC
6352 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6353 _("unwind table"));
57346661
AM
6354 if (!table)
6355 return 0;
6356
1c0751b2
DA
6357 unw_ent_size = 16;
6358 nentries = size / unw_ent_size;
6359 size = unw_ent_size * nentries;
57346661 6360
3f5e193b
NC
6361 tep = aux->table = (struct hppa_unw_table_entry *)
6362 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 6363
1c0751b2 6364 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM
6365 {
6366 unsigned int tmp1, tmp2;
6367
6368 tep->start.section = SHN_UNDEF;
6369 tep->end.section = SHN_UNDEF;
6370
1c0751b2
DA
6371 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6372 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6373 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6374 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6375
6376 tep->start.offset += aux->seg_base;
6377 tep->end.offset += aux->seg_base;
57346661
AM
6378
6379 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6380 tep->Millicode = (tmp1 >> 30) & 0x1;
6381 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6382 tep->Region_description = (tmp1 >> 27) & 0x3;
6383 tep->reserved1 = (tmp1 >> 26) & 0x1;
6384 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6385 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6386 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6387 tep->Args_stored = (tmp1 >> 15) & 0x1;
6388 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6389 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6390 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6391 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6392 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6393 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6394 tep->cxx_info = (tmp1 >> 8) & 0x1;
6395 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6396 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6397 tep->reserved2 = (tmp1 >> 5) & 0x1;
6398 tep->Save_SP = (tmp1 >> 4) & 0x1;
6399 tep->Save_RP = (tmp1 >> 3) & 0x1;
6400 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6401 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6402 tep->Cleanup_defined = tmp1 & 0x1;
6403
6404 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6405 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6406 tep->Large_frame = (tmp2 >> 29) & 0x1;
6407 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6408 tep->reserved4 = (tmp2 >> 27) & 0x1;
6409 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM
6410 }
6411 free (table);
6412
6413 /* Third, apply any relocations to the unwind table. */
57346661
AM
6414 for (relsec = section_headers;
6415 relsec < section_headers + elf_header.e_shnum;
6416 ++relsec)
6417 {
6418 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM
6419 || relsec->sh_info >= elf_header.e_shnum
6420 || section_headers + relsec->sh_info != sec)
57346661
AM
6421 continue;
6422
6423 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6424 & rela, & nrelas))
6425 return 0;
6426
6427 for (rp = rela; rp < rela + nrelas; ++rp)
6428 {
aca88567
NC
6429 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6430 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM
6431
6432 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 6433 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM
6434 {
6435 warn (_("Skipping unexpected relocation type %s\n"), relname);
6436 continue;
6437 }
6438
6439 i = rp->r_offset / unw_ent_size;
6440
89fac5e3 6441 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM
6442 {
6443 case 0:
6444 aux->table[i].start.section = sym->st_shndx;
1e456d54 6445 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM
6446 break;
6447 case 1:
6448 aux->table[i].end.section = sym->st_shndx;
1e456d54 6449 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM
6450 break;
6451 default:
6452 break;
6453 }
6454 }
6455
6456 free (rela);
6457 }
6458
1c0751b2 6459 aux->table_len = nentries;
57346661
AM
6460
6461 return 1;
6462}
6463
1b31d05e 6464static void
2cf0635d 6465hppa_process_unwind (FILE * file)
57346661 6466{
57346661 6467 struct hppa_unw_aux_info aux;
2cf0635d
NC
6468 Elf_Internal_Shdr * unwsec = NULL;
6469 Elf_Internal_Shdr * strsec;
6470 Elf_Internal_Shdr * sec;
18bd398b 6471 unsigned long i;
57346661 6472
c256ffe7 6473 if (string_table == NULL)
1b31d05e
NC
6474 return;
6475
6476 memset (& aux, 0, sizeof (aux));
57346661
AM
6477
6478 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6479 {
c256ffe7 6480 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6481 && sec->sh_link < elf_header.e_shnum)
57346661 6482 {
ba5cdace 6483 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 6484
4fbb74a6 6485 strsec = section_headers + sec->sh_link;
59245841 6486 assert (aux.strtab == NULL);
3f5e193b
NC
6487 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6488 1, strsec->sh_size,
6489 _("string table"));
c256ffe7 6490 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 6491 }
18bd398b 6492 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM
6493 unwsec = sec;
6494 }
6495
6496 if (!unwsec)
6497 printf (_("\nThere are no unwind sections in this file.\n"));
6498
6499 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6500 {
18bd398b 6501 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 6502 {
57346661
AM
6503 printf (_("\nUnwind section "));
6504 printf (_("'%s'"), SECTION_NAME (sec));
6505
6506 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6507 (unsigned long) sec->sh_offset,
89fac5e3 6508 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM
6509
6510 slurp_hppa_unwind_table (file, &aux, sec);
6511 if (aux.table_len > 0)
6512 dump_hppa_unwind (&aux);
6513
6514 if (aux.table)
6515 free ((char *) aux.table);
6516 aux.table = NULL;
6517 }
6518 }
6519
6520 if (aux.symtab)
6521 free (aux.symtab);
6522 if (aux.strtab)
6523 free ((char *) aux.strtab);
57346661
AM
6524}
6525
0b6ae522
DJ
6526struct arm_section
6527{
a734115a
NC
6528 unsigned char * data; /* The unwind data. */
6529 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
6530 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
6531 unsigned long nrelas; /* The number of relocations. */
6532 unsigned int rel_type; /* REL or RELA ? */
6533 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ
6534};
6535
6536struct arm_unw_aux_info
6537{
a734115a
NC
6538 FILE * file; /* The file containing the unwind sections. */
6539 Elf_Internal_Sym * symtab; /* The file's symbol table. */
6540 unsigned long nsyms; /* Number of symbols. */
6541 char * strtab; /* The file's string table. */
6542 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ
6543};
6544
6545static const char *
6546arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6547 bfd_vma fn, struct absaddr addr)
6548{
6549 const char *procname;
6550 bfd_vma sym_offset;
6551
6552 if (addr.section == SHN_UNDEF)
6553 addr.offset = fn;
6554
6555 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6556 aux->strtab_size, addr, &procname,
6557 &sym_offset);
6558
6559 print_vma (fn, PREFIX_HEX);
6560
6561 if (procname)
6562 {
6563 fputs (" <", stdout);
6564 fputs (procname, stdout);
6565
6566 if (sym_offset)
6567 printf ("+0x%lx", (unsigned long) sym_offset);
6568 fputc ('>', stdout);
6569 }
6570
6571 return procname;
6572}
6573
6574static void
6575arm_free_section (struct arm_section *arm_sec)
6576{
6577 if (arm_sec->data != NULL)
6578 free (arm_sec->data);
6579
6580 if (arm_sec->rela != NULL)
6581 free (arm_sec->rela);
6582}
6583
a734115a
NC
6584/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6585 cached section and install SEC instead.
6586 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6587 and return its valued in * WORDP, relocating if necessary.
1b31d05e 6588 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 6589 relocation's offset in ADDR.
1b31d05e
NC
6590 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6591 into the string table of the symbol associated with the reloc. If no
6592 reloc was applied store -1 there.
6593 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC
6594
6595static bfd_boolean
1b31d05e
NC
6596get_unwind_section_word (struct arm_unw_aux_info * aux,
6597 struct arm_section * arm_sec,
6598 Elf_Internal_Shdr * sec,
6599 bfd_vma word_offset,
6600 unsigned int * wordp,
6601 struct absaddr * addr,
6602 bfd_vma * sym_name)
0b6ae522
DJ
6603{
6604 Elf_Internal_Rela *rp;
6605 Elf_Internal_Sym *sym;
6606 const char * relname;
6607 unsigned int word;
6608 bfd_boolean wrapped;
6609
6610 addr->section = SHN_UNDEF;
6611 addr->offset = 0;
6612
1b31d05e
NC
6613 if (sym_name != NULL)
6614 *sym_name = (bfd_vma) -1;
6615
a734115a 6616 /* If necessary, update the section cache. */
0b6ae522
DJ
6617 if (sec != arm_sec->sec)
6618 {
6619 Elf_Internal_Shdr *relsec;
6620
6621 arm_free_section (arm_sec);
6622
6623 arm_sec->sec = sec;
6624 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6625 sec->sh_size, _("unwind data"));
0b6ae522
DJ
6626 arm_sec->rela = NULL;
6627 arm_sec->nrelas = 0;
6628
6629 for (relsec = section_headers;
6630 relsec < section_headers + elf_header.e_shnum;
6631 ++relsec)
6632 {
6633 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC
6634 || section_headers + relsec->sh_info != sec
6635 /* PR 15745: Check the section type as well. */
6636 || (relsec->sh_type != SHT_REL
6637 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ
6638 continue;
6639
a734115a 6640 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ
6641 if (relsec->sh_type == SHT_REL)
6642 {
6643 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6644 relsec->sh_size,
6645 & arm_sec->rela, & arm_sec->nrelas))
a734115a 6646 return FALSE;
0b6ae522 6647 }
1ae40aa4 6648 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ
6649 {
6650 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6651 relsec->sh_size,
6652 & arm_sec->rela, & arm_sec->nrelas))
a734115a 6653 return FALSE;
0b6ae522 6654 }
1ae40aa4 6655 break;
0b6ae522
DJ
6656 }
6657
6658 arm_sec->next_rela = arm_sec->rela;
6659 }
6660
a734115a 6661 /* If there is no unwind data we can do nothing. */
0b6ae522 6662 if (arm_sec->data == NULL)
a734115a 6663 return FALSE;
0b6ae522 6664
a734115a 6665 /* Get the word at the required offset. */
0b6ae522
DJ
6666 word = byte_get (arm_sec->data + word_offset, 4);
6667
a734115a 6668 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ
6669 wrapped = FALSE;
6670 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6671 {
6672 bfd_vma prelval, offset;
6673
6674 if (rp->r_offset > word_offset && !wrapped)
6675 {
6676 rp = arm_sec->rela;
6677 wrapped = TRUE;
6678 }
6679 if (rp->r_offset > word_offset)
6680 break;
6681
6682 if (rp->r_offset & 3)
6683 {
6684 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6685 (unsigned long) rp->r_offset);
6686 continue;
6687 }
6688
6689 if (rp->r_offset < word_offset)
6690 continue;
6691
0b6ae522
DJ
6692 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6693
6694 if (arm_sec->rel_type == SHT_REL)
6695 {
6696 offset = word & 0x7fffffff;
6697 if (offset & 0x40000000)
6698 offset |= ~ (bfd_vma) 0x7fffffff;
6699 }
a734115a 6700 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 6701 offset = rp->r_addend;
a734115a
NC
6702 else
6703 abort ();
0b6ae522
DJ
6704
6705 offset += sym->st_value;
6706 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6707
a734115a
NC
6708 /* Check that we are processing the expected reloc type. */
6709 if (elf_header.e_machine == EM_ARM)
6710 {
6711 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6712
6713 if (streq (relname, "R_ARM_NONE"))
6714 continue;
6715
6716 if (! streq (relname, "R_ARM_PREL31"))
6717 {
6718 warn (_("Skipping unexpected relocation type %s\n"), relname);
6719 continue;
6720 }
6721 }
6722 else if (elf_header.e_machine == EM_TI_C6000)
6723 {
6724 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6725
6726 if (streq (relname, "R_C6000_NONE"))
6727 continue;
6728
6729 if (! streq (relname, "R_C6000_PREL31"))
6730 {
6731 warn (_("Skipping unexpected relocation type %s\n"), relname);
6732 continue;
6733 }
6734
6735 prelval >>= 1;
6736 }
6737 else
6738 /* This function currently only supports ARM and TI unwinders. */
6739 abort ();
fa197c1c 6740
0b6ae522
DJ
6741 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6742 addr->section = sym->st_shndx;
6743 addr->offset = offset;
1b31d05e
NC
6744 if (sym_name)
6745 * sym_name = sym->st_name;
0b6ae522
DJ
6746 break;
6747 }
6748
6749 *wordp = word;
6750 arm_sec->next_rela = rp;
6751
a734115a 6752 return TRUE;
0b6ae522
DJ
6753}
6754
a734115a
NC
6755static const char *tic6x_unwind_regnames[16] =
6756{
6757 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6758 "A14", "A13", "A12", "A11", "A10",
6759 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6760};
fa197c1c 6761
0b6ae522 6762static void
fa197c1c 6763decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 6764{
fa197c1c
PB
6765 int i;
6766
6767 for (i = 12; mask; mask >>= 1, i--)
6768 {
6769 if (mask & 1)
6770 {
6771 fputs (tic6x_unwind_regnames[i], stdout);
6772 if (mask > 1)
6773 fputs (", ", stdout);
6774 }
6775 }
6776}
0b6ae522
DJ
6777
6778#define ADVANCE \
6779 if (remaining == 0 && more_words) \
6780 { \
6781 data_offset += 4; \
1b31d05e
NC
6782 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
6783 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ
6784 return; \
6785 remaining = 4; \
6786 more_words--; \
6787 } \
6788
6789#define GET_OP(OP) \
6790 ADVANCE; \
6791 if (remaining) \
6792 { \
6793 remaining--; \
6794 (OP) = word >> 24; \
6795 word <<= 8; \
6796 } \
6797 else \
6798 { \
2b692964 6799 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ
6800 return; \
6801 } \
cc5914eb 6802 printf ("0x%02x ", OP)
0b6ae522 6803
fa197c1c
PB
6804static void
6805decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
6806 unsigned int word, unsigned int remaining,
6807 unsigned int more_words,
6808 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6809 struct arm_section *data_arm_sec)
6810{
6811 struct absaddr addr;
0b6ae522
DJ
6812
6813 /* Decode the unwinding instructions. */
6814 while (1)
6815 {
6816 unsigned int op, op2;
6817
6818 ADVANCE;
6819 if (remaining == 0)
6820 break;
6821 remaining--;
6822 op = word >> 24;
6823 word <<= 8;
6824
cc5914eb 6825 printf (" 0x%02x ", op);
0b6ae522
DJ
6826
6827 if ((op & 0xc0) == 0x00)
6828 {
6829 int offset = ((op & 0x3f) << 2) + 4;
61865e30 6830
cc5914eb 6831 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ
6832 }
6833 else if ((op & 0xc0) == 0x40)
6834 {
6835 int offset = ((op & 0x3f) << 2) + 4;
61865e30 6836
cc5914eb 6837 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ
6838 }
6839 else if ((op & 0xf0) == 0x80)
6840 {
6841 GET_OP (op2);
6842 if (op == 0x80 && op2 == 0)
6843 printf (_("Refuse to unwind"));
6844 else
6845 {
6846 unsigned int mask = ((op & 0x0f) << 8) | op2;
6847 int first = 1;
6848 int i;
2b692964 6849
0b6ae522
DJ
6850 printf ("pop {");
6851 for (i = 0; i < 12; i++)
6852 if (mask & (1 << i))
6853 {
6854 if (first)
6855 first = 0;
6856 else
6857 printf (", ");
6858 printf ("r%d", 4 + i);
6859 }
6860 printf ("}");
6861 }
6862 }
6863 else if ((op & 0xf0) == 0x90)
6864 {
6865 if (op == 0x9d || op == 0x9f)
6866 printf (_(" [Reserved]"));
6867 else
cc5914eb 6868 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ
6869 }
6870 else if ((op & 0xf0) == 0xa0)
6871 {
6872 int end = 4 + (op & 0x07);
6873 int first = 1;
6874 int i;
61865e30 6875
0b6ae522
DJ
6876 printf (" pop {");
6877 for (i = 4; i <= end; i++)
6878 {
6879 if (first)
6880 first = 0;
6881 else
6882 printf (", ");
6883 printf ("r%d", i);
6884 }
6885 if (op & 0x08)
6886 {
1b31d05e 6887 if (!first)
0b6ae522
DJ
6888 printf (", ");
6889 printf ("r14");
6890 }
6891 printf ("}");
6892 }
6893 else if (op == 0xb0)
6894 printf (_(" finish"));
6895 else if (op == 0xb1)
6896 {
6897 GET_OP (op2);
6898 if (op2 == 0 || (op2 & 0xf0) != 0)
6899 printf (_("[Spare]"));
6900 else
6901 {
6902 unsigned int mask = op2 & 0x0f;
6903 int first = 1;
6904 int i;
61865e30 6905
0b6ae522
DJ
6906 printf ("pop {");
6907 for (i = 0; i < 12; i++)
6908 if (mask & (1 << i))
6909 {
6910 if (first)
6911 first = 0;
6912 else
6913 printf (", ");
6914 printf ("r%d", i);
6915 }
6916 printf ("}");
6917 }
6918 }
6919 else if (op == 0xb2)
6920 {
b115cf96 6921 unsigned char buf[9];
0b6ae522
DJ
6922 unsigned int i, len;
6923 unsigned long offset;
61865e30 6924
b115cf96 6925 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ
6926 {
6927 GET_OP (buf[i]);
6928 if ((buf[i] & 0x80) == 0)
6929 break;
6930 }
6931 assert (i < sizeof (buf));
f6f0e17b 6932 offset = read_uleb128 (buf, &len, buf + i + 1);
0b6ae522
DJ
6933 assert (len == i + 1);
6934 offset = offset * 4 + 0x204;
cc5914eb 6935 printf ("vsp = vsp + %ld", offset);
0b6ae522 6936 }
61865e30 6937 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 6938 {
61865e30
NC
6939 unsigned int first, last;
6940
6941 GET_OP (op2);
6942 first = op2 >> 4;
6943 last = op2 & 0x0f;
6944 if (op == 0xc8)
6945 first = first + 16;
6946 printf ("pop {D%d", first);
6947 if (last)
6948 printf ("-D%d", first + last);
6949 printf ("}");
6950 }
6951 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
6952 {
6953 unsigned int count = op & 0x07;
6954
6955 printf ("pop {D8");
6956 if (count)
6957 printf ("-D%d", 8 + count);
6958 printf ("}");
6959 }
6960 else if (op >= 0xc0 && op <= 0xc5)
6961 {
6962 unsigned int count = op & 0x07;
6963
6964 printf (" pop {wR10");
6965 if (count)
6966 printf ("-wR%d", 10 + count);
6967 printf ("}");
6968 }
6969 else if (op == 0xc6)
6970 {
6971 unsigned int first, last;
6972
6973 GET_OP (op2);
6974 first = op2 >> 4;
6975 last = op2 & 0x0f;
6976 printf ("pop {wR%d", first);
6977 if (last)
6978 printf ("-wR%d", first + last);
6979 printf ("}");
6980 }
6981 else if (op == 0xc7)
6982 {
6983 GET_OP (op2);
6984 if (op2 == 0 || (op2 & 0xf0) != 0)
6985 printf (_("[Spare]"));
0b6ae522
DJ
6986 else
6987 {
61865e30
NC
6988 unsigned int mask = op2 & 0x0f;
6989 int first = 1;
6990 int i;
6991
6992 printf ("pop {");
6993 for (i = 0; i < 4; i++)
6994 if (mask & (1 << i))
6995 {
6996 if (first)
6997 first = 0;
6998 else
6999 printf (", ");
7000 printf ("wCGR%d", i);
7001 }
7002 printf ("}");
0b6ae522
DJ
7003 }
7004 }
61865e30
NC
7005 else
7006 printf (_(" [unsupported opcode]"));
0b6ae522
DJ
7007 printf ("\n");
7008 }
fa197c1c
PB
7009}
7010
7011static void
7012decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
7013 unsigned int word, unsigned int remaining,
7014 unsigned int more_words,
7015 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7016 struct arm_section *data_arm_sec)
7017{
7018 struct absaddr addr;
7019
7020 /* Decode the unwinding instructions. */
7021 while (1)
7022 {
7023 unsigned int op, op2;
7024
7025 ADVANCE;
7026 if (remaining == 0)
7027 break;
7028 remaining--;
7029 op = word >> 24;
7030 word <<= 8;
7031
9cf03b7e 7032 printf (" 0x%02x ", op);
fa197c1c
PB
7033
7034 if ((op & 0xc0) == 0x00)
7035 {
7036 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 7037 printf (" sp = sp + %d", offset);
fa197c1c
PB
7038 }
7039 else if ((op & 0xc0) == 0x80)
7040 {
7041 GET_OP (op2);
7042 if (op == 0x80 && op2 == 0)
7043 printf (_("Refuse to unwind"));
7044 else
7045 {
7046 unsigned int mask = ((op & 0x1f) << 8) | op2;
7047 if (op & 0x20)
7048 printf ("pop compact {");
7049 else
7050 printf ("pop {");
7051
7052 decode_tic6x_unwind_regmask (mask);
7053 printf("}");
7054 }
7055 }
7056 else if ((op & 0xf0) == 0xc0)
7057 {
7058 unsigned int reg;
7059 unsigned int nregs;
7060 unsigned int i;
7061 const char *name;
a734115a
NC
7062 struct
7063 {
fa197c1c
PB
7064 unsigned int offset;
7065 unsigned int reg;
7066 } regpos[16];
7067
7068 /* Scan entire instruction first so that GET_OP output is not
7069 interleaved with disassembly. */
7070 nregs = 0;
7071 for (i = 0; nregs < (op & 0xf); i++)
7072 {
7073 GET_OP (op2);
7074 reg = op2 >> 4;
7075 if (reg != 0xf)
7076 {
7077 regpos[nregs].offset = i * 2;
7078 regpos[nregs].reg = reg;
7079 nregs++;
7080 }
7081
7082 reg = op2 & 0xf;
7083 if (reg != 0xf)
7084 {
7085 regpos[nregs].offset = i * 2 + 1;
7086 regpos[nregs].reg = reg;
7087 nregs++;
7088 }
7089 }
7090
7091 printf (_("pop frame {"));
7092 reg = nregs - 1;
7093 for (i = i * 2; i > 0; i--)
7094 {
7095 if (regpos[reg].offset == i - 1)
7096 {
7097 name = tic6x_unwind_regnames[regpos[reg].reg];
7098 if (reg > 0)
7099 reg--;
7100 }
7101 else
7102 name = _("[pad]");
7103
7104 fputs (name, stdout);
7105 if (i > 1)
7106 printf (", ");
7107 }
7108
7109 printf ("}");
7110 }
7111 else if (op == 0xd0)
7112 printf (" MOV FP, SP");
7113 else if (op == 0xd1)
7114 printf (" __c6xabi_pop_rts");
7115 else if (op == 0xd2)
7116 {
7117 unsigned char buf[9];
7118 unsigned int i, len;
7119 unsigned long offset;
a734115a 7120
fa197c1c
PB
7121 for (i = 0; i < sizeof (buf); i++)
7122 {
7123 GET_OP (buf[i]);
7124 if ((buf[i] & 0x80) == 0)
7125 break;
7126 }
7127 assert (i < sizeof (buf));
f6f0e17b 7128 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB
7129 assert (len == i + 1);
7130 offset = offset * 8 + 0x408;
7131 printf (_("sp = sp + %ld"), offset);
7132 }
7133 else if ((op & 0xf0) == 0xe0)
7134 {
7135 if ((op & 0x0f) == 7)
7136 printf (" RETURN");
7137 else
7138 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7139 }
7140 else
7141 {
7142 printf (_(" [unsupported opcode]"));
7143 }
7144 putchar ('\n');
7145 }
7146}
7147
7148static bfd_vma
a734115a 7149arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB
7150{
7151 bfd_vma offset;
7152
7153 offset = word & 0x7fffffff;
7154 if (offset & 0x40000000)
7155 offset |= ~ (bfd_vma) 0x7fffffff;
7156
7157 if (elf_header.e_machine == EM_TI_C6000)
7158 offset <<= 1;
7159
7160 return offset + where;
7161}
7162
7163static void
1b31d05e
NC
7164decode_arm_unwind (struct arm_unw_aux_info * aux,
7165 unsigned int word,
7166 unsigned int remaining,
7167 bfd_vma data_offset,
7168 Elf_Internal_Shdr * data_sec,
7169 struct arm_section * data_arm_sec)
fa197c1c
PB
7170{
7171 int per_index;
7172 unsigned int more_words = 0;
7173 struct absaddr addr;
1b31d05e 7174 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB
7175
7176 if (remaining == 0)
7177 {
1b31d05e
NC
7178 /* Fetch the first word.
7179 Note - when decoding an object file the address extracted
7180 here will always be 0. So we also pass in the sym_name
7181 parameter so that we can find the symbol associated with
7182 the personality routine. */
7183 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7184 & word, & addr, & sym_name))
fa197c1c 7185 return;
1b31d05e 7186
fa197c1c
PB
7187 remaining = 4;
7188 }
7189
7190 if ((word & 0x80000000) == 0)
7191 {
7192 /* Expand prel31 for personality routine. */
7193 bfd_vma fn;
7194 const char *procname;
7195
a734115a 7196 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 7197 printf (_(" Personality routine: "));
1b31d05e
NC
7198 if (fn == 0
7199 && addr.section == SHN_UNDEF && addr.offset == 0
7200 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7201 {
7202 procname = aux->strtab + sym_name;
7203 print_vma (fn, PREFIX_HEX);
7204 if (procname)
7205 {
7206 fputs (" <", stdout);
7207 fputs (procname, stdout);
7208 fputc ('>', stdout);
7209 }
7210 }
7211 else
7212 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB
7213 fputc ('\n', stdout);
7214
7215 /* The GCC personality routines use the standard compact
7216 encoding, starting with one byte giving the number of
7217 words. */
7218 if (procname != NULL
7219 && (const_strneq (procname, "__gcc_personality_v0")
7220 || const_strneq (procname, "__gxx_personality_v0")
7221 || const_strneq (procname, "__gcj_personality_v0")
7222 || const_strneq (procname, "__gnu_objc_personality_v0")))
7223 {
7224 remaining = 0;
7225 more_words = 1;
7226 ADVANCE;
7227 if (!remaining)
7228 {
7229 printf (_(" [Truncated data]\n"));
7230 return;
7231 }
7232 more_words = word >> 24;
7233 word <<= 8;
7234 remaining--;
7235 per_index = -1;
7236 }
7237 else
7238 return;
7239 }
7240 else
7241 {
1b31d05e
NC
7242 /* ARM EHABI Section 6.3:
7243
7244 An exception-handling table entry for the compact model looks like:
7245
7246 31 30-28 27-24 23-0
7247 -- ----- ----- ----
7248 1 0 index Data for personalityRoutine[index] */
7249
7250 if (elf_header.e_machine == EM_ARM
7251 && (word & 0x70000000))
83c257ca 7252 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 7253
fa197c1c 7254 per_index = (word >> 24) & 0x7f;
1b31d05e 7255 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB
7256 if (per_index == 0)
7257 {
7258 more_words = 0;
7259 word <<= 8;
7260 remaining--;
7261 }
7262 else if (per_index < 3)
7263 {
7264 more_words = (word >> 16) & 0xff;
7265 word <<= 16;
7266 remaining -= 2;
7267 }
7268 }
7269
7270 switch (elf_header.e_machine)
7271 {
7272 case EM_ARM:
7273 if (per_index < 3)
7274 {
7275 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7276 data_offset, data_sec, data_arm_sec);
7277 }
7278 else
1b31d05e
NC
7279 {
7280 warn (_("Unknown ARM compact model index encountered\n"));
7281 printf (_(" [reserved]\n"));
7282 }
fa197c1c
PB
7283 break;
7284
7285 case EM_TI_C6000:
7286 if (per_index < 3)
7287 {
7288 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 7289 data_offset, data_sec, data_arm_sec);
fa197c1c
PB
7290 }
7291 else if (per_index < 5)
7292 {
7293 if (((word >> 17) & 0x7f) == 0x7f)
7294 printf (_(" Restore stack from frame pointer\n"));
7295 else
7296 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
7297 printf (_(" Registers restored: "));
7298 if (per_index == 4)
7299 printf (" (compact) ");
7300 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7301 putchar ('\n');
7302 printf (_(" Return register: %s\n"),
7303 tic6x_unwind_regnames[word & 0xf]);
7304 }
7305 else
1b31d05e 7306 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB
7307 break;
7308
7309 default:
1b31d05e
NC
7310 error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7311 elf_header.e_machine);
fa197c1c 7312 }
0b6ae522
DJ
7313
7314 /* Decode the descriptors. Not implemented. */
7315}
7316
7317static void
7318dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7319{
7320 struct arm_section exidx_arm_sec, extab_arm_sec;
7321 unsigned int i, exidx_len;
7322
7323 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7324 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7325 exidx_len = exidx_sec->sh_size / 8;
7326
7327 for (i = 0; i < exidx_len; i++)
7328 {
7329 unsigned int exidx_fn, exidx_entry;
7330 struct absaddr fn_addr, entry_addr;
7331 bfd_vma fn;
7332
7333 fputc ('\n', stdout);
7334
1b31d05e
NC
7335 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7336 8 * i, & exidx_fn, & fn_addr, NULL)
7337 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7338 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 7339 {
1b31d05e
NC
7340 arm_free_section (& exidx_arm_sec);
7341 arm_free_section (& extab_arm_sec);
0b6ae522
DJ
7342 return;
7343 }
7344
83c257ca
NC
7345 /* ARM EHABI, Section 5:
7346 An index table entry consists of 2 words.
7347 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7348 if (exidx_fn & 0x80000000)
7349 warn (_("corrupt index table entry: %x\n"), exidx_fn);
7350
a734115a 7351 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 7352
a734115a 7353 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ
7354 fputs (": ", stdout);
7355
7356 if (exidx_entry == 1)
7357 {
7358 print_vma (exidx_entry, PREFIX_HEX);
7359 fputs (" [cantunwind]\n", stdout);
7360 }
7361 else if (exidx_entry & 0x80000000)
7362 {
7363 print_vma (exidx_entry, PREFIX_HEX);
7364 fputc ('\n', stdout);
7365 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7366 }
7367 else
7368 {
8f73510c 7369 bfd_vma table, table_offset = 0;
0b6ae522
DJ
7370 Elf_Internal_Shdr *table_sec;
7371
7372 fputs ("@", stdout);
a734115a 7373 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ
7374 print_vma (table, PREFIX_HEX);
7375 printf ("\n");
7376
7377 /* Locate the matching .ARM.extab. */
7378 if (entry_addr.section != SHN_UNDEF
7379 && entry_addr.section < elf_header.e_shnum)
7380 {
7381 table_sec = section_headers + entry_addr.section;
7382 table_offset = entry_addr.offset;
7383 }
7384 else
7385 {
7386 table_sec = find_section_by_address (table);
7387 if (table_sec != NULL)
7388 table_offset = table - table_sec->sh_addr;
7389 }
7390 if (table_sec == NULL)
7391 {
7392 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7393 (unsigned long) table);
7394 continue;
7395 }
7396 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7397 &extab_arm_sec);
7398 }
7399 }
7400
7401 printf ("\n");
7402
7403 arm_free_section (&exidx_arm_sec);
7404 arm_free_section (&extab_arm_sec);
7405}
7406
fa197c1c 7407/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC
7408
7409static void
0b6ae522
DJ
7410arm_process_unwind (FILE *file)
7411{
7412 struct arm_unw_aux_info aux;
7413 Elf_Internal_Shdr *unwsec = NULL;
7414 Elf_Internal_Shdr *strsec;
7415 Elf_Internal_Shdr *sec;
7416 unsigned long i;
fa197c1c 7417 unsigned int sec_type;
0b6ae522 7418
fa197c1c
PB
7419 switch (elf_header.e_machine)
7420 {
7421 case EM_ARM:
7422 sec_type = SHT_ARM_EXIDX;
7423 break;
7424
7425 case EM_TI_C6000:
7426 sec_type = SHT_C6000_UNWIND;
7427 break;
7428
1b31d05e
NC
7429 default:
7430 error (_("Unsupported architecture type %d encountered when processing unwind table"),
7431 elf_header.e_machine);
7432 return;
fa197c1c
PB
7433 }
7434
0b6ae522 7435 if (string_table == NULL)
1b31d05e
NC
7436 return;
7437
7438 memset (& aux, 0, sizeof (aux));
7439 aux.file = file;
0b6ae522
DJ
7440
7441 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7442 {
7443 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7444 {
ba5cdace 7445 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ
7446
7447 strsec = section_headers + sec->sh_link;
59245841 7448 assert (aux.strtab == NULL);
0b6ae522
DJ
7449 aux.strtab = get_data (NULL, file, strsec->sh_offset,
7450 1, strsec->sh_size, _("string table"));
7451 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7452 }
fa197c1c 7453 else if (sec->sh_type == sec_type)
0b6ae522
DJ
7454 unwsec = sec;
7455 }
7456
1b31d05e 7457 if (unwsec == NULL)
0b6ae522 7458 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC
7459 else
7460 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7461 {
7462 if (sec->sh_type == sec_type)
7463 {
7464 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7465 SECTION_NAME (sec),
7466 (unsigned long) sec->sh_offset,
7467 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 7468
1b31d05e
NC
7469 dump_arm_unwind (&aux, sec);
7470 }
7471 }
0b6ae522
DJ
7472
7473 if (aux.symtab)
7474 free (aux.symtab);
7475 if (aux.strtab)
7476 free ((char *) aux.strtab);
0b6ae522
DJ
7477}
7478
1b31d05e 7479static void
2cf0635d 7480process_unwind (FILE * file)
57346661 7481{
2cf0635d
NC
7482 struct unwind_handler
7483 {
57346661 7484 int machtype;
1b31d05e 7485 void (* handler)(FILE *);
2cf0635d
NC
7486 } handlers[] =
7487 {
0b6ae522 7488 { EM_ARM, arm_process_unwind },
57346661
AM
7489 { EM_IA_64, ia64_process_unwind },
7490 { EM_PARISC, hppa_process_unwind },
fa197c1c 7491 { EM_TI_C6000, arm_process_unwind },
57346661
AM
7492 { 0, 0 }
7493 };
7494 int i;
7495
7496 if (!do_unwind)
1b31d05e 7497 return;
57346661
AM
7498
7499 for (i = 0; handlers[i].handler != NULL; i++)
7500 if (elf_header.e_machine == handlers[i].machtype)
9f758fdc
NC
7501 {
7502 handlers[i].handler (file);
7503 return;
7504 }
57346661 7505
1b31d05e
NC
7506 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7507 get_machine_name (elf_header.e_machine));
57346661
AM
7508}
7509
252b5132 7510static void
2cf0635d 7511dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH
7512{
7513 switch (entry->d_tag)
7514 {
7515 case DT_MIPS_FLAGS:
7516 if (entry->d_un.d_val == 0)
4b68bca3 7517 printf (_("NONE"));
252b5132
RH
7518 else
7519 {
7520 static const char * opts[] =
7521 {
7522 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7523 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7524 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7525 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7526 "RLD_ORDER_SAFE"
7527 };
7528 unsigned int cnt;
7529 int first = 1;
2b692964 7530
60bca95a 7531 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH
7532 if (entry->d_un.d_val & (1 << cnt))
7533 {
7534 printf ("%s%s", first ? "" : " ", opts[cnt]);
7535 first = 0;
7536 }
252b5132
RH
7537 }
7538 break;
103f02d3 7539
252b5132 7540 case DT_MIPS_IVERSION:
d79b3d50 7541 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 7542 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 7543 else
4b68bca3 7544 printf (_("<corrupt: %" BFD_VMA_FMT "d>"), entry->d_un.d_ptr);
252b5132 7545 break;
103f02d3 7546
252b5132
RH
7547 case DT_MIPS_TIME_STAMP:
7548 {
7549 char timebuf[20];
2cf0635d 7550 struct tm * tmp;
50da7a9c 7551
91d6fa6a
NC
7552 time_t atime = entry->d_un.d_val;
7553 tmp = gmtime (&atime);
e9e44622
JJ
7554 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7555 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7556 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 7557 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH
7558 }
7559 break;
103f02d3 7560
252b5132
RH
7561 case DT_MIPS_RLD_VERSION:
7562 case DT_MIPS_LOCAL_GOTNO:
7563 case DT_MIPS_CONFLICTNO:
7564 case DT_MIPS_LIBLISTNO:
7565 case DT_MIPS_SYMTABNO:
7566 case DT_MIPS_UNREFEXTNO:
7567 case DT_MIPS_HIPAGENO:
7568 case DT_MIPS_DELTA_CLASS_NO:
7569 case DT_MIPS_DELTA_INSTANCE_NO:
7570 case DT_MIPS_DELTA_RELOC_NO:
7571 case DT_MIPS_DELTA_SYM_NO:
7572 case DT_MIPS_DELTA_CLASSSYM_NO:
7573 case DT_MIPS_COMPACT_SIZE:
4b68bca3 7574 print_vma (entry->d_un.d_ptr, DEC);
252b5132 7575 break;
103f02d3
UD
7576
7577 default:
4b68bca3 7578 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 7579 }
4b68bca3 7580 putchar ('\n');
103f02d3
UD
7581}
7582
103f02d3 7583static void
2cf0635d 7584dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD
7585{
7586 switch (entry->d_tag)
7587 {
7588 case DT_HP_DLD_FLAGS:
7589 {
7590 static struct
7591 {
7592 long int bit;
2cf0635d 7593 const char * str;
5e220199
NC
7594 }
7595 flags[] =
7596 {
7597 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7598 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7599 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7600 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7601 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7602 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7603 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7604 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7605 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7606 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA
7607 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7608 { DT_HP_GST, "HP_GST" },
7609 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7610 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7611 { DT_HP_NODELETE, "HP_NODELETE" },
7612 { DT_HP_GROUP, "HP_GROUP" },
7613 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 7614 };
103f02d3 7615 int first = 1;
5e220199 7616 size_t cnt;
f7a99963 7617 bfd_vma val = entry->d_un.d_val;
103f02d3 7618
60bca95a 7619 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 7620 if (val & flags[cnt].bit)
30800947
NC
7621 {
7622 if (! first)
7623 putchar (' ');
7624 fputs (flags[cnt].str, stdout);
7625 first = 0;
7626 val ^= flags[cnt].bit;
7627 }
76da6bbe 7628
103f02d3 7629 if (val != 0 || first)
f7a99963
NC
7630 {
7631 if (! first)
7632 putchar (' ');
7633 print_vma (val, HEX);
7634 }
103f02d3
UD
7635 }
7636 break;
76da6bbe 7637
252b5132 7638 default:
f7a99963
NC
7639 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7640 break;
252b5132 7641 }
35b1837e 7642 putchar ('\n');
252b5132
RH
7643}
7644
28f997cf
TG
7645#ifdef BFD64
7646
7647/* VMS vs Unix time offset and factor. */
7648
7649#define VMS_EPOCH_OFFSET 35067168000000000LL
7650#define VMS_GRANULARITY_FACTOR 10000000
7651
7652/* Display a VMS time in a human readable format. */
7653
7654static void
7655print_vms_time (bfd_int64_t vmstime)
7656{
7657 struct tm *tm;
7658 time_t unxtime;
7659
7660 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7661 tm = gmtime (&unxtime);
7662 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7663 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7664 tm->tm_hour, tm->tm_min, tm->tm_sec);
7665}
7666#endif /* BFD64 */
7667
ecc51f48 7668static void
2cf0635d 7669dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC
7670{
7671 switch (entry->d_tag)
7672 {
0de14b54 7673 case DT_IA_64_PLT_RESERVE:
bdf4d63a 7674 /* First 3 slots reserved. */
ecc51f48
NC
7675 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7676 printf (" -- ");
7677 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ
7678 break;
7679
28f997cf
TG
7680 case DT_IA_64_VMS_LINKTIME:
7681#ifdef BFD64
7682 print_vms_time (entry->d_un.d_val);
7683#endif
7684 break;
7685
7686 case DT_IA_64_VMS_LNKFLAGS:
7687 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7688 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7689 printf (" CALL_DEBUG");
7690 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7691 printf (" NOP0BUFS");
7692 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7693 printf (" P0IMAGE");
7694 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7695 printf (" MKTHREADS");
7696 if (entry->d_un.d_val & VMS_LF_UPCALLS)
7697 printf (" UPCALLS");
7698 if (entry->d_un.d_val & VMS_LF_IMGSTA)
7699 printf (" IMGSTA");
7700 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7701 printf (" INITIALIZE");
7702 if (entry->d_un.d_val & VMS_LF_MAIN)
7703 printf (" MAIN");
7704 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7705 printf (" EXE_INIT");
7706 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7707 printf (" TBK_IN_IMG");
7708 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7709 printf (" DBG_IN_IMG");
7710 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7711 printf (" TBK_IN_DSF");
7712 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7713 printf (" DBG_IN_DSF");
7714 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7715 printf (" SIGNATURES");
7716 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7717 printf (" REL_SEG_OFF");
7718 break;
7719
bdf4d63a
JJ
7720 default:
7721 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7722 break;
ecc51f48 7723 }
bdf4d63a 7724 putchar ('\n');
ecc51f48
NC
7725}
7726
252b5132 7727static int
2cf0635d 7728get_32bit_dynamic_section (FILE * file)
252b5132 7729{
2cf0635d
NC
7730 Elf32_External_Dyn * edyn;
7731 Elf32_External_Dyn * ext;
7732 Elf_Internal_Dyn * entry;
103f02d3 7733
3f5e193b
NC
7734 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7735 dynamic_size, _("dynamic section"));
a6e9f9df
AM
7736 if (!edyn)
7737 return 0;
103f02d3 7738
ba2685cc
AM
7739/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7740 might not have the luxury of section headers. Look for the DT_NULL
7741 terminator to determine the number of entries. */
7742 for (ext = edyn, dynamic_nent = 0;
7743 (char *) ext < (char *) edyn + dynamic_size;
7744 ext++)
7745 {
7746 dynamic_nent++;
7747 if (BYTE_GET (ext->d_tag) == DT_NULL)
7748 break;
7749 }
252b5132 7750
3f5e193b
NC
7751 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7752 sizeof (* entry));
b2d38a17 7753 if (dynamic_section == NULL)
252b5132 7754 {
9ea033b2
NC
7755 error (_("Out of memory\n"));
7756 free (edyn);
7757 return 0;
7758 }
252b5132 7759
fb514b26 7760 for (ext = edyn, entry = dynamic_section;
ba2685cc 7761 entry < dynamic_section + dynamic_nent;
fb514b26 7762 ext++, entry++)
9ea033b2 7763 {
fb514b26
AM
7764 entry->d_tag = BYTE_GET (ext->d_tag);
7765 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH
7766 }
7767
9ea033b2
NC
7768 free (edyn);
7769
7770 return 1;
7771}
7772
7773static int
2cf0635d 7774get_64bit_dynamic_section (FILE * file)
9ea033b2 7775{
2cf0635d
NC
7776 Elf64_External_Dyn * edyn;
7777 Elf64_External_Dyn * ext;
7778 Elf_Internal_Dyn * entry;
103f02d3 7779
3f5e193b
NC
7780 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7781 dynamic_size, _("dynamic section"));
a6e9f9df
AM
7782 if (!edyn)
7783 return 0;
103f02d3 7784
ba2685cc
AM
7785/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7786 might not have the luxury of section headers. Look for the DT_NULL
7787 terminator to determine the number of entries. */
7788 for (ext = edyn, dynamic_nent = 0;
7789 (char *) ext < (char *) edyn + dynamic_size;
7790 ext++)
7791 {
7792 dynamic_nent++;
66543521 7793 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM
7794 break;
7795 }
252b5132 7796
3f5e193b
NC
7797 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7798 sizeof (* entry));
b2d38a17 7799 if (dynamic_section == NULL)
252b5132
RH
7800 {
7801 error (_("Out of memory\n"));
7802 free (edyn);
7803 return 0;
7804 }
7805
fb514b26 7806 for (ext = edyn, entry = dynamic_section;
ba2685cc 7807 entry < dynamic_section + dynamic_nent;
fb514b26 7808 ext++, entry++)
252b5132 7809 {
66543521
AM
7810 entry->d_tag = BYTE_GET (ext->d_tag);
7811 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH
7812 }
7813
7814 free (edyn);
7815
9ea033b2
NC
7816 return 1;
7817}
7818
e9e44622
JJ
7819static void
7820print_dynamic_flags (bfd_vma flags)
d1133906 7821{
e9e44622 7822 int first = 1;
13ae64f3 7823
d1133906
NC
7824 while (flags)
7825 {
7826 bfd_vma flag;
7827
7828 flag = flags & - flags;
7829 flags &= ~ flag;
7830
e9e44622
JJ
7831 if (first)
7832 first = 0;
7833 else
7834 putc (' ', stdout);
13ae64f3 7835
d1133906
NC
7836 switch (flag)
7837 {
e9e44622
JJ
7838 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
7839 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
7840 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
7841 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
7842 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 7843 default: fputs (_("unknown"), stdout); break;
d1133906
NC
7844 }
7845 }
e9e44622 7846 puts ("");
d1133906
NC
7847}
7848
b2d38a17
NC
7849/* Parse and display the contents of the dynamic section. */
7850
9ea033b2 7851static int
2cf0635d 7852process_dynamic_section (FILE * file)
9ea033b2 7853{
2cf0635d 7854 Elf_Internal_Dyn * entry;
9ea033b2
NC
7855
7856 if (dynamic_size == 0)
7857 {
7858 if (do_dynamic)
b2d38a17 7859 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC
7860
7861 return 1;
7862 }
7863
7864 if (is_32bit_elf)
7865 {
b2d38a17 7866 if (! get_32bit_dynamic_section (file))
9ea033b2
NC
7867 return 0;
7868 }
b2d38a17 7869 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC
7870 return 0;
7871
252b5132
RH
7872 /* Find the appropriate symbol table. */
7873 if (dynamic_symbols == NULL)
7874 {
86dba8ee
AM
7875 for (entry = dynamic_section;
7876 entry < dynamic_section + dynamic_nent;
7877 ++entry)
252b5132 7878 {
c8286bd1 7879 Elf_Internal_Shdr section;
252b5132
RH
7880
7881 if (entry->d_tag != DT_SYMTAB)
7882 continue;
7883
7884 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7885
7886 /* Since we do not know how big the symbol table is,
7887 we default to reading in the entire file (!) and
7888 processing that. This is overkill, I know, but it
e3c8793a 7889 should work. */
d93f0186 7890 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 7891
fb52b2f4
NC
7892 if (archive_file_offset != 0)
7893 section.sh_size = archive_file_size - section.sh_offset;
7894 else
7895 {
7896 if (fseek (file, 0, SEEK_END))
591a748a 7897 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC
7898
7899 section.sh_size = ftell (file) - section.sh_offset;
7900 }
252b5132 7901
9ea033b2 7902 if (is_32bit_elf)
9ad5cbcf 7903 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 7904 else
9ad5cbcf 7905 section.sh_entsize = sizeof (Elf64_External_Sym);
252b5132 7906
ba5cdace 7907 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 7908 if (num_dynamic_syms < 1)
252b5132
RH
7909 {
7910 error (_("Unable to determine the number of symbols to load\n"));
7911 continue;
7912 }
252b5132
RH
7913 }
7914 }
7915
7916 /* Similarly find a string table. */
7917 if (dynamic_strings == NULL)
7918 {
86dba8ee
AM
7919 for (entry = dynamic_section;
7920 entry < dynamic_section + dynamic_nent;
7921 ++entry)
252b5132
RH
7922 {
7923 unsigned long offset;
b34976b6 7924 long str_tab_len;
252b5132
RH
7925
7926 if (entry->d_tag != DT_STRTAB)
7927 continue;
7928
7929 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7930
7931 /* Since we do not know how big the string table is,
7932 we default to reading in the entire file (!) and
7933 processing that. This is overkill, I know, but it
e3c8793a 7934 should work. */
252b5132 7935
d93f0186 7936 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC
7937
7938 if (archive_file_offset != 0)
7939 str_tab_len = archive_file_size - offset;
7940 else
7941 {
7942 if (fseek (file, 0, SEEK_END))
7943 error (_("Unable to seek to end of file\n"));
7944 str_tab_len = ftell (file) - offset;
7945 }
252b5132
RH
7946
7947 if (str_tab_len < 1)
7948 {
7949 error
7950 (_("Unable to determine the length of the dynamic string table\n"));
7951 continue;
7952 }
7953
3f5e193b
NC
7954 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7955 str_tab_len,
7956 _("dynamic string table"));
59245841 7957 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH
7958 break;
7959 }
7960 }
7961
7962 /* And find the syminfo section if available. */
7963 if (dynamic_syminfo == NULL)
7964 {
3e8bba36 7965 unsigned long syminsz = 0;
252b5132 7966
86dba8ee
AM
7967 for (entry = dynamic_section;
7968 entry < dynamic_section + dynamic_nent;
7969 ++entry)
252b5132
RH
7970 {
7971 if (entry->d_tag == DT_SYMINENT)
7972 {
7973 /* Note: these braces are necessary to avoid a syntax
7974 error from the SunOS4 C compiler. */
7975 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7976 }
7977 else if (entry->d_tag == DT_SYMINSZ)
7978 syminsz = entry->d_un.d_val;
7979 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC
7980 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7981 syminsz);
252b5132
RH
7982 }
7983
7984 if (dynamic_syminfo_offset != 0 && syminsz != 0)
7985 {
2cf0635d
NC
7986 Elf_External_Syminfo * extsyminfo;
7987 Elf_External_Syminfo * extsym;
7988 Elf_Internal_Syminfo * syminfo;
252b5132
RH
7989
7990 /* There is a syminfo section. Read the data. */
3f5e193b
NC
7991 extsyminfo = (Elf_External_Syminfo *)
7992 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
7993 _("symbol information"));
a6e9f9df
AM
7994 if (!extsyminfo)
7995 return 0;
252b5132 7996
3f5e193b 7997 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH
7998 if (dynamic_syminfo == NULL)
7999 {
8000 error (_("Out of memory\n"));
8001 return 0;
8002 }
8003
8004 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM
8005 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8006 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8007 ++syminfo, ++extsym)
252b5132 8008 {
86dba8ee
AM
8009 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8010 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH
8011 }
8012
8013 free (extsyminfo);
8014 }
8015 }
8016
8017 if (do_dynamic && dynamic_addr)
86dba8ee
AM
8018 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
8019 dynamic_addr, dynamic_nent);
252b5132
RH
8020 if (do_dynamic)
8021 printf (_(" Tag Type Name/Value\n"));
8022
86dba8ee
AM
8023 for (entry = dynamic_section;
8024 entry < dynamic_section + dynamic_nent;
8025 entry++)
252b5132
RH
8026 {
8027 if (do_dynamic)
f7a99963 8028 {
2cf0635d 8029 const char * dtype;
e699b9ff 8030
f7a99963
NC
8031 putchar (' ');
8032 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT
8033 dtype = get_dynamic_type (entry->d_tag);
8034 printf (" (%s)%*s", dtype,
8035 ((is_32bit_elf ? 27 : 19)
8036 - (int) strlen (dtype)),
f7a99963
NC
8037 " ");
8038 }
252b5132
RH
8039
8040 switch (entry->d_tag)
8041 {
d1133906
NC
8042 case DT_FLAGS:
8043 if (do_dynamic)
e9e44622 8044 print_dynamic_flags (entry->d_un.d_val);
d1133906 8045 break;
76da6bbe 8046
252b5132
RH
8047 case DT_AUXILIARY:
8048 case DT_FILTER:
019148e4
L
8049 case DT_CONFIG:
8050 case DT_DEPAUDIT:
8051 case DT_AUDIT:
252b5132
RH
8052 if (do_dynamic)
8053 {
019148e4 8054 switch (entry->d_tag)
b34976b6 8055 {
019148e4
L
8056 case DT_AUXILIARY:
8057 printf (_("Auxiliary library"));
8058 break;
8059
8060 case DT_FILTER:
8061 printf (_("Filter library"));
8062 break;
8063
b34976b6 8064 case DT_CONFIG:
019148e4
L
8065 printf (_("Configuration file"));
8066 break;
8067
8068 case DT_DEPAUDIT:
8069 printf (_("Dependency audit library"));
8070 break;
8071
8072 case DT_AUDIT:
8073 printf (_("Audit library"));
8074 break;
8075 }
252b5132 8076
d79b3d50
NC
8077 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8078 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8079 else
f7a99963
NC
8080 {
8081 printf (": ");
8082 print_vma (entry->d_un.d_val, PREFIX_HEX);
8083 putchar ('\n');
8084 }
252b5132
RH
8085 }
8086 break;
8087
dcefbbbd 8088 case DT_FEATURE:
252b5132
RH
8089 if (do_dynamic)
8090 {
8091 printf (_("Flags:"));
86f55779 8092
252b5132
RH
8093 if (entry->d_un.d_val == 0)
8094 printf (_(" None\n"));
8095 else
8096 {
8097 unsigned long int val = entry->d_un.d_val;
86f55779 8098
252b5132
RH
8099 if (val & DTF_1_PARINIT)
8100 {
8101 printf (" PARINIT");
8102 val ^= DTF_1_PARINIT;
8103 }
dcefbbbd
L
8104 if (val & DTF_1_CONFEXP)
8105 {
8106 printf (" CONFEXP");
8107 val ^= DTF_1_CONFEXP;
8108 }
252b5132
RH
8109 if (val != 0)
8110 printf (" %lx", val);
8111 puts ("");
8112 }
8113 }
8114 break;
8115
8116 case DT_POSFLAG_1:
8117 if (do_dynamic)
8118 {
8119 printf (_("Flags:"));
86f55779 8120
252b5132
RH
8121 if (entry->d_un.d_val == 0)
8122 printf (_(" None\n"));
8123 else
8124 {
8125 unsigned long int val = entry->d_un.d_val;
86f55779 8126
252b5132
RH
8127 if (val & DF_P1_LAZYLOAD)
8128 {
8129 printf (" LAZYLOAD");
8130 val ^= DF_P1_LAZYLOAD;
8131 }
8132 if (val & DF_P1_GROUPPERM)
8133 {
8134 printf (" GROUPPERM");
8135 val ^= DF_P1_GROUPPERM;
8136 }
8137 if (val != 0)
8138 printf (" %lx", val);
8139 puts ("");
8140 }
8141 }
8142 break;
8143
8144 case DT_FLAGS_1:
8145 if (do_dynamic)
8146 {
8147 printf (_("Flags:"));
8148 if (entry->d_un.d_val == 0)
8149 printf (_(" None\n"));
8150 else
8151 {
8152 unsigned long int val = entry->d_un.d_val;
86f55779 8153
252b5132
RH
8154 if (val & DF_1_NOW)
8155 {
8156 printf (" NOW");
8157 val ^= DF_1_NOW;
8158 }
8159 if (val & DF_1_GLOBAL)
8160 {
8161 printf (" GLOBAL");
8162 val ^= DF_1_GLOBAL;
8163 }
8164 if (val & DF_1_GROUP)
8165 {
8166 printf (" GROUP");
8167 val ^= DF_1_GROUP;
8168 }
8169 if (val & DF_1_NODELETE)
8170 {
8171 printf (" NODELETE");
8172 val ^= DF_1_NODELETE;
8173 }
8174 if (val & DF_1_LOADFLTR)
8175 {
8176 printf (" LOADFLTR");
8177 val ^= DF_1_LOADFLTR;
8178 }
8179 if (val & DF_1_INITFIRST)
8180 {
8181 printf (" INITFIRST");
8182 val ^= DF_1_INITFIRST;
8183 }
8184 if (val & DF_1_NOOPEN)
8185 {
8186 printf (" NOOPEN");
8187 val ^= DF_1_NOOPEN;
8188 }
8189 if (val & DF_1_ORIGIN)
8190 {
8191 printf (" ORIGIN");
8192 val ^= DF_1_ORIGIN;
8193 }
8194 if (val & DF_1_DIRECT)
8195 {
8196 printf (" DIRECT");
8197 val ^= DF_1_DIRECT;
8198 }
8199 if (val & DF_1_TRANS)
8200 {
8201 printf (" TRANS");
8202 val ^= DF_1_TRANS;
8203 }
8204 if (val & DF_1_INTERPOSE)
8205 {
8206 printf (" INTERPOSE");
8207 val ^= DF_1_INTERPOSE;
8208 }
f7db6139 8209 if (val & DF_1_NODEFLIB)
dcefbbbd 8210 {
f7db6139
L
8211 printf (" NODEFLIB");
8212 val ^= DF_1_NODEFLIB;
dcefbbbd
L
8213 }
8214 if (val & DF_1_NODUMP)
8215 {
8216 printf (" NODUMP");
8217 val ^= DF_1_NODUMP;
8218 }
34b60028 8219 if (val & DF_1_CONFALT)
dcefbbbd 8220 {
34b60028
L
8221 printf (" CONFALT");
8222 val ^= DF_1_CONFALT;
8223 }
8224 if (val & DF_1_ENDFILTEE)
8225 {
8226 printf (" ENDFILTEE");
8227 val ^= DF_1_ENDFILTEE;
8228 }
8229 if (val & DF_1_DISPRELDNE)
8230 {
8231 printf (" DISPRELDNE");
8232 val ^= DF_1_DISPRELDNE;
8233 }
8234 if (val & DF_1_DISPRELPND)
8235 {
8236 printf (" DISPRELPND");
8237 val ^= DF_1_DISPRELPND;
8238 }
8239 if (val & DF_1_NODIRECT)
8240 {
8241 printf (" NODIRECT");
8242 val ^= DF_1_NODIRECT;
8243 }
8244 if (val & DF_1_IGNMULDEF)
8245 {
8246 printf (" IGNMULDEF");
8247 val ^= DF_1_IGNMULDEF;
8248 }
8249 if (val & DF_1_NOKSYMS)
8250 {
8251 printf (" NOKSYMS");
8252 val ^= DF_1_NOKSYMS;
8253 }
8254 if (val & DF_1_NOHDR)
8255 {
8256 printf (" NOHDR");
8257 val ^= DF_1_NOHDR;
8258 }
8259 if (val & DF_1_EDITED)
8260 {
8261 printf (" EDITED");
8262 val ^= DF_1_EDITED;
8263 }
8264 if (val & DF_1_NORELOC)
8265 {
8266 printf (" NORELOC");
8267 val ^= DF_1_NORELOC;
8268 }
8269 if (val & DF_1_SYMINTPOSE)
8270 {
8271 printf (" SYMINTPOSE");
8272 val ^= DF_1_SYMINTPOSE;
8273 }
8274 if (val & DF_1_GLOBAUDIT)
8275 {
8276 printf (" GLOBAUDIT");
8277 val ^= DF_1_GLOBAUDIT;
8278 }
8279 if (val & DF_1_SINGLETON)
8280 {
8281 printf (" SINGLETON");
8282 val ^= DF_1_SINGLETON;
dcefbbbd 8283 }
252b5132
RH
8284 if (val != 0)
8285 printf (" %lx", val);
8286 puts ("");
8287 }
8288 }
8289 break;
8290
8291 case DT_PLTREL:
566b0d53 8292 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH
8293 if (do_dynamic)
8294 puts (get_dynamic_type (entry->d_un.d_val));
8295 break;
8296
8297 case DT_NULL :
8298 case DT_NEEDED :
8299 case DT_PLTGOT :
8300 case DT_HASH :
8301 case DT_STRTAB :
8302 case DT_SYMTAB :
8303 case DT_RELA :
8304 case DT_INIT :
8305 case DT_FINI :
8306 case DT_SONAME :
8307 case DT_RPATH :
8308 case DT_SYMBOLIC:
8309 case DT_REL :
8310 case DT_DEBUG :
8311 case DT_TEXTREL :
8312 case DT_JMPREL :
019148e4 8313 case DT_RUNPATH :
252b5132
RH
8314 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8315
8316 if (do_dynamic)
8317 {
2cf0635d 8318 char * name;
252b5132 8319
d79b3d50
NC
8320 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8321 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 8322 else
d79b3d50 8323 name = NULL;
252b5132
RH
8324
8325 if (name)
8326 {
8327 switch (entry->d_tag)
8328 {
8329 case DT_NEEDED:
8330 printf (_("Shared library: [%s]"), name);
8331
18bd398b 8332 if (streq (name, program_interpreter))
f7a99963 8333 printf (_(" program interpreter"));
252b5132
RH
8334 break;
8335
8336 case DT_SONAME:
f7a99963 8337 printf (_("Library soname: [%s]"), name);
252b5132
RH
8338 break;
8339
8340 case DT_RPATH:
f7a99963 8341 printf (_("Library rpath: [%s]"), name);
252b5132
RH
8342 break;
8343
019148e4
L
8344 case DT_RUNPATH:
8345 printf (_("Library runpath: [%s]"), name);
8346 break;
8347
252b5132 8348 default:
f7a99963
NC
8349 print_vma (entry->d_un.d_val, PREFIX_HEX);
8350 break;
252b5132
RH
8351 }
8352 }
8353 else
f7a99963
NC
8354 print_vma (entry->d_un.d_val, PREFIX_HEX);
8355
8356 putchar ('\n');
252b5132
RH
8357 }
8358 break;
8359
8360 case DT_PLTRELSZ:
8361 case DT_RELASZ :
8362 case DT_STRSZ :
8363 case DT_RELSZ :
8364 case DT_RELAENT :
8365 case DT_SYMENT :
8366 case DT_RELENT :
566b0d53 8367 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH
8368 case DT_PLTPADSZ:
8369 case DT_MOVEENT :
8370 case DT_MOVESZ :
8371 case DT_INIT_ARRAYSZ:
8372 case DT_FINI_ARRAYSZ:
047b2264
JJ
8373 case DT_GNU_CONFLICTSZ:
8374 case DT_GNU_LIBLISTSZ:
252b5132 8375 if (do_dynamic)
f7a99963
NC
8376 {
8377 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 8378 printf (_(" (bytes)\n"));
f7a99963 8379 }
252b5132
RH
8380 break;
8381
8382 case DT_VERDEFNUM:
8383 case DT_VERNEEDNUM:
8384 case DT_RELACOUNT:
8385 case DT_RELCOUNT:
8386 if (do_dynamic)
f7a99963
NC
8387 {
8388 print_vma (entry->d_un.d_val, UNSIGNED);
8389 putchar ('\n');
8390 }
252b5132
RH
8391 break;
8392
8393 case DT_SYMINSZ:
8394 case DT_SYMINENT:
8395 case DT_SYMINFO:
8396 case DT_USED:
8397 case DT_INIT_ARRAY:
8398 case DT_FINI_ARRAY:
8399 if (do_dynamic)
8400 {
d79b3d50
NC
8401 if (entry->d_tag == DT_USED
8402 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 8403 {
2cf0635d 8404 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 8405
b34976b6 8406 if (*name)
252b5132
RH
8407 {
8408 printf (_("Not needed object: [%s]\n"), name);
8409 break;
8410 }
8411 }
103f02d3 8412
f7a99963
NC
8413 print_vma (entry->d_un.d_val, PREFIX_HEX);
8414 putchar ('\n');
252b5132
RH
8415 }
8416 break;
8417
8418 case DT_BIND_NOW:
8419 /* The value of this entry is ignored. */
35b1837e
AM
8420 if (do_dynamic)
8421 putchar ('\n');
252b5132 8422 break;
103f02d3 8423
047b2264
JJ
8424 case DT_GNU_PRELINKED:
8425 if (do_dynamic)
8426 {
2cf0635d 8427 struct tm * tmp;
91d6fa6a 8428 time_t atime = entry->d_un.d_val;
047b2264 8429
91d6fa6a 8430 tmp = gmtime (&atime);
047b2264
JJ
8431 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8432 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8433 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8434
8435 }
8436 break;
8437
fdc90cb4
JJ
8438 case DT_GNU_HASH:
8439 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8440 if (do_dynamic)
8441 {
8442 print_vma (entry->d_un.d_val, PREFIX_HEX);
8443 putchar ('\n');
8444 }
8445 break;
8446
252b5132
RH
8447 default:
8448 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 8449 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH
8450 entry->d_un.d_val;
8451
8452 if (do_dynamic)
8453 {
8454 switch (elf_header.e_machine)
8455 {
8456 case EM_MIPS:
4fe85591 8457 case EM_MIPS_RS3_LE:
b2d38a17 8458 dynamic_section_mips_val (entry);
252b5132 8459 break;
103f02d3 8460 case EM_PARISC:
b2d38a17 8461 dynamic_section_parisc_val (entry);
103f02d3 8462 break;
ecc51f48 8463 case EM_IA_64:
b2d38a17 8464 dynamic_section_ia64_val (entry);
ecc51f48 8465 break;
252b5132 8466 default:
f7a99963
NC
8467 print_vma (entry->d_un.d_val, PREFIX_HEX);
8468 putchar ('\n');
252b5132
RH
8469 }
8470 }
8471 break;
8472 }
8473 }
8474
8475 return 1;
8476}
8477
8478static char *
d3ba0551 8479get_ver_flags (unsigned int flags)
252b5132 8480{
b34976b6 8481 static char buff[32];
252b5132
RH
8482
8483 buff[0] = 0;
8484
8485 if (flags == 0)
8486 return _("none");
8487
8488 if (flags & VER_FLG_BASE)
8489 strcat (buff, "BASE ");
8490
8491 if (flags & VER_FLG_WEAK)
8492 {
8493 if (flags & VER_FLG_BASE)
8494 strcat (buff, "| ");
8495
8496 strcat (buff, "WEAK ");
8497 }
8498
44ec90b9
RO
8499 if (flags & VER_FLG_INFO)
8500 {
8501 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8502 strcat (buff, "| ");
8503
8504 strcat (buff, "INFO ");
8505 }
8506
8507 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 8508 strcat (buff, _("| <unknown>"));
252b5132
RH
8509
8510 return buff;
8511}
8512
8513/* Display the contents of the version sections. */
98fb390a 8514
252b5132 8515static int
2cf0635d 8516process_version_sections (FILE * file)
252b5132 8517{
2cf0635d 8518 Elf_Internal_Shdr * section;
b34976b6
AM
8519 unsigned i;
8520 int found = 0;
252b5132
RH
8521
8522 if (! do_version)
8523 return 1;
8524
8525 for (i = 0, section = section_headers;
8526 i < elf_header.e_shnum;
b34976b6 8527 i++, section++)
252b5132
RH
8528 {
8529 switch (section->sh_type)
8530 {
8531 case SHT_GNU_verdef:
8532 {
2cf0635d 8533 Elf_External_Verdef * edefs;
b34976b6
AM
8534 unsigned int idx;
8535 unsigned int cnt;
2cf0635d 8536 char * endbuf;
252b5132
RH
8537
8538 found = 1;
8539
8540 printf
72de5009 8541 (_("\nVersion definition section '%s' contains %u entries:\n"),
252b5132
RH
8542 SECTION_NAME (section), section->sh_info);
8543
8544 printf (_(" Addr: 0x"));
8545 printf_vma (section->sh_addr);
72de5009 8546 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8547 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM
8548 section->sh_link < elf_header.e_shnum
8549 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8550 : _("<corrupt>"));
252b5132 8551
3f5e193b
NC
8552 edefs = (Elf_External_Verdef *)
8553 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8554 _("version definition section"));
a6e9f9df
AM
8555 if (!edefs)
8556 break;
59245841 8557 endbuf = (char *) edefs + section->sh_size;
252b5132 8558
b34976b6 8559 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 8560 {
2cf0635d
NC
8561 char * vstart;
8562 Elf_External_Verdef * edef;
b34976b6 8563 Elf_Internal_Verdef ent;
2cf0635d 8564 Elf_External_Verdaux * eaux;
b34976b6
AM
8565 Elf_Internal_Verdaux aux;
8566 int j;
8567 int isum;
103f02d3 8568
7e26601c
NC
8569 /* Check for very large indicies. */
8570 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC
8571 break;
8572
252b5132 8573 vstart = ((char *) edefs) + idx;
54806181
AM
8574 if (vstart + sizeof (*edef) > endbuf)
8575 break;
252b5132
RH
8576
8577 edef = (Elf_External_Verdef *) vstart;
8578
8579 ent.vd_version = BYTE_GET (edef->vd_version);
8580 ent.vd_flags = BYTE_GET (edef->vd_flags);
8581 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
8582 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
8583 ent.vd_hash = BYTE_GET (edef->vd_hash);
8584 ent.vd_aux = BYTE_GET (edef->vd_aux);
8585 ent.vd_next = BYTE_GET (edef->vd_next);
8586
8587 printf (_(" %#06x: Rev: %d Flags: %s"),
8588 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8589
8590 printf (_(" Index: %d Cnt: %d "),
8591 ent.vd_ndx, ent.vd_cnt);
8592
dd24e3da 8593 /* Check for overflow. */
7e26601c 8594 if (ent.vd_aux > (size_t) (endbuf - vstart))
dd24e3da
NC
8595 break;
8596
252b5132
RH
8597 vstart += ent.vd_aux;
8598
8599 eaux = (Elf_External_Verdaux *) vstart;
8600
8601 aux.vda_name = BYTE_GET (eaux->vda_name);
8602 aux.vda_next = BYTE_GET (eaux->vda_next);
8603
d79b3d50
NC
8604 if (VALID_DYNAMIC_NAME (aux.vda_name))
8605 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH
8606 else
8607 printf (_("Name index: %ld\n"), aux.vda_name);
8608
8609 isum = idx + ent.vd_aux;
8610
b34976b6 8611 for (j = 1; j < ent.vd_cnt; j++)
252b5132 8612 {
dd24e3da 8613 /* Check for overflow. */
7e26601c 8614 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC
8615 break;
8616
252b5132
RH
8617 isum += aux.vda_next;
8618 vstart += aux.vda_next;
8619
8620 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM
8621 if (vstart + sizeof (*eaux) > endbuf)
8622 break;
252b5132
RH
8623
8624 aux.vda_name = BYTE_GET (eaux->vda_name);
8625 aux.vda_next = BYTE_GET (eaux->vda_next);
8626
d79b3d50 8627 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 8628 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 8629 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH
8630 else
8631 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8632 isum, j, aux.vda_name);
8633 }
dd24e3da 8634
54806181
AM
8635 if (j < ent.vd_cnt)
8636 printf (_(" Version def aux past end of section\n"));
252b5132
RH
8637
8638 idx += ent.vd_next;
8639 }
dd24e3da 8640
54806181
AM
8641 if (cnt < section->sh_info)
8642 printf (_(" Version definition past end of section\n"));
252b5132
RH
8643
8644 free (edefs);
8645 }
8646 break;
103f02d3 8647
252b5132
RH
8648 case SHT_GNU_verneed:
8649 {
2cf0635d 8650 Elf_External_Verneed * eneed;
b34976b6
AM
8651 unsigned int idx;
8652 unsigned int cnt;
2cf0635d 8653 char * endbuf;
252b5132
RH
8654
8655 found = 1;
8656
72de5009 8657 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
252b5132
RH
8658 SECTION_NAME (section), section->sh_info);
8659
8660 printf (_(" Addr: 0x"));
8661 printf_vma (section->sh_addr);
72de5009 8662 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8663 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM
8664 section->sh_link < elf_header.e_shnum
8665 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8666 : _("<corrupt>"));
252b5132 8667
3f5e193b
NC
8668 eneed = (Elf_External_Verneed *) get_data (NULL, file,
8669 section->sh_offset, 1,
8670 section->sh_size,
9cf03b7e 8671 _("Version Needs section"));
a6e9f9df
AM
8672 if (!eneed)
8673 break;
59245841 8674 endbuf = (char *) eneed + section->sh_size;
252b5132
RH
8675
8676 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8677 {
2cf0635d 8678 Elf_External_Verneed * entry;
b34976b6
AM
8679 Elf_Internal_Verneed ent;
8680 int j;
8681 int isum;
2cf0635d 8682 char * vstart;
252b5132 8683
7e26601c 8684 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC
8685 break;
8686
252b5132 8687 vstart = ((char *) eneed) + idx;
54806181
AM
8688 if (vstart + sizeof (*entry) > endbuf)
8689 break;
252b5132
RH
8690
8691 entry = (Elf_External_Verneed *) vstart;
8692
8693 ent.vn_version = BYTE_GET (entry->vn_version);
8694 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
8695 ent.vn_file = BYTE_GET (entry->vn_file);
8696 ent.vn_aux = BYTE_GET (entry->vn_aux);
8697 ent.vn_next = BYTE_GET (entry->vn_next);
8698
8699 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
8700
d79b3d50
NC
8701 if (VALID_DYNAMIC_NAME (ent.vn_file))
8702 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH
8703 else
8704 printf (_(" File: %lx"), ent.vn_file);
8705
8706 printf (_(" Cnt: %d\n"), ent.vn_cnt);
8707
dd24e3da 8708 /* Check for overflow. */
7e26601c 8709 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da
NC
8710 break;
8711
252b5132
RH
8712 vstart += ent.vn_aux;
8713
8714 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8715 {
2cf0635d 8716 Elf_External_Vernaux * eaux;
b34976b6 8717 Elf_Internal_Vernaux aux;
252b5132 8718
54806181
AM
8719 if (vstart + sizeof (*eaux) > endbuf)
8720 break;
252b5132
RH
8721 eaux = (Elf_External_Vernaux *) vstart;
8722
8723 aux.vna_hash = BYTE_GET (eaux->vna_hash);
8724 aux.vna_flags = BYTE_GET (eaux->vna_flags);
8725 aux.vna_other = BYTE_GET (eaux->vna_other);
8726 aux.vna_name = BYTE_GET (eaux->vna_name);
8727 aux.vna_next = BYTE_GET (eaux->vna_next);
8728
d79b3d50 8729 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 8730 printf (_(" %#06x: Name: %s"),
d79b3d50 8731 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 8732 else
ecc2063b 8733 printf (_(" %#06x: Name index: %lx"),
252b5132
RH
8734 isum, aux.vna_name);
8735
8736 printf (_(" Flags: %s Version: %d\n"),
8737 get_ver_flags (aux.vna_flags), aux.vna_other);
8738
dd24e3da 8739 /* Check for overflow. */
7e26601c 8740 if (aux.vna_next > (size_t) (endbuf - vstart))
dd24e3da
NC
8741 break;
8742
252b5132
RH
8743 isum += aux.vna_next;
8744 vstart += aux.vna_next;
8745 }
9cf03b7e 8746
54806181 8747 if (j < ent.vn_cnt)
9cf03b7e 8748 warn (_("Missing Version Needs auxillary information\n"));
252b5132
RH
8749
8750 idx += ent.vn_next;
8751 }
9cf03b7e 8752
54806181 8753 if (cnt < section->sh_info)
9cf03b7e 8754 warn (_("Missing Version Needs information\n"));
103f02d3 8755
252b5132
RH
8756 free (eneed);
8757 }
8758 break;
8759
8760 case SHT_GNU_versym:
8761 {
2cf0635d 8762 Elf_Internal_Shdr * link_section;
b34976b6
AM
8763 int total;
8764 int cnt;
2cf0635d
NC
8765 unsigned char * edata;
8766 unsigned short * data;
8767 char * strtab;
8768 Elf_Internal_Sym * symbols;
8769 Elf_Internal_Shdr * string_sec;
ba5cdace 8770 unsigned long num_syms;
d3ba0551 8771 long off;
252b5132 8772
4fbb74a6 8773 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ
8774 break;
8775
4fbb74a6 8776 link_section = section_headers + section->sh_link;
08d8fa11 8777 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 8778
4fbb74a6 8779 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ
8780 break;
8781
252b5132
RH
8782 found = 1;
8783
ba5cdace 8784 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC
8785 if (symbols == NULL)
8786 break;
252b5132 8787
4fbb74a6 8788 string_sec = section_headers + link_section->sh_link;
252b5132 8789
3f5e193b
NC
8790 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8791 string_sec->sh_size,
8792 _("version string table"));
a6e9f9df 8793 if (!strtab)
0429c154
MS
8794 {
8795 free (symbols);
8796 break;
8797 }
252b5132
RH
8798
8799 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8800 SECTION_NAME (section), total);
8801
8802 printf (_(" Addr: "));
8803 printf_vma (section->sh_addr);
72de5009 8804 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8805 (unsigned long) section->sh_offset, section->sh_link,
252b5132
RH
8806 SECTION_NAME (link_section));
8807
d3ba0551
AM
8808 off = offset_from_vma (file,
8809 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8810 total * sizeof (short));
3f5e193b
NC
8811 edata = (unsigned char *) get_data (NULL, file, off, total,
8812 sizeof (short),
8813 _("version symbol data"));
a6e9f9df
AM
8814 if (!edata)
8815 {
8816 free (strtab);
0429c154 8817 free (symbols);
a6e9f9df
AM
8818 break;
8819 }
252b5132 8820
3f5e193b 8821 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH
8822
8823 for (cnt = total; cnt --;)
b34976b6
AM
8824 data[cnt] = byte_get (edata + cnt * sizeof (short),
8825 sizeof (short));
252b5132
RH
8826
8827 free (edata);
8828
8829 for (cnt = 0; cnt < total; cnt += 4)
8830 {
8831 int j, nn;
00d93f34 8832 int check_def, check_need;
2cf0635d 8833 char * name;
252b5132
RH
8834
8835 printf (" %03x:", cnt);
8836
8837 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 8838 switch (data[cnt + j])
252b5132
RH
8839 {
8840 case 0:
8841 fputs (_(" 0 (*local*) "), stdout);
8842 break;
8843
8844 case 1:
8845 fputs (_(" 1 (*global*) "), stdout);
8846 break;
8847
8848 default:
c244d050
NC
8849 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8850 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 8851
dd24e3da 8852 /* If this index value is greater than the size of the symbols
ba5cdace
NC
8853 array, break to avoid an out-of-bounds read. */
8854 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC
8855 {
8856 warn (_("invalid index into symbol array\n"));
8857 break;
8858 }
8859
00d93f34
JJ
8860 check_def = 1;
8861 check_need = 1;
4fbb74a6
AM
8862 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8863 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 8864 != SHT_NOBITS)
252b5132 8865 {
b34976b6 8866 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ
8867 check_def = 0;
8868 else
8869 check_need = 0;
252b5132 8870 }
00d93f34
JJ
8871
8872 if (check_need
b34976b6 8873 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 8874 {
b34976b6
AM
8875 Elf_Internal_Verneed ivn;
8876 unsigned long offset;
252b5132 8877
d93f0186
NC
8878 offset = offset_from_vma
8879 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8880 sizeof (Elf_External_Verneed));
252b5132 8881
b34976b6 8882 do
252b5132 8883 {
b34976b6
AM
8884 Elf_Internal_Vernaux ivna;
8885 Elf_External_Verneed evn;
8886 Elf_External_Vernaux evna;
8887 unsigned long a_off;
252b5132 8888
59245841
NC
8889 if (get_data (&evn, file, offset, sizeof (evn), 1,
8890 _("version need")) == NULL)
8891 break;
8892
252b5132
RH
8893 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8894 ivn.vn_next = BYTE_GET (evn.vn_next);
8895
8896 a_off = offset + ivn.vn_aux;
8897
8898 do
8899 {
59245841
NC
8900 if (get_data (&evna, file, a_off, sizeof (evna),
8901 1, _("version need aux (2)")) == NULL)
8902 {
8903 ivna.vna_next = 0;
8904 ivna.vna_other = 0;
8905 }
8906 else
8907 {
8908 ivna.vna_next = BYTE_GET (evna.vna_next);
8909 ivna.vna_other = BYTE_GET (evna.vna_other);
8910 }
252b5132
RH
8911
8912 a_off += ivna.vna_next;
8913 }
b34976b6 8914 while (ivna.vna_other != data[cnt + j]
252b5132
RH
8915 && ivna.vna_next != 0);
8916
b34976b6 8917 if (ivna.vna_other == data[cnt + j])
252b5132
RH
8918 {
8919 ivna.vna_name = BYTE_GET (evna.vna_name);
8920
54806181
AM
8921 if (ivna.vna_name >= string_sec->sh_size)
8922 name = _("*invalid*");
8923 else
8924 name = strtab + ivna.vna_name;
252b5132 8925 nn += printf ("(%s%-*s",
16062207
ILT
8926 name,
8927 12 - (int) strlen (name),
252b5132 8928 ")");
00d93f34 8929 check_def = 0;
252b5132
RH
8930 break;
8931 }
8932
8933 offset += ivn.vn_next;
8934 }
8935 while (ivn.vn_next);
8936 }
00d93f34 8937
b34976b6
AM
8938 if (check_def && data[cnt + j] != 0x8001
8939 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 8940 {
b34976b6
AM
8941 Elf_Internal_Verdef ivd;
8942 Elf_External_Verdef evd;
8943 unsigned long offset;
252b5132 8944
d93f0186
NC
8945 offset = offset_from_vma
8946 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8947 sizeof evd);
252b5132
RH
8948
8949 do
8950 {
59245841
NC
8951 if (get_data (&evd, file, offset, sizeof (evd), 1,
8952 _("version def")) == NULL)
8953 {
8954 ivd.vd_next = 0;
8955 ivd.vd_ndx = 0;
8956 }
8957 else
8958 {
8959 ivd.vd_next = BYTE_GET (evd.vd_next);
8960 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8961 }
252b5132
RH
8962
8963 offset += ivd.vd_next;
8964 }
c244d050 8965 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH
8966 && ivd.vd_next != 0);
8967
c244d050 8968 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 8969 {
b34976b6
AM
8970 Elf_External_Verdaux evda;
8971 Elf_Internal_Verdaux ivda;
252b5132
RH
8972
8973 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8974
59245841
NC
8975 if (get_data (&evda, file,
8976 offset - ivd.vd_next + ivd.vd_aux,
8977 sizeof (evda), 1,
8978 _("version def aux")) == NULL)
8979 break;
252b5132
RH
8980
8981 ivda.vda_name = BYTE_GET (evda.vda_name);
8982
54806181
AM
8983 if (ivda.vda_name >= string_sec->sh_size)
8984 name = _("*invalid*");
8985 else
8986 name = strtab + ivda.vda_name;
252b5132 8987 nn += printf ("(%s%-*s",
16062207
ILT
8988 name,
8989 12 - (int) strlen (name),
252b5132
RH
8990 ")");
8991 }
8992 }
8993
8994 if (nn < 18)
8995 printf ("%*c", 18 - nn, ' ');
8996 }
8997
8998 putchar ('\n');
8999 }
9000
9001 free (data);
9002 free (strtab);
9003 free (symbols);
9004 }
9005 break;
103f02d3 9006
252b5132
RH
9007 default:
9008 break;
9009 }
9010 }
9011
9012 if (! found)
9013 printf (_("\nNo version information found in this file.\n"));
9014
9015 return 1;
9016}
9017
d1133906 9018static const char *
d3ba0551 9019get_symbol_binding (unsigned int binding)
252b5132 9020{
b34976b6 9021 static char buff[32];
252b5132
RH
9022
9023 switch (binding)
9024 {
b34976b6
AM
9025 case STB_LOCAL: return "LOCAL";
9026 case STB_GLOBAL: return "GLOBAL";
9027 case STB_WEAK: return "WEAK";
252b5132
RH
9028 default:
9029 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ
9030 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9031 binding);
252b5132 9032 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC
9033 {
9034 if (binding == STB_GNU_UNIQUE
9c55345c
TS
9035 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9036 /* GNU is still using the default value 0. */
3e7a7d11
NC
9037 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9038 return "UNIQUE";
9039 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9040 }
252b5132 9041 else
e9e44622 9042 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH
9043 return buff;
9044 }
9045}
9046
d1133906 9047static const char *
d3ba0551 9048get_symbol_type (unsigned int type)
252b5132 9049{
b34976b6 9050 static char buff[32];
252b5132
RH
9051
9052 switch (type)
9053 {
b34976b6
AM
9054 case STT_NOTYPE: return "NOTYPE";
9055 case STT_OBJECT: return "OBJECT";
9056 case STT_FUNC: return "FUNC";
9057 case STT_SECTION: return "SECTION";
9058 case STT_FILE: return "FILE";
9059 case STT_COMMON: return "COMMON";
9060 case STT_TLS: return "TLS";
15ab5209
DB
9061 case STT_RELC: return "RELC";
9062 case STT_SRELC: return "SRELC";
252b5132
RH
9063 default:
9064 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 9065 {
13761a11
NC
9066 if (elf_header.e_machine == EM_ARM)
9067 {
9068 if (type == STT_ARM_TFUNC)
9069 return "THUMB_FUNC";
9070 if (type == STT_ARM_16BIT)
9071 return "THUMB_LABEL";
9072 }
103f02d3 9073
351b4b40 9074 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD
9075 return "REGISTER";
9076
9077 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
9078 return "PARISC_MILLI";
9079
e9e44622 9080 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 9081 }
252b5132 9082 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD
9083 {
9084 if (elf_header.e_machine == EM_PARISC)
9085 {
9086 if (type == STT_HP_OPAQUE)
9087 return "HP_OPAQUE";
9088 if (type == STT_HP_STUB)
9089 return "HP_STUB";
9090 }
9091
d8045f23 9092 if (type == STT_GNU_IFUNC
9c55345c 9093 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 9094 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 9095 /* GNU is still using the default value 0. */
d8045f23
NC
9096 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9097 return "IFUNC";
9098
e9e44622 9099 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 9100 }
252b5132 9101 else
e9e44622 9102 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH
9103 return buff;
9104 }
9105}
9106
d1133906 9107static const char *
d3ba0551 9108get_symbol_visibility (unsigned int visibility)
d1133906
NC
9109{
9110 switch (visibility)
9111 {
b34976b6
AM
9112 case STV_DEFAULT: return "DEFAULT";
9113 case STV_INTERNAL: return "INTERNAL";
9114 case STV_HIDDEN: return "HIDDEN";
d1133906
NC
9115 case STV_PROTECTED: return "PROTECTED";
9116 default: abort ();
9117 }
9118}
9119
5e2b0d47
NC
9120static const char *
9121get_mips_symbol_other (unsigned int other)
9122{
9123 switch (other)
9124 {
df58fc94
RS
9125 case STO_OPTIONAL:
9126 return "OPTIONAL";
9127 case STO_MIPS_PLT:
9128 return "MIPS PLT";
9129 case STO_MIPS_PIC:
9130 return "MIPS PIC";
9131 case STO_MICROMIPS:
9132 return "MICROMIPS";
9133 case STO_MICROMIPS | STO_MIPS_PIC:
9134 return "MICROMIPS, MIPS PIC";
9135 case STO_MIPS16:
9136 return "MIPS16";
9137 default:
9138 return NULL;
5e2b0d47
NC
9139 }
9140}
9141
28f997cf
TG
9142static const char *
9143get_ia64_symbol_other (unsigned int other)
9144{
9145 if (is_ia64_vms ())
9146 {
9147 static char res[32];
9148
9149 res[0] = 0;
9150
9151 /* Function types is for images and .STB files only. */
9152 switch (elf_header.e_type)
9153 {
9154 case ET_DYN:
9155 case ET_EXEC:
9156 switch (VMS_ST_FUNC_TYPE (other))
9157 {
9158 case VMS_SFT_CODE_ADDR:
9159 strcat (res, " CA");
9160 break;
9161 case VMS_SFT_SYMV_IDX:
9162 strcat (res, " VEC");
9163 break;
9164 case VMS_SFT_FD:
9165 strcat (res, " FD");
9166 break;
9167 case VMS_SFT_RESERVE:
9168 strcat (res, " RSV");
9169 break;
9170 default:
9171 abort ();
9172 }
9173 break;
9174 default:
9175 break;
9176 }
9177 switch (VMS_ST_LINKAGE (other))
9178 {
9179 case VMS_STL_IGNORE:
9180 strcat (res, " IGN");
9181 break;
9182 case VMS_STL_RESERVE:
9183 strcat (res, " RSV");
9184 break;
9185 case VMS_STL_STD:
9186 strcat (res, " STD");
9187 break;
9188 case VMS_STL_LNK:
9189 strcat (res, " LNK");
9190 break;
9191 default:
9192 abort ();
9193 }
9194
9195 if (res[0] != 0)
9196 return res + 1;
9197 else
9198 return res;
9199 }
9200 return NULL;
9201}
9202
5e2b0d47
NC
9203static const char *
9204get_symbol_other (unsigned int other)
9205{
9206 const char * result = NULL;
9207 static char buff [32];
9208
9209 if (other == 0)
9210 return "";
9211
9212 switch (elf_header.e_machine)
9213 {
9214 case EM_MIPS:
9215 result = get_mips_symbol_other (other);
28f997cf
TG
9216 break;
9217 case EM_IA_64:
9218 result = get_ia64_symbol_other (other);
9219 break;
5e2b0d47
NC
9220 default:
9221 break;
9222 }
9223
9224 if (result)
9225 return result;
9226
9227 snprintf (buff, sizeof buff, _("<other>: %x"), other);
9228 return buff;
9229}
9230
d1133906 9231static const char *
d3ba0551 9232get_symbol_index_type (unsigned int type)
252b5132 9233{
b34976b6 9234 static char buff[32];
5cf1065c 9235
252b5132
RH
9236 switch (type)
9237 {
b34976b6
AM
9238 case SHN_UNDEF: return "UND";
9239 case SHN_ABS: return "ABS";
9240 case SHN_COMMON: return "COM";
252b5132 9241 default:
9ce701e2
L
9242 if (type == SHN_IA_64_ANSI_COMMON
9243 && elf_header.e_machine == EM_IA_64
9244 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
9245 return "ANSI_COM";
8a9036a4 9246 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L
9247 || elf_header.e_machine == EM_L1OM
9248 || elf_header.e_machine == EM_K1OM)
3b22753a
L
9249 && type == SHN_X86_64_LCOMMON)
9250 return "LARGE_COM";
ac145307
BS
9251 else if ((type == SHN_MIPS_SCOMMON
9252 && elf_header.e_machine == EM_MIPS)
9253 || (type == SHN_TIC6X_SCOMMON
9254 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS
9255 return "SCOM";
9256 else if (type == SHN_MIPS_SUNDEFINED
9257 && elf_header.e_machine == EM_MIPS)
9258 return "SUND";
9ce701e2 9259 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 9260 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 9261 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM
9262 sprintf (buff, "OS [0x%04x]", type & 0xffff);
9263 else if (type >= SHN_LORESERVE)
9264 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4
L
9265 else if (type >= elf_header.e_shnum)
9266 sprintf (buff, "bad section index[%3d]", type);
252b5132 9267 else
232e7cb8 9268 sprintf (buff, "%3d", type);
5cf1065c 9269 break;
252b5132 9270 }
5cf1065c
NC
9271
9272 return buff;
252b5132
RH
9273}
9274
66543521 9275static bfd_vma *
2cf0635d 9276get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
252b5132 9277{
2cf0635d
NC
9278 unsigned char * e_data;
9279 bfd_vma * i_data;
252b5132 9280
3f5e193b 9281 e_data = (unsigned char *) cmalloc (number, ent_size);
252b5132
RH
9282
9283 if (e_data == NULL)
9284 {
9285 error (_("Out of memory\n"));
9286 return NULL;
9287 }
9288
66543521 9289 if (fread (e_data, ent_size, number, file) != number)
252b5132
RH
9290 {
9291 error (_("Unable to read in dynamic data\n"));
9292 return NULL;
9293 }
9294
3f5e193b 9295 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
252b5132
RH
9296
9297 if (i_data == NULL)
9298 {
9299 error (_("Out of memory\n"));
9300 free (e_data);
9301 return NULL;
9302 }
9303
9304 while (number--)
66543521 9305 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH
9306
9307 free (e_data);
9308
9309 return i_data;
9310}
9311
6bd1a22c
L
9312static void
9313print_dynamic_symbol (bfd_vma si, unsigned long hn)
9314{
2cf0635d 9315 Elf_Internal_Sym * psym;
6bd1a22c
L
9316 int n;
9317
9318 psym = dynamic_symbols + si;
9319
9320 n = print_vma (si, DEC_5);
9321 if (n < 5)
9322 fputs (" " + n, stdout);
9323 printf (" %3lu: ", hn);
9324 print_vma (psym->st_value, LONG_HEX);
9325 putchar (' ');
9326 print_vma (psym->st_size, DEC_5);
9327
f4be36b3
AM
9328 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9329 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9330 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L
9331 /* Check to see if any other bits in the st_other field are set.
9332 Note - displaying this information disrupts the layout of the
9333 table being generated, but for the moment this case is very
9334 rare. */
9335 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9336 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9337 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9338 if (VALID_DYNAMIC_NAME (psym->st_name))
9339 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9340 else
2b692964 9341 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L
9342 putchar ('\n');
9343}
9344
e3c8793a 9345/* Dump the symbol table. */
252b5132 9346static int
2cf0635d 9347process_symbol_table (FILE * file)
252b5132 9348{
2cf0635d 9349 Elf_Internal_Shdr * section;
66543521
AM
9350 bfd_vma nbuckets = 0;
9351 bfd_vma nchains = 0;
2cf0635d
NC
9352 bfd_vma * buckets = NULL;
9353 bfd_vma * chains = NULL;
fdc90cb4 9354 bfd_vma ngnubuckets = 0;
2cf0635d
NC
9355 bfd_vma * gnubuckets = NULL;
9356 bfd_vma * gnuchains = NULL;
6bd1a22c 9357 bfd_vma gnusymidx = 0;
252b5132 9358
2c610e4b 9359 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH
9360 return 1;
9361
6bd1a22c
L
9362 if (dynamic_info[DT_HASH]
9363 && (do_histogram
2c610e4b
L
9364 || (do_using_dynamic
9365 && !do_dyn_syms
9366 && dynamic_strings != NULL)))
252b5132 9367 {
66543521
AM
9368 unsigned char nb[8];
9369 unsigned char nc[8];
9370 int hash_ent_size = 4;
9371
9372 if ((elf_header.e_machine == EM_ALPHA
9373 || elf_header.e_machine == EM_S390
9374 || elf_header.e_machine == EM_S390_OLD)
9375 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
9376 hash_ent_size = 8;
9377
fb52b2f4
NC
9378 if (fseek (file,
9379 (archive_file_offset
9380 + offset_from_vma (file, dynamic_info[DT_HASH],
9381 sizeof nb + sizeof nc)),
d93f0186 9382 SEEK_SET))
252b5132 9383 {
591a748a 9384 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9385 goto no_hash;
252b5132
RH
9386 }
9387
66543521 9388 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH
9389 {
9390 error (_("Failed to read in number of buckets\n"));
d3a44ec6 9391 goto no_hash;
252b5132
RH
9392 }
9393
66543521 9394 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH
9395 {
9396 error (_("Failed to read in number of chains\n"));
d3a44ec6 9397 goto no_hash;
252b5132
RH
9398 }
9399
66543521
AM
9400 nbuckets = byte_get (nb, hash_ent_size);
9401 nchains = byte_get (nc, hash_ent_size);
252b5132 9402
66543521
AM
9403 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
9404 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 9405
d3a44ec6 9406 no_hash:
252b5132 9407 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ
9408 {
9409 if (do_using_dynamic)
9410 return 0;
9411 free (buckets);
9412 free (chains);
9413 buckets = NULL;
9414 chains = NULL;
9415 nbuckets = 0;
9416 nchains = 0;
9417 }
252b5132
RH
9418 }
9419
6bd1a22c
L
9420 if (dynamic_info_DT_GNU_HASH
9421 && (do_histogram
2c610e4b
L
9422 || (do_using_dynamic
9423 && !do_dyn_syms
9424 && dynamic_strings != NULL)))
252b5132 9425 {
6bd1a22c
L
9426 unsigned char nb[16];
9427 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
9428 bfd_vma buckets_vma;
9429
9430 if (fseek (file,
9431 (archive_file_offset
9432 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
9433 sizeof nb)),
9434 SEEK_SET))
9435 {
9436 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9437 goto no_gnu_hash;
6bd1a22c 9438 }
252b5132 9439
6bd1a22c
L
9440 if (fread (nb, 16, 1, file) != 1)
9441 {
9442 error (_("Failed to read in number of buckets\n"));
d3a44ec6 9443 goto no_gnu_hash;
6bd1a22c
L
9444 }
9445
9446 ngnubuckets = byte_get (nb, 4);
9447 gnusymidx = byte_get (nb + 4, 4);
9448 bitmaskwords = byte_get (nb + 8, 4);
9449 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 9450 if (is_32bit_elf)
6bd1a22c 9451 buckets_vma += bitmaskwords * 4;
f7a99963 9452 else
6bd1a22c 9453 buckets_vma += bitmaskwords * 8;
252b5132 9454
6bd1a22c
L
9455 if (fseek (file,
9456 (archive_file_offset
9457 + offset_from_vma (file, buckets_vma, 4)),
9458 SEEK_SET))
252b5132 9459 {
6bd1a22c 9460 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9461 goto no_gnu_hash;
6bd1a22c
L
9462 }
9463
9464 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 9465
6bd1a22c 9466 if (gnubuckets == NULL)
d3a44ec6 9467 goto no_gnu_hash;
6bd1a22c
L
9468
9469 for (i = 0; i < ngnubuckets; i++)
9470 if (gnubuckets[i] != 0)
9471 {
9472 if (gnubuckets[i] < gnusymidx)
9473 return 0;
9474
9475 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9476 maxchain = gnubuckets[i];
9477 }
9478
9479 if (maxchain == 0xffffffff)
d3a44ec6 9480 goto no_gnu_hash;
6bd1a22c
L
9481
9482 maxchain -= gnusymidx;
9483
9484 if (fseek (file,
9485 (archive_file_offset
9486 + offset_from_vma (file, buckets_vma
9487 + 4 * (ngnubuckets + maxchain), 4)),
9488 SEEK_SET))
9489 {
9490 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9491 goto no_gnu_hash;
6bd1a22c
L
9492 }
9493
9494 do
9495 {
9496 if (fread (nb, 4, 1, file) != 1)
252b5132 9497 {
6bd1a22c 9498 error (_("Failed to determine last chain length\n"));
d3a44ec6 9499 goto no_gnu_hash;
6bd1a22c 9500 }
252b5132 9501
6bd1a22c 9502 if (maxchain + 1 == 0)
d3a44ec6 9503 goto no_gnu_hash;
252b5132 9504
6bd1a22c
L
9505 ++maxchain;
9506 }
9507 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 9508
6bd1a22c
L
9509 if (fseek (file,
9510 (archive_file_offset
9511 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9512 SEEK_SET))
9513 {
9514 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9515 goto no_gnu_hash;
6bd1a22c
L
9516 }
9517
9518 gnuchains = get_dynamic_data (file, maxchain, 4);
9519
d3a44ec6 9520 no_gnu_hash:
6bd1a22c 9521 if (gnuchains == NULL)
d3a44ec6
JJ
9522 {
9523 free (gnubuckets);
d3a44ec6
JJ
9524 gnubuckets = NULL;
9525 ngnubuckets = 0;
f64fddf1
NC
9526 if (do_using_dynamic)
9527 return 0;
d3a44ec6 9528 }
6bd1a22c
L
9529 }
9530
9531 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9532 && do_syms
9533 && do_using_dynamic
9534 && dynamic_strings != NULL)
9535 {
9536 unsigned long hn;
9537
9538 if (dynamic_info[DT_HASH])
9539 {
9540 bfd_vma si;
9541
9542 printf (_("\nSymbol table for image:\n"));
9543 if (is_32bit_elf)
9544 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9545 else
9546 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9547
9548 for (hn = 0; hn < nbuckets; hn++)
9549 {
9550 if (! buckets[hn])
9551 continue;
9552
9553 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9554 print_dynamic_symbol (si, hn);
252b5132
RH
9555 }
9556 }
6bd1a22c
L
9557
9558 if (dynamic_info_DT_GNU_HASH)
9559 {
9560 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9561 if (is_32bit_elf)
9562 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9563 else
9564 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9565
9566 for (hn = 0; hn < ngnubuckets; ++hn)
9567 if (gnubuckets[hn] != 0)
9568 {
9569 bfd_vma si = gnubuckets[hn];
9570 bfd_vma off = si - gnusymidx;
9571
9572 do
9573 {
9574 print_dynamic_symbol (si, hn);
9575 si++;
9576 }
9577 while ((gnuchains[off++] & 1) == 0);
9578 }
9579 }
252b5132 9580 }
2c610e4b 9581 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
252b5132 9582 {
b34976b6 9583 unsigned int i;
252b5132
RH
9584
9585 for (i = 0, section = section_headers;
9586 i < elf_header.e_shnum;
9587 i++, section++)
9588 {
b34976b6 9589 unsigned int si;
2cf0635d 9590 char * strtab = NULL;
c256ffe7 9591 unsigned long int strtab_size = 0;
2cf0635d
NC
9592 Elf_Internal_Sym * symtab;
9593 Elf_Internal_Sym * psym;
ba5cdace 9594 unsigned long num_syms;
252b5132 9595
2c610e4b
L
9596 if ((section->sh_type != SHT_SYMTAB
9597 && section->sh_type != SHT_DYNSYM)
9598 || (!do_syms
9599 && section->sh_type == SHT_SYMTAB))
252b5132
RH
9600 continue;
9601
dd24e3da
NC
9602 if (section->sh_entsize == 0)
9603 {
9604 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9605 SECTION_NAME (section));
9606 continue;
9607 }
9608
252b5132
RH
9609 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9610 SECTION_NAME (section),
9611 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 9612
f7a99963 9613 if (is_32bit_elf)
ca47b30c 9614 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 9615 else
ca47b30c 9616 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 9617
ba5cdace 9618 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH
9619 if (symtab == NULL)
9620 continue;
9621
9622 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ
9623 {
9624 strtab = string_table;
9625 strtab_size = string_table_length;
9626 }
4fbb74a6 9627 else if (section->sh_link < elf_header.e_shnum)
252b5132 9628 {
2cf0635d 9629 Elf_Internal_Shdr * string_sec;
252b5132 9630
4fbb74a6 9631 string_sec = section_headers + section->sh_link;
252b5132 9632
3f5e193b
NC
9633 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9634 1, string_sec->sh_size,
9635 _("string table"));
c256ffe7 9636 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH
9637 }
9638
ba5cdace 9639 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 9640 {
5e220199 9641 printf ("%6d: ", si);
f7a99963
NC
9642 print_vma (psym->st_value, LONG_HEX);
9643 putchar (' ');
9644 print_vma (psym->st_size, DEC_5);
d1133906
NC
9645 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9646 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 9647 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC
9648 /* Check to see if any other bits in the st_other field are set.
9649 Note - displaying this information disrupts the layout of the
9650 table being generated, but for the moment this case is very rare. */
9651 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9652 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 9653 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 9654 print_symbol (25, psym->st_name < strtab_size
2b692964 9655 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 9656
59245841
NC
9657 if (section->sh_type == SHT_DYNSYM
9658 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
252b5132 9659 {
b34976b6
AM
9660 unsigned char data[2];
9661 unsigned short vers_data;
9662 unsigned long offset;
9663 int is_nobits;
9664 int check_def;
252b5132 9665
d93f0186
NC
9666 offset = offset_from_vma
9667 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9668 sizeof data + si * sizeof (vers_data));
252b5132 9669
59245841
NC
9670 if (get_data (&data, file, offset + si * sizeof (vers_data),
9671 sizeof (data), 1, _("version data")) == NULL)
9672 break;
252b5132
RH
9673
9674 vers_data = byte_get (data, 2);
9675
4fbb74a6
AM
9676 is_nobits = (psym->st_shndx < elf_header.e_shnum
9677 && section_headers[psym->st_shndx].sh_type
c256ffe7 9678 == SHT_NOBITS);
252b5132
RH
9679
9680 check_def = (psym->st_shndx != SHN_UNDEF);
9681
c244d050 9682 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
252b5132 9683 {
b34976b6 9684 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
00d93f34 9685 && (is_nobits || ! check_def))
252b5132 9686 {
b34976b6
AM
9687 Elf_External_Verneed evn;
9688 Elf_Internal_Verneed ivn;
9689 Elf_Internal_Vernaux ivna;
252b5132
RH
9690
9691 /* We must test both. */
d93f0186
NC
9692 offset = offset_from_vma
9693 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9694 sizeof evn);
252b5132 9695
252b5132
RH
9696 do
9697 {
b34976b6 9698 unsigned long vna_off;
252b5132 9699
59245841
NC
9700 if (get_data (&evn, file, offset, sizeof (evn), 1,
9701 _("version need")) == NULL)
9702 {
9703 ivna.vna_next = 0;
9704 ivna.vna_other = 0;
9705 ivna.vna_name = 0;
9706 break;
9707 }
dd27201e
L
9708
9709 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9710 ivn.vn_next = BYTE_GET (evn.vn_next);
9711
252b5132
RH
9712 vna_off = offset + ivn.vn_aux;
9713
9714 do
9715 {
b34976b6 9716 Elf_External_Vernaux evna;
252b5132 9717
59245841
NC
9718 if (get_data (&evna, file, vna_off,
9719 sizeof (evna), 1,
9720 _("version need aux (3)")) == NULL)
9721 {
9722 ivna.vna_next = 0;
9723 ivna.vna_other = 0;
9724 ivna.vna_name = 0;
9725 }
9726 else
9727 {
9728 ivna.vna_other = BYTE_GET (evna.vna_other);
9729 ivna.vna_next = BYTE_GET (evna.vna_next);
9730 ivna.vna_name = BYTE_GET (evna.vna_name);
9731 }
252b5132
RH
9732
9733 vna_off += ivna.vna_next;
9734 }
9735 while (ivna.vna_other != vers_data
9736 && ivna.vna_next != 0);
9737
9738 if (ivna.vna_other == vers_data)
9739 break;
9740
9741 offset += ivn.vn_next;
9742 }
9743 while (ivn.vn_next != 0);
9744
9745 if (ivna.vna_other == vers_data)
9746 {
9747 printf ("@%s (%d)",
c256ffe7 9748 ivna.vna_name < strtab_size
2b692964 9749 ? strtab + ivna.vna_name : _("<corrupt>"),
c256ffe7 9750 ivna.vna_other);
252b5132
RH
9751 check_def = 0;
9752 }
9753 else if (! is_nobits)
591a748a 9754 error (_("bad dynamic symbol\n"));
252b5132
RH
9755 else
9756 check_def = 1;
9757 }
9758
9759 if (check_def)
9760 {
00d93f34 9761 if (vers_data != 0x8001
b34976b6 9762 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9763 {
b34976b6
AM
9764 Elf_Internal_Verdef ivd;
9765 Elf_Internal_Verdaux ivda;
9766 Elf_External_Verdaux evda;
91d6fa6a 9767 unsigned long off;
252b5132 9768
91d6fa6a 9769 off = offset_from_vma
d93f0186
NC
9770 (file,
9771 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9772 sizeof (Elf_External_Verdef));
252b5132
RH
9773
9774 do
9775 {
b34976b6 9776 Elf_External_Verdef evd;
252b5132 9777
59245841
NC
9778 if (get_data (&evd, file, off, sizeof (evd),
9779 1, _("version def")) == NULL)
9780 {
9781 ivd.vd_ndx = 0;
9782 ivd.vd_aux = 0;
9783 ivd.vd_next = 0;
9784 }
9785 else
9786 {
9787 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9788 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9789 ivd.vd_next = BYTE_GET (evd.vd_next);
9790 }
252b5132 9791
91d6fa6a 9792 off += ivd.vd_next;
252b5132 9793 }
c244d050 9794 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
252b5132
RH
9795 && ivd.vd_next != 0);
9796
91d6fa6a
NC
9797 off -= ivd.vd_next;
9798 off += ivd.vd_aux;
252b5132 9799
59245841
NC
9800 if (get_data (&evda, file, off, sizeof (evda),
9801 1, _("version def aux")) == NULL)
9802 break;
252b5132
RH
9803
9804 ivda.vda_name = BYTE_GET (evda.vda_name);
9805
9806 if (psym->st_name != ivda.vda_name)
c244d050 9807 printf ((vers_data & VERSYM_HIDDEN)
252b5132 9808 ? "@%s" : "@@%s",
c256ffe7 9809 ivda.vda_name < strtab_size
2b692964 9810 ? strtab + ivda.vda_name : _("<corrupt>"));
252b5132
RH
9811 }
9812 }
9813 }
9814 }
9815
9816 putchar ('\n');
9817 }
9818
9819 free (symtab);
9820 if (strtab != string_table)
9821 free (strtab);
9822 }
9823 }
9824 else if (do_syms)
9825 printf
9826 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9827
9828 if (do_histogram && buckets != NULL)
9829 {
2cf0635d
NC
9830 unsigned long * lengths;
9831 unsigned long * counts;
66543521
AM
9832 unsigned long hn;
9833 bfd_vma si;
9834 unsigned long maxlength = 0;
9835 unsigned long nzero_counts = 0;
9836 unsigned long nsyms = 0;
252b5132 9837
66543521
AM
9838 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9839 (unsigned long) nbuckets);
252b5132
RH
9840 printf (_(" Length Number %% of total Coverage\n"));
9841
3f5e193b 9842 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH
9843 if (lengths == NULL)
9844 {
591a748a 9845 error (_("Out of memory\n"));
252b5132
RH
9846 return 0;
9847 }
9848 for (hn = 0; hn < nbuckets; ++hn)
9849 {
f7a99963 9850 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
252b5132 9851 {
b34976b6 9852 ++nsyms;
252b5132 9853 if (maxlength < ++lengths[hn])
b34976b6 9854 ++maxlength;
252b5132
RH
9855 }
9856 }
9857
3f5e193b 9858 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH
9859 if (counts == NULL)
9860 {
591a748a 9861 error (_("Out of memory\n"));
252b5132
RH
9862 return 0;
9863 }
9864
9865 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 9866 ++counts[lengths[hn]];
252b5132 9867
103f02d3 9868 if (nbuckets > 0)
252b5132 9869 {
66543521
AM
9870 unsigned long i;
9871 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 9872 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 9873 for (i = 1; i <= maxlength; ++i)
103f02d3 9874 {
66543521
AM
9875 nzero_counts += counts[i] * i;
9876 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9877 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD
9878 (nzero_counts * 100.0) / nsyms);
9879 }
252b5132
RH
9880 }
9881
9882 free (counts);
9883 free (lengths);
9884 }
9885
9886 if (buckets != NULL)
9887 {
9888 free (buckets);
9889 free (chains);
9890 }
9891
d3a44ec6 9892 if (do_histogram && gnubuckets != NULL)
fdc90cb4 9893 {
2cf0635d
NC
9894 unsigned long * lengths;
9895 unsigned long * counts;
fdc90cb4
JJ
9896 unsigned long hn;
9897 unsigned long maxlength = 0;
9898 unsigned long nzero_counts = 0;
9899 unsigned long nsyms = 0;
fdc90cb4 9900
3f5e193b 9901 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ
9902 if (lengths == NULL)
9903 {
591a748a 9904 error (_("Out of memory\n"));
fdc90cb4
JJ
9905 return 0;
9906 }
9907
9908 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9909 (unsigned long) ngnubuckets);
9910 printf (_(" Length Number %% of total Coverage\n"));
9911
9912 for (hn = 0; hn < ngnubuckets; ++hn)
9913 if (gnubuckets[hn] != 0)
9914 {
9915 bfd_vma off, length = 1;
9916
6bd1a22c 9917 for (off = gnubuckets[hn] - gnusymidx;
fdc90cb4
JJ
9918 (gnuchains[off] & 1) == 0; ++off)
9919 ++length;
9920 lengths[hn] = length;
9921 if (length > maxlength)
9922 maxlength = length;
9923 nsyms += length;
9924 }
9925
3f5e193b 9926 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ
9927 if (counts == NULL)
9928 {
591a748a 9929 error (_("Out of memory\n"));
fdc90cb4
JJ
9930 return 0;
9931 }
9932
9933 for (hn = 0; hn < ngnubuckets; ++hn)
9934 ++counts[lengths[hn]];
9935
9936 if (ngnubuckets > 0)
9937 {
9938 unsigned long j;
9939 printf (" 0 %-10lu (%5.1f%%)\n",
9940 counts[0], (counts[0] * 100.0) / ngnubuckets);
9941 for (j = 1; j <= maxlength; ++j)
9942 {
9943 nzero_counts += counts[j] * j;
9944 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9945 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9946 (nzero_counts * 100.0) / nsyms);
9947 }
9948 }
9949
9950 free (counts);
9951 free (lengths);
9952 free (gnubuckets);
9953 free (gnuchains);
9954 }
9955
252b5132
RH
9956 return 1;
9957}
9958
9959static int
2cf0635d 9960process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 9961{
b4c96d0d 9962 unsigned int i;
252b5132
RH
9963
9964 if (dynamic_syminfo == NULL
9965 || !do_dynamic)
9966 /* No syminfo, this is ok. */
9967 return 1;
9968
9969 /* There better should be a dynamic symbol section. */
9970 if (dynamic_symbols == NULL || dynamic_strings == NULL)
9971 return 0;
9972
9973 if (dynamic_addr)
9974 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9975 dynamic_syminfo_offset, dynamic_syminfo_nent);
9976
9977 printf (_(" Num: Name BoundTo Flags\n"));
9978 for (i = 0; i < dynamic_syminfo_nent; ++i)
9979 {
9980 unsigned short int flags = dynamic_syminfo[i].si_flags;
9981
31104126 9982 printf ("%4d: ", i);
d79b3d50
NC
9983 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9984 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9985 else
2b692964 9986 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 9987 putchar (' ');
252b5132
RH
9988
9989 switch (dynamic_syminfo[i].si_boundto)
9990 {
9991 case SYMINFO_BT_SELF:
9992 fputs ("SELF ", stdout);
9993 break;
9994 case SYMINFO_BT_PARENT:
9995 fputs ("PARENT ", stdout);
9996 break;
9997 default:
9998 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC
9999 && dynamic_syminfo[i].si_boundto < dynamic_nent
10000 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 10001 {
d79b3d50 10002 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC
10003 putchar (' ' );
10004 }
252b5132
RH
10005 else
10006 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
10007 break;
10008 }
10009
10010 if (flags & SYMINFO_FLG_DIRECT)
10011 printf (" DIRECT");
10012 if (flags & SYMINFO_FLG_PASSTHRU)
10013 printf (" PASSTHRU");
10014 if (flags & SYMINFO_FLG_COPY)
10015 printf (" COPY");
10016 if (flags & SYMINFO_FLG_LAZYLOAD)
10017 printf (" LAZYLOAD");
10018
10019 puts ("");
10020 }
10021
10022 return 1;
10023}
10024
cf13d699
NC
10025/* Check to see if the given reloc needs to be handled in a target specific
10026 manner. If so then process the reloc and return TRUE otherwise return
10027 FALSE. */
09c11c86 10028
cf13d699
NC
10029static bfd_boolean
10030target_specific_reloc_handling (Elf_Internal_Rela * reloc,
10031 unsigned char * start,
10032 Elf_Internal_Sym * symtab)
252b5132 10033{
cf13d699 10034 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 10035
cf13d699 10036 switch (elf_header.e_machine)
252b5132 10037 {
13761a11
NC
10038 case EM_MSP430:
10039 case EM_MSP430_OLD:
10040 {
10041 static Elf_Internal_Sym * saved_sym = NULL;
10042
10043 switch (reloc_type)
10044 {
10045 case 10: /* R_MSP430_SYM_DIFF */
10046 if (uses_msp430x_relocs ())
10047 break;
10048 case 21: /* R_MSP430X_SYM_DIFF */
10049 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10050 return TRUE;
10051
10052 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10053 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10054 goto handle_sym_diff;
10055
10056 case 5: /* R_MSP430_16_BYTE */
10057 case 9: /* R_MSP430_8 */
10058 if (uses_msp430x_relocs ())
10059 break;
10060 goto handle_sym_diff;
10061
10062 case 2: /* R_MSP430_ABS16 */
10063 case 15: /* R_MSP430X_ABS16 */
10064 if (! uses_msp430x_relocs ())
10065 break;
10066 goto handle_sym_diff;
10067
10068 handle_sym_diff:
10069 if (saved_sym != NULL)
10070 {
10071 bfd_vma value;
10072
10073 value = reloc->r_addend
10074 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10075 - saved_sym->st_value);
10076
10077 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10078
10079 saved_sym = NULL;
10080 return TRUE;
10081 }
10082 break;
10083
10084 default:
10085 if (saved_sym != NULL)
10086 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc"));
10087 break;
10088 }
10089 break;
10090 }
10091
cf13d699
NC
10092 case EM_MN10300:
10093 case EM_CYGNUS_MN10300:
10094 {
10095 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 10096
cf13d699
NC
10097 switch (reloc_type)
10098 {
10099 case 34: /* R_MN10300_ALIGN */
10100 return TRUE;
10101 case 33: /* R_MN10300_SYM_DIFF */
10102 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10103 return TRUE;
10104 case 1: /* R_MN10300_32 */
10105 case 2: /* R_MN10300_16 */
10106 if (saved_sym != NULL)
10107 {
10108 bfd_vma value;
252b5132 10109
cf13d699
NC
10110 value = reloc->r_addend
10111 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10112 - saved_sym->st_value);
252b5132 10113
cf13d699 10114 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 10115
cf13d699
NC
10116 saved_sym = NULL;
10117 return TRUE;
10118 }
10119 break;
10120 default:
10121 if (saved_sym != NULL)
10122 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
10123 break;
10124 }
10125 break;
10126 }
252b5132
RH
10127 }
10128
cf13d699 10129 return FALSE;
252b5132
RH
10130}
10131
aca88567
NC
10132/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10133 DWARF debug sections. This is a target specific test. Note - we do not
10134 go through the whole including-target-headers-multiple-times route, (as
10135 we have already done with <elf/h8.h>) because this would become very
10136 messy and even then this function would have to contain target specific
10137 information (the names of the relocs instead of their numeric values).
10138 FIXME: This is not the correct way to solve this problem. The proper way
10139 is to have target specific reloc sizing and typing functions created by
10140 the reloc-macros.h header, in the same way that it already creates the
10141 reloc naming functions. */
10142
10143static bfd_boolean
10144is_32bit_abs_reloc (unsigned int reloc_type)
10145{
10146 switch (elf_header.e_machine)
10147 {
41e92641
NC
10148 case EM_386:
10149 case EM_486:
10150 return reloc_type == 1; /* R_386_32. */
aca88567
NC
10151 case EM_68K:
10152 return reloc_type == 1; /* R_68K_32. */
10153 case EM_860:
10154 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM
10155 case EM_960:
10156 return reloc_type == 2; /* R_960_32. */
a06ea964
NC
10157 case EM_AARCH64:
10158 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 10159 case EM_ALPHA:
137b6b5f 10160 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC
10161 case EM_ARC:
10162 return reloc_type == 1; /* R_ARC_32. */
10163 case EM_ARM:
10164 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 10165 case EM_AVR_OLD:
aca88567
NC
10166 case EM_AVR:
10167 return reloc_type == 1;
cfb8c092
NC
10168 case EM_ADAPTEVA_EPIPHANY:
10169 return reloc_type == 3;
aca88567
NC
10170 case EM_BLACKFIN:
10171 return reloc_type == 0x12; /* R_byte4_data. */
10172 case EM_CRIS:
10173 return reloc_type == 3; /* R_CRIS_32. */
10174 case EM_CR16:
10175 return reloc_type == 3; /* R_CR16_NUM32. */
10176 case EM_CRX:
10177 return reloc_type == 15; /* R_CRX_NUM32. */
10178 case EM_CYGNUS_FRV:
10179 return reloc_type == 1;
41e92641
NC
10180 case EM_CYGNUS_D10V:
10181 case EM_D10V:
10182 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC
10183 case EM_CYGNUS_D30V:
10184 case EM_D30V:
10185 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC
10186 case EM_DLX:
10187 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC
10188 case EM_CYGNUS_FR30:
10189 case EM_FR30:
10190 return reloc_type == 3; /* R_FR30_32. */
10191 case EM_H8S:
10192 case EM_H8_300:
10193 case EM_H8_300H:
10194 return reloc_type == 1; /* R_H8_DIR32. */
3730236a
NC
10195 case EM_IA_64:
10196 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
aca88567
NC
10197 case EM_IP2K_OLD:
10198 case EM_IP2K:
10199 return reloc_type == 2; /* R_IP2K_32. */
10200 case EM_IQ2000:
10201 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC
10202 case EM_LATTICEMICO32:
10203 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 10204 case EM_M32C_OLD:
aca88567
NC
10205 case EM_M32C:
10206 return reloc_type == 3; /* R_M32C_32. */
10207 case EM_M32R:
10208 return reloc_type == 34; /* R_M32R_32_RELA. */
10209 case EM_MCORE:
10210 return reloc_type == 1; /* R_MCORE_ADDR32. */
10211 case EM_CYGNUS_MEP:
10212 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC
10213 case EM_METAG:
10214 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM
10215 case EM_MICROBLAZE:
10216 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC
10217 case EM_MIPS:
10218 return reloc_type == 2; /* R_MIPS_32. */
10219 case EM_MMIX:
10220 return reloc_type == 4; /* R_MMIX_32. */
10221 case EM_CYGNUS_MN10200:
10222 case EM_MN10200:
10223 return reloc_type == 1; /* R_MN10200_32. */
10224 case EM_CYGNUS_MN10300:
10225 case EM_MN10300:
10226 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM
10227 case EM_MOXIE:
10228 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC
10229 case EM_MSP430_OLD:
10230 case EM_MSP430:
13761a11 10231 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC
10232 case EM_MT:
10233 return reloc_type == 2; /* R_MT_32. */
3e0873ac 10234 case EM_ALTERA_NIOS2:
36591ba1 10235 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC
10236 case EM_NIOS32:
10237 return reloc_type == 1; /* R_NIOS_32. */
41e92641
NC
10238 case EM_OPENRISC:
10239 case EM_OR32:
10240 return reloc_type == 1; /* R_OR32_32. */
aca88567 10241 case EM_PARISC:
5fda8eca
NC
10242 return (reloc_type == 1 /* R_PARISC_DIR32. */
10243 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC
10244 case EM_PJ:
10245 case EM_PJ_OLD:
10246 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
10247 case EM_PPC64:
10248 return reloc_type == 1; /* R_PPC64_ADDR32. */
10249 case EM_PPC:
10250 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD
10251 case EM_RL78:
10252 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC
10253 case EM_RX:
10254 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC
10255 case EM_S370:
10256 return reloc_type == 1; /* R_I370_ADDR31. */
10257 case EM_S390_OLD:
10258 case EM_S390:
10259 return reloc_type == 4; /* R_S390_32. */
41e92641
NC
10260 case EM_SCORE:
10261 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC
10262 case EM_SH:
10263 return reloc_type == 1; /* R_SH_DIR32. */
10264 case EM_SPARC32PLUS:
10265 case EM_SPARCV9:
10266 case EM_SPARC:
10267 return reloc_type == 3 /* R_SPARC_32. */
10268 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM
10269 case EM_SPU:
10270 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM
10271 case EM_TI_C6000:
10272 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC
10273 case EM_TILEGX:
10274 return reloc_type == 2; /* R_TILEGX_32. */
10275 case EM_TILEPRO:
10276 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC
10277 case EM_CYGNUS_V850:
10278 case EM_V850:
10279 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC
10280 case EM_V800:
10281 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC
10282 case EM_VAX:
10283 return reloc_type == 1; /* R_VAX_32. */
10284 case EM_X86_64:
8a9036a4 10285 case EM_L1OM:
7a9068fe 10286 case EM_K1OM:
aca88567 10287 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC
10288 case EM_XC16X:
10289 case EM_C166:
10290 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC
10291 case EM_XGATE:
10292 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC
10293 case EM_XSTORMY16:
10294 return reloc_type == 1; /* R_XSTROMY16_32. */
10295 case EM_XTENSA_OLD:
10296 case EM_XTENSA:
10297 return reloc_type == 1; /* R_XTENSA_32. */
aca88567
NC
10298 default:
10299 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10300 elf_header.e_machine);
10301 abort ();
10302 }
10303}
10304
10305/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10306 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10307
10308static bfd_boolean
10309is_32bit_pcrel_reloc (unsigned int reloc_type)
10310{
10311 switch (elf_header.e_machine)
10312 {
41e92641
NC
10313 case EM_386:
10314 case EM_486:
3e0873ac 10315 return reloc_type == 2; /* R_386_PC32. */
aca88567 10316 case EM_68K:
3e0873ac 10317 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC
10318 case EM_AARCH64:
10319 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC
10320 case EM_ADAPTEVA_EPIPHANY:
10321 return reloc_type == 6;
aca88567
NC
10322 case EM_ALPHA:
10323 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 10324 case EM_ARM:
3e0873ac 10325 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM
10326 case EM_MICROBLAZE:
10327 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
aca88567 10328 case EM_PARISC:
85acf597 10329 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC
10330 case EM_PPC:
10331 return reloc_type == 26; /* R_PPC_REL32. */
10332 case EM_PPC64:
3e0873ac 10333 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC
10334 case EM_S390_OLD:
10335 case EM_S390:
3e0873ac 10336 return reloc_type == 5; /* R_390_PC32. */
aca88567 10337 case EM_SH:
3e0873ac 10338 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC
10339 case EM_SPARC32PLUS:
10340 case EM_SPARCV9:
10341 case EM_SPARC:
3e0873ac 10342 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM
10343 case EM_SPU:
10344 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC
10345 case EM_TILEGX:
10346 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
10347 case EM_TILEPRO:
10348 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
aca88567 10349 case EM_X86_64:
8a9036a4 10350 case EM_L1OM:
7a9068fe 10351 case EM_K1OM:
3e0873ac 10352 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW
10353 case EM_XTENSA_OLD:
10354 case EM_XTENSA:
10355 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC
10356 default:
10357 /* Do not abort or issue an error message here. Not all targets use
10358 pc-relative 32-bit relocs in their DWARF debug information and we
10359 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC
10360 more helpful warning message will be generated by apply_relocations
10361 anyway, so just return. */
aca88567
NC
10362 return FALSE;
10363 }
10364}
10365
10366/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10367 a 64-bit absolute RELA relocation used in DWARF debug sections. */
10368
10369static bfd_boolean
10370is_64bit_abs_reloc (unsigned int reloc_type)
10371{
10372 switch (elf_header.e_machine)
10373 {
a06ea964
NC
10374 case EM_AARCH64:
10375 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC
10376 case EM_ALPHA:
10377 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC
10378 case EM_IA_64:
10379 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC
10380 case EM_PARISC:
10381 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC
10382 case EM_PPC64:
10383 return reloc_type == 38; /* R_PPC64_ADDR64. */
10384 case EM_SPARC32PLUS:
10385 case EM_SPARCV9:
10386 case EM_SPARC:
10387 return reloc_type == 54; /* R_SPARC_UA64. */
10388 case EM_X86_64:
8a9036a4 10389 case EM_L1OM:
7a9068fe 10390 case EM_K1OM:
aca88567 10391 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS
10392 case EM_S390_OLD:
10393 case EM_S390:
aa137e4d
NC
10394 return reloc_type == 22; /* R_S390_64. */
10395 case EM_TILEGX:
10396 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 10397 case EM_MIPS:
aa137e4d 10398 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC
10399 default:
10400 return FALSE;
10401 }
10402}
10403
85acf597
RH
10404/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10405 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10406
10407static bfd_boolean
10408is_64bit_pcrel_reloc (unsigned int reloc_type)
10409{
10410 switch (elf_header.e_machine)
10411 {
a06ea964
NC
10412 case EM_AARCH64:
10413 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 10414 case EM_ALPHA:
aa137e4d 10415 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 10416 case EM_IA_64:
aa137e4d 10417 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 10418 case EM_PARISC:
aa137e4d 10419 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 10420 case EM_PPC64:
aa137e4d 10421 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH
10422 case EM_SPARC32PLUS:
10423 case EM_SPARCV9:
10424 case EM_SPARC:
aa137e4d 10425 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 10426 case EM_X86_64:
8a9036a4 10427 case EM_L1OM:
7a9068fe 10428 case EM_K1OM:
aa137e4d 10429 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH
10430 case EM_S390_OLD:
10431 case EM_S390:
aa137e4d
NC
10432 return reloc_type == 23; /* R_S390_PC64. */
10433 case EM_TILEGX:
10434 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH
10435 default:
10436 return FALSE;
10437 }
10438}
10439
4dc3c23d
AM
10440/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10441 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10442
10443static bfd_boolean
10444is_24bit_abs_reloc (unsigned int reloc_type)
10445{
10446 switch (elf_header.e_machine)
10447 {
10448 case EM_CYGNUS_MN10200:
10449 case EM_MN10200:
10450 return reloc_type == 4; /* R_MN10200_24. */
10451 default:
10452 return FALSE;
10453 }
10454}
10455
aca88567
NC
10456/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10457 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10458
10459static bfd_boolean
10460is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC
10461{
10462 switch (elf_header.e_machine)
10463 {
aca88567
NC
10464 case EM_AVR_OLD:
10465 case EM_AVR:
10466 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC
10467 case EM_ADAPTEVA_EPIPHANY:
10468 return reloc_type == 5;
41e92641
NC
10469 case EM_CYGNUS_D10V:
10470 case EM_D10V:
10471 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC
10472 case EM_H8S:
10473 case EM_H8_300:
10474 case EM_H8_300H:
aca88567
NC
10475 return reloc_type == R_H8_DIR16;
10476 case EM_IP2K_OLD:
10477 case EM_IP2K:
10478 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 10479 case EM_M32C_OLD:
f4236fe4
DD
10480 case EM_M32C:
10481 return reloc_type == 1; /* R_M32C_16 */
aca88567 10482 case EM_MSP430:
13761a11
NC
10483 if (uses_msp430x_relocs ())
10484 return reloc_type == 2; /* R_MSP430_ABS16. */
78c8d46c 10485 case EM_MSP430_OLD:
aca88567 10486 return reloc_type == 5; /* R_MSP430_16_BYTE. */
3e0873ac 10487 case EM_ALTERA_NIOS2:
36591ba1 10488 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC
10489 case EM_NIOS32:
10490 return reloc_type == 9; /* R_NIOS_16. */
40b36596
JM
10491 case EM_TI_C6000:
10492 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC
10493 case EM_XC16X:
10494 case EM_C166:
10495 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM
10496 case EM_CYGNUS_MN10200:
10497 case EM_MN10200:
10498 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC
10499 case EM_CYGNUS_MN10300:
10500 case EM_MN10300:
10501 return reloc_type == 2; /* R_MN10300_16. */
f6c1a2d5
NC
10502 case EM_XGATE:
10503 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 10504 default:
aca88567 10505 return FALSE;
4b78141a
NC
10506 }
10507}
10508
2a7b2e88
JK
10509/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10510 relocation entries (possibly formerly used for SHT_GROUP sections). */
10511
10512static bfd_boolean
10513is_none_reloc (unsigned int reloc_type)
10514{
10515 switch (elf_header.e_machine)
10516 {
cb8f3167
NC
10517 case EM_68K: /* R_68K_NONE. */
10518 case EM_386: /* R_386_NONE. */
2a7b2e88
JK
10519 case EM_SPARC32PLUS:
10520 case EM_SPARCV9:
cb8f3167
NC
10521 case EM_SPARC: /* R_SPARC_NONE. */
10522 case EM_MIPS: /* R_MIPS_NONE. */
10523 case EM_PARISC: /* R_PARISC_NONE. */
10524 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 10525 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC
10526 case EM_PPC: /* R_PPC_NONE. */
10527 case EM_PPC64: /* R_PPC64_NONE. */
10528 case EM_ARM: /* R_ARM_NONE. */
10529 case EM_IA_64: /* R_IA64_NONE. */
10530 case EM_SH: /* R_SH_NONE. */
2a7b2e88 10531 case EM_S390_OLD:
cb8f3167
NC
10532 case EM_S390: /* R_390_NONE. */
10533 case EM_CRIS: /* R_CRIS_NONE. */
10534 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 10535 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 10536 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 10537 case EM_MN10300: /* R_MN10300_NONE. */
5506d11a 10538 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 10539 case EM_M32R: /* R_M32R_NONE. */
40b36596 10540 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC
10541 case EM_TILEGX: /* R_TILEGX_NONE. */
10542 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC
10543 case EM_XC16X:
10544 case EM_C166: /* R_XC16X_NONE. */
36591ba1
SL
10545 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
10546 case EM_NIOS32: /* R_NIOS_NONE. */
cb8f3167 10547 return reloc_type == 0;
a06ea964
NC
10548 case EM_AARCH64:
10549 return reloc_type == 0 || reloc_type == 256;
58332dda
JK
10550 case EM_XTENSA_OLD:
10551 case EM_XTENSA:
4dc3c23d
AM
10552 return (reloc_type == 0 /* R_XTENSA_NONE. */
10553 || reloc_type == 17 /* R_XTENSA_DIFF8. */
10554 || reloc_type == 18 /* R_XTENSA_DIFF16. */
10555 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
a3c62988
NC
10556 case EM_METAG:
10557 return reloc_type == 3; /* R_METAG_NONE. */
2a7b2e88
JK
10558 }
10559 return FALSE;
10560}
10561
cf13d699
NC
10562/* Apply relocations to a section.
10563 Note: So far support has been added only for those relocations
10564 which can be found in debug sections.
10565 FIXME: Add support for more relocations ? */
1b315056 10566
cf13d699
NC
10567static void
10568apply_relocations (void * file,
10569 Elf_Internal_Shdr * section,
10570 unsigned char * start)
1b315056 10571{
cf13d699
NC
10572 Elf_Internal_Shdr * relsec;
10573 unsigned char * end = start + section->sh_size;
cb8f3167 10574
cf13d699
NC
10575 if (elf_header.e_type != ET_REL)
10576 return;
1b315056 10577
cf13d699 10578 /* Find the reloc section associated with the section. */
5b18a4bc
NC
10579 for (relsec = section_headers;
10580 relsec < section_headers + elf_header.e_shnum;
10581 ++relsec)
252b5132 10582 {
41e92641
NC
10583 bfd_boolean is_rela;
10584 unsigned long num_relocs;
2cf0635d
NC
10585 Elf_Internal_Rela * relocs;
10586 Elf_Internal_Rela * rp;
10587 Elf_Internal_Shdr * symsec;
10588 Elf_Internal_Sym * symtab;
ba5cdace 10589 unsigned long num_syms;
2cf0635d 10590 Elf_Internal_Sym * sym;
252b5132 10591
41e92641 10592 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM
10593 || relsec->sh_info >= elf_header.e_shnum
10594 || section_headers + relsec->sh_info != section
c256ffe7 10595 || relsec->sh_size == 0
4fbb74a6 10596 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 10597 continue;
428409d5 10598
41e92641
NC
10599 is_rela = relsec->sh_type == SHT_RELA;
10600
10601 if (is_rela)
10602 {
3f5e193b
NC
10603 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10604 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC
10605 return;
10606 }
10607 else
10608 {
3f5e193b
NC
10609 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10610 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC
10611 return;
10612 }
10613
10614 /* SH uses RELA but uses in place value instead of the addend field. */
10615 if (elf_header.e_machine == EM_SH)
10616 is_rela = FALSE;
428409d5 10617
4fbb74a6 10618 symsec = section_headers + relsec->sh_link;
ba5cdace 10619 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 10620
41e92641 10621 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 10622 {
41e92641
NC
10623 bfd_vma addend;
10624 unsigned int reloc_type;
10625 unsigned int reloc_size;
91d6fa6a 10626 unsigned char * rloc;
ba5cdace 10627 unsigned long sym_index;
4b78141a 10628
aca88567 10629 reloc_type = get_reloc_type (rp->r_info);
41e92641 10630
98fb390a 10631 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 10632 continue;
98fb390a
NC
10633 else if (is_none_reloc (reloc_type))
10634 continue;
10635 else if (is_32bit_abs_reloc (reloc_type)
10636 || is_32bit_pcrel_reloc (reloc_type))
aca88567 10637 reloc_size = 4;
85acf597
RH
10638 else if (is_64bit_abs_reloc (reloc_type)
10639 || is_64bit_pcrel_reloc (reloc_type))
aca88567 10640 reloc_size = 8;
4dc3c23d
AM
10641 else if (is_24bit_abs_reloc (reloc_type))
10642 reloc_size = 3;
aca88567
NC
10643 else if (is_16bit_abs_reloc (reloc_type))
10644 reloc_size = 2;
10645 else
4b78141a 10646 {
41e92641 10647 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
aca88567 10648 reloc_type, SECTION_NAME (section));
4b78141a
NC
10649 continue;
10650 }
103f02d3 10651
91d6fa6a 10652 rloc = start + rp->r_offset;
c8da6823 10653 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L
10654 {
10655 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10656 (unsigned long) rp->r_offset,
10657 SECTION_NAME (section));
10658 continue;
10659 }
103f02d3 10660
ba5cdace
NC
10661 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
10662 if (sym_index >= num_syms)
10663 {
10664 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10665 sym_index, SECTION_NAME (section));
10666 continue;
10667 }
10668 sym = symtab + sym_index;
41e92641
NC
10669
10670 /* If the reloc has a symbol associated with it,
55f25fc3
L
10671 make sure that it is of an appropriate type.
10672
10673 Relocations against symbols without type can happen.
10674 Gcc -feliminate-dwarf2-dups may generate symbols
10675 without type for debug info.
10676
10677 Icc generates relocations against function symbols
10678 instead of local labels.
10679
10680 Relocations against object symbols can happen, eg when
10681 referencing a global array. For an example of this see
10682 the _clz.o binary in libgcc.a. */
aca88567 10683 if (sym != symtab
55f25fc3 10684 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 10685 {
41e92641 10686 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 10687 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 10688 (long int)(rp - relocs),
41e92641 10689 SECTION_NAME (relsec));
aca88567 10690 continue;
5b18a4bc 10691 }
252b5132 10692
4dc3c23d
AM
10693 addend = 0;
10694 if (is_rela)
10695 addend += rp->r_addend;
c47320c3
AM
10696 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10697 partial_inplace. */
4dc3c23d
AM
10698 if (!is_rela
10699 || (elf_header.e_machine == EM_XTENSA
10700 && reloc_type == 1)
10701 || ((elf_header.e_machine == EM_PJ
10702 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM
10703 && reloc_type == 1)
10704 || ((elf_header.e_machine == EM_D30V
10705 || elf_header.e_machine == EM_CYGNUS_D30V)
10706 && reloc_type == 12))
91d6fa6a 10707 addend += byte_get (rloc, reloc_size);
cb8f3167 10708
85acf597
RH
10709 if (is_32bit_pcrel_reloc (reloc_type)
10710 || is_64bit_pcrel_reloc (reloc_type))
10711 {
10712 /* On HPPA, all pc-relative relocations are biased by 8. */
10713 if (elf_header.e_machine == EM_PARISC)
10714 addend -= 8;
91d6fa6a 10715 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH
10716 reloc_size);
10717 }
41e92641 10718 else
91d6fa6a 10719 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 10720 }
252b5132 10721
5b18a4bc 10722 free (symtab);
41e92641 10723 free (relocs);
5b18a4bc
NC
10724 break;
10725 }
5b18a4bc 10726}
103f02d3 10727
cf13d699
NC
10728#ifdef SUPPORT_DISASSEMBLY
10729static int
10730disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10731{
10732 printf (_("\nAssembly dump of section %s\n"),
10733 SECTION_NAME (section));
10734
10735 /* XXX -- to be done --- XXX */
10736
10737 return 1;
10738}
10739#endif
10740
10741/* Reads in the contents of SECTION from FILE, returning a pointer
10742 to a malloc'ed buffer or NULL if something went wrong. */
10743
10744static char *
10745get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10746{
10747 bfd_size_type num_bytes;
10748
10749 num_bytes = section->sh_size;
10750
10751 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
10752 {
10753 printf (_("\nSection '%s' has no data to dump.\n"),
10754 SECTION_NAME (section));
10755 return NULL;
10756 }
10757
3f5e193b
NC
10758 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
10759 _("section contents"));
cf13d699
NC
10760}
10761
dd24e3da 10762
cf13d699
NC
10763static void
10764dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
10765{
10766 Elf_Internal_Shdr * relsec;
10767 bfd_size_type num_bytes;
cf13d699
NC
10768 char * data;
10769 char * end;
10770 char * start;
10771 char * name = SECTION_NAME (section);
10772 bfd_boolean some_strings_shown;
10773
10774 start = get_section_contents (section, file);
10775 if (start == NULL)
10776 return;
10777
10778 printf (_("\nString dump of section '%s':\n"), name);
10779
10780 /* If the section being dumped has relocations against it the user might
10781 be expecting these relocations to have been applied. Check for this
10782 case and issue a warning message in order to avoid confusion.
10783 FIXME: Maybe we ought to have an option that dumps a section with
10784 relocs applied ? */
10785 for (relsec = section_headers;
10786 relsec < section_headers + elf_header.e_shnum;
10787 ++relsec)
10788 {
10789 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10790 || relsec->sh_info >= elf_header.e_shnum
10791 || section_headers + relsec->sh_info != section
10792 || relsec->sh_size == 0
10793 || relsec->sh_link >= elf_header.e_shnum)
10794 continue;
10795
10796 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10797 break;
10798 }
10799
10800 num_bytes = section->sh_size;
cf13d699
NC
10801 data = start;
10802 end = start + num_bytes;
10803 some_strings_shown = FALSE;
10804
10805 while (data < end)
10806 {
10807 while (!ISPRINT (* data))
10808 if (++ data >= end)
10809 break;
10810
10811 if (data < end)
10812 {
10813#ifndef __MSVCRT__
c975cc98
NC
10814 /* PR 11128: Use two separate invocations in order to work
10815 around bugs in the Solaris 8 implementation of printf. */
10816 printf (" [%6tx] ", data - start);
10817 printf ("%s\n", data);
cf13d699
NC
10818#else
10819 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
10820#endif
10821 data += strlen (data);
10822 some_strings_shown = TRUE;
10823 }
10824 }
10825
10826 if (! some_strings_shown)
10827 printf (_(" No strings found in this section."));
10828
10829 free (start);
10830
10831 putchar ('\n');
10832}
10833
10834static void
10835dump_section_as_bytes (Elf_Internal_Shdr * section,
10836 FILE * file,
10837 bfd_boolean relocate)
10838{
10839 Elf_Internal_Shdr * relsec;
10840 bfd_size_type bytes;
10841 bfd_vma addr;
10842 unsigned char * data;
10843 unsigned char * start;
10844
10845 start = (unsigned char *) get_section_contents (section, file);
10846 if (start == NULL)
10847 return;
10848
10849 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
10850
10851 if (relocate)
10852 {
10853 apply_relocations (file, section, start);
10854 }
10855 else
10856 {
10857 /* If the section being dumped has relocations against it the user might
10858 be expecting these relocations to have been applied. Check for this
10859 case and issue a warning message in order to avoid confusion.
10860 FIXME: Maybe we ought to have an option that dumps a section with
10861 relocs applied ? */
10862 for (relsec = section_headers;
10863 relsec < section_headers + elf_header.e_shnum;
10864 ++relsec)
10865 {
10866 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10867 || relsec->sh_info >= elf_header.e_shnum
10868 || section_headers + relsec->sh_info != section
10869 || relsec->sh_size == 0
10870 || relsec->sh_link >= elf_header.e_shnum)
10871 continue;
10872
10873 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10874 break;
10875 }
10876 }
10877
10878 addr = section->sh_addr;
10879 bytes = section->sh_size;
10880 data = start;
10881
10882 while (bytes)
10883 {
10884 int j;
10885 int k;
10886 int lbytes;
10887
10888 lbytes = (bytes > 16 ? 16 : bytes);
10889
10890 printf (" 0x%8.8lx ", (unsigned long) addr);
10891
10892 for (j = 0; j < 16; j++)
10893 {
10894 if (j < lbytes)
10895 printf ("%2.2x", data[j]);
10896 else
10897 printf (" ");
10898
10899 if ((j & 3) == 3)
10900 printf (" ");
10901 }
10902
10903 for (j = 0; j < lbytes; j++)
10904 {
10905 k = data[j];
10906 if (k >= ' ' && k < 0x7f)
10907 printf ("%c", k);
10908 else
10909 printf (".");
10910 }
10911
10912 putchar ('\n');
10913
10914 data += lbytes;
10915 addr += lbytes;
10916 bytes -= lbytes;
10917 }
10918
10919 free (start);
10920
10921 putchar ('\n');
10922}
10923
4a114e3e 10924/* Uncompresses a section that was compressed using zlib, in place. */
cf13d699
NC
10925
10926static int
d3dbc530
AM
10927uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10928 dwarf_size_type *size ATTRIBUTE_UNUSED)
cf13d699
NC
10929{
10930#ifndef HAVE_ZLIB_H
cf13d699
NC
10931 return FALSE;
10932#else
10933 dwarf_size_type compressed_size = *size;
10934 unsigned char * compressed_buffer = *buffer;
10935 dwarf_size_type uncompressed_size;
10936 unsigned char * uncompressed_buffer;
10937 z_stream strm;
10938 int rc;
10939 dwarf_size_type header_size = 12;
10940
10941 /* Read the zlib header. In this case, it should be "ZLIB" followed
10942 by the uncompressed section size, 8 bytes in big-endian order. */
10943 if (compressed_size < header_size
10944 || ! streq ((char *) compressed_buffer, "ZLIB"))
10945 return 0;
10946
10947 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10948 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10949 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10950 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10951 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10952 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10953 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10954 uncompressed_size += compressed_buffer[11];
10955
10956 /* It is possible the section consists of several compressed
10957 buffers concatenated together, so we uncompress in a loop. */
10958 strm.zalloc = NULL;
10959 strm.zfree = NULL;
10960 strm.opaque = NULL;
10961 strm.avail_in = compressed_size - header_size;
10962 strm.next_in = (Bytef *) compressed_buffer + header_size;
10963 strm.avail_out = uncompressed_size;
3f5e193b 10964 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
cf13d699
NC
10965
10966 rc = inflateInit (& strm);
10967 while (strm.avail_in > 0)
10968 {
10969 if (rc != Z_OK)
10970 goto fail;
10971 strm.next_out = ((Bytef *) uncompressed_buffer
10972 + (uncompressed_size - strm.avail_out));
10973 rc = inflate (&strm, Z_FINISH);
10974 if (rc != Z_STREAM_END)
10975 goto fail;
10976 rc = inflateReset (& strm);
10977 }
10978 rc = inflateEnd (& strm);
10979 if (rc != Z_OK
10980 || strm.avail_out != 0)
10981 goto fail;
10982
10983 free (compressed_buffer);
10984 *buffer = uncompressed_buffer;
10985 *size = uncompressed_size;
10986 return 1;
10987
10988 fail:
10989 free (uncompressed_buffer);
4a114e3e
L
10990 /* Indicate decompression failure. */
10991 *buffer = NULL;
cf13d699
NC
10992 return 0;
10993#endif /* HAVE_ZLIB_H */
10994}
10995
d966045b
DJ
10996static int
10997load_specific_debug_section (enum dwarf_section_display_enum debug,
2cf0635d 10998 Elf_Internal_Shdr * sec, void * file)
1007acb3 10999{
2cf0635d 11000 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 11001 char buf [64];
1007acb3 11002
19e6b90e
L
11003 /* If it is already loaded, do nothing. */
11004 if (section->start != NULL)
11005 return 1;
1007acb3 11006
19e6b90e
L
11007 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
11008 section->address = sec->sh_addr;
3f5e193b
NC
11009 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
11010 sec->sh_offset, 1,
11011 sec->sh_size, buf);
59245841
NC
11012 if (section->start == NULL)
11013 section->size = 0;
11014 else
11015 {
11016 section->size = sec->sh_size;
11017 if (uncompress_section_contents (&section->start, &section->size))
11018 sec->sh_size = section->size;
11019 }
4a114e3e 11020
1b315056
CS
11021 if (section->start == NULL)
11022 return 0;
11023
19e6b90e 11024 if (debug_displays [debug].relocate)
3f5e193b 11025 apply_relocations ((FILE *) file, sec, section->start);
1007acb3 11026
1b315056 11027 return 1;
1007acb3
L
11028}
11029
657d0d47
CC
11030/* If this is not NULL, load_debug_section will only look for sections
11031 within the list of sections given here. */
11032unsigned int *section_subset = NULL;
11033
d966045b 11034int
2cf0635d 11035load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 11036{
2cf0635d
NC
11037 struct dwarf_section * section = &debug_displays [debug].section;
11038 Elf_Internal_Shdr * sec;
d966045b
DJ
11039
11040 /* Locate the debug section. */
657d0d47 11041 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ
11042 if (sec != NULL)
11043 section->name = section->uncompressed_name;
11044 else
11045 {
657d0d47 11046 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ
11047 if (sec != NULL)
11048 section->name = section->compressed_name;
11049 }
11050 if (sec == NULL)
11051 return 0;
11052
657d0d47
CC
11053 /* If we're loading from a subset of sections, and we've loaded
11054 a section matching this name before, it's likely that it's a
11055 different one. */
11056 if (section_subset != NULL)
11057 free_debug_section (debug);
11058
3f5e193b 11059 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ
11060}
11061
19e6b90e
L
11062void
11063free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 11064{
2cf0635d 11065 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 11066
19e6b90e
L
11067 if (section->start == NULL)
11068 return;
1007acb3 11069
19e6b90e
L
11070 free ((char *) section->start);
11071 section->start = NULL;
11072 section->address = 0;
11073 section->size = 0;
1007acb3
L
11074}
11075
1007acb3 11076static int
657d0d47 11077display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 11078{
2cf0635d 11079 char * name = SECTION_NAME (section);
19e6b90e
L
11080 bfd_size_type length;
11081 int result = 1;
3f5e193b 11082 int i;
1007acb3 11083
19e6b90e
L
11084 length = section->sh_size;
11085 if (length == 0)
1007acb3 11086 {
19e6b90e
L
11087 printf (_("\nSection '%s' has no debugging data.\n"), name);
11088 return 0;
1007acb3 11089 }
5dff79d8
NC
11090 if (section->sh_type == SHT_NOBITS)
11091 {
11092 /* There is no point in dumping the contents of a debugging section
11093 which has the NOBITS type - the bits in the file will be random.
11094 This can happen when a file containing a .eh_frame section is
11095 stripped with the --only-keep-debug command line option. */
11096 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
11097 return 0;
11098 }
1007acb3 11099
0112cd26 11100 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 11101 name = ".debug_info";
1007acb3 11102
19e6b90e
L
11103 /* See if we know how to display the contents of this section. */
11104 for (i = 0; i < max; i++)
1b315056 11105 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 11106 || (i == line && const_strneq (name, ".debug_line."))
1b315056 11107 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 11108 {
2cf0635d 11109 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ
11110 int secondary = (section != find_section (name));
11111
11112 if (secondary)
3f5e193b 11113 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 11114
b40bf0a2
NC
11115 if (i == line && const_strneq (name, ".debug_line."))
11116 sec->name = name;
11117 else if (streq (sec->uncompressed_name, name))
d966045b
DJ
11118 sec->name = sec->uncompressed_name;
11119 else
11120 sec->name = sec->compressed_name;
3f5e193b
NC
11121 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
11122 section, file))
19e6b90e 11123 {
657d0d47
CC
11124 /* If this debug section is part of a CU/TU set in a .dwp file,
11125 restrict load_debug_section to the sections in that set. */
11126 section_subset = find_cu_tu_set (file, shndx);
11127
19e6b90e 11128 result &= debug_displays[i].display (sec, file);
1007acb3 11129
657d0d47
CC
11130 section_subset = NULL;
11131
d966045b 11132 if (secondary || (i != info && i != abbrev))
3f5e193b 11133 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 11134 }
1007acb3 11135
19e6b90e
L
11136 break;
11137 }
1007acb3 11138
19e6b90e 11139 if (i == max)
1007acb3 11140 {
19e6b90e
L
11141 printf (_("Unrecognized debug section: %s\n"), name);
11142 result = 0;
1007acb3
L
11143 }
11144
19e6b90e 11145 return result;
5b18a4bc 11146}
103f02d3 11147
aef1f6d0
DJ
11148/* Set DUMP_SECTS for all sections where dumps were requested
11149 based on section name. */
11150
11151static void
11152initialise_dumps_byname (void)
11153{
2cf0635d 11154 struct dump_list_entry * cur;
aef1f6d0
DJ
11155
11156 for (cur = dump_sects_byname; cur; cur = cur->next)
11157 {
11158 unsigned int i;
11159 int any;
11160
11161 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
11162 if (streq (SECTION_NAME (section_headers + i), cur->name))
11163 {
09c11c86 11164 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ
11165 any = 1;
11166 }
11167
11168 if (!any)
11169 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11170 cur->name);
11171 }
11172}
11173
5b18a4bc 11174static void
2cf0635d 11175process_section_contents (FILE * file)
5b18a4bc 11176{
2cf0635d 11177 Elf_Internal_Shdr * section;
19e6b90e 11178 unsigned int i;
103f02d3 11179
19e6b90e
L
11180 if (! do_dump)
11181 return;
103f02d3 11182
aef1f6d0
DJ
11183 initialise_dumps_byname ();
11184
19e6b90e
L
11185 for (i = 0, section = section_headers;
11186 i < elf_header.e_shnum && i < num_dump_sects;
11187 i++, section++)
11188 {
11189#ifdef SUPPORT_DISASSEMBLY
11190 if (dump_sects[i] & DISASS_DUMP)
11191 disassemble_section (section, file);
11192#endif
11193 if (dump_sects[i] & HEX_DUMP)
cf13d699 11194 dump_section_as_bytes (section, file, FALSE);
103f02d3 11195
cf13d699
NC
11196 if (dump_sects[i] & RELOC_DUMP)
11197 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC
11198
11199 if (dump_sects[i] & STRING_DUMP)
11200 dump_section_as_strings (section, file);
cf13d699
NC
11201
11202 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 11203 display_debug_section (i, section, file);
5b18a4bc 11204 }
103f02d3 11205
19e6b90e
L
11206 /* Check to see if the user requested a
11207 dump of a section that does not exist. */
11208 while (i++ < num_dump_sects)
11209 if (dump_sects[i])
11210 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 11211}
103f02d3 11212
5b18a4bc 11213static void
19e6b90e 11214process_mips_fpe_exception (int mask)
5b18a4bc 11215{
19e6b90e
L
11216 if (mask)
11217 {
11218 int first = 1;
11219 if (mask & OEX_FPU_INEX)
11220 fputs ("INEX", stdout), first = 0;
11221 if (mask & OEX_FPU_UFLO)
11222 printf ("%sUFLO", first ? "" : "|"), first = 0;
11223 if (mask & OEX_FPU_OFLO)
11224 printf ("%sOFLO", first ? "" : "|"), first = 0;
11225 if (mask & OEX_FPU_DIV0)
11226 printf ("%sDIV0", first ? "" : "|"), first = 0;
11227 if (mask & OEX_FPU_INVAL)
11228 printf ("%sINVAL", first ? "" : "|");
11229 }
5b18a4bc 11230 else
19e6b90e 11231 fputs ("0", stdout);
5b18a4bc 11232}
103f02d3 11233
f6f0e17b
NC
11234/* Display's the value of TAG at location P. If TAG is
11235 greater than 0 it is assumed to be an unknown tag, and
11236 a message is printed to this effect. Otherwise it is
11237 assumed that a message has already been printed.
11238
11239 If the bottom bit of TAG is set it assumed to have a
11240 string value, otherwise it is assumed to have an integer
11241 value.
11242
11243 Returns an updated P pointing to the first unread byte
11244 beyond the end of TAG's value.
11245
11246 Reads at or beyond END will not be made. */
11247
11248static unsigned char *
11249display_tag_value (int tag,
11250 unsigned char * p,
11251 const unsigned char * const end)
11252{
11253 unsigned long val;
11254
11255 if (tag > 0)
11256 printf (" Tag_unknown_%d: ", tag);
11257
11258 if (p >= end)
11259 {
11260 warn (_("corrupt tag\n"));
11261 }
11262 else if (tag & 1)
11263 {
11264 /* FIXME: we could read beyond END here. */
11265 printf ("\"%s\"\n", p);
11266 p += strlen ((char *) p) + 1;
11267 }
11268 else
11269 {
11270 unsigned int len;
11271
11272 val = read_uleb128 (p, &len, end);
11273 p += len;
11274 printf ("%ld (0x%lx)\n", val, val);
11275 }
11276
11277 return p;
11278}
11279
11c1ff18
PB
11280/* ARM EABI attributes section. */
11281typedef struct
11282{
11283 int tag;
2cf0635d 11284 const char * name;
11c1ff18
PB
11285 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
11286 int type;
2cf0635d 11287 const char ** table;
11c1ff18
PB
11288} arm_attr_public_tag;
11289
2cf0635d 11290static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 11291 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 11292 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC
11293static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
11294static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 11295 {"No", "Thumb-1", "Thumb-2"};
75375b3e 11296static const char * arm_attr_tag_FP_arch[] =
bca38921
MGD
11297 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11298 "FP for ARMv8"};
2cf0635d 11299static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 11300static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 11301 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 11302static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB
11303 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11304 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 11305static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 11306 {"V6", "SB", "TLS", "Unused"};
2cf0635d 11307static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 11308 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 11309static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 11310 {"Absolute", "PC-relative", "None"};
2cf0635d 11311static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 11312 {"None", "direct", "GOT-indirect"};
2cf0635d 11313static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 11314 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC
11315static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
11316static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 11317 {"Unused", "Needed", "Sign only"};
2cf0635d
NC
11318static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
11319static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
11320static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 11321 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 11322static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 11323 {"Unused", "small", "int", "forced to int"};
2cf0635d 11324static const char * arm_attr_tag_ABI_HardFP_use[] =
75375b3e 11325 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
2cf0635d 11326static const char * arm_attr_tag_ABI_VFP_args[] =
11c1ff18 11327 {"AAPCS", "VFP registers", "custom"};
2cf0635d 11328static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 11329 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 11330static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB
11331 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11332 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 11333static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB
11334 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11335 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 11336static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 11337static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 11338 {"Not Allowed", "Allowed"};
2cf0635d 11339static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 11340 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 11341static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD
11342 {"Not Allowed", "Allowed"};
11343static const char * arm_attr_tag_DIV_use[] =
dd24e3da 11344 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 11345 "Allowed in v7-A with integer division extension"};
2cf0635d
NC
11346static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
11347static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 11348 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 11349 "TrustZone and Virtualization Extensions"};
dd24e3da 11350static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 11351 {"Not Allowed", "Allowed"};
11c1ff18
PB
11352
11353#define LOOKUP(id, name) \
11354 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 11355static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB
11356{
11357 {4, "CPU_raw_name", 1, NULL},
11358 {5, "CPU_name", 1, NULL},
11359 LOOKUP(6, CPU_arch),
11360 {7, "CPU_arch_profile", 0, NULL},
11361 LOOKUP(8, ARM_ISA_use),
11362 LOOKUP(9, THUMB_ISA_use),
75375b3e 11363 LOOKUP(10, FP_arch),
11c1ff18 11364 LOOKUP(11, WMMX_arch),
f5f53991
AS
11365 LOOKUP(12, Advanced_SIMD_arch),
11366 LOOKUP(13, PCS_config),
11c1ff18
PB
11367 LOOKUP(14, ABI_PCS_R9_use),
11368 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 11369 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB
11370 LOOKUP(17, ABI_PCS_GOT_use),
11371 LOOKUP(18, ABI_PCS_wchar_t),
11372 LOOKUP(19, ABI_FP_rounding),
11373 LOOKUP(20, ABI_FP_denormal),
11374 LOOKUP(21, ABI_FP_exceptions),
11375 LOOKUP(22, ABI_FP_user_exceptions),
11376 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD
11377 {24, "ABI_align_needed", 0, NULL},
11378 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB
11379 LOOKUP(26, ABI_enum_size),
11380 LOOKUP(27, ABI_HardFP_use),
11381 LOOKUP(28, ABI_VFP_args),
11382 LOOKUP(29, ABI_WMMX_args),
11383 LOOKUP(30, ABI_optimization_goals),
11384 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 11385 {32, "compatibility", 0, NULL},
f5f53991 11386 LOOKUP(34, CPU_unaligned_access),
75375b3e 11387 LOOKUP(36, FP_HP_extension),
8e79c3df 11388 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD
11389 LOOKUP(42, MPextension_use),
11390 LOOKUP(44, DIV_use),
f5f53991
AS
11391 {64, "nodefaults", 0, NULL},
11392 {65, "also_compatible_with", 0, NULL},
11393 LOOKUP(66, T2EE_use),
11394 {67, "conformance", 1, NULL},
11395 LOOKUP(68, Virtualization_use),
cd21e546 11396 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB
11397};
11398#undef LOOKUP
11399
11c1ff18 11400static unsigned char *
f6f0e17b
NC
11401display_arm_attribute (unsigned char * p,
11402 const unsigned char * const end)
11c1ff18
PB
11403{
11404 int tag;
11405 unsigned int len;
11406 int val;
2cf0635d 11407 arm_attr_public_tag * attr;
11c1ff18
PB
11408 unsigned i;
11409 int type;
11410
f6f0e17b 11411 tag = read_uleb128 (p, &len, end);
11c1ff18
PB
11412 p += len;
11413 attr = NULL;
2cf0635d 11414 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB
11415 {
11416 if (arm_attr_public_tags[i].tag == tag)
11417 {
11418 attr = &arm_attr_public_tags[i];
11419 break;
11420 }
11421 }
11422
11423 if (attr)
11424 {
11425 printf (" Tag_%s: ", attr->name);
11426 switch (attr->type)
11427 {
11428 case 0:
11429 switch (tag)
11430 {
11431 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 11432 val = read_uleb128 (p, &len, end);
11c1ff18
PB
11433 p += len;
11434 switch (val)
11435 {
2b692964
NC
11436 case 0: printf (_("None\n")); break;
11437 case 'A': printf (_("Application\n")); break;
11438 case 'R': printf (_("Realtime\n")); break;
11439 case 'M': printf (_("Microcontroller\n")); break;
11440 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB
11441 default: printf ("??? (%d)\n", val); break;
11442 }
11443 break;
11444
75375b3e 11445 case 24: /* Tag_align_needed. */
f6f0e17b 11446 val = read_uleb128 (p, &len, end);
75375b3e
MGD
11447 p += len;
11448 switch (val)
11449 {
2b692964
NC
11450 case 0: printf (_("None\n")); break;
11451 case 1: printf (_("8-byte\n")); break;
11452 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD
11453 case 3: printf ("??? 3\n"); break;
11454 default:
11455 if (val <= 12)
dd24e3da 11456 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD
11457 1 << val);
11458 else
11459 printf ("??? (%d)\n", val);
11460 break;
11461 }
11462 break;
11463
11464 case 25: /* Tag_align_preserved. */
f6f0e17b 11465 val = read_uleb128 (p, &len, end);
75375b3e
MGD
11466 p += len;
11467 switch (val)
11468 {
2b692964
NC
11469 case 0: printf (_("None\n")); break;
11470 case 1: printf (_("8-byte, except leaf SP\n")); break;
11471 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD
11472 case 3: printf ("??? 3\n"); break;
11473 default:
11474 if (val <= 12)
dd24e3da 11475 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD
11476 1 << val);
11477 else
11478 printf ("??? (%d)\n", val);
11479 break;
11480 }
11481 break;
11482
11c1ff18 11483 case 32: /* Tag_compatibility. */
f6f0e17b 11484 val = read_uleb128 (p, &len, end);
11c1ff18 11485 p += len;
2b692964 11486 printf (_("flag = %d, vendor = %s\n"), val, p);
2cf0635d 11487 p += strlen ((char *) p) + 1;
11c1ff18
PB
11488 break;
11489
f5f53991
AS
11490 case 64: /* Tag_nodefaults. */
11491 p++;
2b692964 11492 printf (_("True\n"));
f5f53991
AS
11493 break;
11494
11495 case 65: /* Tag_also_compatible_with. */
f6f0e17b 11496 val = read_uleb128 (p, &len, end);
f5f53991
AS
11497 p += len;
11498 if (val == 6 /* Tag_CPU_arch. */)
11499 {
f6f0e17b 11500 val = read_uleb128 (p, &len, end);
f5f53991 11501 p += len;
2cf0635d 11502 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS
11503 printf ("??? (%d)\n", val);
11504 else
11505 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
11506 }
11507 else
11508 printf ("???\n");
11509 while (*(p++) != '\0' /* NUL terminator. */);
11510 break;
11511
11c1ff18 11512 default:
2cf0635d 11513 abort ();
11c1ff18
PB
11514 }
11515 return p;
11516
11517 case 1:
f6f0e17b 11518 return display_tag_value (-1, p, end);
11c1ff18 11519 case 2:
f6f0e17b 11520 return display_tag_value (0, p, end);
11c1ff18
PB
11521
11522 default:
11523 assert (attr->type & 0x80);
f6f0e17b 11524 val = read_uleb128 (p, &len, end);
11c1ff18
PB
11525 p += len;
11526 type = attr->type & 0x7f;
11527 if (val >= type)
11528 printf ("??? (%d)\n", val);
11529 else
11530 printf ("%s\n", attr->table[val]);
11531 return p;
11532 }
11533 }
11c1ff18 11534
f6f0e17b 11535 return display_tag_value (tag, p, end);
11c1ff18
PB
11536}
11537
104d59d1 11538static unsigned char *
60bca95a 11539display_gnu_attribute (unsigned char * p,
f6f0e17b
NC
11540 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
11541 const unsigned char * const end)
104d59d1
JM
11542{
11543 int tag;
11544 unsigned int len;
11545 int val;
104d59d1 11546
f6f0e17b 11547 tag = read_uleb128 (p, &len, end);
104d59d1
JM
11548 p += len;
11549
11550 /* Tag_compatibility is the only generic GNU attribute defined at
11551 present. */
11552 if (tag == 32)
11553 {
f6f0e17b 11554 val = read_uleb128 (p, &len, end);
104d59d1 11555 p += len;
f6f0e17b
NC
11556 if (p == end)
11557 {
11558 printf (_("flag = %d, vendor = <corrupt>\n"), val);
11559 warn (_("corrupt vendor attribute\n"));
11560 }
11561 else
11562 {
11563 printf (_("flag = %d, vendor = %s\n"), val, p);
11564 p += strlen ((char *) p) + 1;
11565 }
104d59d1
JM
11566 return p;
11567 }
11568
11569 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 11570 return display_proc_gnu_attribute (p, tag, end);
104d59d1 11571
f6f0e17b 11572 return display_tag_value (tag, p, end);
104d59d1
JM
11573}
11574
34c8bcba 11575static unsigned char *
f6f0e17b
NC
11576display_power_gnu_attribute (unsigned char * p,
11577 int tag,
11578 const unsigned char * const end)
34c8bcba 11579{
34c8bcba
JM
11580 unsigned int len;
11581 int val;
11582
11583 if (tag == Tag_GNU_Power_ABI_FP)
11584 {
f6f0e17b 11585 val = read_uleb128 (p, &len, end);
34c8bcba
JM
11586 p += len;
11587 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 11588
34c8bcba
JM
11589 switch (val)
11590 {
11591 case 0:
2b692964 11592 printf (_("Hard or soft float\n"));
34c8bcba
JM
11593 break;
11594 case 1:
2b692964 11595 printf (_("Hard float\n"));
34c8bcba
JM
11596 break;
11597 case 2:
2b692964 11598 printf (_("Soft float\n"));
34c8bcba 11599 break;
3c7b9897 11600 case 3:
2b692964 11601 printf (_("Single-precision hard float\n"));
3c7b9897 11602 break;
34c8bcba
JM
11603 default:
11604 printf ("??? (%d)\n", val);
11605 break;
11606 }
11607 return p;
11608 }
11609
c6e65352
DJ
11610 if (tag == Tag_GNU_Power_ABI_Vector)
11611 {
f6f0e17b 11612 val = read_uleb128 (p, &len, end);
c6e65352
DJ
11613 p += len;
11614 printf (" Tag_GNU_Power_ABI_Vector: ");
11615 switch (val)
11616 {
11617 case 0:
2b692964 11618 printf (_("Any\n"));
c6e65352
DJ
11619 break;
11620 case 1:
2b692964 11621 printf (_("Generic\n"));
c6e65352
DJ
11622 break;
11623 case 2:
11624 printf ("AltiVec\n");
11625 break;
11626 case 3:
11627 printf ("SPE\n");
11628 break;
11629 default:
11630 printf ("??? (%d)\n", val);
11631 break;
11632 }
11633 return p;
11634 }
11635
f82e0623
NF
11636 if (tag == Tag_GNU_Power_ABI_Struct_Return)
11637 {
f6f0e17b
NC
11638 if (p == end)
11639 {
11640 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return"));
11641 return p;
11642 }
11643
11644 val = read_uleb128 (p, &len, end);
f82e0623
NF
11645 p += len;
11646 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11647 switch (val)
11648 {
11649 case 0:
2b692964 11650 printf (_("Any\n"));
f82e0623
NF
11651 break;
11652 case 1:
11653 printf ("r3/r4\n");
11654 break;
11655 case 2:
2b692964 11656 printf (_("Memory\n"));
f82e0623
NF
11657 break;
11658 default:
11659 printf ("??? (%d)\n", val);
11660 break;
11661 }
11662 return p;
11663 }
11664
f6f0e17b 11665 return display_tag_value (tag & 1, p, end);
34c8bcba
JM
11666}
11667
9e8c70f9
DM
11668static void
11669display_sparc_hwcaps (int mask)
11670{
11671 if (mask)
11672 {
11673 int first = 1;
11674 if (mask & ELF_SPARC_HWCAP_MUL32)
11675 fputs ("mul32", stdout), first = 0;
11676 if (mask & ELF_SPARC_HWCAP_DIV32)
11677 printf ("%sdiv32", first ? "" : "|"), first = 0;
11678 if (mask & ELF_SPARC_HWCAP_FSMULD)
11679 printf ("%sfsmuld", first ? "" : "|"), first = 0;
11680 if (mask & ELF_SPARC_HWCAP_V8PLUS)
11681 printf ("%sv8plus", first ? "" : "|"), first = 0;
11682 if (mask & ELF_SPARC_HWCAP_POPC)
11683 printf ("%spopc", first ? "" : "|"), first = 0;
11684 if (mask & ELF_SPARC_HWCAP_VIS)
11685 printf ("%svis", first ? "" : "|"), first = 0;
11686 if (mask & ELF_SPARC_HWCAP_VIS2)
11687 printf ("%svis2", first ? "" : "|"), first = 0;
11688 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
11689 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
11690 if (mask & ELF_SPARC_HWCAP_FMAF)
11691 printf ("%sfmaf", first ? "" : "|"), first = 0;
11692 if (mask & ELF_SPARC_HWCAP_VIS3)
11693 printf ("%svis3", first ? "" : "|"), first = 0;
11694 if (mask & ELF_SPARC_HWCAP_HPC)
11695 printf ("%shpc", first ? "" : "|"), first = 0;
11696 if (mask & ELF_SPARC_HWCAP_RANDOM)
11697 printf ("%srandom", first ? "" : "|"), first = 0;
11698 if (mask & ELF_SPARC_HWCAP_TRANS)
11699 printf ("%strans", first ? "" : "|"), first = 0;
11700 if (mask & ELF_SPARC_HWCAP_FJFMAU)
11701 printf ("%sfjfmau", first ? "" : "|"), first = 0;
11702 if (mask & ELF_SPARC_HWCAP_IMA)
11703 printf ("%sima", first ? "" : "|"), first = 0;
11704 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
11705 printf ("%scspare", first ? "" : "|"), first = 0;
11706 }
11707 else
11708 fputc('0', stdout);
11709 fputc('\n', stdout);
11710}
11711
11712static unsigned char *
f6f0e17b
NC
11713display_sparc_gnu_attribute (unsigned char * p,
11714 int tag,
11715 const unsigned char * const end)
9e8c70f9 11716{
9e8c70f9
DM
11717 if (tag == Tag_GNU_Sparc_HWCAPS)
11718 {
f6f0e17b
NC
11719 unsigned int len;
11720 int val;
11721
11722 val = read_uleb128 (p, &len, end);
9e8c70f9
DM
11723 p += len;
11724 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM
11725 display_sparc_hwcaps (val);
11726 return p;
11727 }
11728
f6f0e17b 11729 return display_tag_value (tag, p, end);
9e8c70f9
DM
11730}
11731
2cf19d5c 11732static unsigned char *
f6f0e17b
NC
11733display_mips_gnu_attribute (unsigned char * p,
11734 int tag,
11735 const unsigned char * const end)
2cf19d5c 11736{
2cf19d5c
JM
11737 if (tag == Tag_GNU_MIPS_ABI_FP)
11738 {
f6f0e17b
NC
11739 unsigned int len;
11740 int val;
11741
11742 val = read_uleb128 (p, &len, end);
2cf19d5c
JM
11743 p += len;
11744 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 11745
2cf19d5c
JM
11746 switch (val)
11747 {
d929bc19 11748 case Val_GNU_MIPS_ABI_FP_ANY:
2b692964 11749 printf (_("Hard or soft float\n"));
2cf19d5c 11750 break;
d929bc19 11751 case Val_GNU_MIPS_ABI_FP_DOUBLE:
2b692964 11752 printf (_("Hard float (double precision)\n"));
2cf19d5c 11753 break;
d929bc19 11754 case Val_GNU_MIPS_ABI_FP_SINGLE:
2b692964 11755 printf (_("Hard float (single precision)\n"));
2cf19d5c 11756 break;
d929bc19 11757 case Val_GNU_MIPS_ABI_FP_SOFT:
2b692964 11758 printf (_("Soft float\n"));
2cf19d5c 11759 break;
d929bc19 11760 case Val_GNU_MIPS_ABI_FP_64:
9eeefea8 11761 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
42554f6a 11762 break;
2cf19d5c
JM
11763 default:
11764 printf ("??? (%d)\n", val);
11765 break;
11766 }
11767 return p;
11768 }
11769
f6f0e17b 11770 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM
11771}
11772
59e6276b 11773static unsigned char *
f6f0e17b
NC
11774display_tic6x_attribute (unsigned char * p,
11775 const unsigned char * const end)
59e6276b
JM
11776{
11777 int tag;
11778 unsigned int len;
11779 int val;
11780
f6f0e17b 11781 tag = read_uleb128 (p, &len, end);
59e6276b
JM
11782 p += len;
11783
11784 switch (tag)
11785 {
75fa6dc1 11786 case Tag_ISA:
f6f0e17b 11787 val = read_uleb128 (p, &len, end);
59e6276b 11788 p += len;
75fa6dc1 11789 printf (" Tag_ISA: ");
59e6276b
JM
11790
11791 switch (val)
11792 {
75fa6dc1 11793 case C6XABI_Tag_ISA_none:
59e6276b
JM
11794 printf (_("None\n"));
11795 break;
75fa6dc1 11796 case C6XABI_Tag_ISA_C62X:
59e6276b
JM
11797 printf ("C62x\n");
11798 break;
75fa6dc1 11799 case C6XABI_Tag_ISA_C67X:
59e6276b
JM
11800 printf ("C67x\n");
11801 break;
75fa6dc1 11802 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM
11803 printf ("C67x+\n");
11804 break;
75fa6dc1 11805 case C6XABI_Tag_ISA_C64X:
59e6276b
JM
11806 printf ("C64x\n");
11807 break;
75fa6dc1 11808 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM
11809 printf ("C64x+\n");
11810 break;
75fa6dc1 11811 case C6XABI_Tag_ISA_C674X:
59e6276b
JM
11812 printf ("C674x\n");
11813 break;
11814 default:
11815 printf ("??? (%d)\n", val);
11816 break;
11817 }
11818 return p;
11819
87779176 11820 case Tag_ABI_wchar_t:
f6f0e17b 11821 val = read_uleb128 (p, &len, end);
87779176
JM
11822 p += len;
11823 printf (" Tag_ABI_wchar_t: ");
11824 switch (val)
11825 {
11826 case 0:
11827 printf (_("Not used\n"));
11828 break;
11829 case 1:
11830 printf (_("2 bytes\n"));
11831 break;
11832 case 2:
11833 printf (_("4 bytes\n"));
11834 break;
11835 default:
11836 printf ("??? (%d)\n", val);
11837 break;
11838 }
11839 return p;
11840
11841 case Tag_ABI_stack_align_needed:
f6f0e17b 11842 val = read_uleb128 (p, &len, end);
87779176
JM
11843 p += len;
11844 printf (" Tag_ABI_stack_align_needed: ");
11845 switch (val)
11846 {
11847 case 0:
11848 printf (_("8-byte\n"));
11849 break;
11850 case 1:
11851 printf (_("16-byte\n"));
11852 break;
11853 default:
11854 printf ("??? (%d)\n", val);
11855 break;
11856 }
11857 return p;
11858
11859 case Tag_ABI_stack_align_preserved:
f6f0e17b 11860 val = read_uleb128 (p, &len, end);
87779176
JM
11861 p += len;
11862 printf (" Tag_ABI_stack_align_preserved: ");
11863 switch (val)
11864 {
11865 case 0:
11866 printf (_("8-byte\n"));
11867 break;
11868 case 1:
11869 printf (_("16-byte\n"));
11870 break;
11871 default:
11872 printf ("??? (%d)\n", val);
11873 break;
11874 }
11875 return p;
11876
b5593623 11877 case Tag_ABI_DSBT:
f6f0e17b 11878 val = read_uleb128 (p, &len, end);
b5593623
JM
11879 p += len;
11880 printf (" Tag_ABI_DSBT: ");
11881 switch (val)
11882 {
11883 case 0:
11884 printf (_("DSBT addressing not used\n"));
11885 break;
11886 case 1:
11887 printf (_("DSBT addressing used\n"));
11888 break;
11889 default:
11890 printf ("??? (%d)\n", val);
11891 break;
11892 }
11893 return p;
11894
87779176 11895 case Tag_ABI_PID:
f6f0e17b 11896 val = read_uleb128 (p, &len, end);
87779176
JM
11897 p += len;
11898 printf (" Tag_ABI_PID: ");
11899 switch (val)
11900 {
11901 case 0:
11902 printf (_("Data addressing position-dependent\n"));
11903 break;
11904 case 1:
11905 printf (_("Data addressing position-independent, GOT near DP\n"));
11906 break;
11907 case 2:
11908 printf (_("Data addressing position-independent, GOT far from DP\n"));
11909 break;
11910 default:
11911 printf ("??? (%d)\n", val);
11912 break;
11913 }
11914 return p;
11915
11916 case Tag_ABI_PIC:
f6f0e17b 11917 val = read_uleb128 (p, &len, end);
87779176
JM
11918 p += len;
11919 printf (" Tag_ABI_PIC: ");
11920 switch (val)
11921 {
11922 case 0:
11923 printf (_("Code addressing position-dependent\n"));
11924 break;
11925 case 1:
11926 printf (_("Code addressing position-independent\n"));
11927 break;
11928 default:
11929 printf ("??? (%d)\n", val);
11930 break;
11931 }
11932 return p;
11933
11934 case Tag_ABI_array_object_alignment:
f6f0e17b 11935 val = read_uleb128 (p, &len, end);
87779176
JM
11936 p += len;
11937 printf (" Tag_ABI_array_object_alignment: ");
11938 switch (val)
11939 {
11940 case 0:
11941 printf (_("8-byte\n"));
11942 break;
11943 case 1:
11944 printf (_("4-byte\n"));
11945 break;
11946 case 2:
11947 printf (_("16-byte\n"));
11948 break;
11949 default:
11950 printf ("??? (%d)\n", val);
11951 break;
11952 }
11953 return p;
11954
11955 case Tag_ABI_array_object_align_expected:
f6f0e17b 11956 val = read_uleb128 (p, &len, end);
87779176
JM
11957 p += len;
11958 printf (" Tag_ABI_array_object_align_expected: ");
11959 switch (val)
11960 {
11961 case 0:
11962 printf (_("8-byte\n"));
11963 break;
11964 case 1:
11965 printf (_("4-byte\n"));
11966 break;
11967 case 2:
11968 printf (_("16-byte\n"));
11969 break;
11970 default:
11971 printf ("??? (%d)\n", val);
11972 break;
11973 }
11974 return p;
11975
3cbd1c06 11976 case Tag_ABI_compatibility:
f6f0e17b 11977 val = read_uleb128 (p, &len, end);
59e6276b 11978 p += len;
3cbd1c06 11979 printf (" Tag_ABI_compatibility: ");
59e6276b
JM
11980 printf (_("flag = %d, vendor = %s\n"), val, p);
11981 p += strlen ((char *) p) + 1;
11982 return p;
87779176
JM
11983
11984 case Tag_ABI_conformance:
11985 printf (" Tag_ABI_conformance: ");
11986 printf ("\"%s\"\n", p);
11987 p += strlen ((char *) p) + 1;
11988 return p;
59e6276b
JM
11989 }
11990
f6f0e17b
NC
11991 return display_tag_value (tag, p, end);
11992}
59e6276b 11993
f6f0e17b
NC
11994static void
11995display_raw_attribute (unsigned char * p, unsigned char * end)
11996{
11997 unsigned long addr = 0;
11998 size_t bytes = end - p;
11999
12000 while (bytes)
87779176 12001 {
f6f0e17b
NC
12002 int j;
12003 int k;
12004 int lbytes = (bytes > 16 ? 16 : bytes);
12005
12006 printf (" 0x%8.8lx ", addr);
12007
12008 for (j = 0; j < 16; j++)
12009 {
12010 if (j < lbytes)
12011 printf ("%2.2x", p[j]);
12012 else
12013 printf (" ");
12014
12015 if ((j & 3) == 3)
12016 printf (" ");
12017 }
12018
12019 for (j = 0; j < lbytes; j++)
12020 {
12021 k = p[j];
12022 if (k >= ' ' && k < 0x7f)
12023 printf ("%c", k);
12024 else
12025 printf (".");
12026 }
12027
12028 putchar ('\n');
12029
12030 p += lbytes;
12031 bytes -= lbytes;
12032 addr += lbytes;
87779176 12033 }
59e6276b 12034
f6f0e17b 12035 putchar ('\n');
59e6276b
JM
12036}
12037
13761a11
NC
12038static unsigned char *
12039display_msp430x_attribute (unsigned char * p,
12040 const unsigned char * const end)
12041{
12042 unsigned int len;
12043 int val;
12044 int tag;
12045
12046 tag = read_uleb128 (p, & len, end);
12047 p += len;
12048
12049 switch (tag)
12050 {
12051 case OFBA_MSPABI_Tag_ISA:
12052 val = read_uleb128 (p, &len, end);
12053 p += len;
12054 printf (" Tag_ISA: ");
12055 switch (val)
12056 {
12057 case 0: printf (_("None\n")); break;
12058 case 1: printf (_("MSP430\n")); break;
12059 case 2: printf (_("MSP430X\n")); break;
12060 default: printf ("??? (%d)\n", val); break;
12061 }
12062 break;
12063
12064 case OFBA_MSPABI_Tag_Code_Model:
12065 val = read_uleb128 (p, &len, end);
12066 p += len;
12067 printf (" Tag_Code_Model: ");
12068 switch (val)
12069 {
12070 case 0: printf (_("None\n")); break;
12071 case 1: printf (_("Small\n")); break;
12072 case 2: printf (_("Large\n")); break;
12073 default: printf ("??? (%d)\n", val); break;
12074 }
12075 break;
12076
12077 case OFBA_MSPABI_Tag_Data_Model:
12078 val = read_uleb128 (p, &len, end);
12079 p += len;
12080 printf (" Tag_Data_Model: ");
12081 switch (val)
12082 {
12083 case 0: printf (_("None\n")); break;
12084 case 1: printf (_("Small\n")); break;
12085 case 2: printf (_("Large\n")); break;
12086 case 3: printf (_("Restricted Large\n")); break;
12087 default: printf ("??? (%d)\n", val); break;
12088 }
12089 break;
12090
12091 default:
12092 printf (_(" <unknown tag %d>: "), tag);
12093
12094 if (tag & 1)
12095 {
12096 printf ("\"%s\"\n", p);
12097 p += strlen ((char *) p) + 1;
12098 }
12099 else
12100 {
12101 val = read_uleb128 (p, &len, end);
12102 p += len;
12103 printf ("%d (0x%x)\n", val, val);
12104 }
12105 break;
12106 }
12107
12108 return p;
12109}
12110
11c1ff18 12111static int
60bca95a
NC
12112process_attributes (FILE * file,
12113 const char * public_name,
104d59d1 12114 unsigned int proc_type,
f6f0e17b
NC
12115 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
12116 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 12117{
2cf0635d
NC
12118 Elf_Internal_Shdr * sect;
12119 unsigned char * contents;
12120 unsigned char * p;
12121 unsigned char * end;
11c1ff18
PB
12122 bfd_vma section_len;
12123 bfd_vma len;
12124 unsigned i;
12125
12126 /* Find the section header so that we get the size. */
12127 for (i = 0, sect = section_headers;
12128 i < elf_header.e_shnum;
12129 i++, sect++)
12130 {
104d59d1 12131 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB
12132 continue;
12133
3f5e193b
NC
12134 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
12135 sect->sh_size, _("attributes"));
60bca95a 12136 if (contents == NULL)
11c1ff18 12137 continue;
60bca95a 12138
11c1ff18
PB
12139 p = contents;
12140 if (*p == 'A')
12141 {
12142 len = sect->sh_size - 1;
12143 p++;
60bca95a 12144
11c1ff18
PB
12145 while (len > 0)
12146 {
12147 int namelen;
12148 bfd_boolean public_section;
104d59d1 12149 bfd_boolean gnu_section;
11c1ff18
PB
12150
12151 section_len = byte_get (p, 4);
12152 p += 4;
60bca95a 12153
11c1ff18
PB
12154 if (section_len > len)
12155 {
12156 printf (_("ERROR: Bad section length (%d > %d)\n"),
60bca95a 12157 (int) section_len, (int) len);
11c1ff18
PB
12158 section_len = len;
12159 }
60bca95a 12160
11c1ff18 12161 len -= section_len;
2b692964 12162 printf (_("Attribute Section: %s\n"), p);
60bca95a
NC
12163
12164 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB
12165 public_section = TRUE;
12166 else
12167 public_section = FALSE;
60bca95a
NC
12168
12169 if (streq ((char *) p, "gnu"))
104d59d1
JM
12170 gnu_section = TRUE;
12171 else
12172 gnu_section = FALSE;
60bca95a
NC
12173
12174 namelen = strlen ((char *) p) + 1;
11c1ff18
PB
12175 p += namelen;
12176 section_len -= namelen + 4;
60bca95a 12177
11c1ff18
PB
12178 while (section_len > 0)
12179 {
12180 int tag = *(p++);
12181 int val;
12182 bfd_vma size;
60bca95a 12183
11c1ff18
PB
12184 size = byte_get (p, 4);
12185 if (size > section_len)
12186 {
12187 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
60bca95a 12188 (int) size, (int) section_len);
11c1ff18
PB
12189 size = section_len;
12190 }
60bca95a 12191
11c1ff18
PB
12192 section_len -= size;
12193 end = p + size - 1;
12194 p += 4;
60bca95a 12195
11c1ff18
PB
12196 switch (tag)
12197 {
12198 case 1:
2b692964 12199 printf (_("File Attributes\n"));
11c1ff18
PB
12200 break;
12201 case 2:
2b692964 12202 printf (_("Section Attributes:"));
11c1ff18
PB
12203 goto do_numlist;
12204 case 3:
2b692964 12205 printf (_("Symbol Attributes:"));
11c1ff18
PB
12206 do_numlist:
12207 for (;;)
12208 {
91d6fa6a 12209 unsigned int j;
60bca95a 12210
f6f0e17b 12211 val = read_uleb128 (p, &j, end);
91d6fa6a 12212 p += j;
11c1ff18
PB
12213 if (val == 0)
12214 break;
12215 printf (" %d", val);
12216 }
12217 printf ("\n");
12218 break;
12219 default:
2b692964 12220 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB
12221 public_section = FALSE;
12222 break;
12223 }
60bca95a 12224
11c1ff18
PB
12225 if (public_section)
12226 {
12227 while (p < end)
f6f0e17b 12228 p = display_pub_attribute (p, end);
104d59d1
JM
12229 }
12230 else if (gnu_section)
12231 {
12232 while (p < end)
12233 p = display_gnu_attribute (p,
f6f0e17b
NC
12234 display_proc_gnu_attribute,
12235 end);
11c1ff18
PB
12236 }
12237 else
12238 {
2b692964 12239 printf (_(" Unknown section contexts\n"));
f6f0e17b 12240 display_raw_attribute (p, end);
11c1ff18
PB
12241 p = end;
12242 }
12243 }
12244 }
12245 }
12246 else
60bca95a 12247 printf (_("Unknown format '%c'\n"), *p);
d70c5fc7 12248
60bca95a 12249 free (contents);
11c1ff18
PB
12250 }
12251 return 1;
12252}
12253
104d59d1 12254static int
2cf0635d 12255process_arm_specific (FILE * file)
104d59d1
JM
12256{
12257 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
12258 display_arm_attribute, NULL);
12259}
12260
34c8bcba 12261static int
2cf0635d 12262process_power_specific (FILE * file)
34c8bcba
JM
12263{
12264 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12265 display_power_gnu_attribute);
12266}
12267
9e8c70f9
DM
12268static int
12269process_sparc_specific (FILE * file)
12270{
12271 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12272 display_sparc_gnu_attribute);
12273}
12274
59e6276b
JM
12275static int
12276process_tic6x_specific (FILE * file)
12277{
12278 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
12279 display_tic6x_attribute, NULL);
12280}
12281
13761a11
NC
12282static int
12283process_msp430x_specific (FILE * file)
12284{
12285 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
12286 display_msp430x_attribute, NULL);
12287}
12288
ccb4c951
RS
12289/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12290 Print the Address, Access and Initial fields of an entry at VMA ADDR
12291 and return the VMA of the next entry. */
12292
12293static bfd_vma
2cf0635d 12294print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
ccb4c951
RS
12295{
12296 printf (" ");
12297 print_vma (addr, LONG_HEX);
12298 printf (" ");
12299 if (addr < pltgot + 0xfff0)
12300 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
12301 else
12302 printf ("%10s", "");
12303 printf (" ");
12304 if (data == NULL)
2b692964 12305 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS
12306 else
12307 {
12308 bfd_vma entry;
12309
12310 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12311 print_vma (entry, LONG_HEX);
12312 }
12313 return addr + (is_32bit_elf ? 4 : 8);
12314}
12315
861fb55a
DJ
12316/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12317 PLTGOT. Print the Address and Initial fields of an entry at VMA
12318 ADDR and return the VMA of the next entry. */
12319
12320static bfd_vma
2cf0635d 12321print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ
12322{
12323 printf (" ");
12324 print_vma (addr, LONG_HEX);
12325 printf (" ");
12326 if (data == NULL)
2b692964 12327 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ
12328 else
12329 {
12330 bfd_vma entry;
12331
12332 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12333 print_vma (entry, LONG_HEX);
12334 }
12335 return addr + (is_32bit_elf ? 4 : 8);
12336}
12337
19e6b90e 12338static int
2cf0635d 12339process_mips_specific (FILE * file)
5b18a4bc 12340{
2cf0635d 12341 Elf_Internal_Dyn * entry;
19e6b90e
L
12342 size_t liblist_offset = 0;
12343 size_t liblistno = 0;
12344 size_t conflictsno = 0;
12345 size_t options_offset = 0;
12346 size_t conflicts_offset = 0;
861fb55a
DJ
12347 size_t pltrelsz = 0;
12348 size_t pltrel = 0;
ccb4c951 12349 bfd_vma pltgot = 0;
861fb55a
DJ
12350 bfd_vma mips_pltgot = 0;
12351 bfd_vma jmprel = 0;
ccb4c951
RS
12352 bfd_vma local_gotno = 0;
12353 bfd_vma gotsym = 0;
12354 bfd_vma symtabno = 0;
103f02d3 12355
2cf19d5c
JM
12356 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12357 display_mips_gnu_attribute);
12358
19e6b90e
L
12359 /* We have a lot of special sections. Thanks SGI! */
12360 if (dynamic_section == NULL)
12361 /* No information available. */
12362 return 0;
252b5132 12363
b2d38a17 12364 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
252b5132
RH
12365 switch (entry->d_tag)
12366 {
12367 case DT_MIPS_LIBLIST:
d93f0186
NC
12368 liblist_offset
12369 = offset_from_vma (file, entry->d_un.d_val,
12370 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH
12371 break;
12372 case DT_MIPS_LIBLISTNO:
12373 liblistno = entry->d_un.d_val;
12374 break;
12375 case DT_MIPS_OPTIONS:
d93f0186 12376 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH
12377 break;
12378 case DT_MIPS_CONFLICT:
d93f0186
NC
12379 conflicts_offset
12380 = offset_from_vma (file, entry->d_un.d_val,
12381 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH
12382 break;
12383 case DT_MIPS_CONFLICTNO:
12384 conflictsno = entry->d_un.d_val;
12385 break;
ccb4c951 12386 case DT_PLTGOT:
861fb55a
DJ
12387 pltgot = entry->d_un.d_ptr;
12388 break;
ccb4c951
RS
12389 case DT_MIPS_LOCAL_GOTNO:
12390 local_gotno = entry->d_un.d_val;
12391 break;
12392 case DT_MIPS_GOTSYM:
12393 gotsym = entry->d_un.d_val;
12394 break;
12395 case DT_MIPS_SYMTABNO:
12396 symtabno = entry->d_un.d_val;
12397 break;
861fb55a
DJ
12398 case DT_MIPS_PLTGOT:
12399 mips_pltgot = entry->d_un.d_ptr;
12400 break;
12401 case DT_PLTREL:
12402 pltrel = entry->d_un.d_val;
12403 break;
12404 case DT_PLTRELSZ:
12405 pltrelsz = entry->d_un.d_val;
12406 break;
12407 case DT_JMPREL:
12408 jmprel = entry->d_un.d_ptr;
12409 break;
252b5132
RH
12410 default:
12411 break;
12412 }
12413
12414 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
12415 {
2cf0635d 12416 Elf32_External_Lib * elib;
252b5132
RH
12417 size_t cnt;
12418
3f5e193b
NC
12419 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
12420 liblistno,
12421 sizeof (Elf32_External_Lib),
9cf03b7e 12422 _("liblist section data"));
a6e9f9df 12423 if (elib)
252b5132 12424 {
2b692964 12425 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 12426 (unsigned long) liblistno);
2b692964 12427 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM
12428 stdout);
12429
12430 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 12431 {
a6e9f9df 12432 Elf32_Lib liblist;
91d6fa6a 12433 time_t atime;
a6e9f9df 12434 char timebuf[20];
2cf0635d 12435 struct tm * tmp;
a6e9f9df
AM
12436
12437 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 12438 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM
12439 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12440 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12441 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12442
91d6fa6a 12443 tmp = gmtime (&atime);
e9e44622
JJ
12444 snprintf (timebuf, sizeof (timebuf),
12445 "%04u-%02u-%02uT%02u:%02u:%02u",
12446 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12447 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 12448
31104126 12449 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC
12450 if (VALID_DYNAMIC_NAME (liblist.l_name))
12451 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
12452 else
2b692964 12453 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC
12454 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
12455 liblist.l_version);
a6e9f9df
AM
12456
12457 if (liblist.l_flags == 0)
2b692964 12458 puts (_(" NONE"));
a6e9f9df
AM
12459 else
12460 {
12461 static const struct
252b5132 12462 {
2cf0635d 12463 const char * name;
a6e9f9df 12464 int bit;
252b5132 12465 }
a6e9f9df
AM
12466 l_flags_vals[] =
12467 {
12468 { " EXACT_MATCH", LL_EXACT_MATCH },
12469 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
12470 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
12471 { " EXPORTS", LL_EXPORTS },
12472 { " DELAY_LOAD", LL_DELAY_LOAD },
12473 { " DELTA", LL_DELTA }
12474 };
12475 int flags = liblist.l_flags;
12476 size_t fcnt;
12477
60bca95a 12478 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM
12479 if ((flags & l_flags_vals[fcnt].bit) != 0)
12480 {
12481 fputs (l_flags_vals[fcnt].name, stdout);
12482 flags ^= l_flags_vals[fcnt].bit;
12483 }
12484 if (flags != 0)
12485 printf (" %#x", (unsigned int) flags);
252b5132 12486
a6e9f9df
AM
12487 puts ("");
12488 }
252b5132 12489 }
252b5132 12490
a6e9f9df
AM
12491 free (elib);
12492 }
252b5132
RH
12493 }
12494
12495 if (options_offset != 0)
12496 {
2cf0635d
NC
12497 Elf_External_Options * eopt;
12498 Elf_Internal_Shdr * sect = section_headers;
12499 Elf_Internal_Options * iopt;
12500 Elf_Internal_Options * option;
252b5132
RH
12501 size_t offset;
12502 int cnt;
12503
12504 /* Find the section header so that we get the size. */
12505 while (sect->sh_type != SHT_MIPS_OPTIONS)
b34976b6 12506 ++sect;
252b5132 12507
3f5e193b
NC
12508 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
12509 sect->sh_size, _("options"));
a6e9f9df 12510 if (eopt)
252b5132 12511 {
3f5e193b
NC
12512 iopt = (Elf_Internal_Options *)
12513 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM
12514 if (iopt == NULL)
12515 {
591a748a 12516 error (_("Out of memory\n"));
a6e9f9df
AM
12517 return 0;
12518 }
76da6bbe 12519
a6e9f9df
AM
12520 offset = cnt = 0;
12521 option = iopt;
252b5132 12522
a6e9f9df
AM
12523 while (offset < sect->sh_size)
12524 {
2cf0635d 12525 Elf_External_Options * eoption;
252b5132 12526
a6e9f9df 12527 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 12528
a6e9f9df
AM
12529 option->kind = BYTE_GET (eoption->kind);
12530 option->size = BYTE_GET (eoption->size);
12531 option->section = BYTE_GET (eoption->section);
12532 option->info = BYTE_GET (eoption->info);
76da6bbe 12533
a6e9f9df 12534 offset += option->size;
252b5132 12535
a6e9f9df
AM
12536 ++option;
12537 ++cnt;
12538 }
252b5132 12539
a6e9f9df
AM
12540 printf (_("\nSection '%s' contains %d entries:\n"),
12541 SECTION_NAME (sect), cnt);
76da6bbe 12542
a6e9f9df 12543 option = iopt;
252b5132 12544
a6e9f9df 12545 while (cnt-- > 0)
252b5132 12546 {
a6e9f9df
AM
12547 size_t len;
12548
12549 switch (option->kind)
252b5132 12550 {
a6e9f9df
AM
12551 case ODK_NULL:
12552 /* This shouldn't happen. */
12553 printf (" NULL %d %lx", option->section, option->info);
12554 break;
12555 case ODK_REGINFO:
12556 printf (" REGINFO ");
12557 if (elf_header.e_machine == EM_MIPS)
12558 {
12559 /* 32bit form. */
2cf0635d 12560 Elf32_External_RegInfo * ereg;
b34976b6 12561 Elf32_RegInfo reginfo;
a6e9f9df
AM
12562
12563 ereg = (Elf32_External_RegInfo *) (option + 1);
12564 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12565 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12566 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12567 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12568 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12569 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
12570
12571 printf ("GPR %08lx GP 0x%lx\n",
12572 reginfo.ri_gprmask,
12573 (unsigned long) reginfo.ri_gp_value);
12574 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12575 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12576 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12577 }
12578 else
12579 {
12580 /* 64 bit form. */
2cf0635d 12581 Elf64_External_RegInfo * ereg;
a6e9f9df
AM
12582 Elf64_Internal_RegInfo reginfo;
12583
12584 ereg = (Elf64_External_RegInfo *) (option + 1);
12585 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12586 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12587 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12588 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12589 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 12590 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM
12591
12592 printf ("GPR %08lx GP 0x",
12593 reginfo.ri_gprmask);
12594 printf_vma (reginfo.ri_gp_value);
12595 printf ("\n");
12596
12597 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12598 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12599 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12600 }
12601 ++option;
12602 continue;
12603 case ODK_EXCEPTIONS:
12604 fputs (" EXCEPTIONS fpe_min(", stdout);
12605 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
12606 fputs (") fpe_max(", stdout);
12607 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
12608 fputs (")", stdout);
12609
12610 if (option->info & OEX_PAGE0)
12611 fputs (" PAGE0", stdout);
12612 if (option->info & OEX_SMM)
12613 fputs (" SMM", stdout);
12614 if (option->info & OEX_FPDBUG)
12615 fputs (" FPDBUG", stdout);
12616 if (option->info & OEX_DISMISS)
12617 fputs (" DISMISS", stdout);
12618 break;
12619 case ODK_PAD:
12620 fputs (" PAD ", stdout);
12621 if (option->info & OPAD_PREFIX)
12622 fputs (" PREFIX", stdout);
12623 if (option->info & OPAD_POSTFIX)
12624 fputs (" POSTFIX", stdout);
12625 if (option->info & OPAD_SYMBOL)
12626 fputs (" SYMBOL", stdout);
12627 break;
12628 case ODK_HWPATCH:
12629 fputs (" HWPATCH ", stdout);
12630 if (option->info & OHW_R4KEOP)
12631 fputs (" R4KEOP", stdout);
12632 if (option->info & OHW_R8KPFETCH)
12633 fputs (" R8KPFETCH", stdout);
12634 if (option->info & OHW_R5KEOP)
12635 fputs (" R5KEOP", stdout);
12636 if (option->info & OHW_R5KCVTL)
12637 fputs (" R5KCVTL", stdout);
12638 break;
12639 case ODK_FILL:
12640 fputs (" FILL ", stdout);
12641 /* XXX Print content of info word? */
12642 break;
12643 case ODK_TAGS:
12644 fputs (" TAGS ", stdout);
12645 /* XXX Print content of info word? */
12646 break;
12647 case ODK_HWAND:
12648 fputs (" HWAND ", stdout);
12649 if (option->info & OHWA0_R4KEOP_CHECKED)
12650 fputs (" R4KEOP_CHECKED", stdout);
12651 if (option->info & OHWA0_R4KEOP_CLEAN)
12652 fputs (" R4KEOP_CLEAN", stdout);
12653 break;
12654 case ODK_HWOR:
12655 fputs (" HWOR ", stdout);
12656 if (option->info & OHWA0_R4KEOP_CHECKED)
12657 fputs (" R4KEOP_CHECKED", stdout);
12658 if (option->info & OHWA0_R4KEOP_CLEAN)
12659 fputs (" R4KEOP_CLEAN", stdout);
12660 break;
12661 case ODK_GP_GROUP:
12662 printf (" GP_GROUP %#06lx self-contained %#06lx",
12663 option->info & OGP_GROUP,
12664 (option->info & OGP_SELF) >> 16);
12665 break;
12666 case ODK_IDENT:
12667 printf (" IDENT %#06lx self-contained %#06lx",
12668 option->info & OGP_GROUP,
12669 (option->info & OGP_SELF) >> 16);
12670 break;
12671 default:
12672 /* This shouldn't happen. */
12673 printf (" %3d ??? %d %lx",
12674 option->kind, option->section, option->info);
12675 break;
252b5132 12676 }
a6e9f9df 12677
2cf0635d 12678 len = sizeof (* eopt);
a6e9f9df
AM
12679 while (len < option->size)
12680 if (((char *) option)[len] >= ' '
12681 && ((char *) option)[len] < 0x7f)
12682 printf ("%c", ((char *) option)[len++]);
12683 else
12684 printf ("\\%03o", ((char *) option)[len++]);
12685
12686 fputs ("\n", stdout);
252b5132 12687 ++option;
252b5132
RH
12688 }
12689
a6e9f9df 12690 free (eopt);
252b5132 12691 }
252b5132
RH
12692 }
12693
12694 if (conflicts_offset != 0 && conflictsno != 0)
12695 {
2cf0635d 12696 Elf32_Conflict * iconf;
252b5132
RH
12697 size_t cnt;
12698
12699 if (dynamic_symbols == NULL)
12700 {
591a748a 12701 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH
12702 return 0;
12703 }
12704
3f5e193b 12705 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH
12706 if (iconf == NULL)
12707 {
591a748a 12708 error (_("Out of memory\n"));
252b5132
RH
12709 return 0;
12710 }
12711
9ea033b2 12712 if (is_32bit_elf)
252b5132 12713 {
2cf0635d 12714 Elf32_External_Conflict * econf32;
a6e9f9df 12715
3f5e193b
NC
12716 econf32 = (Elf32_External_Conflict *)
12717 get_data (NULL, file, conflicts_offset, conflictsno,
12718 sizeof (* econf32), _("conflict"));
a6e9f9df
AM
12719 if (!econf32)
12720 return 0;
252b5132
RH
12721
12722 for (cnt = 0; cnt < conflictsno; ++cnt)
12723 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM
12724
12725 free (econf32);
252b5132
RH
12726 }
12727 else
12728 {
2cf0635d 12729 Elf64_External_Conflict * econf64;
a6e9f9df 12730
3f5e193b
NC
12731 econf64 = (Elf64_External_Conflict *)
12732 get_data (NULL, file, conflicts_offset, conflictsno,
12733 sizeof (* econf64), _("conflict"));
a6e9f9df
AM
12734 if (!econf64)
12735 return 0;
252b5132
RH
12736
12737 for (cnt = 0; cnt < conflictsno; ++cnt)
12738 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM
12739
12740 free (econf64);
252b5132
RH
12741 }
12742
c7e7ca54
NC
12743 printf (_("\nSection '.conflict' contains %lu entries:\n"),
12744 (unsigned long) conflictsno);
252b5132
RH
12745 puts (_(" Num: Index Value Name"));
12746
12747 for (cnt = 0; cnt < conflictsno; ++cnt)
12748 {
2cf0635d 12749 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
252b5132 12750
b34976b6 12751 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
f7a99963 12752 print_vma (psym->st_value, FULL_HEX);
31104126 12753 putchar (' ');
d79b3d50
NC
12754 if (VALID_DYNAMIC_NAME (psym->st_name))
12755 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
12756 else
2b692964 12757 printf (_("<corrupt: %14ld>"), psym->st_name);
31104126 12758 putchar ('\n');
252b5132
RH
12759 }
12760
252b5132
RH
12761 free (iconf);
12762 }
12763
ccb4c951
RS
12764 if (pltgot != 0 && local_gotno != 0)
12765 {
91d6fa6a 12766 bfd_vma ent, local_end, global_end;
bbeee7ea 12767 size_t i, offset;
2cf0635d 12768 unsigned char * data;
bbeee7ea 12769 int addr_size;
ccb4c951 12770
91d6fa6a 12771 ent = pltgot;
ccb4c951
RS
12772 addr_size = (is_32bit_elf ? 4 : 8);
12773 local_end = pltgot + local_gotno * addr_size;
12774 global_end = local_end + (symtabno - gotsym) * addr_size;
12775
12776 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 12777 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC
12778 global_end - pltgot, 1,
12779 _("Global Offset Table data"));
59245841
NC
12780 if (data == NULL)
12781 return 0;
12782
ccb4c951
RS
12783 printf (_("\nPrimary GOT:\n"));
12784 printf (_(" Canonical gp value: "));
12785 print_vma (pltgot + 0x7ff0, LONG_HEX);
12786 printf ("\n\n");
12787
12788 printf (_(" Reserved entries:\n"));
12789 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC
12790 addr_size * 2, _("Address"), _("Access"),
12791 addr_size * 2, _("Initial"));
91d6fa6a 12792 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 12793 printf (_(" Lazy resolver\n"));
ccb4c951 12794 if (data
91d6fa6a 12795 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS
12796 >> (addr_size * 8 - 1)) != 0)
12797 {
91d6fa6a 12798 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 12799 printf (_(" Module pointer (GNU extension)\n"));
ccb4c951
RS
12800 }
12801 printf ("\n");
12802
91d6fa6a 12803 if (ent < local_end)
ccb4c951
RS
12804 {
12805 printf (_(" Local entries:\n"));
cc5914eb 12806 printf (" %*s %10s %*s\n",
2b692964
NC
12807 addr_size * 2, _("Address"), _("Access"),
12808 addr_size * 2, _("Initial"));
91d6fa6a 12809 while (ent < local_end)
ccb4c951 12810 {
91d6fa6a 12811 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS
12812 printf ("\n");
12813 }
12814 printf ("\n");
12815 }
12816
12817 if (gotsym < symtabno)
12818 {
12819 int sym_width;
12820
12821 printf (_(" Global entries:\n"));
cc5914eb 12822 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC
12823 addr_size * 2, _("Address"),
12824 _("Access"),
2b692964 12825 addr_size * 2, _("Initial"),
9cf03b7e
NC
12826 addr_size * 2, _("Sym.Val."),
12827 _("Type"),
12828 /* Note for translators: "Ndx" = abbreviated form of "Index". */
12829 _("Ndx"), _("Name"));
12830
ccb4c951
RS
12831 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
12832 for (i = gotsym; i < symtabno; i++)
12833 {
2cf0635d 12834 Elf_Internal_Sym * psym;
ccb4c951
RS
12835
12836 psym = dynamic_symbols + i;
91d6fa6a 12837 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS
12838 printf (" ");
12839 print_vma (psym->st_value, LONG_HEX);
12840 printf (" %-7s %3s ",
12841 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12842 get_symbol_index_type (psym->st_shndx));
12843 if (VALID_DYNAMIC_NAME (psym->st_name))
12844 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12845 else
2b692964 12846 printf (_("<corrupt: %14ld>"), psym->st_name);
ccb4c951
RS
12847 printf ("\n");
12848 }
12849 printf ("\n");
12850 }
12851
12852 if (data)
12853 free (data);
12854 }
12855
861fb55a
DJ
12856 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
12857 {
91d6fa6a 12858 bfd_vma ent, end;
861fb55a
DJ
12859 size_t offset, rel_offset;
12860 unsigned long count, i;
2cf0635d 12861 unsigned char * data;
861fb55a 12862 int addr_size, sym_width;
2cf0635d 12863 Elf_Internal_Rela * rels;
861fb55a
DJ
12864
12865 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
12866 if (pltrel == DT_RELA)
12867 {
12868 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
12869 return 0;
12870 }
12871 else
12872 {
12873 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
12874 return 0;
12875 }
12876
91d6fa6a 12877 ent = mips_pltgot;
861fb55a
DJ
12878 addr_size = (is_32bit_elf ? 4 : 8);
12879 end = mips_pltgot + (2 + count) * addr_size;
12880
12881 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 12882 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 12883 1, _("Procedure Linkage Table data"));
59245841
NC
12884 if (data == NULL)
12885 return 0;
12886
9cf03b7e 12887 printf ("\nPLT GOT:\n\n");
861fb55a
DJ
12888 printf (_(" Reserved entries:\n"));
12889 printf (_(" %*s %*s Purpose\n"),
2b692964 12890 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 12891 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 12892 printf (_(" PLT lazy resolver\n"));
91d6fa6a 12893 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 12894 printf (_(" Module pointer\n"));
861fb55a
DJ
12895 printf ("\n");
12896
12897 printf (_(" Entries:\n"));
cc5914eb 12898 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC
12899 addr_size * 2, _("Address"),
12900 addr_size * 2, _("Initial"),
12901 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ
12902 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
12903 for (i = 0; i < count; i++)
12904 {
2cf0635d 12905 Elf_Internal_Sym * psym;
861fb55a
DJ
12906
12907 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
91d6fa6a 12908 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a
DJ
12909 printf (" ");
12910 print_vma (psym->st_value, LONG_HEX);
12911 printf (" %-7s %3s ",
12912 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12913 get_symbol_index_type (psym->st_shndx));
12914 if (VALID_DYNAMIC_NAME (psym->st_name))
12915 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12916 else
2b692964 12917 printf (_("<corrupt: %14ld>"), psym->st_name);
861fb55a
DJ
12918 printf ("\n");
12919 }
12920 printf ("\n");
12921
12922 if (data)
12923 free (data);
12924 free (rels);
12925 }
12926
252b5132
RH
12927 return 1;
12928}
12929
047b2264 12930static int
2cf0635d 12931process_gnu_liblist (FILE * file)
047b2264 12932{
2cf0635d
NC
12933 Elf_Internal_Shdr * section;
12934 Elf_Internal_Shdr * string_sec;
12935 Elf32_External_Lib * elib;
12936 char * strtab;
c256ffe7 12937 size_t strtab_size;
047b2264
JJ
12938 size_t cnt;
12939 unsigned i;
12940
12941 if (! do_arch)
12942 return 0;
12943
12944 for (i = 0, section = section_headers;
12945 i < elf_header.e_shnum;
b34976b6 12946 i++, section++)
047b2264
JJ
12947 {
12948 switch (section->sh_type)
12949 {
12950 case SHT_GNU_LIBLIST:
4fbb74a6 12951 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ
12952 break;
12953
3f5e193b
NC
12954 elib = (Elf32_External_Lib *)
12955 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 12956 _("liblist section data"));
047b2264
JJ
12957
12958 if (elib == NULL)
12959 break;
4fbb74a6 12960 string_sec = section_headers + section->sh_link;
047b2264 12961
3f5e193b
NC
12962 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
12963 string_sec->sh_size,
12964 _("liblist string table"));
047b2264
JJ
12965 if (strtab == NULL
12966 || section->sh_entsize != sizeof (Elf32_External_Lib))
12967 {
12968 free (elib);
2842702f 12969 free (strtab);
047b2264
JJ
12970 break;
12971 }
59245841 12972 strtab_size = string_sec->sh_size;
047b2264
JJ
12973
12974 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12975 SECTION_NAME (section),
0af1713e 12976 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 12977
2b692964 12978 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ
12979
12980 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
12981 ++cnt)
12982 {
12983 Elf32_Lib liblist;
91d6fa6a 12984 time_t atime;
047b2264 12985 char timebuf[20];
2cf0635d 12986 struct tm * tmp;
047b2264
JJ
12987
12988 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 12989 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ
12990 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12991 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12992 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12993
91d6fa6a 12994 tmp = gmtime (&atime);
e9e44622
JJ
12995 snprintf (timebuf, sizeof (timebuf),
12996 "%04u-%02u-%02uT%02u:%02u:%02u",
12997 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12998 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ
12999
13000 printf ("%3lu: ", (unsigned long) cnt);
13001 if (do_wide)
c256ffe7 13002 printf ("%-20s", liblist.l_name < strtab_size
2b692964 13003 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 13004 else
c256ffe7 13005 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 13006 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ
13007 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
13008 liblist.l_version, liblist.l_flags);
13009 }
13010
13011 free (elib);
2842702f 13012 free (strtab);
047b2264
JJ
13013 }
13014 }
13015
13016 return 1;
13017}
13018
9437c45b 13019static const char *
d3ba0551 13020get_note_type (unsigned e_type)
779fe533
NC
13021{
13022 static char buff[64];
103f02d3 13023
1ec5cd37
NC
13024 if (elf_header.e_type == ET_CORE)
13025 switch (e_type)
13026 {
57346661 13027 case NT_AUXV:
1ec5cd37 13028 return _("NT_AUXV (auxiliary vector)");
57346661 13029 case NT_PRSTATUS:
1ec5cd37 13030 return _("NT_PRSTATUS (prstatus structure)");
57346661 13031 case NT_FPREGSET:
1ec5cd37 13032 return _("NT_FPREGSET (floating point registers)");
57346661 13033 case NT_PRPSINFO:
1ec5cd37 13034 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 13035 case NT_TASKSTRUCT:
1ec5cd37 13036 return _("NT_TASKSTRUCT (task structure)");
57346661 13037 case NT_PRXFPREG:
1ec5cd37 13038 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM
13039 case NT_PPC_VMX:
13040 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM
13041 case NT_PPC_VSX:
13042 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT
13043 case NT_386_TLS:
13044 return _("NT_386_TLS (x86 TLS information)");
13045 case NT_386_IOPERM:
13046 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L
13047 case NT_X86_XSTATE:
13048 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW
13049 case NT_S390_HIGH_GPRS:
13050 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS
13051 case NT_S390_TIMER:
13052 return _("NT_S390_TIMER (s390 timer register)");
13053 case NT_S390_TODCMP:
13054 return _("NT_S390_TODCMP (s390 TOD comparator register)");
13055 case NT_S390_TODPREG:
13056 return _("NT_S390_TODPREG (s390 TOD programmable register)");
13057 case NT_S390_CTRS:
13058 return _("NT_S390_CTRS (s390 control registers)");
13059 case NT_S390_PREFIX:
13060 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK
13061 case NT_S390_LAST_BREAK:
13062 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
13063 case NT_S390_SYSTEM_CALL:
13064 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC
13065 case NT_S390_TDB:
13066 return _("NT_S390_TDB (s390 transaction diagnostic block)");
faa9a424
UW
13067 case NT_ARM_VFP:
13068 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ
13069 case NT_ARM_TLS:
13070 return _("NT_ARM_TLS (AArch TLS registers)");
13071 case NT_ARM_HW_BREAK:
13072 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
13073 case NT_ARM_HW_WATCH:
13074 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 13075 case NT_PSTATUS:
1ec5cd37 13076 return _("NT_PSTATUS (pstatus structure)");
57346661 13077 case NT_FPREGS:
1ec5cd37 13078 return _("NT_FPREGS (floating point registers)");
57346661 13079 case NT_PSINFO:
1ec5cd37 13080 return _("NT_PSINFO (psinfo structure)");
57346661 13081 case NT_LWPSTATUS:
1ec5cd37 13082 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 13083 case NT_LWPSINFO:
1ec5cd37 13084 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 13085 case NT_WIN32PSTATUS:
1ec5cd37 13086 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT
13087 case NT_SIGINFO:
13088 return _("NT_SIGINFO (siginfo_t data)");
13089 case NT_FILE:
13090 return _("NT_FILE (mapped files)");
1ec5cd37
NC
13091 default:
13092 break;
13093 }
13094 else
13095 switch (e_type)
13096 {
13097 case NT_VERSION:
13098 return _("NT_VERSION (version)");
13099 case NT_ARCH:
13100 return _("NT_ARCH (architecture)");
13101 default:
13102 break;
13103 }
13104
e9e44622 13105 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 13106 return buff;
779fe533
NC
13107}
13108
9ece1fa9
TT
13109static int
13110print_core_note (Elf_Internal_Note *pnote)
13111{
13112 unsigned int addr_size = is_32bit_elf ? 4 : 8;
13113 bfd_vma count, page_size;
13114 unsigned char *descdata, *filenames, *descend;
13115
13116 if (pnote->type != NT_FILE)
13117 return 1;
13118
13119#ifndef BFD64
13120 if (!is_32bit_elf)
13121 {
13122 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
13123 /* Still "successful". */
13124 return 1;
13125 }
13126#endif
13127
13128 if (pnote->descsz < 2 * addr_size)
13129 {
13130 printf (_(" Malformed note - too short for header\n"));
13131 return 0;
13132 }
13133
13134 descdata = (unsigned char *) pnote->descdata;
13135 descend = descdata + pnote->descsz;
13136
13137 if (descdata[pnote->descsz - 1] != '\0')
13138 {
13139 printf (_(" Malformed note - does not end with \\0\n"));
13140 return 0;
13141 }
13142
13143 count = byte_get (descdata, addr_size);
13144 descdata += addr_size;
13145
13146 page_size = byte_get (descdata, addr_size);
13147 descdata += addr_size;
13148
13149 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
13150 {
13151 printf (_(" Malformed note - too short for supplied file count\n"));
13152 return 0;
13153 }
13154
13155 printf (_(" Page size: "));
13156 print_vma (page_size, DEC);
13157 printf ("\n");
13158
13159 printf (_(" %*s%*s%*s\n"),
13160 (int) (2 + 2 * addr_size), _("Start"),
13161 (int) (4 + 2 * addr_size), _("End"),
13162 (int) (4 + 2 * addr_size), _("Page Offset"));
13163 filenames = descdata + count * 3 * addr_size;
13164 while (--count > 0)
13165 {
13166 bfd_vma start, end, file_ofs;
13167
13168 if (filenames == descend)
13169 {
13170 printf (_(" Malformed note - filenames end too early\n"));
13171 return 0;
13172 }
13173
13174 start = byte_get (descdata, addr_size);
13175 descdata += addr_size;
13176 end = byte_get (descdata, addr_size);
13177 descdata += addr_size;
13178 file_ofs = byte_get (descdata, addr_size);
13179 descdata += addr_size;
13180
13181 printf (" ");
13182 print_vma (start, FULL_HEX);
13183 printf (" ");
13184 print_vma (end, FULL_HEX);
13185 printf (" ");
13186 print_vma (file_ofs, FULL_HEX);
13187 printf ("\n %s\n", filenames);
13188
13189 filenames += 1 + strlen ((char *) filenames);
13190 }
13191
13192 return 1;
13193}
13194
1118d252
RM
13195static const char *
13196get_gnu_elf_note_type (unsigned e_type)
13197{
13198 static char buff[64];
13199
13200 switch (e_type)
13201 {
13202 case NT_GNU_ABI_TAG:
13203 return _("NT_GNU_ABI_TAG (ABI version tag)");
13204 case NT_GNU_HWCAP:
13205 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
13206 case NT_GNU_BUILD_ID:
13207 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM
13208 case NT_GNU_GOLD_VERSION:
13209 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM
13210 default:
13211 break;
13212 }
13213
13214 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13215 return buff;
13216}
13217
664f90a3
TT
13218static int
13219print_gnu_note (Elf_Internal_Note *pnote)
13220{
13221 switch (pnote->type)
13222 {
13223 case NT_GNU_BUILD_ID:
13224 {
13225 unsigned long i;
13226
13227 printf (_(" Build ID: "));
13228 for (i = 0; i < pnote->descsz; ++i)
13229 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 13230 printf ("\n");
664f90a3
TT
13231 }
13232 break;
13233
13234 case NT_GNU_ABI_TAG:
13235 {
13236 unsigned long os, major, minor, subminor;
13237 const char *osname;
13238
13239 os = byte_get ((unsigned char *) pnote->descdata, 4);
13240 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
13241 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
13242 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
13243
13244 switch (os)
13245 {
13246 case GNU_ABI_TAG_LINUX:
13247 osname = "Linux";
13248 break;
13249 case GNU_ABI_TAG_HURD:
13250 osname = "Hurd";
13251 break;
13252 case GNU_ABI_TAG_SOLARIS:
13253 osname = "Solaris";
13254 break;
13255 case GNU_ABI_TAG_FREEBSD:
13256 osname = "FreeBSD";
13257 break;
13258 case GNU_ABI_TAG_NETBSD:
13259 osname = "NetBSD";
13260 break;
13261 default:
13262 osname = "Unknown";
13263 break;
13264 }
13265
13266 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
13267 major, minor, subminor);
13268 }
13269 break;
13270 }
13271
13272 return 1;
13273}
13274
9437c45b 13275static const char *
d3ba0551 13276get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT
13277{
13278 static char buff[64];
13279
b4db1224 13280 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT
13281 {
13282 /* NetBSD core "procinfo" structure. */
13283 return _("NetBSD procinfo structure");
13284 }
13285
13286 /* As of Jan 2002 there are no other machine-independent notes
13287 defined for NetBSD core files. If the note type is less
13288 than the start of the machine-dependent note types, we don't
13289 understand it. */
13290
b4db1224 13291 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 13292 {
e9e44622 13293 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT
13294 return buff;
13295 }
13296
13297 switch (elf_header.e_machine)
13298 {
13299 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
13300 and PT_GETFPREGS == mach+2. */
13301
13302 case EM_OLD_ALPHA:
13303 case EM_ALPHA:
13304 case EM_SPARC:
13305 case EM_SPARC32PLUS:
13306 case EM_SPARCV9:
13307 switch (e_type)
13308 {
2b692964 13309 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 13310 return _("PT_GETREGS (reg structure)");
2b692964 13311 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 13312 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT
13313 default:
13314 break;
13315 }
13316 break;
13317
13318 /* On all other arch's, PT_GETREGS == mach+1 and
13319 PT_GETFPREGS == mach+3. */
13320 default:
13321 switch (e_type)
13322 {
2b692964 13323 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 13324 return _("PT_GETREGS (reg structure)");
2b692964 13325 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 13326 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT
13327 default:
13328 break;
13329 }
13330 }
13331
9cf03b7e 13332 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 13333 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT
13334 return buff;
13335}
13336
70616151
TT
13337static const char *
13338get_stapsdt_note_type (unsigned e_type)
13339{
13340 static char buff[64];
13341
13342 switch (e_type)
13343 {
13344 case NT_STAPSDT:
13345 return _("NT_STAPSDT (SystemTap probe descriptors)");
13346
13347 default:
13348 break;
13349 }
13350
13351 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13352 return buff;
13353}
13354
c6a9fc58
TT
13355static int
13356print_stapsdt_note (Elf_Internal_Note *pnote)
13357{
13358 int addr_size = is_32bit_elf ? 4 : 8;
13359 char *data = pnote->descdata;
13360 char *data_end = pnote->descdata + pnote->descsz;
13361 bfd_vma pc, base_addr, semaphore;
13362 char *provider, *probe, *arg_fmt;
13363
13364 pc = byte_get ((unsigned char *) data, addr_size);
13365 data += addr_size;
13366 base_addr = byte_get ((unsigned char *) data, addr_size);
13367 data += addr_size;
13368 semaphore = byte_get ((unsigned char *) data, addr_size);
13369 data += addr_size;
13370
13371 provider = data;
13372 data += strlen (data) + 1;
13373 probe = data;
13374 data += strlen (data) + 1;
13375 arg_fmt = data;
13376 data += strlen (data) + 1;
13377
13378 printf (_(" Provider: %s\n"), provider);
13379 printf (_(" Name: %s\n"), probe);
13380 printf (_(" Location: "));
13381 print_vma (pc, FULL_HEX);
13382 printf (_(", Base: "));
13383 print_vma (base_addr, FULL_HEX);
13384 printf (_(", Semaphore: "));
13385 print_vma (semaphore, FULL_HEX);
9cf03b7e 13386 printf ("\n");
c6a9fc58
TT
13387 printf (_(" Arguments: %s\n"), arg_fmt);
13388
13389 return data == data_end;
13390}
13391
00e98fc7
TG
13392static const char *
13393get_ia64_vms_note_type (unsigned e_type)
13394{
13395 static char buff[64];
13396
13397 switch (e_type)
13398 {
13399 case NT_VMS_MHD:
13400 return _("NT_VMS_MHD (module header)");
13401 case NT_VMS_LNM:
13402 return _("NT_VMS_LNM (language name)");
13403 case NT_VMS_SRC:
13404 return _("NT_VMS_SRC (source files)");
13405 case NT_VMS_TITLE:
9cf03b7e 13406 return "NT_VMS_TITLE";
00e98fc7
TG
13407 case NT_VMS_EIDC:
13408 return _("NT_VMS_EIDC (consistency check)");
13409 case NT_VMS_FPMODE:
13410 return _("NT_VMS_FPMODE (FP mode)");
13411 case NT_VMS_LINKTIME:
9cf03b7e 13412 return "NT_VMS_LINKTIME";
00e98fc7
TG
13413 case NT_VMS_IMGNAM:
13414 return _("NT_VMS_IMGNAM (image name)");
13415 case NT_VMS_IMGID:
13416 return _("NT_VMS_IMGID (image id)");
13417 case NT_VMS_LINKID:
13418 return _("NT_VMS_LINKID (link id)");
13419 case NT_VMS_IMGBID:
13420 return _("NT_VMS_IMGBID (build id)");
13421 case NT_VMS_GSTNAM:
13422 return _("NT_VMS_GSTNAM (sym table name)");
13423 case NT_VMS_ORIG_DYN:
9cf03b7e 13424 return "NT_VMS_ORIG_DYN";
00e98fc7 13425 case NT_VMS_PATCHTIME:
9cf03b7e 13426 return "NT_VMS_PATCHTIME";
00e98fc7
TG
13427 default:
13428 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13429 return buff;
13430 }
13431}
13432
13433static int
13434print_ia64_vms_note (Elf_Internal_Note * pnote)
13435{
13436 switch (pnote->type)
13437 {
13438 case NT_VMS_MHD:
13439 if (pnote->descsz > 36)
13440 {
13441 size_t l = strlen (pnote->descdata + 34);
13442 printf (_(" Creation date : %.17s\n"), pnote->descdata);
13443 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
13444 printf (_(" Module name : %s\n"), pnote->descdata + 34);
13445 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
13446 }
13447 else
13448 printf (_(" Invalid size\n"));
13449 break;
13450 case NT_VMS_LNM:
13451 printf (_(" Language: %s\n"), pnote->descdata);
13452 break;
13453#ifdef BFD64
13454 case NT_VMS_FPMODE:
9cf03b7e 13455 printf (_(" Floating Point mode: "));
4a5cb34f 13456 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG
13457 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
13458 break;
13459 case NT_VMS_LINKTIME:
13460 printf (_(" Link time: "));
13461 print_vms_time
13462 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13463 printf ("\n");
13464 break;
13465 case NT_VMS_PATCHTIME:
13466 printf (_(" Patch time: "));
13467 print_vms_time
13468 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13469 printf ("\n");
13470 break;
13471 case NT_VMS_ORIG_DYN:
13472 printf (_(" Major id: %u, minor id: %u\n"),
13473 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
13474 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 13475 printf (_(" Last modified : "));
00e98fc7
TG
13476 print_vms_time
13477 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 13478 printf (_("\n Link flags : "));
4a5cb34f 13479 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG
13480 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
13481 printf (_(" Header flags: 0x%08x\n"),
13482 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
13483 printf (_(" Image id : %s\n"), pnote->descdata + 32);
13484 break;
13485#endif
13486 case NT_VMS_IMGNAM:
13487 printf (_(" Image name: %s\n"), pnote->descdata);
13488 break;
13489 case NT_VMS_GSTNAM:
13490 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
13491 break;
13492 case NT_VMS_IMGID:
13493 printf (_(" Image id: %s\n"), pnote->descdata);
13494 break;
13495 case NT_VMS_LINKID:
13496 printf (_(" Linker id: %s\n"), pnote->descdata);
13497 break;
13498 default:
13499 break;
13500 }
13501 return 1;
13502}
13503
6d118b09
NC
13504/* Note that by the ELF standard, the name field is already null byte
13505 terminated, and namesz includes the terminating null byte.
13506 I.E. the value of namesz for the name "FSF" is 4.
13507
e3c8793a 13508 If the value of namesz is zero, there is no name present. */
779fe533 13509static int
2cf0635d 13510process_note (Elf_Internal_Note * pnote)
779fe533 13511{
2cf0635d
NC
13512 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
13513 const char * nt;
9437c45b
JT
13514
13515 if (pnote->namesz == 0)
1ec5cd37
NC
13516 /* If there is no note name, then use the default set of
13517 note type strings. */
13518 nt = get_note_type (pnote->type);
13519
1118d252
RM
13520 else if (const_strneq (pnote->namedata, "GNU"))
13521 /* GNU-specific object file notes. */
13522 nt = get_gnu_elf_note_type (pnote->type);
13523
0112cd26 13524 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC
13525 /* NetBSD-specific core file notes. */
13526 nt = get_netbsd_elfcore_note_type (pnote->type);
13527
b15fa79e
AM
13528 else if (strneq (pnote->namedata, "SPU/", 4))
13529 {
13530 /* SPU-specific core file notes. */
13531 nt = pnote->namedata + 4;
13532 name = "SPU";
13533 }
13534
00e98fc7
TG
13535 else if (const_strneq (pnote->namedata, "IPF/VMS"))
13536 /* VMS/ia64-specific file notes. */
13537 nt = get_ia64_vms_note_type (pnote->type);
13538
70616151
TT
13539 else if (const_strneq (pnote->namedata, "stapsdt"))
13540 nt = get_stapsdt_note_type (pnote->type);
13541
9437c45b 13542 else
1ec5cd37
NC
13543 /* Don't recognize this note name; just use the default set of
13544 note type strings. */
00e98fc7 13545 nt = get_note_type (pnote->type);
9437c45b 13546
2aee03ae 13547 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG
13548
13549 if (const_strneq (pnote->namedata, "IPF/VMS"))
13550 return print_ia64_vms_note (pnote);
664f90a3
TT
13551 else if (const_strneq (pnote->namedata, "GNU"))
13552 return print_gnu_note (pnote);
c6a9fc58
TT
13553 else if (const_strneq (pnote->namedata, "stapsdt"))
13554 return print_stapsdt_note (pnote);
9ece1fa9
TT
13555 else if (const_strneq (pnote->namedata, "CORE"))
13556 return print_core_note (pnote);
00e98fc7
TG
13557 else
13558 return 1;
779fe533
NC
13559}
13560
6d118b09 13561
779fe533 13562static int
2cf0635d 13563process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 13564{
2cf0635d
NC
13565 Elf_External_Note * pnotes;
13566 Elf_External_Note * external;
b34976b6 13567 int res = 1;
103f02d3 13568
779fe533
NC
13569 if (length <= 0)
13570 return 0;
103f02d3 13571
3f5e193b 13572 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 13573 _("notes"));
dd24e3da 13574 if (pnotes == NULL)
a6e9f9df 13575 return 0;
779fe533 13576
103f02d3 13577 external = pnotes;
103f02d3 13578
9dd3a467 13579 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 13580 (unsigned long) offset, (unsigned long) length);
2aee03ae 13581 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 13582
15b42fb0 13583 while ((char *) external < (char *) pnotes + length)
779fe533 13584 {
b34976b6 13585 Elf_Internal_Note inote;
15b42fb0
AM
13586 size_t min_notesz;
13587 char *next;
2cf0635d 13588 char * temp = NULL;
15b42fb0 13589 size_t data_remaining = ((char *) pnotes + length) - (char *) external;
6d118b09 13590
00e98fc7 13591 if (!is_ia64_vms ())
15b42fb0 13592 {
9dd3a467
NC
13593 /* PR binutils/15191
13594 Make sure that there is enough data to read. */
15b42fb0
AM
13595 min_notesz = offsetof (Elf_External_Note, name);
13596 if (data_remaining < min_notesz)
9dd3a467
NC
13597 {
13598 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
13599 (int) data_remaining);
13600 break;
13601 }
15b42fb0
AM
13602 inote.type = BYTE_GET (external->type);
13603 inote.namesz = BYTE_GET (external->namesz);
13604 inote.namedata = external->name;
13605 inote.descsz = BYTE_GET (external->descsz);
13606 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
13607 inote.descpos = offset + (inote.descdata - (char *) pnotes);
13608 next = inote.descdata + align_power (inote.descsz, 2);
13609 }
00e98fc7 13610 else
15b42fb0
AM
13611 {
13612 Elf64_External_VMS_Note *vms_external;
00e98fc7 13613
9dd3a467
NC
13614 /* PR binutils/15191
13615 Make sure that there is enough data to read. */
15b42fb0
AM
13616 min_notesz = offsetof (Elf64_External_VMS_Note, name);
13617 if (data_remaining < min_notesz)
9dd3a467
NC
13618 {
13619 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
13620 (int) data_remaining);
13621 break;
13622 }
3e55a963 13623
15b42fb0
AM
13624 vms_external = (Elf64_External_VMS_Note *) external;
13625 inote.type = BYTE_GET (vms_external->type);
13626 inote.namesz = BYTE_GET (vms_external->namesz);
13627 inote.namedata = vms_external->name;
13628 inote.descsz = BYTE_GET (vms_external->descsz);
13629 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
13630 inote.descpos = offset + (inote.descdata - (char *) pnotes);
13631 next = inote.descdata + align_power (inote.descsz, 3);
13632 }
13633
13634 if (inote.descdata < (char *) external + min_notesz
13635 || next < (char *) external + min_notesz
13636 || data_remaining < (size_t)(next - (char *) external))
3e55a963 13637 {
15b42fb0 13638 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 13639 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 13640 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC
13641 inote.type, inote.namesz, inote.descsz);
13642 break;
13643 }
13644
15b42fb0 13645 external = (Elf_External_Note *) next;
dd24e3da 13646
6d118b09
NC
13647 /* Verify that name is null terminated. It appears that at least
13648 one version of Linux (RedHat 6.0) generates corefiles that don't
13649 comply with the ELF spec by failing to include the null byte in
13650 namesz. */
8b971f9f 13651 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 13652 {
3f5e193b 13653 temp = (char *) malloc (inote.namesz + 1);
76da6bbe 13654
6d118b09
NC
13655 if (temp == NULL)
13656 {
13657 error (_("Out of memory\n"));
13658 res = 0;
13659 break;
13660 }
76da6bbe 13661
6d118b09
NC
13662 strncpy (temp, inote.namedata, inote.namesz);
13663 temp[inote.namesz] = 0;
76da6bbe 13664
6d118b09
NC
13665 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
13666 inote.namedata = temp;
13667 }
13668
13669 res &= process_note (& inote);
103f02d3 13670
6d118b09
NC
13671 if (temp != NULL)
13672 {
13673 free (temp);
13674 temp = NULL;
13675 }
779fe533
NC
13676 }
13677
13678 free (pnotes);
103f02d3 13679
779fe533
NC
13680 return res;
13681}
13682
13683static int
2cf0635d 13684process_corefile_note_segments (FILE * file)
779fe533 13685{
2cf0635d 13686 Elf_Internal_Phdr * segment;
b34976b6
AM
13687 unsigned int i;
13688 int res = 1;
103f02d3 13689
d93f0186 13690 if (! get_program_headers (file))
779fe533 13691 return 0;
103f02d3 13692
779fe533
NC
13693 for (i = 0, segment = program_headers;
13694 i < elf_header.e_phnum;
b34976b6 13695 i++, segment++)
779fe533
NC
13696 {
13697 if (segment->p_type == PT_NOTE)
103f02d3 13698 res &= process_corefile_note_segment (file,
30800947
NC
13699 (bfd_vma) segment->p_offset,
13700 (bfd_vma) segment->p_filesz);
779fe533 13701 }
103f02d3 13702
779fe533
NC
13703 return res;
13704}
13705
13706static int
2cf0635d 13707process_note_sections (FILE * file)
1ec5cd37 13708{
2cf0635d 13709 Elf_Internal_Shdr * section;
1ec5cd37
NC
13710 unsigned long i;
13711 int res = 1;
13712
13713 for (i = 0, section = section_headers;
fa1908fd 13714 i < elf_header.e_shnum && section != NULL;
1ec5cd37
NC
13715 i++, section++)
13716 if (section->sh_type == SHT_NOTE)
13717 res &= process_corefile_note_segment (file,
13718 (bfd_vma) section->sh_offset,
13719 (bfd_vma) section->sh_size);
13720
13721 return res;
13722}
13723
13724static int
2cf0635d 13725process_notes (FILE * file)
779fe533
NC
13726{
13727 /* If we have not been asked to display the notes then do nothing. */
13728 if (! do_notes)
13729 return 1;
103f02d3 13730
779fe533 13731 if (elf_header.e_type != ET_CORE)
1ec5cd37 13732 return process_note_sections (file);
103f02d3 13733
779fe533 13734 /* No program headers means no NOTE segment. */
1ec5cd37
NC
13735 if (elf_header.e_phnum > 0)
13736 return process_corefile_note_segments (file);
779fe533 13737
1ec5cd37
NC
13738 printf (_("No note segments present in the core file.\n"));
13739 return 1;
779fe533
NC
13740}
13741
252b5132 13742static int
2cf0635d 13743process_arch_specific (FILE * file)
252b5132 13744{
a952a375
NC
13745 if (! do_arch)
13746 return 1;
13747
252b5132
RH
13748 switch (elf_header.e_machine)
13749 {
11c1ff18
PB
13750 case EM_ARM:
13751 return process_arm_specific (file);
252b5132 13752 case EM_MIPS:
4fe85591 13753 case EM_MIPS_RS3_LE:
252b5132
RH
13754 return process_mips_specific (file);
13755 break;
34c8bcba
JM
13756 case EM_PPC:
13757 return process_power_specific (file);
13758 break;
9e8c70f9
DM
13759 case EM_SPARC:
13760 case EM_SPARC32PLUS:
13761 case EM_SPARCV9:
13762 return process_sparc_specific (file);
13763 break;
59e6276b
JM
13764 case EM_TI_C6000:
13765 return process_tic6x_specific (file);
13766 break;
13761a11
NC
13767 case EM_MSP430:
13768 return process_msp430x_specific (file);
252b5132
RH
13769 default:
13770 break;
13771 }
13772 return 1;
13773}
13774
13775static int
2cf0635d 13776get_file_header (FILE * file)
252b5132 13777{
9ea033b2
NC
13778 /* Read in the identity array. */
13779 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH
13780 return 0;
13781
9ea033b2 13782 /* Determine how to read the rest of the header. */
b34976b6 13783 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC
13784 {
13785 default: /* fall through */
13786 case ELFDATANONE: /* fall through */
adab8cdc
AO
13787 case ELFDATA2LSB:
13788 byte_get = byte_get_little_endian;
13789 byte_put = byte_put_little_endian;
13790 break;
13791 case ELFDATA2MSB:
13792 byte_get = byte_get_big_endian;
13793 byte_put = byte_put_big_endian;
13794 break;
9ea033b2
NC
13795 }
13796
13797 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 13798 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC
13799
13800 /* Read in the rest of the header. */
13801 if (is_32bit_elf)
13802 {
13803 Elf32_External_Ehdr ehdr32;
252b5132 13804
9ea033b2
NC
13805 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
13806 return 0;
103f02d3 13807
9ea033b2
NC
13808 elf_header.e_type = BYTE_GET (ehdr32.e_type);
13809 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
13810 elf_header.e_version = BYTE_GET (ehdr32.e_version);
13811 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
13812 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
13813 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
13814 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
13815 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
13816 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
13817 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
13818 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
13819 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
13820 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
13821 }
252b5132 13822 else
9ea033b2
NC
13823 {
13824 Elf64_External_Ehdr ehdr64;
a952a375
NC
13825
13826 /* If we have been compiled with sizeof (bfd_vma) == 4, then
13827 we will not be able to cope with the 64bit data found in
13828 64 ELF files. Detect this now and abort before we start
50c2245b 13829 overwriting things. */
a952a375
NC
13830 if (sizeof (bfd_vma) < 8)
13831 {
e3c8793a
NC
13832 error (_("This instance of readelf has been built without support for a\n\
1383364 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC
13834 return 0;
13835 }
103f02d3 13836
9ea033b2
NC
13837 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
13838 return 0;
103f02d3 13839
9ea033b2
NC
13840 elf_header.e_type = BYTE_GET (ehdr64.e_type);
13841 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
13842 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM
13843 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
13844 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
13845 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC
13846 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
13847 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
13848 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
13849 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
13850 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
13851 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
13852 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
13853 }
252b5132 13854
7ece0d85
JJ
13855 if (elf_header.e_shoff)
13856 {
13857 /* There may be some extensions in the first section header. Don't
13858 bomb if we can't read it. */
13859 if (is_32bit_elf)
13860 get_32bit_section_headers (file, 1);
13861 else
13862 get_64bit_section_headers (file, 1);
13863 }
560f3c1c 13864
252b5132
RH
13865 return 1;
13866}
13867
fb52b2f4
NC
13868/* Process one ELF object file according to the command line options.
13869 This file may actually be stored in an archive. The file is
13870 positioned at the start of the ELF object. */
13871
ff78d6d6 13872static int
2cf0635d 13873process_object (char * file_name, FILE * file)
252b5132 13874{
252b5132
RH
13875 unsigned int i;
13876
252b5132
RH
13877 if (! get_file_header (file))
13878 {
13879 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 13880 return 1;
252b5132
RH
13881 }
13882
13883 /* Initialise per file variables. */
60bca95a 13884 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH
13885 version_info[i] = 0;
13886
60bca95a 13887 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 13888 dynamic_info[i] = 0;
5115b233 13889 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH
13890
13891 /* Process the file. */
13892 if (show_name)
13893 printf (_("\nFile: %s\n"), file_name);
13894
18bd398b
NC
13895 /* Initialise the dump_sects array from the cmdline_dump_sects array.
13896 Note we do this even if cmdline_dump_sects is empty because we
13897 must make sure that the dump_sets array is zeroed out before each
13898 object file is processed. */
13899 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 13900 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC
13901
13902 if (num_cmdline_dump_sects > 0)
13903 {
13904 if (num_dump_sects == 0)
13905 /* A sneaky way of allocating the dump_sects array. */
09c11c86 13906 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC
13907
13908 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC
13909 memcpy (dump_sects, cmdline_dump_sects,
13910 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 13911 }
d70c5fc7 13912
252b5132 13913 if (! process_file_header ())
fb52b2f4 13914 return 1;
252b5132 13915
d1f5c6e3 13916 if (! process_section_headers (file))
2f62977e 13917 {
d1f5c6e3
L
13918 /* Without loaded section headers we cannot process lots of
13919 things. */
2f62977e 13920 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 13921
2f62977e 13922 if (! do_using_dynamic)
2c610e4b 13923 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 13924 }
252b5132 13925
d1f5c6e3
L
13926 if (! process_section_groups (file))
13927 {
13928 /* Without loaded section groups we cannot process unwind. */
13929 do_unwind = 0;
13930 }
13931
2f62977e 13932 if (process_program_headers (file))
b2d38a17 13933 process_dynamic_section (file);
252b5132
RH
13934
13935 process_relocs (file);
13936
4d6ed7c8
NC
13937 process_unwind (file);
13938
252b5132
RH
13939 process_symbol_table (file);
13940
13941 process_syminfo (file);
13942
13943 process_version_sections (file);
13944
13945 process_section_contents (file);
f5842774 13946
1ec5cd37 13947 process_notes (file);
103f02d3 13948
047b2264
JJ
13949 process_gnu_liblist (file);
13950
252b5132
RH
13951 process_arch_specific (file);
13952
d93f0186
NC
13953 if (program_headers)
13954 {
13955 free (program_headers);
13956 program_headers = NULL;
13957 }
13958
252b5132
RH
13959 if (section_headers)
13960 {
13961 free (section_headers);
13962 section_headers = NULL;
13963 }
13964
13965 if (string_table)
13966 {
13967 free (string_table);
13968 string_table = NULL;
d40ac9bd 13969 string_table_length = 0;
252b5132
RH
13970 }
13971
13972 if (dynamic_strings)
13973 {
13974 free (dynamic_strings);
13975 dynamic_strings = NULL;
d79b3d50 13976 dynamic_strings_length = 0;
252b5132
RH
13977 }
13978
13979 if (dynamic_symbols)
13980 {
13981 free (dynamic_symbols);
13982 dynamic_symbols = NULL;
19936277 13983 num_dynamic_syms = 0;
252b5132
RH
13984 }
13985
13986 if (dynamic_syminfo)
13987 {
13988 free (dynamic_syminfo);
13989 dynamic_syminfo = NULL;
13990 }
ff78d6d6 13991
293c573e
MR
13992 if (dynamic_section)
13993 {
13994 free (dynamic_section);
13995 dynamic_section = NULL;
13996 }
13997
e4b17d5c
L
13998 if (section_headers_groups)
13999 {
14000 free (section_headers_groups);
14001 section_headers_groups = NULL;
14002 }
14003
14004 if (section_groups)
14005 {
2cf0635d
NC
14006 struct group_list * g;
14007 struct group_list * next;
e4b17d5c
L
14008
14009 for (i = 0; i < group_count; i++)
14010 {
14011 for (g = section_groups [i].root; g != NULL; g = next)
14012 {
14013 next = g->next;
14014 free (g);
14015 }
14016 }
14017
14018 free (section_groups);
14019 section_groups = NULL;
14020 }
14021
19e6b90e 14022 free_debug_memory ();
18bd398b 14023
ff78d6d6 14024 return 0;
252b5132
RH
14025}
14026
2cf0635d
NC
14027/* Process an ELF archive.
14028 On entry the file is positioned just after the ARMAG string. */
14029
14030static int
14031process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
14032{
14033 struct archive_info arch;
14034 struct archive_info nested_arch;
14035 size_t got;
2cf0635d
NC
14036 int ret;
14037
14038 show_name = 1;
14039
14040 /* The ARCH structure is used to hold information about this archive. */
14041 arch.file_name = NULL;
14042 arch.file = NULL;
14043 arch.index_array = NULL;
14044 arch.sym_table = NULL;
14045 arch.longnames = NULL;
14046
14047 /* The NESTED_ARCH structure is used as a single-item cache of information
14048 about a nested archive (when members of a thin archive reside within
14049 another regular archive file). */
14050 nested_arch.file_name = NULL;
14051 nested_arch.file = NULL;
14052 nested_arch.index_array = NULL;
14053 nested_arch.sym_table = NULL;
14054 nested_arch.longnames = NULL;
14055
14056 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
14057 {
14058 ret = 1;
14059 goto out;
4145f1d5 14060 }
fb52b2f4 14061
4145f1d5
NC
14062 if (do_archive_index)
14063 {
2cf0635d 14064 if (arch.sym_table == NULL)
4145f1d5
NC
14065 error (_("%s: unable to dump the index as none was found\n"), file_name);
14066 else
14067 {
2cf0635d 14068 unsigned int i, l;
4145f1d5
NC
14069 unsigned long current_pos;
14070
14071 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
c2a7d3f5 14072 file_name, (long) arch.index_num, arch.sym_size);
4145f1d5
NC
14073 current_pos = ftell (file);
14074
2cf0635d 14075 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 14076 {
2cf0635d
NC
14077 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
14078 {
14079 char * member_name;
4145f1d5 14080
2cf0635d
NC
14081 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
14082
14083 if (member_name != NULL)
14084 {
14085 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
14086
14087 if (qualified_name != NULL)
14088 {
c2a7d3f5
NC
14089 printf (_("Contents of binary %s at offset "), qualified_name);
14090 (void) print_vma (arch.index_array[i], PREFIX_HEX);
14091 putchar ('\n');
2cf0635d
NC
14092 free (qualified_name);
14093 }
4145f1d5
NC
14094 }
14095 }
2cf0635d
NC
14096
14097 if (l >= arch.sym_size)
4145f1d5
NC
14098 {
14099 error (_("%s: end of the symbol table reached before the end of the index\n"),
14100 file_name);
cb8f3167 14101 break;
4145f1d5 14102 }
2cf0635d
NC
14103 printf ("\t%s\n", arch.sym_table + l);
14104 l += strlen (arch.sym_table + l) + 1;
4145f1d5
NC
14105 }
14106
c2a7d3f5
NC
14107 if (arch.uses_64bit_indicies)
14108 l = (l + 7) & ~ 7;
14109 else
14110 l += l & 1;
14111
2cf0635d 14112 if (l < arch.sym_size)
c2a7d3f5
NC
14113 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
14114 file_name, arch.sym_size - l);
4145f1d5 14115
4145f1d5
NC
14116 if (fseek (file, current_pos, SEEK_SET) != 0)
14117 {
14118 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC
14119 ret = 1;
14120 goto out;
4145f1d5 14121 }
fb52b2f4 14122 }
4145f1d5
NC
14123
14124 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
14125 && !do_segments && !do_header && !do_dump && !do_version
14126 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 14127 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC
14128 {
14129 ret = 0; /* Archive index only. */
14130 goto out;
14131 }
fb52b2f4
NC
14132 }
14133
d989285c 14134 ret = 0;
fb52b2f4
NC
14135
14136 while (1)
14137 {
2cf0635d
NC
14138 char * name;
14139 size_t namelen;
14140 char * qualified_name;
14141
14142 /* Read the next archive header. */
14143 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
14144 {
14145 error (_("%s: failed to seek to next archive header\n"), file_name);
14146 return 1;
14147 }
14148 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
14149 if (got != sizeof arch.arhdr)
14150 {
14151 if (got == 0)
14152 break;
14153 error (_("%s: failed to read archive header\n"), file_name);
14154 ret = 1;
14155 break;
14156 }
14157 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
14158 {
14159 error (_("%s: did not find a valid archive header\n"), arch.file_name);
14160 ret = 1;
14161 break;
14162 }
14163
14164 arch.next_arhdr_offset += sizeof arch.arhdr;
14165
14166 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
14167 if (archive_file_size & 01)
14168 ++archive_file_size;
14169
14170 name = get_archive_member_name (&arch, &nested_arch);
14171 if (name == NULL)
fb52b2f4 14172 {
0fd3a477 14173 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT
14174 ret = 1;
14175 break;
fb52b2f4 14176 }
2cf0635d 14177 namelen = strlen (name);
fb52b2f4 14178
2cf0635d
NC
14179 qualified_name = make_qualified_name (&arch, &nested_arch, name);
14180 if (qualified_name == NULL)
fb52b2f4 14181 {
2cf0635d 14182 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT
14183 ret = 1;
14184 break;
fb52b2f4
NC
14185 }
14186
2cf0635d
NC
14187 if (is_thin_archive && arch.nested_member_origin == 0)
14188 {
14189 /* This is a proxy for an external member of a thin archive. */
14190 FILE * member_file;
14191 char * member_file_name = adjust_relative_path (file_name, name, namelen);
14192 if (member_file_name == NULL)
14193 {
14194 ret = 1;
14195 break;
14196 }
14197
14198 member_file = fopen (member_file_name, "rb");
14199 if (member_file == NULL)
14200 {
14201 error (_("Input file '%s' is not readable.\n"), member_file_name);
14202 free (member_file_name);
14203 ret = 1;
14204 break;
14205 }
14206
14207 archive_file_offset = arch.nested_member_origin;
14208
14209 ret |= process_object (qualified_name, member_file);
14210
14211 fclose (member_file);
14212 free (member_file_name);
14213 }
14214 else if (is_thin_archive)
14215 {
a043396b
NC
14216 /* PR 15140: Allow for corrupt thin archives. */
14217 if (nested_arch.file == NULL)
14218 {
14219 error (_("%s: contains corrupt thin archive: %s\n"),
14220 file_name, name);
14221 ret = 1;
14222 break;
14223 }
14224
2cf0635d
NC
14225 /* This is a proxy for a member of a nested archive. */
14226 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
14227
14228 /* The nested archive file will have been opened and setup by
14229 get_archive_member_name. */
14230 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
14231 {
14232 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
14233 ret = 1;
14234 break;
14235 }
14236
14237 ret |= process_object (qualified_name, nested_arch.file);
14238 }
14239 else
14240 {
14241 archive_file_offset = arch.next_arhdr_offset;
14242 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 14243
2cf0635d
NC
14244 ret |= process_object (qualified_name, file);
14245 }
fb52b2f4 14246
2b52916e
L
14247 if (dump_sects != NULL)
14248 {
14249 free (dump_sects);
14250 dump_sects = NULL;
14251 num_dump_sects = 0;
14252 }
14253
2cf0635d 14254 free (qualified_name);
fb52b2f4
NC
14255 }
14256
4145f1d5 14257 out:
2cf0635d
NC
14258 if (nested_arch.file != NULL)
14259 fclose (nested_arch.file);
14260 release_archive (&nested_arch);
14261 release_archive (&arch);
fb52b2f4 14262
d989285c 14263 return ret;
fb52b2f4
NC
14264}
14265
14266static int
2cf0635d 14267process_file (char * file_name)
fb52b2f4 14268{
2cf0635d 14269 FILE * file;
fb52b2f4
NC
14270 struct stat statbuf;
14271 char armag[SARMAG];
14272 int ret;
14273
14274 if (stat (file_name, &statbuf) < 0)
14275 {
f24ddbdd
NC
14276 if (errno == ENOENT)
14277 error (_("'%s': No such file\n"), file_name);
14278 else
14279 error (_("Could not locate '%s'. System error message: %s\n"),
14280 file_name, strerror (errno));
14281 return 1;
14282 }
14283
14284 if (! S_ISREG (statbuf.st_mode))
14285 {
14286 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC
14287 return 1;
14288 }
14289
14290 file = fopen (file_name, "rb");
14291 if (file == NULL)
14292 {
f24ddbdd 14293 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC
14294 return 1;
14295 }
14296
14297 if (fread (armag, SARMAG, 1, file) != 1)
14298 {
4145f1d5 14299 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC
14300 fclose (file);
14301 return 1;
14302 }
14303
14304 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC
14305 ret = process_archive (file_name, file, FALSE);
14306 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
14307 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC
14308 else
14309 {
4145f1d5
NC
14310 if (do_archive_index)
14311 error (_("File %s is not an archive so its index cannot be displayed.\n"),
14312 file_name);
14313
fb52b2f4
NC
14314 rewind (file);
14315 archive_file_size = archive_file_offset = 0;
14316 ret = process_object (file_name, file);
14317 }
14318
14319 fclose (file);
14320
14321 return ret;
14322}
14323
252b5132
RH
14324#ifdef SUPPORT_DISASSEMBLY
14325/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 14326 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 14327 symbols. */
252b5132
RH
14328
14329void
2cf0635d 14330print_address (unsigned int addr, FILE * outfile)
252b5132
RH
14331{
14332 fprintf (outfile,"0x%8.8x", addr);
14333}
14334
e3c8793a 14335/* Needed by the i386 disassembler. */
252b5132
RH
14336void
14337db_task_printsym (unsigned int addr)
14338{
14339 print_address (addr, stderr);
14340}
14341#endif
14342
14343int
2cf0635d 14344main (int argc, char ** argv)
252b5132 14345{
ff78d6d6
L
14346 int err;
14347
252b5132
RH
14348#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
14349 setlocale (LC_MESSAGES, "");
3882b010
L
14350#endif
14351#if defined (HAVE_SETLOCALE)
14352 setlocale (LC_CTYPE, "");
252b5132
RH
14353#endif
14354 bindtextdomain (PACKAGE, LOCALEDIR);
14355 textdomain (PACKAGE);
14356
869b9d07
MM
14357 expandargv (&argc, &argv);
14358
252b5132
RH
14359 parse_args (argc, argv);
14360
18bd398b 14361 if (num_dump_sects > 0)
59f14fc0 14362 {
18bd398b 14363 /* Make a copy of the dump_sects array. */
3f5e193b
NC
14364 cmdline_dump_sects = (dump_type *)
14365 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 14366 if (cmdline_dump_sects == NULL)
591a748a 14367 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS
14368 else
14369 {
09c11c86
NC
14370 memcpy (cmdline_dump_sects, dump_sects,
14371 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS
14372 num_cmdline_dump_sects = num_dump_sects;
14373 }
14374 }
14375
18bd398b
NC
14376 if (optind < (argc - 1))
14377 show_name = 1;
14378
ff78d6d6 14379 err = 0;
252b5132 14380 while (optind < argc)
18bd398b 14381 err |= process_file (argv[optind++]);
252b5132
RH
14382
14383 if (dump_sects != NULL)
14384 free (dump_sects);
59f14fc0
AS
14385 if (cmdline_dump_sects != NULL)
14386 free (cmdline_dump_sects);
252b5132 14387
ff78d6d6 14388 return err;
252b5132 14389}
This page took 2.424168 seconds and 4 git commands to generate.