]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - binutils/readelf.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
*** empty log message ***
[thirdparty/binutils-gdb.git] / binutils / readelf.c
CommitLineData
252b5132 1/* readelf.c -- display contents of an ELF format file
6e3d6dc1 2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
8b971f9f 3 2008, 2009, 2010, 2011, 2012
a0f19280 4 Free Software Foundation, Inc.
252b5132
RH		 5
6 Originally developed by Eric Youngdale <eric@andante.jic.com>
12ab83a9 7 Modifications by Nick Clifton <nickc@redhat.com>
252b5132
RH		 8
9 This file is part of GNU Binutils.
10
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
32866df7 13 the Free Software Foundation; either version 3 of the License, or
252b5132
RH		 14 (at your option) any later version.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
b43b5d5f
NC		 23 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 02110-1301, USA. */
252b5132 25\f
9eb20dd8 26/* The difference between readelf and objdump:
252b5132 27
74013231 28 Both programs are capable of displaying the contents of ELF format files,
9eb20dd8 29 so why does the binutils project have two file dumpers ?
0de14b54 30
9eb20dd8
NC		 31 The reason is that objdump sees an ELF file through a BFD filter of the
32 world; if BFD has a bug where, say, it disagrees about a machine constant
33 in e_flags, then the odds are good that it will remain internally
34 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
35 GAS sees it the BFD way. There was need for a tool to go find out what
36 the file actually says.
37
38 This is why the readelf program does not link against the BFD library - it
39 exists as an independent program to help verify the correct working of BFD.
40
41 There is also the case that readelf can provide more information about an
42 ELF file than is provided by objdump. In particular it can display DWARF
43 debugging information which (at the moment) objdump cannot. */
44\f
3db64b00 45#include "sysdep.h"
252b5132 46#include <assert.h>
252b5132 47#include <time.h>
1b315056
CS		 48#ifdef HAVE_ZLIB_H
49#include <zlib.h>
50#endif
3bfcb652 51#ifdef HAVE_WCHAR_H
7bfd842d 52#include <wchar.h>
3bfcb652 53#endif
252b5132 54
a952a375 55#if __GNUC__ >= 2
19936277 56/* Define BFD64 here, even if our default architecture is 32 bit ELF
a952a375 57 as this will allow us to read in and parse 64bit and 32bit ELF files.
b34976b6 58 Only do this if we believe that the compiler can support a 64 bit
a952a375 59 data type. For now we only rely on GCC being able to do this. */
19936277 60#define BFD64
a952a375
NC		 61#endif
62
3db64b00
AM		 63#include "bfd.h"
64#include "bucomm.h"
3284fe0c 65#include "elfcomm.h"
19e6b90e 66#include "dwarf.h"
252b5132
RH		 67
68#include "elf/common.h"
69#include "elf/external.h"
70#include "elf/internal.h"
252b5132 71
4b78141a
NC		 72
73/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
74 we can obtain the H8 reloc numbers. We need these for the
75 get_reloc_size() function. We include h8.h again after defining
76 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
77
78#include "elf/h8.h"
79#undef _ELF_H8_H
80
81/* Undo the effects of #including reloc-macros.h. */
82
83#undef START_RELOC_NUMBERS
84#undef RELOC_NUMBER
85#undef FAKE_RELOC
86#undef EMPTY_RELOC
87#undef END_RELOC_NUMBERS
88#undef _RELOC_MACROS_H
89
252b5132
RH		 90/* The following headers use the elf/reloc-macros.h file to
91 automatically generate relocation recognition functions
92 such as elf_mips_reloc_type() */
93
94#define RELOC_MACROS_GEN_FUNC
95
a06ea964 96#include "elf/aarch64.h"
252b5132 97#include "elf/alpha.h"
3b16e843 98#include "elf/arc.h"
252b5132 99#include "elf/arm.h"
3b16e843 100#include "elf/avr.h"
1d65ded4 101#include "elf/bfin.h"
60bca95a 102#include "elf/cr16.h"
3b16e843 103#include "elf/cris.h"
1c0d3aa6 104#include "elf/crx.h"
252b5132
RH		 105#include "elf/d10v.h"
106#include "elf/d30v.h"
d172d4ba 107#include "elf/dlx.h"
cfb8c092 108#include "elf/epiphany.h"
252b5132 109#include "elf/fr30.h"
5c70f934 110#include "elf/frv.h"
3b16e843
NC		 111#include "elf/h8.h"
112#include "elf/hppa.h"
113#include "elf/i386.h"
35b1837e 114#include "elf/i370.h"
3b16e843
NC		 115#include "elf/i860.h"
116#include "elf/i960.h"
117#include "elf/ia64.h"
1e4cf259 118#include "elf/ip2k.h"
84e94c90 119#include "elf/lm32.h"
1c0d3aa6 120#include "elf/iq2000.h"
49f58d10 121#include "elf/m32c.h"
3b16e843
NC		 122#include "elf/m32r.h"
123#include "elf/m68k.h"
75751cd9 124#include "elf/m68hc11.h"
252b5132 125#include "elf/mcore.h"
15ab5209 126#include "elf/mep.h"
7ba29e2a 127#include "elf/microblaze.h"
3b16e843 128#include "elf/mips.h"
3c3bdf30 129#include "elf/mmix.h"
3b16e843
NC		 130#include "elf/mn10200.h"
131#include "elf/mn10300.h"
5506d11a 132#include "elf/moxie.h"
4970f871 133#include "elf/mt.h"
2469cfa2 134#include "elf/msp430.h"
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
2cf0635d 162char * program_name = "readelf";
85b1c36d
BE		 163static long archive_file_offset;
164static unsigned long archive_file_size;
165static unsigned long dynamic_addr;
166static bfd_size_type dynamic_size;
167static unsigned int dynamic_nent;
2cf0635d 168static char * dynamic_strings;
85b1c36d 169static unsigned long dynamic_strings_length;
2cf0635d 170static char * string_table;
85b1c36d
BE		 171static unsigned long string_table_length;
172static unsigned long num_dynamic_syms;
2cf0635d
NC		 173static Elf_Internal_Sym * dynamic_symbols;
174static Elf_Internal_Syminfo * dynamic_syminfo;
85b1c36d
BE		 175static unsigned long dynamic_syminfo_offset;
176static unsigned int dynamic_syminfo_nent;
f8eae8b2 177static char program_interpreter[PATH_MAX];
bb8a0291 178static bfd_vma dynamic_info[DT_ENCODING];
fdc90cb4 179static bfd_vma dynamic_info_DT_GNU_HASH;
85b1c36d
BE		 180static bfd_vma version_info[16];
181static Elf_Internal_Ehdr elf_header;
2cf0635d
NC		 182static Elf_Internal_Shdr * section_headers;
183static Elf_Internal_Phdr * program_headers;
184static Elf_Internal_Dyn * dynamic_section;
185static Elf_Internal_Shdr * symtab_shndx_hdr;
85b1c36d
BE		 186static int show_name;
187static int do_dynamic;
188static int do_syms;
2c610e4b 189static int do_dyn_syms;
85b1c36d
BE		 190static int do_reloc;
191static int do_sections;
192static int do_section_groups;
5477e8a0 193static int do_section_details;
85b1c36d
BE		 194static int do_segments;
195static int do_unwind;
196static int do_using_dynamic;
197static int do_header;
198static int do_dump;
199static int do_version;
85b1c36d
BE		 200static int do_histogram;
201static int do_debugging;
85b1c36d
BE		 202static int do_arch;
203static int do_notes;
4145f1d5 204static int do_archive_index;
85b1c36d 205static int is_32bit_elf;
252b5132 206
e4b17d5c
L		 207struct group_list
208{
2cf0635d 209 struct group_list * next;
e4b17d5c
L		 210 unsigned int section_index;
211};
212
213struct group
214{
2cf0635d 215 struct group_list * root;
e4b17d5c
L		 216 unsigned int group_index;
217};
218
85b1c36d 219static size_t group_count;
2cf0635d
NC		 220static struct group * section_groups;
221static struct group ** section_headers_groups;
e4b17d5c 222
09c11c86
NC		 223
224/* Flag bits indicating particular types of dump. */
225#define HEX_DUMP (1 << 0) /* The -x command line switch. */
226#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
227#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
228#define STRING_DUMP (1 << 3) /* The -p command line switch. */
cf13d699 229#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
09c11c86
NC		 230
231typedef unsigned char dump_type;
232
233/* A linked list of the section names for which dumps were requested. */
aef1f6d0
DJ		 234struct dump_list_entry
235{
2cf0635d 236 char * name;
09c11c86 237 dump_type type;
2cf0635d 238 struct dump_list_entry * next;
aef1f6d0 239};
2cf0635d 240static struct dump_list_entry * dump_sects_byname;
aef1f6d0 241
09c11c86
NC		 242/* A dynamic array of flags indicating for which sections a dump
243 has been requested via command line switches. */
244static dump_type * cmdline_dump_sects = NULL;
245static unsigned int num_cmdline_dump_sects = 0;
18bd398b
NC		 246
247/* A dynamic array of flags indicating for which sections a dump of
248 some kind has been requested. It is reset on a per-object file
aef1f6d0
DJ		 249 basis and then initialised from the cmdline_dump_sects array,
250 the results of interpreting the -w switch, and the
251 dump_sects_byname list. */
09c11c86
NC		 252static dump_type * dump_sects = NULL;
253static unsigned int num_dump_sects = 0;
252b5132 254
252b5132 255
c256ffe7 256/* How to print a vma value. */
843dd992
NC		 257typedef enum print_mode
258{
259 HEX,
260 DEC,
261 DEC_5,
262 UNSIGNED,
263 PREFIX_HEX,
264 FULL_HEX,
265 LONG_HEX
266}
267print_mode;
268
9c19a809
NC		 269#define UNKNOWN -1
270
2b692964
NC		 271#define SECTION_NAME(X) \
272 ((X) == NULL ? _("<none>") \
273 : string_table == NULL ? _("<no-name>") \
274 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
0b49d371 275 : string_table + (X)->sh_name))
252b5132 276
ee42cf8c 277#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
252b5132 278
ba5cdace
NC		 279#define GET_ELF_SYMBOLS(file, section, sym_count) \
280 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
281 : get_64bit_elf_symbols (file, section, sym_count))
9ea033b2 282
d79b3d50
NC		 283#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
284/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
285 already been called and verified that the string exists. */
286#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
18bd398b 287
61865e30
NC		 288#define REMOVE_ARCH_BITS(ADDR) \
289 do \
290 { \
291 if (elf_header.e_machine == EM_ARM) \
292 (ADDR) &= ~1; \
293 } \
294 while (0)
d79b3d50 295\f
59245841
NC		 296/* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
297 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
298 using malloc and fill that. In either case return the pointer to the start of
299 the retrieved data or NULL if something went wrong. If something does go wrong
300 emit an error message using REASON as part of the context. */
301
c256ffe7 302static void *
2cf0635d
NC		 303get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
304 const char * reason)
a6e9f9df 305{
2cf0635d 306 void * mvar;
a6e9f9df 307
c256ffe7 308 if (size == 0 || nmemb == 0)
a6e9f9df
AM		 309 return NULL;
310
fb52b2f4 311 if (fseek (file, archive_file_offset + offset, SEEK_SET))
a6e9f9df 312 {
0fd3a477 313 error (_("Unable to seek to 0x%lx for %s\n"),
0af1713e 314 (unsigned long) archive_file_offset + offset, reason);
a6e9f9df
AM		 315 return NULL;
316 }
317
318 mvar = var;
319 if (mvar == NULL)
320 {
c256ffe7
JJ		 321 /* Check for overflow. */
322 if (nmemb < (~(size_t) 0 - 1) / size)
323 /* + 1 so that we can '\0' terminate invalid string table sections. */
324 mvar = malloc (size * nmemb + 1);
a6e9f9df
AM		 325
326 if (mvar == NULL)
327 {
0fd3a477
JW		 328 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
329 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM		 330 return NULL;
331 }
c256ffe7
JJ		 332
333 ((char *) mvar)[size * nmemb] = '\0';
a6e9f9df
AM		 334 }
335
c256ffe7 336 if (fread (mvar, size, nmemb, file) != nmemb)
a6e9f9df 337 {
0fd3a477
JW		 338 error (_("Unable to read in 0x%lx bytes of %s\n"),
339 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM		 340 if (mvar != var)
341 free (mvar);
342 return NULL;
343 }
344
345 return mvar;
346}
347
14a91970 348/* Print a VMA value. */
cb8f3167 349
66543521 350static int
14a91970 351print_vma (bfd_vma vma, print_mode mode)
66543521 352{
66543521
AM		 353 int nc = 0;
354
14a91970 355 switch (mode)
66543521 356 {
14a91970
AM		 357 case FULL_HEX:
358 nc = printf ("0x");
359 /* Drop through. */
66543521 360
14a91970 361 case LONG_HEX:
f7a99963 362#ifdef BFD64
14a91970 363 if (is_32bit_elf)
437c2fb7 364 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
f7a99963 365#endif
14a91970
AM		 366 printf_vma (vma);
367 return nc + 16;
b19aac67 368
14a91970
AM		 369 case DEC_5:
370 if (vma <= 99999)
371 return printf ("%5" BFD_VMA_FMT "d", vma);
372 /* Drop through. */
66543521 373
14a91970
AM		 374 case PREFIX_HEX:
375 nc = printf ("0x");
376 /* Drop through. */
66543521 377
14a91970
AM		 378 case HEX:
379 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 380
14a91970
AM		 381 case DEC:
382 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 383
14a91970
AM		 384 case UNSIGNED:
385 return printf ("%" BFD_VMA_FMT "u", vma);
f7a99963 386 }
66543521 387 return 0;
f7a99963
NC		 388}
389
7bfd842d 390/* Display a symbol on stdout. Handles the display of control characters and
3bfcb652 391 multibye characters (assuming the host environment supports them).
31104126 392
7bfd842d
NC		 393 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
394
395 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
396 padding as necessary.
171191ba
NC		 397
398 Returns the number of emitted characters. */
399
400static unsigned int
7a88bc9c 401print_symbol (int width, const char *symbol)
31104126 402{
171191ba 403 bfd_boolean extra_padding = FALSE;
7bfd842d 404 int num_printed = 0;
3bfcb652 405#ifdef HAVE_MBSTATE_T
7bfd842d 406 mbstate_t state;
3bfcb652 407#endif
7bfd842d 408 int width_remaining;
961c521f 409
7bfd842d 410 if (width < 0)
961c521f 411 {
961c521f
NC		 412 /* Keep the width positive. This also helps. */
413 width = - width;
171191ba 414 extra_padding = TRUE;
7bfd842d 415 }
961c521f 416
7bfd842d
NC		 417 if (do_wide)
418 /* Set the remaining width to a very large value.
419 This simplifies the code below. */
420 width_remaining = INT_MAX;
421 else
422 width_remaining = width;
cb8f3167 423
3bfcb652 424#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 425 /* Initialise the multibyte conversion state. */
426 memset (& state, 0, sizeof (state));
3bfcb652 427#endif
961c521f 428
7bfd842d
NC		 429 while (width_remaining)
430 {
431 size_t n;
7bfd842d 432 const char c = *symbol++;
961c521f 433
7bfd842d 434 if (c == 0)
961c521f
NC		 435 break;
436
7bfd842d
NC		 437 /* Do not print control characters directly as they can affect terminal
438 settings. Such characters usually appear in the names generated
439 by the assembler for local labels. */
440 if (ISCNTRL (c))
961c521f 441 {
7bfd842d 442 if (width_remaining < 2)
961c521f
NC		 443 break;
444
7bfd842d
NC		 445 printf ("^%c", c + 0x40);
446 width_remaining -= 2;
171191ba 447 num_printed += 2;
961c521f 448 }
7bfd842d
NC		 449 else if (ISPRINT (c))
450 {
451 putchar (c);
452 width_remaining --;
453 num_printed ++;
454 }
961c521f
NC		 455 else
456 {
3bfcb652
NC		 457#ifdef HAVE_MBSTATE_T
458 wchar_t w;
459#endif
7bfd842d
NC		 460 /* Let printf do the hard work of displaying multibyte characters. */
461 printf ("%.1s", symbol - 1);
462 width_remaining --;
463 num_printed ++;
464
3bfcb652 465#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 466 /* Try to find out how many bytes made up the character that was
467 just printed. Advance the symbol pointer past the bytes that
468 were displayed. */
469 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
3bfcb652
NC		 470#else
471 n = 1;
472#endif
7bfd842d
NC		 473 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
474 symbol += (n - 1);
961c521f 475 }
961c521f 476 }
171191ba 477
7bfd842d 478 if (extra_padding && num_printed < width)
171191ba
NC		 479 {
480 /* Fill in the remaining spaces. */
7bfd842d
NC		 481 printf ("%-*s", width - num_printed, " ");
482 num_printed = width;
171191ba
NC		 483 }
484
485 return num_printed;
31104126
NC		 486}
487
89fac5e3
RS		 488/* Return a pointer to section NAME, or NULL if no such section exists. */
489
490static Elf_Internal_Shdr *
2cf0635d 491find_section (const char * name)
89fac5e3
RS		 492{
493 unsigned int i;
494
495 for (i = 0; i < elf_header.e_shnum; i++)
496 if (streq (SECTION_NAME (section_headers + i), name))
497 return section_headers + i;
498
499 return NULL;
500}
501
0b6ae522
DJ		 502/* Return a pointer to a section containing ADDR, or NULL if no such
503 section exists. */
504
505static Elf_Internal_Shdr *
506find_section_by_address (bfd_vma addr)
507{
508 unsigned int i;
509
510 for (i = 0; i < elf_header.e_shnum; i++)
511 {
512 Elf_Internal_Shdr *sec = section_headers + i;
513 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
514 return sec;
515 }
516
517 return NULL;
518}
519
657d0d47
CC		 520/* Return a pointer to section NAME, or NULL if no such section exists,
521 restricted to the list of sections given in SET. */
522
523static Elf_Internal_Shdr *
524find_section_in_set (const char * name, unsigned int * set)
525{
526 unsigned int i;
527
528 if (set != NULL)
529 {
530 while ((i = *set++) > 0)
531 if (streq (SECTION_NAME (section_headers + i), name))
532 return section_headers + i;
533 }
534
535 return find_section (name);
536}
537
0b6ae522
DJ		 538/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
539 bytes read. */
540
541static unsigned long
542read_uleb128 (unsigned char *data, unsigned int *length_return)
543{
544 return read_leb128 (data, length_return, 0);
545}
546
28f997cf
TG		 547/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
548 This OS has so many departures from the ELF standard that we test it at
549 many places. */
550
551static inline int
552is_ia64_vms (void)
553{
554 return elf_header.e_machine == EM_IA_64
555 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
556}
557
bcedfee6 558/* Guess the relocation size commonly used by the specific machines. */
252b5132 559
252b5132 560static int
2dc4cec1 561guess_is_rela (unsigned int e_machine)
252b5132 562{
9c19a809 563 switch (e_machine)
252b5132
RH		 564 {
565 /* Targets that use REL relocations. */
252b5132
RH		 566 case EM_386:
567 case EM_486:
63fcb9e9 568 case EM_960:
e9f53129 569 case EM_ARM:
2b0337b0 570 case EM_D10V:
252b5132 571 case EM_CYGNUS_D10V:
e9f53129 572 case EM_DLX:
252b5132 573 case EM_MIPS:
4fe85591 574 case EM_MIPS_RS3_LE:
e9f53129
AM		 575 case EM_CYGNUS_M32R:
576 case EM_OPENRISC:
577 case EM_OR32:
1c0d3aa6 578 case EM_SCORE:
f6c1a2d5 579 case EM_XGATE:
9c19a809 580 return FALSE;
103f02d3 581
252b5132
RH		 582 /* Targets that use RELA relocations. */
583 case EM_68K:
e9f53129 584 case EM_860:
a06ea964 585 case EM_AARCH64:
cfb8c092 586 case EM_ADAPTEVA_EPIPHANY:
e9f53129
AM		 587 case EM_ALPHA:
588 case EM_ALTERA_NIOS2:
589 case EM_AVR:
590 case EM_AVR_OLD:
591 case EM_BLACKFIN:
60bca95a 592 case EM_CR16:
e9f53129
AM		 593 case EM_CRIS:
594 case EM_CRX:
2b0337b0 595 case EM_D30V:
252b5132 596 case EM_CYGNUS_D30V:
2b0337b0 597 case EM_FR30:
252b5132 598 case EM_CYGNUS_FR30:
5c70f934 599 case EM_CYGNUS_FRV:
e9f53129
AM		 600 case EM_H8S:
601 case EM_H8_300:
602 case EM_H8_300H:
800eeca4 603 case EM_IA_64:
1e4cf259
NC		 604 case EM_IP2K:
605 case EM_IP2K_OLD:
3b36097d 606 case EM_IQ2000:
84e94c90 607 case EM_LATTICEMICO32:
ff7eeb89 608 case EM_M32C_OLD:
49f58d10 609 case EM_M32C:
e9f53129
AM		 610 case EM_M32R:
611 case EM_MCORE:
15ab5209 612 case EM_CYGNUS_MEP:
e9f53129
AM		 613 case EM_MMIX:
614 case EM_MN10200:
615 case EM_CYGNUS_MN10200:
616 case EM_MN10300:
617 case EM_CYGNUS_MN10300:
5506d11a 618 case EM_MOXIE:
e9f53129
AM		 619 case EM_MSP430:
620 case EM_MSP430_OLD:
d031aafb 621 case EM_MT:
64fd6348 622 case EM_NIOS32:
e9f53129
AM		 623 case EM_PPC64:
624 case EM_PPC:
99c513f6 625 case EM_RL78:
c7927a3c 626 case EM_RX:
e9f53129
AM		 627 case EM_S390:
628 case EM_S390_OLD:
629 case EM_SH:
630 case EM_SPARC:
631 case EM_SPARC32PLUS:
632 case EM_SPARCV9:
633 case EM_SPU:
40b36596 634 case EM_TI_C6000:
aa137e4d
NC		 635 case EM_TILEGX:
636 case EM_TILEPRO:
708e2187 637 case EM_V800:
e9f53129
AM		 638 case EM_V850:
639 case EM_CYGNUS_V850:
640 case EM_VAX:
641 case EM_X86_64:
8a9036a4 642 case EM_L1OM:
7a9068fe 643 case EM_K1OM:
e9f53129
AM		 644 case EM_XSTORMY16:
645 case EM_XTENSA:
646 case EM_XTENSA_OLD:
7ba29e2a
NC		 647 case EM_MICROBLAZE:
648 case EM_MICROBLAZE_OLD:
9c19a809 649 return TRUE;
103f02d3 650
e9f53129
AM		 651 case EM_68HC05:
652 case EM_68HC08:
653 case EM_68HC11:
654 case EM_68HC16:
655 case EM_FX66:
656 case EM_ME16:
d1133906 657 case EM_MMA:
d1133906
NC		 658 case EM_NCPU:
659 case EM_NDR1:
e9f53129 660 case EM_PCP:
d1133906 661 case EM_ST100:
e9f53129 662 case EM_ST19:
d1133906 663 case EM_ST7:
e9f53129
AM		 664 case EM_ST9PLUS:
665 case EM_STARCORE:
d1133906 666 case EM_SVX:
e9f53129 667 case EM_TINYJ:
9c19a809
NC		 668 default:
669 warn (_("Don't know about relocations on this machine architecture\n"));
670 return FALSE;
671 }
672}
252b5132 673
9c19a809 674static int
2cf0635d 675slurp_rela_relocs (FILE * file,
d3ba0551
AM		 676 unsigned long rel_offset,
677 unsigned long rel_size,
2cf0635d
NC		 678 Elf_Internal_Rela ** relasp,
679 unsigned long * nrelasp)
9c19a809 680{
2cf0635d 681 Elf_Internal_Rela * relas;
4d6ed7c8
NC		 682 unsigned long nrelas;
683 unsigned int i;
252b5132 684
4d6ed7c8
NC		 685 if (is_32bit_elf)
686 {
2cf0635d 687 Elf32_External_Rela * erelas;
103f02d3 688
3f5e193b 689 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 690 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 691 if (!erelas)
692 return 0;
252b5132 693
4d6ed7c8 694 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 695
3f5e193b
NC		 696 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
697 sizeof (Elf_Internal_Rela));
103f02d3 698
4d6ed7c8
NC		 699 if (relas == NULL)
700 {
c256ffe7 701 free (erelas);
591a748a 702 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 703 return 0;
704 }
103f02d3 705
4d6ed7c8
NC		 706 for (i = 0; i < nrelas; i++)
707 {
708 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
709 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 710 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 711 }
103f02d3 712
4d6ed7c8
NC		 713 free (erelas);
714 }
715 else
716 {
2cf0635d 717 Elf64_External_Rela * erelas;
103f02d3 718
3f5e193b 719 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 720 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 721 if (!erelas)
722 return 0;
4d6ed7c8
NC		 723
724 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 725
3f5e193b
NC		 726 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
727 sizeof (Elf_Internal_Rela));
103f02d3 728
4d6ed7c8
NC		 729 if (relas == NULL)
730 {
c256ffe7 731 free (erelas);
591a748a 732 error (_("out of memory parsing relocs\n"));
4d6ed7c8 733 return 0;
9c19a809 734 }
4d6ed7c8
NC		 735
736 for (i = 0; i < nrelas; i++)
9c19a809 737 {
66543521
AM		 738 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
739 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 740 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 741
742 /* The #ifdef BFD64 below is to prevent a compile time
743 warning. We know that if we do not have a 64 bit data
744 type that we will never execute this code anyway. */
745#ifdef BFD64
746 if (elf_header.e_machine == EM_MIPS
747 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
748 {
749 /* In little-endian objects, r_info isn't really a
750 64-bit little-endian value: it has a 32-bit
751 little-endian symbol index followed by four
752 individual byte fields. Reorder INFO
753 accordingly. */
91d6fa6a
NC		 754 bfd_vma inf = relas[i].r_info;
755 inf = (((inf & 0xffffffff) << 32)
756 | ((inf >> 56) & 0xff)
757 | ((inf >> 40) & 0xff00)
758 | ((inf >> 24) & 0xff0000)
759 | ((inf >> 8) & 0xff000000));
760 relas[i].r_info = inf;
861fb55a
DJ		 761 }
762#endif /* BFD64 */
4d6ed7c8 763 }
103f02d3 764
4d6ed7c8
NC		 765 free (erelas);
766 }
767 *relasp = relas;
768 *nrelasp = nrelas;
769 return 1;
770}
103f02d3 771
4d6ed7c8 772static int
2cf0635d 773slurp_rel_relocs (FILE * file,
d3ba0551
AM		 774 unsigned long rel_offset,
775 unsigned long rel_size,
2cf0635d
NC		 776 Elf_Internal_Rela ** relsp,
777 unsigned long * nrelsp)
4d6ed7c8 778{
2cf0635d 779 Elf_Internal_Rela * rels;
4d6ed7c8
NC		 780 unsigned long nrels;
781 unsigned int i;
103f02d3 782
4d6ed7c8
NC		 783 if (is_32bit_elf)
784 {
2cf0635d 785 Elf32_External_Rel * erels;
103f02d3 786
3f5e193b 787 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 788 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 789 if (!erels)
790 return 0;
103f02d3 791
4d6ed7c8 792 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 793
3f5e193b 794 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 795
4d6ed7c8
NC		 796 if (rels == NULL)
797 {
c256ffe7 798 free (erels);
591a748a 799 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 800 return 0;
801 }
802
803 for (i = 0; i < nrels; i++)
804 {
805 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
806 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 807 rels[i].r_addend = 0;
9ea033b2 808 }
4d6ed7c8
NC		 809
810 free (erels);
9c19a809
NC		 811 }
812 else
813 {
2cf0635d 814 Elf64_External_Rel * erels;
9ea033b2 815
3f5e193b 816 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 817 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 818 if (!erels)
819 return 0;
103f02d3 820
4d6ed7c8 821 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 822
3f5e193b 823 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 824
4d6ed7c8 825 if (rels == NULL)
9c19a809 826 {
c256ffe7 827 free (erels);
591a748a 828 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 829 return 0;
830 }
103f02d3 831
4d6ed7c8
NC		 832 for (i = 0; i < nrels; i++)
833 {
66543521
AM		 834 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
835 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 836 rels[i].r_addend = 0;
861fb55a
DJ		 837
838 /* The #ifdef BFD64 below is to prevent a compile time
839 warning. We know that if we do not have a 64 bit data
840 type that we will never execute this code anyway. */
841#ifdef BFD64
842 if (elf_header.e_machine == EM_MIPS
843 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
844 {
845 /* In little-endian objects, r_info isn't really a
846 64-bit little-endian value: it has a 32-bit
847 little-endian symbol index followed by four
848 individual byte fields. Reorder INFO
849 accordingly. */
91d6fa6a
NC		 850 bfd_vma inf = rels[i].r_info;
851 inf = (((inf & 0xffffffff) << 32)
852 | ((inf >> 56) & 0xff)
853 | ((inf >> 40) & 0xff00)
854 | ((inf >> 24) & 0xff0000)
855 | ((inf >> 8) & 0xff000000));
856 rels[i].r_info = inf;
861fb55a
DJ		 857 }
858#endif /* BFD64 */
4d6ed7c8 859 }
103f02d3 860
4d6ed7c8
NC		 861 free (erels);
862 }
863 *relsp = rels;
864 *nrelsp = nrels;
865 return 1;
866}
103f02d3 867
aca88567
NC		 868/* Returns the reloc type extracted from the reloc info field. */
869
870static unsigned int
871get_reloc_type (bfd_vma reloc_info)
872{
873 if (is_32bit_elf)
874 return ELF32_R_TYPE (reloc_info);
875
876 switch (elf_header.e_machine)
877 {
878 case EM_MIPS:
879 /* Note: We assume that reloc_info has already been adjusted for us. */
880 return ELF64_MIPS_R_TYPE (reloc_info);
881
882 case EM_SPARCV9:
883 return ELF64_R_TYPE_ID (reloc_info);
884
885 default:
886 return ELF64_R_TYPE (reloc_info);
887 }
888}
889
890/* Return the symbol index extracted from the reloc info field. */
891
892static bfd_vma
893get_reloc_symindex (bfd_vma reloc_info)
894{
895 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
896}
897
d3ba0551
AM		 898/* Display the contents of the relocation data found at the specified
899 offset. */
ee42cf8c 900
41e92641 901static void
2cf0635d 902dump_relocations (FILE * file,
d3ba0551
AM		 903 unsigned long rel_offset,
904 unsigned long rel_size,
2cf0635d 905 Elf_Internal_Sym * symtab,
d3ba0551 906 unsigned long nsyms,
2cf0635d 907 char * strtab,
d79b3d50 908 unsigned long strtablen,
d3ba0551 909 int is_rela)
4d6ed7c8 910{
b34976b6 911 unsigned int i;
2cf0635d 912 Elf_Internal_Rela * rels;
103f02d3 913
4d6ed7c8
NC		 914 if (is_rela == UNKNOWN)
915 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 916
4d6ed7c8
NC		 917 if (is_rela)
918 {
c8286bd1 919 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 920 return;
4d6ed7c8
NC		 921 }
922 else
923 {
924 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 925 return;
252b5132
RH		 926 }
927
410f7a12
L		 928 if (is_32bit_elf)
929 {
930 if (is_rela)
2c71103e
NC		 931 {
932 if (do_wide)
933 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
934 else
935 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
936 }
410f7a12 937 else
2c71103e
NC		 938 {
939 if (do_wide)
940 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
941 else
942 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
943 }
410f7a12 944 }
252b5132 945 else
410f7a12
L		 946 {
947 if (is_rela)
2c71103e
NC		 948 {
949 if (do_wide)
8beeaeb7 950 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 951 else
952 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
953 }
410f7a12 954 else
2c71103e
NC		 955 {
956 if (do_wide)
8beeaeb7 957 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 958 else
959 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
960 }
410f7a12 961 }
252b5132
RH		 962
963 for (i = 0; i < rel_size; i++)
964 {
2cf0635d 965 const char * rtype;
b34976b6 966 bfd_vma offset;
91d6fa6a 967 bfd_vma inf;
b34976b6
AM		 968 bfd_vma symtab_index;
969 bfd_vma type;
103f02d3 970
b34976b6 971 offset = rels[i].r_offset;
91d6fa6a 972 inf = rels[i].r_info;
103f02d3 973
91d6fa6a
NC		 974 type = get_reloc_type (inf);
975 symtab_index = get_reloc_symindex (inf);
252b5132 976
410f7a12
L		 977 if (is_32bit_elf)
978 {
39dbeff8
AM		 979 printf ("%8.8lx %8.8lx ",
980 (unsigned long) offset & 0xffffffff,
91d6fa6a 981 (unsigned long) inf & 0xffffffff);
410f7a12
L		 982 }
983 else
984 {
39dbeff8
AM		 985#if BFD_HOST_64BIT_LONG
986 printf (do_wide
987 ? "%16.16lx %16.16lx "
988 : "%12.12lx %12.12lx ",
91d6fa6a 989 offset, inf);
39dbeff8 990#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 991#ifndef __MSVCRT__
39dbeff8
AM		 992 printf (do_wide
993 ? "%16.16llx %16.16llx "
994 : "%12.12llx %12.12llx ",
91d6fa6a 995 offset, inf);
6e3d6dc1
NC		 996#else
997 printf (do_wide
998 ? "%16.16I64x %16.16I64x "
999 : "%12.12I64x %12.12I64x ",
91d6fa6a 1000 offset, inf);
6e3d6dc1 1001#endif
39dbeff8 1002#else
2c71103e
NC		 1003 printf (do_wide
1004 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1005 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 1006 _bfd_int64_high (offset),
1007 _bfd_int64_low (offset),
91d6fa6a
NC		 1008 _bfd_int64_high (inf),
1009 _bfd_int64_low (inf));
9ea033b2 1010#endif
410f7a12 1011 }
103f02d3 1012
252b5132
RH		 1013 switch (elf_header.e_machine)
1014 {
1015 default:
1016 rtype = NULL;
1017 break;
1018
a06ea964
NC		 1019 case EM_AARCH64:
1020 rtype = elf_aarch64_reloc_type (type);
1021 break;
1022
2b0337b0 1023 case EM_M32R:
252b5132 1024 case EM_CYGNUS_M32R:
9ea033b2 1025 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 1026 break;
1027
1028 case EM_386:
1029 case EM_486:
9ea033b2 1030 rtype = elf_i386_reloc_type (type);
252b5132
RH		 1031 break;
1032
ba2685cc
AM		 1033 case EM_68HC11:
1034 case EM_68HC12:
1035 rtype = elf_m68hc11_reloc_type (type);
1036 break;
75751cd9 1037
252b5132 1038 case EM_68K:
9ea033b2 1039 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1040 break;
1041
63fcb9e9 1042 case EM_960:
9ea033b2 1043 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1044 break;
1045
adde6300 1046 case EM_AVR:
2b0337b0 1047 case EM_AVR_OLD:
adde6300
AM		 1048 rtype = elf_avr_reloc_type (type);
1049 break;
1050
9ea033b2
NC		 1051 case EM_OLD_SPARCV9:
1052 case EM_SPARC32PLUS:
1053 case EM_SPARCV9:
252b5132 1054 case EM_SPARC:
9ea033b2 1055 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1056 break;
1057
e9f53129
AM		 1058 case EM_SPU:
1059 rtype = elf_spu_reloc_type (type);
1060 break;
1061
708e2187
NC		 1062 case EM_V800:
1063 rtype = v800_reloc_type (type);
1064 break;
2b0337b0 1065 case EM_V850:
252b5132 1066 case EM_CYGNUS_V850:
9ea033b2 1067 rtype = v850_reloc_type (type);
252b5132
RH		 1068 break;
1069
2b0337b0 1070 case EM_D10V:
252b5132 1071 case EM_CYGNUS_D10V:
9ea033b2 1072 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1073 break;
1074
2b0337b0 1075 case EM_D30V:
252b5132 1076 case EM_CYGNUS_D30V:
9ea033b2 1077 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1078 break;
1079
d172d4ba
NC		 1080 case EM_DLX:
1081 rtype = elf_dlx_reloc_type (type);
1082 break;
1083
252b5132 1084 case EM_SH:
9ea033b2 1085 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1086 break;
1087
2b0337b0 1088 case EM_MN10300:
252b5132 1089 case EM_CYGNUS_MN10300:
9ea033b2 1090 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1091 break;
1092
2b0337b0 1093 case EM_MN10200:
252b5132 1094 case EM_CYGNUS_MN10200:
9ea033b2 1095 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1096 break;
1097
2b0337b0 1098 case EM_FR30:
252b5132 1099 case EM_CYGNUS_FR30:
9ea033b2 1100 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1101 break;
1102
ba2685cc
AM		 1103 case EM_CYGNUS_FRV:
1104 rtype = elf_frv_reloc_type (type);
1105 break;
5c70f934 1106
252b5132 1107 case EM_MCORE:
9ea033b2 1108 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1109 break;
1110
3c3bdf30
NC		 1111 case EM_MMIX:
1112 rtype = elf_mmix_reloc_type (type);
1113 break;
1114
5506d11a
AM		 1115 case EM_MOXIE:
1116 rtype = elf_moxie_reloc_type (type);
1117 break;
1118
2469cfa2
NC		 1119 case EM_MSP430:
1120 case EM_MSP430_OLD:
1121 rtype = elf_msp430_reloc_type (type);
1122 break;
1123
252b5132 1124 case EM_PPC:
9ea033b2 1125 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1126 break;
1127
c833c019
AM		 1128 case EM_PPC64:
1129 rtype = elf_ppc64_reloc_type (type);
1130 break;
1131
252b5132 1132 case EM_MIPS:
4fe85591 1133 case EM_MIPS_RS3_LE:
9ea033b2 1134 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1135 break;
1136
1137 case EM_ALPHA:
9ea033b2 1138 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1139 break;
1140
1141 case EM_ARM:
9ea033b2 1142 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1143 break;
1144
584da044 1145 case EM_ARC:
9ea033b2 1146 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1147 break;
1148
1149 case EM_PARISC:
69e617ca 1150 rtype = elf_hppa_reloc_type (type);
252b5132 1151 break;
7d466069 1152
b8720f9d
JL		 1153 case EM_H8_300:
1154 case EM_H8_300H:
1155 case EM_H8S:
1156 rtype = elf_h8_reloc_type (type);
1157 break;
1158
3b16e843
NC		 1159 case EM_OPENRISC:
1160 case EM_OR32:
1161 rtype = elf_or32_reloc_type (type);
1162 break;
1163
7d466069 1164 case EM_PJ:
2b0337b0 1165 case EM_PJ_OLD:
7d466069
ILT		 1166 rtype = elf_pj_reloc_type (type);
1167 break;
800eeca4
JW		 1168 case EM_IA_64:
1169 rtype = elf_ia64_reloc_type (type);
1170 break;
1b61cf92
HPN		 1171
1172 case EM_CRIS:
1173 rtype = elf_cris_reloc_type (type);
1174 break;
535c37ff
JE		 1175
1176 case EM_860:
1177 rtype = elf_i860_reloc_type (type);
1178 break;
bcedfee6
NC		 1179
1180 case EM_X86_64:
8a9036a4 1181 case EM_L1OM:
7a9068fe 1182 case EM_K1OM:
bcedfee6
NC		 1183 rtype = elf_x86_64_reloc_type (type);
1184 break;
a85d7ed0 1185
35b1837e
AM		 1186 case EM_S370:
1187 rtype = i370_reloc_type (type);
1188 break;
1189
53c7db4b
KH		 1190 case EM_S390_OLD:
1191 case EM_S390:
1192 rtype = elf_s390_reloc_type (type);
1193 break;
93fbbb04 1194
1c0d3aa6
NC		 1195 case EM_SCORE:
1196 rtype = elf_score_reloc_type (type);
1197 break;
1198
93fbbb04
GK		 1199 case EM_XSTORMY16:
1200 rtype = elf_xstormy16_reloc_type (type);
1201 break;
179d3252 1202
1fe1f39c
NC		 1203 case EM_CRX:
1204 rtype = elf_crx_reloc_type (type);
1205 break;
1206
179d3252
JT		 1207 case EM_VAX:
1208 rtype = elf_vax_reloc_type (type);
1209 break;
1e4cf259 1210
cfb8c092
NC		 1211 case EM_ADAPTEVA_EPIPHANY:
1212 rtype = elf_epiphany_reloc_type (type);
1213 break;
1214
1e4cf259
NC		 1215 case EM_IP2K:
1216 case EM_IP2K_OLD:
1217 rtype = elf_ip2k_reloc_type (type);
1218 break;
3b36097d
SC		 1219
1220 case EM_IQ2000:
1221 rtype = elf_iq2000_reloc_type (type);
1222 break;
88da6820
NC		 1223
1224 case EM_XTENSA_OLD:
1225 case EM_XTENSA:
1226 rtype = elf_xtensa_reloc_type (type);
1227 break;
a34e3ecb 1228
84e94c90
NC		 1229 case EM_LATTICEMICO32:
1230 rtype = elf_lm32_reloc_type (type);
1231 break;
1232
ff7eeb89 1233 case EM_M32C_OLD:
49f58d10
JB		 1234 case EM_M32C:
1235 rtype = elf_m32c_reloc_type (type);
1236 break;
1237
d031aafb
NS		 1238 case EM_MT:
1239 rtype = elf_mt_reloc_type (type);
a34e3ecb 1240 break;
1d65ded4
CM		 1241
1242 case EM_BLACKFIN:
1243 rtype = elf_bfin_reloc_type (type);
1244 break;
15ab5209
DB		 1245
1246 case EM_CYGNUS_MEP:
1247 rtype = elf_mep_reloc_type (type);
1248 break;
60bca95a
NC		 1249
1250 case EM_CR16:
1251 rtype = elf_cr16_reloc_type (type);
1252 break;
dd24e3da 1253
7ba29e2a
NC		 1254 case EM_MICROBLAZE:
1255 case EM_MICROBLAZE_OLD:
1256 rtype = elf_microblaze_reloc_type (type);
1257 break;
c7927a3c 1258
99c513f6
DD		 1259 case EM_RL78:
1260 rtype = elf_rl78_reloc_type (type);
1261 break;
1262
c7927a3c
NC		 1263 case EM_RX:
1264 rtype = elf_rx_reloc_type (type);
1265 break;
c29aca4a
NC		 1266
1267 case EM_XC16X:
1268 case EM_C166:
1269 rtype = elf_xc16x_reloc_type (type);
1270 break;
40b36596
JM		 1271
1272 case EM_TI_C6000:
1273 rtype = elf_tic6x_reloc_type (type);
1274 break;
aa137e4d
NC		 1275
1276 case EM_TILEGX:
1277 rtype = elf_tilegx_reloc_type (type);
1278 break;
1279
1280 case EM_TILEPRO:
1281 rtype = elf_tilepro_reloc_type (type);
1282 break;
f6c1a2d5
NC		 1283
1284 case EM_XGATE:
1285 rtype = elf_xgate_reloc_type (type);
1286 break;
252b5132
RH		 1287 }
1288
1289 if (rtype == NULL)
39dbeff8 1290 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1291 else
8beeaeb7 1292 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1293
7ace3541 1294 if (elf_header.e_machine == EM_ALPHA
157c2599 1295 && rtype != NULL
7ace3541
RH		 1296 && streq (rtype, "R_ALPHA_LITUSE")
1297 && is_rela)
1298 {
1299 switch (rels[i].r_addend)
1300 {
1301 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1302 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1303 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1304 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1305 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1306 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1307 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1308 default: rtype = NULL;
1309 }
1310 if (rtype)
1311 printf (" (%s)", rtype);
1312 else
1313 {
1314 putchar (' ');
1315 printf (_("<unknown addend: %lx>"),
1316 (unsigned long) rels[i].r_addend);
1317 }
1318 }
1319 else if (symtab_index)
252b5132 1320 {
af3fc3bc 1321 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1322 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1323 else
19936277 1324 {
2cf0635d 1325 Elf_Internal_Sym * psym;
19936277 1326
af3fc3bc 1327 psym = symtab + symtab_index;
103f02d3 1328
af3fc3bc 1329 printf (" ");
171191ba 1330
d8045f23
NC		 1331 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1332 {
1333 const char * name;
1334 unsigned int len;
1335 unsigned int width = is_32bit_elf ? 8 : 14;
1336
1337 /* Relocations against GNU_IFUNC symbols do not use the value
1338 of the symbol as the address to relocate against. Instead
1339 they invoke the function named by the symbol and use its
1340 result as the address for relocation.
1341
1342 To indicate this to the user, do not display the value of
1343 the symbol in the "Symbols's Value" field. Instead show
1344 its name followed by () as a hint that the symbol is
1345 invoked. */
1346
1347 if (strtab == NULL
1348 || psym->st_name == 0
1349 || psym->st_name >= strtablen)
1350 name = "??";
1351 else
1352 name = strtab + psym->st_name;
1353
1354 len = print_symbol (width, name);
1355 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1356 }
1357 else
1358 {
1359 print_vma (psym->st_value, LONG_HEX);
171191ba 1360
d8045f23
NC		 1361 printf (is_32bit_elf ? " " : " ");
1362 }
103f02d3 1363
af3fc3bc 1364 if (psym->st_name == 0)
f1ef08cb 1365 {
2cf0635d 1366 const char * sec_name = "<null>";
f1ef08cb
AM		 1367 char name_buf[40];
1368
1369 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1370 {
4fbb74a6
AM		 1371 if (psym->st_shndx < elf_header.e_shnum)
1372 sec_name
1373 = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1374 else if (psym->st_shndx == SHN_ABS)
1375 sec_name = "ABS";
1376 else if (psym->st_shndx == SHN_COMMON)
1377 sec_name = "COMMON";
ac145307
BS		 1378 else if ((elf_header.e_machine == EM_MIPS
1379 && psym->st_shndx == SHN_MIPS_SCOMMON)
1380 || (elf_header.e_machine == EM_TI_C6000
1381 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1382 sec_name = "SCOMMON";
1383 else if (elf_header.e_machine == EM_MIPS
1384 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1385 sec_name = "SUNDEF";
8a9036a4 1386 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1387 || elf_header.e_machine == EM_L1OM
1388 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1389 && psym->st_shndx == SHN_X86_64_LCOMMON)
1390 sec_name = "LARGE_COMMON";
9ce701e2
L		 1391 else if (elf_header.e_machine == EM_IA_64
1392 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1393 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1394 sec_name = "ANSI_COM";
28f997cf 1395 else if (is_ia64_vms ()
148b93f2
NC		 1396 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1397 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1398 else
1399 {
1400 sprintf (name_buf, "<section 0x%x>",
1401 (unsigned int) psym->st_shndx);
1402 sec_name = name_buf;
1403 }
1404 }
1405 print_symbol (22, sec_name);
1406 }
af3fc3bc 1407 else if (strtab == NULL)
d79b3d50 1408 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1409 else if (psym->st_name >= strtablen)
d79b3d50 1410 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1411 else
2c71103e 1412 print_symbol (22, strtab + psym->st_name);
103f02d3 1413
af3fc3bc 1414 if (is_rela)
171191ba 1415 {
598aaa76 1416 bfd_signed_vma off = rels[i].r_addend;
171191ba 1417
91d6fa6a 1418 if (off < 0)
598aaa76 1419 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1420 else
598aaa76 1421 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1422 }
19936277 1423 }
252b5132 1424 }
1b228002 1425 else if (is_rela)
f7a99963 1426 {
e04d7088
L		 1427 bfd_signed_vma off = rels[i].r_addend;
1428
1429 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1430 if (off < 0)
1431 printf ("-%" BFD_VMA_FMT "x", - off);
1432 else
1433 printf ("%" BFD_VMA_FMT "x", off);
f7a99963 1434 }
252b5132 1435
157c2599
NC		 1436 if (elf_header.e_machine == EM_SPARCV9
1437 && rtype != NULL
1438 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1439 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1440
252b5132 1441 putchar ('\n');
2c71103e 1442
aca88567 1443#ifdef BFD64
53c7db4b 1444 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1445 {
91d6fa6a
NC		 1446 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1447 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1448 const char * rtype2 = elf_mips_reloc_type (type2);
1449 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1450
2c71103e
NC		 1451 printf (" Type2: ");
1452
1453 if (rtype2 == NULL)
39dbeff8
AM		 1454 printf (_("unrecognized: %-7lx"),
1455 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1456 else
1457 printf ("%-17.17s", rtype2);
1458
18bd398b 1459 printf ("\n Type3: ");
2c71103e
NC		 1460
1461 if (rtype3 == NULL)
39dbeff8
AM		 1462 printf (_("unrecognized: %-7lx"),
1463 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1464 else
1465 printf ("%-17.17s", rtype3);
1466
53c7db4b 1467 putchar ('\n');
2c71103e 1468 }
aca88567 1469#endif /* BFD64 */
252b5132
RH		 1470 }
1471
c8286bd1 1472 free (rels);
252b5132
RH		 1473}
1474
1475static const char *
d3ba0551 1476get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1477{
1478 switch (type)
1479 {
1480 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1481 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1482 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1483 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1484 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1485 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1486 case DT_MIPS_MSYM: return "MIPS_MSYM";
1487 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1488 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1489 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1490 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1491 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1492 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1493 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1494 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1495 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1496 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1497 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1498 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1499 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1500 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1501 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1502 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1503 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1504 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1505 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1506 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1507 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1508 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1509 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1510 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1511 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1512 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1513 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1514 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1515 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1516 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1517 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1518 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1519 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1520 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1521 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1522 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1523 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1524 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1525 default:
1526 return NULL;
1527 }
1528}
1529
9a097730 1530static const char *
d3ba0551 1531get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1532{
1533 switch (type)
1534 {
1535 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1536 default:
1537 return NULL;
1538 }
103f02d3
UD		 1539}
1540
7490d522
AM		 1541static const char *
1542get_ppc_dynamic_type (unsigned long type)
1543{
1544 switch (type)
1545 {
a7f2871e
AM		 1546 case DT_PPC_GOT: return "PPC_GOT";
1547 case DT_PPC_TLSOPT: return "PPC_TLSOPT";
7490d522
AM		 1548 default:
1549 return NULL;
1550 }
1551}
1552
f1cb7e17 1553static const char *
d3ba0551 1554get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1555{
1556 switch (type)
1557 {
a7f2871e
AM		 1558 case DT_PPC64_GLINK: return "PPC64_GLINK";
1559 case DT_PPC64_OPD: return "PPC64_OPD";
1560 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1561 case DT_PPC64_TLSOPT: return "PPC64_TLSOPT";
f1cb7e17
AM		 1562 default:
1563 return NULL;
1564 }
1565}
1566
103f02d3 1567static const char *
d3ba0551 1568get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1569{
1570 switch (type)
1571 {
1572 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1573 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1574 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1575 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1576 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1577 case DT_HP_PREINIT: return "HP_PREINIT";
1578 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1579 case DT_HP_NEEDED: return "HP_NEEDED";
1580 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1581 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1582 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1583 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1584 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1585 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1586 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1587 case DT_HP_FILTERED: return "HP_FILTERED";
1588 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1589 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1590 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1591 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1592 case DT_PLT: return "PLT";
1593 case DT_PLT_SIZE: return "PLT_SIZE";
1594 case DT_DLT: return "DLT";
1595 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1596 default:
1597 return NULL;
1598 }
1599}
9a097730 1600
ecc51f48 1601static const char *
d3ba0551 1602get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1603{
1604 switch (type)
1605 {
148b93f2
NC		 1606 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1607 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1608 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1609 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1610 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1611 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1612 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1613 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1614 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1615 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1616 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1617 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1618 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1619 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1620 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1621 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1622 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1623 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1624 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1625 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1626 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1627 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1628 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1629 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1630 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1631 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1632 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1633 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1634 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1635 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1636 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1637 default:
1638 return NULL;
1639 }
1640}
1641
fabcb361
RH		 1642static const char *
1643get_alpha_dynamic_type (unsigned long type)
1644{
1645 switch (type)
1646 {
1647 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1648 default:
1649 return NULL;
1650 }
1651}
1652
1c0d3aa6
NC		 1653static const char *
1654get_score_dynamic_type (unsigned long type)
1655{
1656 switch (type)
1657 {
1658 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1659 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1660 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1661 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1662 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1663 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1664 default:
1665 return NULL;
1666 }
1667}
1668
40b36596
JM		 1669static const char *
1670get_tic6x_dynamic_type (unsigned long type)
1671{
1672 switch (type)
1673 {
1674 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1675 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1676 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1677 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1678 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1679 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1680 default:
1681 return NULL;
1682 }
1683}
1c0d3aa6 1684
252b5132 1685static const char *
d3ba0551 1686get_dynamic_type (unsigned long type)
252b5132 1687{
e9e44622 1688 static char buff[64];
252b5132
RH		 1689
1690 switch (type)
1691 {
1692 case DT_NULL: return "NULL";
1693 case DT_NEEDED: return "NEEDED";
1694 case DT_PLTRELSZ: return "PLTRELSZ";
1695 case DT_PLTGOT: return "PLTGOT";
1696 case DT_HASH: return "HASH";
1697 case DT_STRTAB: return "STRTAB";
1698 case DT_SYMTAB: return "SYMTAB";
1699 case DT_RELA: return "RELA";
1700 case DT_RELASZ: return "RELASZ";
1701 case DT_RELAENT: return "RELAENT";
1702 case DT_STRSZ: return "STRSZ";
1703 case DT_SYMENT: return "SYMENT";
1704 case DT_INIT: return "INIT";
1705 case DT_FINI: return "FINI";
1706 case DT_SONAME: return "SONAME";
1707 case DT_RPATH: return "RPATH";
1708 case DT_SYMBOLIC: return "SYMBOLIC";
1709 case DT_REL: return "REL";
1710 case DT_RELSZ: return "RELSZ";
1711 case DT_RELENT: return "RELENT";
1712 case DT_PLTREL: return "PLTREL";
1713 case DT_DEBUG: return "DEBUG";
1714 case DT_TEXTREL: return "TEXTREL";
1715 case DT_JMPREL: return "JMPREL";
1716 case DT_BIND_NOW: return "BIND_NOW";
1717 case DT_INIT_ARRAY: return "INIT_ARRAY";
1718 case DT_FINI_ARRAY: return "FINI_ARRAY";
1719 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1720 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1721 case DT_RUNPATH: return "RUNPATH";
1722 case DT_FLAGS: return "FLAGS";
2d0e6f43 1723
d1133906
NC		 1724 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1725 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1726
05107a46 1727 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1728 case DT_PLTPADSZ: return "PLTPADSZ";
1729 case DT_MOVEENT: return "MOVEENT";
1730 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1731 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1732 case DT_POSFLAG_1: return "POSFLAG_1";
1733 case DT_SYMINSZ: return "SYMINSZ";
1734 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1735
252b5132 1736 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1737 case DT_CONFIG: return "CONFIG";
1738 case DT_DEPAUDIT: return "DEPAUDIT";
1739 case DT_AUDIT: return "AUDIT";
1740 case DT_PLTPAD: return "PLTPAD";
1741 case DT_MOVETAB: return "MOVETAB";
252b5132 1742 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1743
252b5132 1744 case DT_VERSYM: return "VERSYM";
103f02d3 1745
67a4f2b7
AO		 1746 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1747 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1748 case DT_RELACOUNT: return "RELACOUNT";
1749 case DT_RELCOUNT: return "RELCOUNT";
1750 case DT_FLAGS_1: return "FLAGS_1";
1751 case DT_VERDEF: return "VERDEF";
1752 case DT_VERDEFNUM: return "VERDEFNUM";
1753 case DT_VERNEED: return "VERNEED";
1754 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1755
019148e4 1756 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1757 case DT_USED: return "USED";
1758 case DT_FILTER: return "FILTER";
103f02d3 1759
047b2264
JJ		 1760 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1761 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1762 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1763 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1764 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1765 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1766
252b5132
RH		 1767 default:
1768 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1769 {
2cf0635d 1770 const char * result;
103f02d3 1771
252b5132
RH		 1772 switch (elf_header.e_machine)
1773 {
1774 case EM_MIPS:
4fe85591 1775 case EM_MIPS_RS3_LE:
252b5132
RH		 1776 result = get_mips_dynamic_type (type);
1777 break;
9a097730
RH		 1778 case EM_SPARCV9:
1779 result = get_sparc64_dynamic_type (type);
1780 break;
7490d522
AM		 1781 case EM_PPC:
1782 result = get_ppc_dynamic_type (type);
1783 break;
f1cb7e17
AM		 1784 case EM_PPC64:
1785 result = get_ppc64_dynamic_type (type);
1786 break;
ecc51f48
NC		 1787 case EM_IA_64:
1788 result = get_ia64_dynamic_type (type);
1789 break;
fabcb361
RH		 1790 case EM_ALPHA:
1791 result = get_alpha_dynamic_type (type);
1792 break;
1c0d3aa6
NC		 1793 case EM_SCORE:
1794 result = get_score_dynamic_type (type);
1795 break;
40b36596
JM		 1796 case EM_TI_C6000:
1797 result = get_tic6x_dynamic_type (type);
1798 break;
252b5132
RH		 1799 default:
1800 result = NULL;
1801 break;
1802 }
1803
1804 if (result != NULL)
1805 return result;
1806
e9e44622 1807 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 1808 }
eec8f817
DA		 1809 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1810 || (elf_header.e_machine == EM_PARISC
1811 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 1812 {
2cf0635d 1813 const char * result;
103f02d3
UD		 1814
1815 switch (elf_header.e_machine)
1816 {
1817 case EM_PARISC:
1818 result = get_parisc_dynamic_type (type);
1819 break;
148b93f2
NC		 1820 case EM_IA_64:
1821 result = get_ia64_dynamic_type (type);
1822 break;
103f02d3
UD		 1823 default:
1824 result = NULL;
1825 break;
1826 }
1827
1828 if (result != NULL)
1829 return result;
1830
e9e44622
JJ		 1831 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1832 type);
103f02d3 1833 }
252b5132 1834 else
e9e44622 1835 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 1836
252b5132
RH		 1837 return buff;
1838 }
1839}
1840
1841static char *
d3ba0551 1842get_file_type (unsigned e_type)
252b5132 1843{
b34976b6 1844 static char buff[32];
252b5132
RH		 1845
1846 switch (e_type)
1847 {
1848 case ET_NONE: return _("NONE (None)");
1849 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 1850 case ET_EXEC: return _("EXEC (Executable file)");
1851 case ET_DYN: return _("DYN (Shared object file)");
1852 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 1853
1854 default:
1855 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 1856 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 1857 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 1858 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 1859 else
e9e44622 1860 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 1861 return buff;
1862 }
1863}
1864
1865static char *
d3ba0551 1866get_machine_name (unsigned e_machine)
252b5132 1867{
b34976b6 1868 static char buff[64]; /* XXX */
252b5132
RH		 1869
1870 switch (e_machine)
1871 {
c45021f2 1872 case EM_NONE: return _("None");
a06ea964 1873 case EM_AARCH64: return "AArch64";
c45021f2
NC		 1874 case EM_M32: return "WE32100";
1875 case EM_SPARC: return "Sparc";
e9f53129 1876 case EM_SPU: return "SPU";
c45021f2
NC		 1877 case EM_386: return "Intel 80386";
1878 case EM_68K: return "MC68000";
1879 case EM_88K: return "MC88000";
1880 case EM_486: return "Intel 80486";
1881 case EM_860: return "Intel 80860";
1882 case EM_MIPS: return "MIPS R3000";
1883 case EM_S370: return "IBM System/370";
7036c0e1 1884 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 1885 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 1886 case EM_PARISC: return "HPPA";
252b5132 1887 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 1888 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 1889 case EM_960: return "Intel 90860";
1890 case EM_PPC: return "PowerPC";
285d1771 1891 case EM_PPC64: return "PowerPC64";
c45021f2
NC		 1892 case EM_FR20: return "Fujitsu FR20";
1893 case EM_RH32: return "TRW RH32";
b34976b6 1894 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 1895 case EM_ARM: return "ARM";
1896 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 1897 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 1898 case EM_SPARCV9: return "Sparc v9";
1899 case EM_TRICORE: return "Siemens Tricore";
584da044 1900 case EM_ARC: return "ARC";
c2dcd04e
NC		 1901 case EM_H8_300: return "Renesas H8/300";
1902 case EM_H8_300H: return "Renesas H8/300H";
1903 case EM_H8S: return "Renesas H8S";
1904 case EM_H8_500: return "Renesas H8/500";
30800947 1905 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 1906 case EM_MIPS_X: return "Stanford MIPS-X";
1907 case EM_COLDFIRE: return "Motorola Coldfire";
c45021f2 1908 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 1909 case EM_CYGNUS_D10V:
1910 case EM_D10V: return "d10v";
1911 case EM_CYGNUS_D30V:
b34976b6 1912 case EM_D30V: return "d30v";
2b0337b0 1913 case EM_CYGNUS_M32R:
26597c86 1914 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 1915 case EM_CYGNUS_V850:
708e2187 1916 case EM_V800: return "Renesas V850 (using RH850 ABI)";
f6c1a2d5 1917 case EM_V850: return "Renesas V850";
2b0337b0
AO		 1918 case EM_CYGNUS_MN10300:
1919 case EM_MN10300: return "mn10300";
1920 case EM_CYGNUS_MN10200:
1921 case EM_MN10200: return "mn10200";
5506d11a 1922 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 1923 case EM_CYGNUS_FR30:
1924 case EM_FR30: return "Fujitsu FR30";
b34976b6 1925 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 1926 case EM_PJ_OLD:
b34976b6 1927 case EM_PJ: return "picoJava";
7036c0e1
AJ		 1928 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1929 case EM_PCP: return "Siemens PCP";
1930 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1931 case EM_NDR1: return "Denso NDR1 microprocesspr";
1932 case EM_STARCORE: return "Motorola Star*Core processor";
1933 case EM_ME16: return "Toyota ME16 processor";
1934 case EM_ST100: return "STMicroelectronics ST100 processor";
1935 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 1936 case EM_PDSP: return "Sony DSP processor";
1937 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
1938 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 1939 case EM_FX66: return "Siemens FX66 microcontroller";
1940 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1941 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1942 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
6927f982 1943 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ		 1944 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1945 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1946 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1947 case EM_SVX: return "Silicon Graphics SVx";
1948 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1949 case EM_VAX: return "Digital VAX";
2b0337b0 1950 case EM_AVR_OLD:
b34976b6 1951 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 1952 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 1953 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1954 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1955 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 1956 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 1957 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 1958 case EM_PRISM: return "Vitesse Prism";
bcedfee6 1959 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 1960 case EM_L1OM: return "Intel L1OM";
7a9068fe 1961 case EM_K1OM: return "Intel K1OM";
b7498e0e 1962 case EM_S390_OLD:
b34976b6 1963 case EM_S390: return "IBM S/390";
1c0d3aa6 1964 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 1965 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
3b16e843
NC		 1966 case EM_OPENRISC:
1967 case EM_OR32: return "OpenRISC";
11636f9e 1968 case EM_ARC_A5: return "ARC International ARCompact processor";
1fe1f39c 1969 case EM_CRX: return "National Semiconductor CRX microprocessor";
cfb8c092 1970 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
d172d4ba 1971 case EM_DLX: return "OpenDLX";
1e4cf259 1972 case EM_IP2K_OLD:
b34976b6 1973 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 1974 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 1975 case EM_XTENSA_OLD:
1976 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 1977 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
1978 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
1979 case EM_NS32K: return "National Semiconductor 32000 series";
1980 case EM_TPC: return "Tenor Network TPC processor";
1981 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
1982 case EM_MAX: return "MAX Processor";
1983 case EM_CR: return "National Semiconductor CompactRISC";
1984 case EM_F2MC16: return "Fujitsu F2MC16";
1985 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 1986 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 1987 case EM_M32C_OLD:
49f58d10 1988 case EM_M32C: return "Renesas M32c";
d031aafb 1989 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 1990 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 1991 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
1992 case EM_SEP: return "Sharp embedded microprocessor";
1993 case EM_ARCA: return "Arca RISC microprocessor";
1994 case EM_UNICORE: return "Unicore";
1995 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
1996 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 1997 case EM_NIOS32: return "Altera Nios";
1998 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 1999 case EM_C166:
d70c5fc7 2000 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 2001 case EM_M16C: return "Renesas M16C series microprocessors";
2002 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2003 case EM_CE: return "Freescale Communication Engine RISC core";
2004 case EM_TSK3000: return "Altium TSK3000 core";
2005 case EM_RS08: return "Freescale RS08 embedded processor";
2006 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2007 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2008 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2009 case EM_SE_C17: return "Seiko Epson C17 family";
2010 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2011 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2012 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2013 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2014 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2015 case EM_R32C: return "Renesas R32C series microprocessors";
2016 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2017 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2018 case EM_8051: return "Intel 8051 and variants";
2019 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2020 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2021 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2022 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2023 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2024 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2025 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 2026 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 2027 case EM_CR16:
f6c1a2d5 2028 case EM_MICROBLAZE:
7ba29e2a 2029 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
99c513f6 2030 case EM_RL78: return "Renesas RL78";
c7927a3c 2031 case EM_RX: return "Renesas RX";
11636f9e
JM		 2032 case EM_METAG: return "Imagination Technologies META processor architecture";
2033 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2034 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2035 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2036 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2037 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2038 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2039 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2040 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 2041 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 2042 case EM_CUDA: return "NVIDIA CUDA architecture";
f6c1a2d5 2043 case EM_XGATE: return "Motorola XGATE embedded processor";
252b5132 2044 default:
35d9dd2f 2045 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2046 return buff;
2047 }
2048}
2049
f3485b74 2050static void
d3ba0551 2051decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2052{
2053 unsigned eabi;
2054 int unknown = 0;
2055
2056 eabi = EF_ARM_EABI_VERSION (e_flags);
2057 e_flags &= ~ EF_ARM_EABIMASK;
2058
2059 /* Handle "generic" ARM flags. */
2060 if (e_flags & EF_ARM_RELEXEC)
2061 {
2062 strcat (buf, ", relocatable executable");
2063 e_flags &= ~ EF_ARM_RELEXEC;
2064 }
76da6bbe 2065
f3485b74
NC		 2066 if (e_flags & EF_ARM_HASENTRY)
2067 {
2068 strcat (buf, ", has entry point");
2069 e_flags &= ~ EF_ARM_HASENTRY;
2070 }
76da6bbe 2071
f3485b74
NC		 2072 /* Now handle EABI specific flags. */
2073 switch (eabi)
2074 {
2075 default:
2c71103e 2076 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2077 if (e_flags)
2078 unknown = 1;
2079 break;
2080
2081 case EF_ARM_EABI_VER1:
a5bcd848 2082 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2083 while (e_flags)
2084 {
2085 unsigned flag;
76da6bbe 2086
f3485b74
NC		 2087 /* Process flags one bit at a time. */
2088 flag = e_flags & - e_flags;
2089 e_flags &= ~ flag;
76da6bbe 2090
f3485b74
NC		 2091 switch (flag)
2092 {
a5bcd848 2093 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2094 strcat (buf, ", sorted symbol tables");
2095 break;
76da6bbe 2096
f3485b74
NC		 2097 default:
2098 unknown = 1;
2099 break;
2100 }
2101 }
2102 break;
76da6bbe 2103
a5bcd848
PB		 2104 case EF_ARM_EABI_VER2:
2105 strcat (buf, ", Version2 EABI");
2106 while (e_flags)
2107 {
2108 unsigned flag;
2109
2110 /* Process flags one bit at a time. */
2111 flag = e_flags & - e_flags;
2112 e_flags &= ~ flag;
2113
2114 switch (flag)
2115 {
2116 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2117 strcat (buf, ", sorted symbol tables");
2118 break;
2119
2120 case EF_ARM_DYNSYMSUSESEGIDX:
2121 strcat (buf, ", dynamic symbols use segment index");
2122 break;
2123
2124 case EF_ARM_MAPSYMSFIRST:
2125 strcat (buf, ", mapping symbols precede others");
2126 break;
2127
2128 default:
2129 unknown = 1;
2130 break;
2131 }
2132 }
2133 break;
2134
d507cf36
PB		 2135 case EF_ARM_EABI_VER3:
2136 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2137 break;
2138
2139 case EF_ARM_EABI_VER4:
2140 strcat (buf, ", Version4 EABI");
3bfcb652
NC		 2141 while (e_flags)
2142 {
2143 unsigned flag;
2144
2145 /* Process flags one bit at a time. */
2146 flag = e_flags & - e_flags;
2147 e_flags &= ~ flag;
2148
2149 switch (flag)
2150 {
2151 case EF_ARM_BE8:
2152 strcat (buf, ", BE8");
2153 break;
2154
2155 case EF_ARM_LE8:
2156 strcat (buf, ", LE8");
2157 break;
2158
2159 default:
2160 unknown = 1;
2161 break;
2162 }
2163 break;
2164 }
2165 break;
3a4a14e9
PB		 2166
2167 case EF_ARM_EABI_VER5:
2168 strcat (buf, ", Version5 EABI");
d507cf36
PB		 2169 while (e_flags)
2170 {
2171 unsigned flag;
2172
2173 /* Process flags one bit at a time. */
2174 flag = e_flags & - e_flags;
2175 e_flags &= ~ flag;
2176
2177 switch (flag)
2178 {
2179 case EF_ARM_BE8:
2180 strcat (buf, ", BE8");
2181 break;
2182
2183 case EF_ARM_LE8:
2184 strcat (buf, ", LE8");
2185 break;
2186
3bfcb652
NC		 2187 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2188 strcat (buf, ", soft-float ABI");
2189 break;
2190
2191 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2192 strcat (buf, ", hard-float ABI");
2193 break;
2194
d507cf36
PB		 2195 default:
2196 unknown = 1;
2197 break;
2198 }
2199 }
2200 break;
2201
f3485b74 2202 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2203 strcat (buf, ", GNU EABI");
f3485b74
NC		 2204 while (e_flags)
2205 {
2206 unsigned flag;
76da6bbe 2207
f3485b74
NC		 2208 /* Process flags one bit at a time. */
2209 flag = e_flags & - e_flags;
2210 e_flags &= ~ flag;
76da6bbe 2211
f3485b74
NC		 2212 switch (flag)
2213 {
a5bcd848 2214 case EF_ARM_INTERWORK:
f3485b74
NC		 2215 strcat (buf, ", interworking enabled");
2216 break;
76da6bbe 2217
a5bcd848 2218 case EF_ARM_APCS_26:
f3485b74
NC		 2219 strcat (buf, ", uses APCS/26");
2220 break;
76da6bbe 2221
a5bcd848 2222 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2223 strcat (buf, ", uses APCS/float");
2224 break;
76da6bbe 2225
a5bcd848 2226 case EF_ARM_PIC:
f3485b74
NC		 2227 strcat (buf, ", position independent");
2228 break;
76da6bbe 2229
a5bcd848 2230 case EF_ARM_ALIGN8:
f3485b74
NC		 2231 strcat (buf, ", 8 bit structure alignment");
2232 break;
76da6bbe 2233
a5bcd848 2234 case EF_ARM_NEW_ABI:
f3485b74
NC		 2235 strcat (buf, ", uses new ABI");
2236 break;
76da6bbe 2237
a5bcd848 2238 case EF_ARM_OLD_ABI:
f3485b74
NC		 2239 strcat (buf, ", uses old ABI");
2240 break;
76da6bbe 2241
a5bcd848 2242 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2243 strcat (buf, ", software FP");
2244 break;
76da6bbe 2245
90e01f86
ILT		 2246 case EF_ARM_VFP_FLOAT:
2247 strcat (buf, ", VFP");
2248 break;
2249
fde78edd
NC		 2250 case EF_ARM_MAVERICK_FLOAT:
2251 strcat (buf, ", Maverick FP");
2252 break;
2253
f3485b74
NC		 2254 default:
2255 unknown = 1;
2256 break;
2257 }
2258 }
2259 }
f3485b74
NC		 2260
2261 if (unknown)
2b692964 2262 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2263}
2264
252b5132 2265static char *
d3ba0551 2266get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2267{
b34976b6 2268 static char buf[1024];
252b5132
RH		 2269
2270 buf[0] = '\0';
76da6bbe 2271
252b5132
RH		 2272 if (e_flags)
2273 {
2274 switch (e_machine)
2275 {
2276 default:
2277 break;
2278
f3485b74
NC		 2279 case EM_ARM:
2280 decode_ARM_machine_flags (e_flags, buf);
2281 break;
76da6bbe 2282
781303ce
MF		 2283 case EM_BLACKFIN:
2284 if (e_flags & EF_BFIN_PIC)
2285 strcat (buf, ", PIC");
2286
2287 if (e_flags & EF_BFIN_FDPIC)
2288 strcat (buf, ", FDPIC");
2289
2290 if (e_flags & EF_BFIN_CODE_IN_L1)
2291 strcat (buf, ", code in L1");
2292
2293 if (e_flags & EF_BFIN_DATA_IN_L1)
2294 strcat (buf, ", data in L1");
2295
2296 break;
2297
ec2dfb42
AO		 2298 case EM_CYGNUS_FRV:
2299 switch (e_flags & EF_FRV_CPU_MASK)
2300 {
2301 case EF_FRV_CPU_GENERIC:
2302 break;
2303
2304 default:
2305 strcat (buf, ", fr???");
2306 break;
57346661 2307
ec2dfb42
AO		 2308 case EF_FRV_CPU_FR300:
2309 strcat (buf, ", fr300");
2310 break;
2311
2312 case EF_FRV_CPU_FR400:
2313 strcat (buf, ", fr400");
2314 break;
2315 case EF_FRV_CPU_FR405:
2316 strcat (buf, ", fr405");
2317 break;
2318
2319 case EF_FRV_CPU_FR450:
2320 strcat (buf, ", fr450");
2321 break;
2322
2323 case EF_FRV_CPU_FR500:
2324 strcat (buf, ", fr500");
2325 break;
2326 case EF_FRV_CPU_FR550:
2327 strcat (buf, ", fr550");
2328 break;
2329
2330 case EF_FRV_CPU_SIMPLE:
2331 strcat (buf, ", simple");
2332 break;
2333 case EF_FRV_CPU_TOMCAT:
2334 strcat (buf, ", tomcat");
2335 break;
2336 }
1c877e87 2337 break;
ec2dfb42 2338
53c7db4b 2339 case EM_68K:
425c6cb0 2340 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2341 strcat (buf, ", m68000");
425c6cb0 2342 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2343 strcat (buf, ", cpu32");
2344 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2345 strcat (buf, ", fido_a");
425c6cb0 2346 else
266abb8f 2347 {
2cf0635d
NC		 2348 char const * isa = _("unknown");
2349 char const * mac = _("unknown mac");
2350 char const * additional = NULL;
0112cd26 2351
c694fd50 2352 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2353 {
c694fd50 2354 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2355 isa = "A";
2356 additional = ", nodiv";
2357 break;
c694fd50 2358 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2359 isa = "A";
2360 break;
c694fd50 2361 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2362 isa = "A+";
2363 break;
c694fd50 2364 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2365 isa = "B";
2366 additional = ", nousp";
2367 break;
c694fd50 2368 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2369 isa = "B";
2370 break;
f608cd77
NS		 2371 case EF_M68K_CF_ISA_C:
2372 isa = "C";
2373 break;
2374 case EF_M68K_CF_ISA_C_NODIV:
2375 isa = "C";
2376 additional = ", nodiv";
2377 break;
266abb8f
NS		 2378 }
2379 strcat (buf, ", cf, isa ");
2380 strcat (buf, isa);
0b2e31dc
NS		 2381 if (additional)
2382 strcat (buf, additional);
c694fd50 2383 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2384 strcat (buf, ", float");
c694fd50 2385 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2386 {
2387 case 0:
2388 mac = NULL;
2389 break;
c694fd50 2390 case EF_M68K_CF_MAC:
266abb8f
NS		 2391 mac = "mac";
2392 break;
c694fd50 2393 case EF_M68K_CF_EMAC:
266abb8f
NS		 2394 mac = "emac";
2395 break;
f608cd77
NS		 2396 case EF_M68K_CF_EMAC_B:
2397 mac = "emac_b";
2398 break;
266abb8f
NS		 2399 }
2400 if (mac)
2401 {
2402 strcat (buf, ", ");
2403 strcat (buf, mac);
2404 }
266abb8f 2405 }
53c7db4b 2406 break;
33c63f9d 2407
252b5132
RH		 2408 case EM_PPC:
2409 if (e_flags & EF_PPC_EMB)
2410 strcat (buf, ", emb");
2411
2412 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2413 strcat (buf, _(", relocatable"));
252b5132
RH		 2414
2415 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 2416 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 2417 break;
2418
708e2187
NC		 2419 case EM_V800:
2420 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2421 strcat (buf, ", RH850 ABI");
2422
2423 if (e_flags & EF_V800_850E3)
2424 strcat (buf, ", V3 architecture");
2425
2426 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2427 strcat (buf, ", FPU not used");
2428
2429 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2430 strcat (buf, ", regmode: COMMON");
2431
2432 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2433 strcat (buf, ", r4 not used");
2434
2435 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2436 strcat (buf, ", r30 not used");
2437
2438 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2439 strcat (buf, ", r5 not used");
2440
2441 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2442 strcat (buf, ", r2 not used");
2443
2444 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2445 {
2446 switch (e_flags & - e_flags)
2447 {
2448 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2449 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2450 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2451 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2452 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2453 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2454 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2455 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2456 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2457 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2458 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2459 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2460 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2461 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2462 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2463 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2464 default: break;
2465 }
2466 }
2467 break;
2468
2b0337b0 2469 case EM_V850:
252b5132
RH		 2470 case EM_CYGNUS_V850:
2471 switch (e_flags & EF_V850_ARCH)
2472 {
1cd986c5
NC		 2473 case E_V850E2V3_ARCH:
2474 strcat (buf, ", v850e2v3");
2475 break;
2476 case E_V850E2_ARCH:
2477 strcat (buf, ", v850e2");
2478 break;
2479 case E_V850E1_ARCH:
2480 strcat (buf, ", v850e1");
8ad30312 2481 break;
252b5132
RH		 2482 case E_V850E_ARCH:
2483 strcat (buf, ", v850e");
2484 break;
252b5132
RH		 2485 case E_V850_ARCH:
2486 strcat (buf, ", v850");
2487 break;
2488 default:
2b692964 2489 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 2490 break;
2491 }
2492 break;
2493
2b0337b0 2494 case EM_M32R:
252b5132
RH		 2495 case EM_CYGNUS_M32R:
2496 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2497 strcat (buf, ", m32r");
252b5132
RH		 2498 break;
2499
2500 case EM_MIPS:
4fe85591 2501 case EM_MIPS_RS3_LE:
252b5132
RH		 2502 if (e_flags & EF_MIPS_NOREORDER)
2503 strcat (buf, ", noreorder");
2504
2505 if (e_flags & EF_MIPS_PIC)
2506 strcat (buf, ", pic");
2507
2508 if (e_flags & EF_MIPS_CPIC)
2509 strcat (buf, ", cpic");
2510
d1bdd336
TS		 2511 if (e_flags & EF_MIPS_UCODE)
2512 strcat (buf, ", ugen_reserved");
2513
252b5132
RH		 2514 if (e_flags & EF_MIPS_ABI2)
2515 strcat (buf, ", abi2");
2516
43521d43
TS		 2517 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2518 strcat (buf, ", odk first");
2519
a5d22d2a
TS		 2520 if (e_flags & EF_MIPS_32BITMODE)
2521 strcat (buf, ", 32bitmode");
2522
156c2f8b
NC		 2523 switch ((e_flags & EF_MIPS_MACH))
2524 {
2525 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2526 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2527 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 2528 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 2529 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2530 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2531 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2532 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 2533 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 2534 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 2535 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2536 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 2537 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 2538 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 2539 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
52b6b6b9 2540 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 2541 case 0:
2542 /* We simply ignore the field in this case to avoid confusion:
2543 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2544 extension. */
2545 break;
2b692964 2546 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 2547 }
43521d43
TS		 2548
2549 switch ((e_flags & EF_MIPS_ABI))
2550 {
2551 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2552 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2553 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2554 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2555 case 0:
2556 /* We simply ignore the field in this case to avoid confusion:
2557 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2558 This means it is likely to be an o32 file, but not for
2559 sure. */
2560 break;
2b692964 2561 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 2562 }
2563
2564 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2565 strcat (buf, ", mdmx");
2566
2567 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2568 strcat (buf, ", mips16");
2569
df58fc94
RS		 2570 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2571 strcat (buf, ", micromips");
2572
43521d43
TS		 2573 switch ((e_flags & EF_MIPS_ARCH))
2574 {
2575 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2576 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2577 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2578 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2579 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2580 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 2581 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
43521d43 2582 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 2583 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2b692964 2584 default: strcat (buf, _(", unknown ISA")); break;
43521d43
TS		 2585 }
2586
8e45593f
NC		 2587 if (e_flags & EF_SH_PIC)
2588 strcat (buf, ", pic");
2589
2590 if (e_flags & EF_SH_FDPIC)
2591 strcat (buf, ", fdpic");
252b5132 2592 break;
351b4b40 2593
ccde1100
AO		 2594 case EM_SH:
2595 switch ((e_flags & EF_SH_MACH_MASK))
2596 {
2597 case EF_SH1: strcat (buf, ", sh1"); break;
2598 case EF_SH2: strcat (buf, ", sh2"); break;
2599 case EF_SH3: strcat (buf, ", sh3"); break;
2600 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2601 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2602 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2603 case EF_SH3E: strcat (buf, ", sh3e"); break;
2604 case EF_SH4: strcat (buf, ", sh4"); break;
2605 case EF_SH5: strcat (buf, ", sh5"); break;
2606 case EF_SH2E: strcat (buf, ", sh2e"); break;
2607 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 2608 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 2609 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2610 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 2611 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 2612 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2613 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2614 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2615 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2616 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2617 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 2618 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 2619 }
2620
2621 break;
57346661 2622
351b4b40
RH		 2623 case EM_SPARCV9:
2624 if (e_flags & EF_SPARC_32PLUS)
2625 strcat (buf, ", v8+");
2626
2627 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 2628 strcat (buf, ", ultrasparcI");
2629
2630 if (e_flags & EF_SPARC_SUN_US3)
2631 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 2632
2633 if (e_flags & EF_SPARC_HAL_R1)
2634 strcat (buf, ", halr1");
2635
2636 if (e_flags & EF_SPARC_LEDATA)
2637 strcat (buf, ", ledata");
2638
2639 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2640 strcat (buf, ", tso");
2641
2642 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2643 strcat (buf, ", pso");
2644
2645 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2646 strcat (buf, ", rmo");
2647 break;
7d466069 2648
103f02d3
UD		 2649 case EM_PARISC:
2650 switch (e_flags & EF_PARISC_ARCH)
2651 {
2652 case EFA_PARISC_1_0:
2653 strcpy (buf, ", PA-RISC 1.0");
2654 break;
2655 case EFA_PARISC_1_1:
2656 strcpy (buf, ", PA-RISC 1.1");
2657 break;
2658 case EFA_PARISC_2_0:
2659 strcpy (buf, ", PA-RISC 2.0");
2660 break;
2661 default:
2662 break;
2663 }
2664 if (e_flags & EF_PARISC_TRAPNIL)
2665 strcat (buf, ", trapnil");
2666 if (e_flags & EF_PARISC_EXT)
2667 strcat (buf, ", ext");
2668 if (e_flags & EF_PARISC_LSB)
2669 strcat (buf, ", lsb");
2670 if (e_flags & EF_PARISC_WIDE)
2671 strcat (buf, ", wide");
2672 if (e_flags & EF_PARISC_NO_KABP)
2673 strcat (buf, ", no kabp");
2674 if (e_flags & EF_PARISC_LAZYSWAP)
2675 strcat (buf, ", lazyswap");
30800947 2676 break;
76da6bbe 2677
7d466069 2678 case EM_PJ:
2b0337b0 2679 case EM_PJ_OLD:
7d466069
ILT		 2680 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2681 strcat (buf, ", new calling convention");
2682
2683 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2684 strcat (buf, ", gnu calling convention");
2685 break;
4d6ed7c8
NC		 2686
2687 case EM_IA_64:
2688 if ((e_flags & EF_IA_64_ABI64))
2689 strcat (buf, ", 64-bit");
2690 else
2691 strcat (buf, ", 32-bit");
2692 if ((e_flags & EF_IA_64_REDUCEDFP))
2693 strcat (buf, ", reduced fp model");
2694 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2695 strcat (buf, ", no function descriptors, constant gp");
2696 else if ((e_flags & EF_IA_64_CONS_GP))
2697 strcat (buf, ", constant gp");
2698 if ((e_flags & EF_IA_64_ABSOLUTE))
2699 strcat (buf, ", absolute");
28f997cf
TG		 2700 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2701 {
2702 if ((e_flags & EF_IA_64_VMS_LINKAGES))
2703 strcat (buf, ", vms_linkages");
2704 switch ((e_flags & EF_IA_64_VMS_COMCOD))
2705 {
2706 case EF_IA_64_VMS_COMCOD_SUCCESS:
2707 break;
2708 case EF_IA_64_VMS_COMCOD_WARNING:
2709 strcat (buf, ", warning");
2710 break;
2711 case EF_IA_64_VMS_COMCOD_ERROR:
2712 strcat (buf, ", error");
2713 break;
2714 case EF_IA_64_VMS_COMCOD_ABORT:
2715 strcat (buf, ", abort");
2716 break;
2717 default:
2718 abort ();
2719 }
2720 }
4d6ed7c8 2721 break;
179d3252
JT		 2722
2723 case EM_VAX:
2724 if ((e_flags & EF_VAX_NONPIC))
2725 strcat (buf, ", non-PIC");
2726 if ((e_flags & EF_VAX_DFLOAT))
2727 strcat (buf, ", D-Float");
2728 if ((e_flags & EF_VAX_GFLOAT))
2729 strcat (buf, ", G-Float");
2730 break;
c7927a3c
NC		 2731
2732 case EM_RX:
2733 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2734 strcat (buf, ", 64-bit doubles");
2735 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 2736 strcat (buf, ", dsp");
d4cb0ea0
NC		 2737 if (e_flags & E_FLAG_RX_PID)
2738 strcat (buf, ", pid");
708e2187
NC		 2739 if (e_flags & E_FLAG_RX_ABI)
2740 strcat (buf, ", RX ABI");
d4cb0ea0 2741 break;
55786da2
AK		 2742
2743 case EM_S390:
2744 if (e_flags & EF_S390_HIGH_GPRS)
2745 strcat (buf, ", highgprs");
d4cb0ea0 2746 break;
40b36596
JM		 2747
2748 case EM_TI_C6000:
2749 if ((e_flags & EF_C6000_REL))
2750 strcat (buf, ", relocatable module");
d4cb0ea0 2751 break;
252b5132
RH		 2752 }
2753 }
2754
2755 return buf;
2756}
2757
252b5132 2758static const char *
d3ba0551
AM		 2759get_osabi_name (unsigned int osabi)
2760{
2761 static char buff[32];
2762
2763 switch (osabi)
2764 {
2765 case ELFOSABI_NONE: return "UNIX - System V";
2766 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2767 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 2768 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 2769 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2770 case ELFOSABI_AIX: return "UNIX - AIX";
2771 case ELFOSABI_IRIX: return "UNIX - IRIX";
2772 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2773 case ELFOSABI_TRU64: return "UNIX - TRU64";
2774 case ELFOSABI_MODESTO: return "Novell - Modesto";
2775 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2776 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2777 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 2778 case ELFOSABI_AROS: return "AROS";
11636f9e 2779 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 2780 default:
40b36596
JM		 2781 if (osabi >= 64)
2782 switch (elf_header.e_machine)
2783 {
2784 case EM_ARM:
2785 switch (osabi)
2786 {
2787 case ELFOSABI_ARM: return "ARM";
2788 default:
2789 break;
2790 }
2791 break;
2792
2793 case EM_MSP430:
2794 case EM_MSP430_OLD:
2795 switch (osabi)
2796 {
2797 case ELFOSABI_STANDALONE: return _("Standalone App");
2798 default:
2799 break;
2800 }
2801 break;
2802
2803 case EM_TI_C6000:
2804 switch (osabi)
2805 {
2806 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
2807 case ELFOSABI_C6000_LINUX: return "Linux C6000";
2808 default:
2809 break;
2810 }
2811 break;
2812
2813 default:
2814 break;
2815 }
e9e44622 2816 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 2817 return buff;
2818 }
2819}
2820
a06ea964
NC		 2821static const char *
2822get_aarch64_segment_type (unsigned long type)
2823{
2824 switch (type)
2825 {
2826 case PT_AARCH64_ARCHEXT:
2827 return "AARCH64_ARCHEXT";
2828 default:
2829 break;
2830 }
2831
2832 return NULL;
2833}
2834
b294bdf8
MM		 2835static const char *
2836get_arm_segment_type (unsigned long type)
2837{
2838 switch (type)
2839 {
2840 case PT_ARM_EXIDX:
2841 return "EXIDX";
2842 default:
2843 break;
2844 }
2845
2846 return NULL;
2847}
2848
d3ba0551
AM		 2849static const char *
2850get_mips_segment_type (unsigned long type)
252b5132
RH		 2851{
2852 switch (type)
2853 {
2854 case PT_MIPS_REGINFO:
2855 return "REGINFO";
2856 case PT_MIPS_RTPROC:
2857 return "RTPROC";
2858 case PT_MIPS_OPTIONS:
2859 return "OPTIONS";
2860 default:
2861 break;
2862 }
2863
2864 return NULL;
2865}
2866
103f02d3 2867static const char *
d3ba0551 2868get_parisc_segment_type (unsigned long type)
103f02d3
UD		 2869{
2870 switch (type)
2871 {
2872 case PT_HP_TLS: return "HP_TLS";
2873 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2874 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2875 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2876 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2877 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2878 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2879 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2880 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2881 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2882 case PT_HP_PARALLEL: return "HP_PARALLEL";
2883 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 2884 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
2885 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
2886 case PT_HP_STACK: return "HP_STACK";
2887 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 2888 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2889 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 2890 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 2891 default:
2892 break;
2893 }
2894
2895 return NULL;
2896}
2897
4d6ed7c8 2898static const char *
d3ba0551 2899get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 2900{
2901 switch (type)
2902 {
2903 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2904 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 2905 case PT_HP_TLS: return "HP_TLS";
2906 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2907 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2908 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 2909 default:
2910 break;
2911 }
2912
2913 return NULL;
2914}
2915
40b36596
JM		 2916static const char *
2917get_tic6x_segment_type (unsigned long type)
2918{
2919 switch (type)
2920 {
2921 case PT_C6000_PHATTR: return "C6000_PHATTR";
2922 default:
2923 break;
2924 }
2925
2926 return NULL;
2927}
2928
252b5132 2929static const char *
d3ba0551 2930get_segment_type (unsigned long p_type)
252b5132 2931{
b34976b6 2932 static char buff[32];
252b5132
RH		 2933
2934 switch (p_type)
2935 {
b34976b6
AM		 2936 case PT_NULL: return "NULL";
2937 case PT_LOAD: return "LOAD";
252b5132 2938 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 2939 case PT_INTERP: return "INTERP";
2940 case PT_NOTE: return "NOTE";
2941 case PT_SHLIB: return "SHLIB";
2942 case PT_PHDR: return "PHDR";
13ae64f3 2943 case PT_TLS: return "TLS";
252b5132 2944
65765700
JJ		 2945 case PT_GNU_EH_FRAME:
2946 return "GNU_EH_FRAME";
2b05f1b7 2947 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 2948 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 2949
252b5132
RH		 2950 default:
2951 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2952 {
2cf0635d 2953 const char * result;
103f02d3 2954
252b5132
RH		 2955 switch (elf_header.e_machine)
2956 {
a06ea964
NC		 2957 case EM_AARCH64:
2958 result = get_aarch64_segment_type (p_type);
2959 break;
b294bdf8
MM		 2960 case EM_ARM:
2961 result = get_arm_segment_type (p_type);
2962 break;
252b5132 2963 case EM_MIPS:
4fe85591 2964 case EM_MIPS_RS3_LE:
252b5132
RH		 2965 result = get_mips_segment_type (p_type);
2966 break;
103f02d3
UD		 2967 case EM_PARISC:
2968 result = get_parisc_segment_type (p_type);
2969 break;
4d6ed7c8
NC		 2970 case EM_IA_64:
2971 result = get_ia64_segment_type (p_type);
2972 break;
40b36596
JM		 2973 case EM_TI_C6000:
2974 result = get_tic6x_segment_type (p_type);
2975 break;
252b5132
RH		 2976 default:
2977 result = NULL;
2978 break;
2979 }
103f02d3 2980
252b5132
RH		 2981 if (result != NULL)
2982 return result;
103f02d3 2983
252b5132
RH		 2984 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2985 }
2986 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 2987 {
2cf0635d 2988 const char * result;
103f02d3
UD		 2989
2990 switch (elf_header.e_machine)
2991 {
2992 case EM_PARISC:
2993 result = get_parisc_segment_type (p_type);
2994 break;
00428cca
AM		 2995 case EM_IA_64:
2996 result = get_ia64_segment_type (p_type);
2997 break;
103f02d3
UD		 2998 default:
2999 result = NULL;
3000 break;
3001 }
3002
3003 if (result != NULL)
3004 return result;
3005
3006 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3007 }
252b5132 3008 else
e9e44622 3009 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3010
3011 return buff;
3012 }
3013}
3014
3015static const char *
d3ba0551 3016get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3017{
3018 switch (sh_type)
3019 {
b34976b6
AM		 3020 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3021 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3022 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3023 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3024 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3025 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3026 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3027 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3028 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3029 case SHT_MIPS_RELD: return "MIPS_RELD";
3030 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3031 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3032 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3033 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3034 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3035 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3036 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3037 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3038 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3039 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3040 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3041 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3042 case SHT_MIPS_LINE: return "MIPS_LINE";
3043 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3044 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3045 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3046 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3047 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3048 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3049 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3050 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3051 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3052 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3053 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3054 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3055 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3056 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3057 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132
RH		 3058 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3059 default:
3060 break;
3061 }
3062 return NULL;
3063}
3064
103f02d3 3065static const char *
d3ba0551 3066get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3067{
3068 switch (sh_type)
3069 {
3070 case SHT_PARISC_EXT: return "PARISC_EXT";
3071 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3072 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3073 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3074 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3075 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3076 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3077 default:
3078 break;
3079 }
3080 return NULL;
3081}
3082
4d6ed7c8 3083static const char *
d3ba0551 3084get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3085{
18bd398b 3086 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3087 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3088 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3089
4d6ed7c8
NC		 3090 switch (sh_type)
3091 {
148b93f2
NC		 3092 case SHT_IA_64_EXT: return "IA_64_EXT";
3093 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3094 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3095 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3096 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3097 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3098 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3099 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3100 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3101 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3102 default:
3103 break;
3104 }
3105 return NULL;
3106}
3107
d2b2c203
DJ		 3108static const char *
3109get_x86_64_section_type_name (unsigned int sh_type)
3110{
3111 switch (sh_type)
3112 {
3113 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3114 default:
3115 break;
3116 }
3117 return NULL;
3118}
3119
a06ea964
NC		 3120static const char *
3121get_aarch64_section_type_name (unsigned int sh_type)
3122{
3123 switch (sh_type)
3124 {
3125 case SHT_AARCH64_ATTRIBUTES:
3126 return "AARCH64_ATTRIBUTES";
3127 default:
3128 break;
3129 }
3130 return NULL;
3131}
3132
40a18ebd
NC		 3133static const char *
3134get_arm_section_type_name (unsigned int sh_type)
3135{
3136 switch (sh_type)
3137 {
7f6fed87
NC		 3138 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3139 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3140 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3141 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3142 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3143 default:
3144 break;
3145 }
3146 return NULL;
3147}
3148
40b36596
JM		 3149static const char *
3150get_tic6x_section_type_name (unsigned int sh_type)
3151{
3152 switch (sh_type)
3153 {
3154 case SHT_C6000_UNWIND:
3155 return "C6000_UNWIND";
3156 case SHT_C6000_PREEMPTMAP:
3157 return "C6000_PREEMPTMAP";
3158 case SHT_C6000_ATTRIBUTES:
3159 return "C6000_ATTRIBUTES";
3160 case SHT_TI_ICODE:
3161 return "TI_ICODE";
3162 case SHT_TI_XREF:
3163 return "TI_XREF";
3164 case SHT_TI_HANDLER:
3165 return "TI_HANDLER";
3166 case SHT_TI_INITINFO:
3167 return "TI_INITINFO";
3168 case SHT_TI_PHATTRS:
3169 return "TI_PHATTRS";
3170 default:
3171 break;
3172 }
3173 return NULL;
3174}
3175
252b5132 3176static const char *
d3ba0551 3177get_section_type_name (unsigned int sh_type)
252b5132 3178{
b34976b6 3179 static char buff[32];
252b5132
RH		 3180
3181 switch (sh_type)
3182 {
3183 case SHT_NULL: return "NULL";
3184 case SHT_PROGBITS: return "PROGBITS";
3185 case SHT_SYMTAB: return "SYMTAB";
3186 case SHT_STRTAB: return "STRTAB";
3187 case SHT_RELA: return "RELA";
3188 case SHT_HASH: return "HASH";
3189 case SHT_DYNAMIC: return "DYNAMIC";
3190 case SHT_NOTE: return "NOTE";
3191 case SHT_NOBITS: return "NOBITS";
3192 case SHT_REL: return "REL";
3193 case SHT_SHLIB: return "SHLIB";
3194 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3195 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3196 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3197 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3198 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3199 case SHT_GROUP: return "GROUP";
3200 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3201 case SHT_GNU_verdef: return "VERDEF";
3202 case SHT_GNU_verneed: return "VERNEED";
3203 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3204 case 0x6ffffff0: return "VERSYM";
3205 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3206 case 0x7ffffffd: return "AUXILIARY";
3207 case 0x7fffffff: return "FILTER";
047b2264 3208 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3209
3210 default:
3211 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3212 {
2cf0635d 3213 const char * result;
252b5132
RH		 3214
3215 switch (elf_header.e_machine)
3216 {
3217 case EM_MIPS:
4fe85591 3218 case EM_MIPS_RS3_LE:
252b5132
RH		 3219 result = get_mips_section_type_name (sh_type);
3220 break;
103f02d3
UD		 3221 case EM_PARISC:
3222 result = get_parisc_section_type_name (sh_type);
3223 break;
4d6ed7c8
NC		 3224 case EM_IA_64:
3225 result = get_ia64_section_type_name (sh_type);
3226 break;
d2b2c203 3227 case EM_X86_64:
8a9036a4 3228 case EM_L1OM:
7a9068fe 3229 case EM_K1OM:
d2b2c203
DJ		 3230 result = get_x86_64_section_type_name (sh_type);
3231 break;
a06ea964
NC		 3232 case EM_AARCH64:
3233 result = get_aarch64_section_type_name (sh_type);
3234 break;
40a18ebd
NC		 3235 case EM_ARM:
3236 result = get_arm_section_type_name (sh_type);
3237 break;
40b36596
JM		 3238 case EM_TI_C6000:
3239 result = get_tic6x_section_type_name (sh_type);
3240 break;
252b5132
RH		 3241 default:
3242 result = NULL;
3243 break;
3244 }
3245
3246 if (result != NULL)
3247 return result;
3248
c91d0dfb 3249 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3250 }
3251 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3252 {
2cf0635d 3253 const char * result;
148b93f2
NC		 3254
3255 switch (elf_header.e_machine)
3256 {
3257 case EM_IA_64:
3258 result = get_ia64_section_type_name (sh_type);
3259 break;
3260 default:
3261 result = NULL;
3262 break;
3263 }
3264
3265 if (result != NULL)
3266 return result;
3267
3268 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3269 }
252b5132 3270 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
c91d0dfb 3271 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
252b5132 3272 else
a7dbfd1c
NC		 3273 /* This message is probably going to be displayed in a 15
3274 character wide field, so put the hex value first. */
3275 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3276
252b5132
RH		 3277 return buff;
3278 }
3279}
3280
2979dc34 3281#define OPTION_DEBUG_DUMP 512
2c610e4b 3282#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3283#define OPTION_DWARF_DEPTH 514
3284#define OPTION_DWARF_START 515
4723351a 3285#define OPTION_DWARF_CHECK 516
2979dc34 3286
85b1c36d 3287static struct option options[] =
252b5132 3288{
b34976b6 3289 {"all", no_argument, 0, 'a'},
252b5132
RH		 3290 {"file-header", no_argument, 0, 'h'},
3291 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3292 {"headers", no_argument, 0, 'e'},
3293 {"histogram", no_argument, 0, 'I'},
3294 {"segments", no_argument, 0, 'l'},
3295 {"sections", no_argument, 0, 'S'},
252b5132 3296 {"section-headers", no_argument, 0, 'S'},
f5842774 3297 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3298 {"section-details", no_argument, 0, 't'},
595cf52e 3299 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3300 {"symbols", no_argument, 0, 's'},
3301 {"syms", no_argument, 0, 's'},
2c610e4b 3302 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3303 {"relocs", no_argument, 0, 'r'},
3304 {"notes", no_argument, 0, 'n'},
3305 {"dynamic", no_argument, 0, 'd'},
a952a375 3306 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3307 {"version-info", no_argument, 0, 'V'},
3308 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3309 {"unwind", no_argument, 0, 'u'},
4145f1d5 3310 {"archive-index", no_argument, 0, 'c'},
b34976b6 3311 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3312 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3313 {"string-dump", required_argument, 0, 'p'},
252b5132
RH		 3314#ifdef SUPPORT_DISASSEMBLY
3315 {"instruction-dump", required_argument, 0, 'i'},
3316#endif
cf13d699 3317 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3318
fd2f0033
TT		 3319 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3320 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 3321 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 3322
b34976b6
AM		 3323 {"version", no_argument, 0, 'v'},
3324 {"wide", no_argument, 0, 'W'},
3325 {"help", no_argument, 0, 'H'},
3326 {0, no_argument, 0, 0}
252b5132
RH		 3327};
3328
3329static void
2cf0635d 3330usage (FILE * stream)
252b5132 3331{
92f01d61
JM		 3332 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3333 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3334 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3335 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3336 -h --file-header Display the ELF file header\n\
3337 -l --program-headers Display the program headers\n\
3338 --segments An alias for --program-headers\n\
3339 -S --section-headers Display the sections' header\n\
3340 --sections An alias for --section-headers\n\
f5842774 3341 -g --section-groups Display the section groups\n\
5477e8a0 3342 -t --section-details Display the section details\n\
8b53311e
NC		 3343 -e --headers Equivalent to: -h -l -S\n\
3344 -s --syms Display the symbol table\n\
3f08eb35 3345 --symbols An alias for --syms\n\
2c610e4b 3346 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3347 -n --notes Display the core notes (if present)\n\
3348 -r --relocs Display the relocations (if present)\n\
3349 -u --unwind Display the unwind info (if present)\n\
b2d38a17 3350 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 3351 -V --version-info Display the version sections (if present)\n\
1b31d05e 3352 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 3353 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 3354 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 3355 -x --hex-dump=<number|name>\n\
3356 Dump the contents of section <number|name> as bytes\n\
3357 -p --string-dump=<number|name>\n\
3358 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 3359 -R --relocated-dump=<number|name>\n\
3360 Dump the contents of section <number|name> as relocated bytes\n\
f9f0e732 3361 -w[lLiaprmfFsoRt] or\n\
1ed06042 3362 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 3363 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 3364 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3365 =addr,=cu_index]\n\
8b53311e 3366 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 3367 fprintf (stream, _("\
3368 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3369 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3370 or deeper\n"));
252b5132 3371#ifdef SUPPORT_DISASSEMBLY
92f01d61 3372 fprintf (stream, _("\
09c11c86
NC		 3373 -i --instruction-dump=<number|name>\n\
3374 Disassemble the contents of section <number|name>\n"));
252b5132 3375#endif
92f01d61 3376 fprintf (stream, _("\
8b53311e
NC		 3377 -I --histogram Display histogram of bucket list lengths\n\
3378 -W --wide Allow output width to exceed 80 characters\n\
07012eee 3379 @<file> Read options from <file>\n\
8b53311e
NC		 3380 -H --help Display this information\n\
3381 -v --version Display the version number of readelf\n"));
1118d252 3382
92f01d61
JM		 3383 if (REPORT_BUGS_TO[0] && stream == stdout)
3384 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 3385
92f01d61 3386 exit (stream == stdout ? 0 : 1);
252b5132
RH		 3387}
3388
18bd398b
NC		 3389/* Record the fact that the user wants the contents of section number
3390 SECTION to be displayed using the method(s) encoded as flags bits
3391 in TYPE. Note, TYPE can be zero if we are creating the array for
3392 the first time. */
3393
252b5132 3394static void
09c11c86 3395request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 3396{
3397 if (section >= num_dump_sects)
3398 {
2cf0635d 3399 dump_type * new_dump_sects;
252b5132 3400
3f5e193b
NC		 3401 new_dump_sects = (dump_type *) calloc (section + 1,
3402 sizeof (* dump_sects));
252b5132
RH		 3403
3404 if (new_dump_sects == NULL)
591a748a 3405 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 3406 else
3407 {
3408 /* Copy current flag settings. */
09c11c86 3409 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 3410
3411 free (dump_sects);
3412
3413 dump_sects = new_dump_sects;
3414 num_dump_sects = section + 1;
3415 }
3416 }
3417
3418 if (dump_sects)
b34976b6 3419 dump_sects[section] |= type;
252b5132
RH		 3420
3421 return;
3422}
3423
aef1f6d0
DJ		 3424/* Request a dump by section name. */
3425
3426static void
2cf0635d 3427request_dump_byname (const char * section, dump_type type)
aef1f6d0 3428{
2cf0635d 3429 struct dump_list_entry * new_request;
aef1f6d0 3430
3f5e193b
NC		 3431 new_request = (struct dump_list_entry *)
3432 malloc (sizeof (struct dump_list_entry));
aef1f6d0 3433 if (!new_request)
591a748a 3434 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3435
3436 new_request->name = strdup (section);
3437 if (!new_request->name)
591a748a 3438 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3439
3440 new_request->type = type;
3441
3442 new_request->next = dump_sects_byname;
3443 dump_sects_byname = new_request;
3444}
3445
cf13d699
NC		 3446static inline void
3447request_dump (dump_type type)
3448{
3449 int section;
3450 char * cp;
3451
3452 do_dump++;
3453 section = strtoul (optarg, & cp, 0);
3454
3455 if (! *cp && section >= 0)
3456 request_dump_bynumber (section, type);
3457 else
3458 request_dump_byname (optarg, type);
3459}
3460
3461
252b5132 3462static void
2cf0635d 3463parse_args (int argc, char ** argv)
252b5132
RH		 3464{
3465 int c;
3466
3467 if (argc < 2)
92f01d61 3468 usage (stderr);
252b5132
RH		 3469
3470 while ((c = getopt_long
cf13d699 3471 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
252b5132 3472 {
252b5132
RH		 3473 switch (c)
3474 {
3475 case 0:
3476 /* Long options. */
3477 break;
3478 case 'H':
92f01d61 3479 usage (stdout);
252b5132
RH		 3480 break;
3481
3482 case 'a':
b34976b6
AM		 3483 do_syms++;
3484 do_reloc++;
3485 do_unwind++;
3486 do_dynamic++;
3487 do_header++;
3488 do_sections++;
f5842774 3489 do_section_groups++;
b34976b6
AM		 3490 do_segments++;
3491 do_version++;
3492 do_histogram++;
3493 do_arch++;
3494 do_notes++;
252b5132 3495 break;
f5842774
L		 3496 case 'g':
3497 do_section_groups++;
3498 break;
5477e8a0 3499 case 't':
595cf52e 3500 case 'N':
5477e8a0
L		 3501 do_sections++;
3502 do_section_details++;
595cf52e 3503 break;
252b5132 3504 case 'e':
b34976b6
AM		 3505 do_header++;
3506 do_sections++;
3507 do_segments++;
252b5132 3508 break;
a952a375 3509 case 'A':
b34976b6 3510 do_arch++;
a952a375 3511 break;
252b5132 3512 case 'D':
b34976b6 3513 do_using_dynamic++;
252b5132
RH		 3514 break;
3515 case 'r':
b34976b6 3516 do_reloc++;
252b5132 3517 break;
4d6ed7c8 3518 case 'u':
b34976b6 3519 do_unwind++;
4d6ed7c8 3520 break;
252b5132 3521 case 'h':
b34976b6 3522 do_header++;
252b5132
RH		 3523 break;
3524 case 'l':
b34976b6 3525 do_segments++;
252b5132
RH		 3526 break;
3527 case 's':
b34976b6 3528 do_syms++;
252b5132
RH		 3529 break;
3530 case 'S':
b34976b6 3531 do_sections++;
252b5132
RH		 3532 break;
3533 case 'd':
b34976b6 3534 do_dynamic++;
252b5132 3535 break;
a952a375 3536 case 'I':
b34976b6 3537 do_histogram++;
a952a375 3538 break;
779fe533 3539 case 'n':
b34976b6 3540 do_notes++;
779fe533 3541 break;
4145f1d5
NC		 3542 case 'c':
3543 do_archive_index++;
3544 break;
252b5132 3545 case 'x':
cf13d699 3546 request_dump (HEX_DUMP);
aef1f6d0 3547 break;
09c11c86 3548 case 'p':
cf13d699
NC		 3549 request_dump (STRING_DUMP);
3550 break;
3551 case 'R':
3552 request_dump (RELOC_DUMP);
09c11c86 3553 break;
252b5132 3554 case 'w':
b34976b6 3555 do_dump++;
252b5132 3556 if (optarg == 0)
613ff48b
CC		 3557 {
3558 do_debugging = 1;
3559 dwarf_select_sections_all ();
3560 }
252b5132
RH		 3561 else
3562 {
3563 do_debugging = 0;
4cb93e3b 3564 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 3565 }
3566 break;
2979dc34 3567 case OPTION_DEBUG_DUMP:
b34976b6 3568 do_dump++;
2979dc34
JJ		 3569 if (optarg == 0)
3570 do_debugging = 1;
3571 else
3572 {
2979dc34 3573 do_debugging = 0;
4cb93e3b 3574 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 3575 }
3576 break;
fd2f0033
TT		 3577 case OPTION_DWARF_DEPTH:
3578 {
3579 char *cp;
3580
3581 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3582 }
3583 break;
3584 case OPTION_DWARF_START:
3585 {
3586 char *cp;
3587
3588 dwarf_start_die = strtoul (optarg, & cp, 0);
3589 }
3590 break;
4723351a
CC		 3591 case OPTION_DWARF_CHECK:
3592 dwarf_check = 1;
3593 break;
2c610e4b
L		 3594 case OPTION_DYN_SYMS:
3595 do_dyn_syms++;
3596 break;
252b5132
RH		 3597#ifdef SUPPORT_DISASSEMBLY
3598 case 'i':
cf13d699
NC		 3599 request_dump (DISASS_DUMP);
3600 break;
252b5132
RH		 3601#endif
3602 case 'v':
3603 print_version (program_name);
3604 break;
3605 case 'V':
b34976b6 3606 do_version++;
252b5132 3607 break;
d974e256 3608 case 'W':
b34976b6 3609 do_wide++;
d974e256 3610 break;
252b5132 3611 default:
252b5132
RH		 3612 /* xgettext:c-format */
3613 error (_("Invalid option '-%c'\n"), c);
3614 /* Drop through. */
3615 case '?':
92f01d61 3616 usage (stderr);
252b5132
RH		 3617 }
3618 }
3619
4d6ed7c8 3620 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 3621 && !do_segments && !do_header && !do_dump && !do_version
f5842774 3622 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 3623 && !do_section_groups && !do_archive_index
3624 && !do_dyn_syms)
92f01d61 3625 usage (stderr);
252b5132
RH		 3626 else if (argc < 3)
3627 {
3628 warn (_("Nothing to do.\n"));
92f01d61 3629 usage (stderr);
252b5132
RH		 3630 }
3631}
3632
3633static const char *
d3ba0551 3634get_elf_class (unsigned int elf_class)
252b5132 3635{
b34976b6 3636 static char buff[32];
103f02d3 3637
252b5132
RH		 3638 switch (elf_class)
3639 {
3640 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 3641 case ELFCLASS32: return "ELF32";
3642 case ELFCLASS64: return "ELF64";
ab5e7794 3643 default:
e9e44622 3644 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 3645 return buff;
252b5132
RH		 3646 }
3647}
3648
3649static const char *
d3ba0551 3650get_data_encoding (unsigned int encoding)
252b5132 3651{
b34976b6 3652 static char buff[32];
103f02d3 3653
252b5132
RH		 3654 switch (encoding)
3655 {
3656 case ELFDATANONE: return _("none");
33c63f9d
CM		 3657 case ELFDATA2LSB: return _("2's complement, little endian");
3658 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 3659 default:
e9e44622 3660 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 3661 return buff;
252b5132
RH		 3662 }
3663}
3664
252b5132 3665/* Decode the data held in 'elf_header'. */
ee42cf8c 3666
252b5132 3667static int
d3ba0551 3668process_file_header (void)
252b5132 3669{
b34976b6
AM		 3670 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3671 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3672 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3673 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 3674 {
3675 error
3676 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3677 return 0;
3678 }
3679
2dc4cec1
L		 3680 init_dwarf_regnames (elf_header.e_machine);
3681
252b5132
RH		 3682 if (do_header)
3683 {
3684 int i;
3685
3686 printf (_("ELF Header:\n"));
3687 printf (_(" Magic: "));
b34976b6
AM		 3688 for (i = 0; i < EI_NIDENT; i++)
3689 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 3690 printf ("\n");
3691 printf (_(" Class: %s\n"),
b34976b6 3692 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 3693 printf (_(" Data: %s\n"),
b34976b6 3694 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 3695 printf (_(" Version: %d %s\n"),
b34976b6
AM		 3696 elf_header.e_ident[EI_VERSION],
3697 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 3698 ? "(current)"
b34976b6 3699 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 3700 ? _("<unknown: %lx>")
789be9f7 3701 : "")));
252b5132 3702 printf (_(" OS/ABI: %s\n"),
b34976b6 3703 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 3704 printf (_(" ABI Version: %d\n"),
b34976b6 3705 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 3706 printf (_(" Type: %s\n"),
3707 get_file_type (elf_header.e_type));
3708 printf (_(" Machine: %s\n"),
3709 get_machine_name (elf_header.e_machine));
3710 printf (_(" Version: 0x%lx\n"),
3711 (unsigned long) elf_header.e_version);
76da6bbe 3712
f7a99963
NC		 3713 printf (_(" Entry point address: "));
3714 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3715 printf (_("\n Start of program headers: "));
3716 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3717 printf (_(" (bytes into file)\n Start of section headers: "));
3718 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3719 printf (_(" (bytes into file)\n"));
76da6bbe 3720
252b5132
RH		 3721 printf (_(" Flags: 0x%lx%s\n"),
3722 (unsigned long) elf_header.e_flags,
3723 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3724 printf (_(" Size of this header: %ld (bytes)\n"),
3725 (long) elf_header.e_ehsize);
3726 printf (_(" Size of program headers: %ld (bytes)\n"),
3727 (long) elf_header.e_phentsize);
2046a35d 3728 printf (_(" Number of program headers: %ld"),
252b5132 3729 (long) elf_header.e_phnum);
2046a35d
AM		 3730 if (section_headers != NULL
3731 && elf_header.e_phnum == PN_XNUM
3732 && section_headers[0].sh_info != 0)
cc5914eb 3733 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 3734 putc ('\n', stdout);
252b5132
RH		 3735 printf (_(" Size of section headers: %ld (bytes)\n"),
3736 (long) elf_header.e_shentsize);
560f3c1c 3737 printf (_(" Number of section headers: %ld"),
252b5132 3738 (long) elf_header.e_shnum);
4fbb74a6 3739 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 3740 printf (" (%ld)", (long) section_headers[0].sh_size);
3741 putc ('\n', stdout);
3742 printf (_(" Section header string table index: %ld"),
252b5132 3743 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 3744 if (section_headers != NULL
3745 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 3746 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 3747 else if (elf_header.e_shstrndx != SHN_UNDEF
3748 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 3749 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 3750 putc ('\n', stdout);
3751 }
3752
3753 if (section_headers != NULL)
3754 {
2046a35d
AM		 3755 if (elf_header.e_phnum == PN_XNUM
3756 && section_headers[0].sh_info != 0)
3757 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 3758 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 3759 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 3760 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 3761 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 3762 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 3763 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 3764 free (section_headers);
3765 section_headers = NULL;
252b5132 3766 }
103f02d3 3767
9ea033b2
NC		 3768 return 1;
3769}
3770
252b5132 3771
9ea033b2 3772static int
91d6fa6a 3773get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3774{
2cf0635d
NC		 3775 Elf32_External_Phdr * phdrs;
3776 Elf32_External_Phdr * external;
3777 Elf_Internal_Phdr * internal;
b34976b6 3778 unsigned int i;
103f02d3 3779
3f5e193b
NC		 3780 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3781 elf_header.e_phentsize,
3782 elf_header.e_phnum,
3783 _("program headers"));
a6e9f9df
AM		 3784 if (!phdrs)
3785 return 0;
9ea033b2 3786
91d6fa6a 3787 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3788 i < elf_header.e_phnum;
b34976b6 3789 i++, internal++, external++)
252b5132 3790 {
9ea033b2
NC		 3791 internal->p_type = BYTE_GET (external->p_type);
3792 internal->p_offset = BYTE_GET (external->p_offset);
3793 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3794 internal->p_paddr = BYTE_GET (external->p_paddr);
3795 internal->p_filesz = BYTE_GET (external->p_filesz);
3796 internal->p_memsz = BYTE_GET (external->p_memsz);
3797 internal->p_flags = BYTE_GET (external->p_flags);
3798 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 3799 }
3800
9ea033b2
NC		 3801 free (phdrs);
3802
252b5132
RH		 3803 return 1;
3804}
3805
9ea033b2 3806static int
91d6fa6a 3807get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3808{
2cf0635d
NC		 3809 Elf64_External_Phdr * phdrs;
3810 Elf64_External_Phdr * external;
3811 Elf_Internal_Phdr * internal;
b34976b6 3812 unsigned int i;
103f02d3 3813
3f5e193b
NC		 3814 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3815 elf_header.e_phentsize,
3816 elf_header.e_phnum,
3817 _("program headers"));
a6e9f9df
AM		 3818 if (!phdrs)
3819 return 0;
9ea033b2 3820
91d6fa6a 3821 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3822 i < elf_header.e_phnum;
b34976b6 3823 i++, internal++, external++)
9ea033b2
NC		 3824 {
3825 internal->p_type = BYTE_GET (external->p_type);
3826 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 3827 internal->p_offset = BYTE_GET (external->p_offset);
3828 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3829 internal->p_paddr = BYTE_GET (external->p_paddr);
3830 internal->p_filesz = BYTE_GET (external->p_filesz);
3831 internal->p_memsz = BYTE_GET (external->p_memsz);
3832 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 3833 }
3834
3835 free (phdrs);
3836
3837 return 1;
3838}
252b5132 3839
d93f0186
NC		 3840/* Returns 1 if the program headers were read into `program_headers'. */
3841
3842static int
2cf0635d 3843get_program_headers (FILE * file)
d93f0186 3844{
2cf0635d 3845 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 3846
3847 /* Check cache of prior read. */
3848 if (program_headers != NULL)
3849 return 1;
3850
3f5e193b
NC		 3851 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3852 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 3853
3854 if (phdrs == NULL)
3855 {
3856 error (_("Out of memory\n"));
3857 return 0;
3858 }
3859
3860 if (is_32bit_elf
3861 ? get_32bit_program_headers (file, phdrs)
3862 : get_64bit_program_headers (file, phdrs))
3863 {
3864 program_headers = phdrs;
3865 return 1;
3866 }
3867
3868 free (phdrs);
3869 return 0;
3870}
3871
2f62977e
NC		 3872/* Returns 1 if the program headers were loaded. */
3873
252b5132 3874static int
2cf0635d 3875process_program_headers (FILE * file)
252b5132 3876{
2cf0635d 3877 Elf_Internal_Phdr * segment;
b34976b6 3878 unsigned int i;
252b5132
RH		 3879
3880 if (elf_header.e_phnum == 0)
3881 {
82f2dbf7
NC		 3882 /* PR binutils/12467. */
3883 if (elf_header.e_phoff != 0)
3884 warn (_("possibly corrupt ELF header - it has a non-zero program"
3885 " header offset, but no program headers"));
3886 else if (do_segments)
252b5132 3887 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 3888 return 0;
252b5132
RH		 3889 }
3890
3891 if (do_segments && !do_header)
3892 {
f7a99963
NC		 3893 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3894 printf (_("Entry point "));
3895 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3896 printf (_("\nThere are %d program headers, starting at offset "),
3897 elf_header.e_phnum);
3898 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3899 printf ("\n");
252b5132
RH		 3900 }
3901
d93f0186 3902 if (! get_program_headers (file))
252b5132 3903 return 0;
103f02d3 3904
252b5132
RH		 3905 if (do_segments)
3906 {
3a1a2036
NC		 3907 if (elf_header.e_phnum > 1)
3908 printf (_("\nProgram Headers:\n"));
3909 else
3910 printf (_("\nProgram Headers:\n"));
76da6bbe 3911
f7a99963
NC		 3912 if (is_32bit_elf)
3913 printf
3914 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 3915 else if (do_wide)
3916 printf
3917 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 3918 else
3919 {
3920 printf
3921 (_(" Type Offset VirtAddr PhysAddr\n"));
3922 printf
3923 (_(" FileSiz MemSiz Flags Align\n"));
3924 }
252b5132
RH		 3925 }
3926
252b5132 3927 dynamic_addr = 0;
1b228002 3928 dynamic_size = 0;
252b5132
RH		 3929
3930 for (i = 0, segment = program_headers;
3931 i < elf_header.e_phnum;
b34976b6 3932 i++, segment++)
252b5132
RH		 3933 {
3934 if (do_segments)
3935 {
103f02d3 3936 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 3937
3938 if (is_32bit_elf)
3939 {
3940 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3941 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3942 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3943 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3944 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3945 printf ("%c%c%c ",
3946 (segment->p_flags & PF_R ? 'R' : ' '),
3947 (segment->p_flags & PF_W ? 'W' : ' '),
3948 (segment->p_flags & PF_X ? 'E' : ' '));
3949 printf ("%#lx", (unsigned long) segment->p_align);
3950 }
d974e256
JJ		 3951 else if (do_wide)
3952 {
3953 if ((unsigned long) segment->p_offset == segment->p_offset)
3954 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3955 else
3956 {
3957 print_vma (segment->p_offset, FULL_HEX);
3958 putchar (' ');
3959 }
3960
3961 print_vma (segment->p_vaddr, FULL_HEX);
3962 putchar (' ');
3963 print_vma (segment->p_paddr, FULL_HEX);
3964 putchar (' ');
3965
3966 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3967 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3968 else
3969 {
3970 print_vma (segment->p_filesz, FULL_HEX);
3971 putchar (' ');
3972 }
3973
3974 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3975 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3976 else
3977 {
f48e6c45 3978 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 3979 }
3980
3981 printf (" %c%c%c ",
3982 (segment->p_flags & PF_R ? 'R' : ' '),
3983 (segment->p_flags & PF_W ? 'W' : ' '),
3984 (segment->p_flags & PF_X ? 'E' : ' '));
3985
3986 if ((unsigned long) segment->p_align == segment->p_align)
3987 printf ("%#lx", (unsigned long) segment->p_align);
3988 else
3989 {
3990 print_vma (segment->p_align, PREFIX_HEX);
3991 }
3992 }
f7a99963
NC		 3993 else
3994 {
3995 print_vma (segment->p_offset, FULL_HEX);
3996 putchar (' ');
3997 print_vma (segment->p_vaddr, FULL_HEX);
3998 putchar (' ');
3999 print_vma (segment->p_paddr, FULL_HEX);
4000 printf ("\n ");
4001 print_vma (segment->p_filesz, FULL_HEX);
4002 putchar (' ');
4003 print_vma (segment->p_memsz, FULL_HEX);
4004 printf (" %c%c%c ",
4005 (segment->p_flags & PF_R ? 'R' : ' '),
4006 (segment->p_flags & PF_W ? 'W' : ' '),
4007 (segment->p_flags & PF_X ? 'E' : ' '));
4008 print_vma (segment->p_align, HEX);
4009 }
252b5132
RH		 4010 }
4011
4012 switch (segment->p_type)
4013 {
252b5132
RH		 4014 case PT_DYNAMIC:
4015 if (dynamic_addr)
4016 error (_("more than one dynamic segment\n"));
4017
20737c13
AM		 4018 /* By default, assume that the .dynamic section is the first
4019 section in the DYNAMIC segment. */
4020 dynamic_addr = segment->p_offset;
4021 dynamic_size = segment->p_filesz;
4022
b2d38a17
NC		 4023 /* Try to locate the .dynamic section. If there is
4024 a section header table, we can easily locate it. */
4025 if (section_headers != NULL)
4026 {
2cf0635d 4027 Elf_Internal_Shdr * sec;
b2d38a17 4028
89fac5e3
RS		 4029 sec = find_section (".dynamic");
4030 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4031 {
28f997cf
TG		 4032 /* A corresponding .dynamic section is expected, but on
4033 IA-64/OpenVMS it is OK for it to be missing. */
4034 if (!is_ia64_vms ())
4035 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 4036 break;
4037 }
4038
42bb2e33 4039 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 4040 {
4041 dynamic_size = 0;
4042 break;
4043 }
42bb2e33 4044
b2d38a17
NC		 4045 dynamic_addr = sec->sh_offset;
4046 dynamic_size = sec->sh_size;
4047
4048 if (dynamic_addr < segment->p_offset
4049 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 4050 warn (_("the .dynamic section is not contained"
4051 " within the dynamic segment\n"));
b2d38a17 4052 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 4053 warn (_("the .dynamic section is not the first section"
4054 " in the dynamic segment.\n"));
b2d38a17 4055 }
252b5132
RH		 4056 break;
4057
4058 case PT_INTERP:
fb52b2f4
NC		 4059 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4060 SEEK_SET))
252b5132
RH		 4061 error (_("Unable to find program interpreter name\n"));
4062 else
4063 {
f8eae8b2
L		 4064 char fmt [32];
4065 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
4066
4067 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4068 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4069
252b5132 4070 program_interpreter[0] = 0;
7bd7b3ef
AM		 4071 if (fscanf (file, fmt, program_interpreter) <= 0)
4072 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 4073
4074 if (do_segments)
4075 printf (_("\n [Requesting program interpreter: %s]"),
4076 program_interpreter);
4077 }
4078 break;
4079 }
4080
4081 if (do_segments)
4082 putc ('\n', stdout);
4083 }
4084
c256ffe7 4085 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 4086 {
4087 printf (_("\n Section to Segment mapping:\n"));
4088 printf (_(" Segment Sections...\n"));
4089
252b5132
RH		 4090 for (i = 0; i < elf_header.e_phnum; i++)
4091 {
9ad5cbcf 4092 unsigned int j;
2cf0635d 4093 Elf_Internal_Shdr * section;
252b5132
RH		 4094
4095 segment = program_headers + i;
b391a3e3 4096 section = section_headers + 1;
252b5132
RH		 4097
4098 printf (" %2.2d ", i);
4099
b34976b6 4100 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4101 {
f4638467
AM		 4102 if (!ELF_TBSS_SPECIAL (section, segment)
4103 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
252b5132
RH		 4104 printf ("%s ", SECTION_NAME (section));
4105 }
4106
4107 putc ('\n',stdout);
4108 }
4109 }
4110
252b5132
RH		 4111 return 1;
4112}
4113
4114
d93f0186
NC		 4115/* Find the file offset corresponding to VMA by using the program headers. */
4116
4117static long
2cf0635d 4118offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4119{
2cf0635d 4120 Elf_Internal_Phdr * seg;
d93f0186
NC		 4121
4122 if (! get_program_headers (file))
4123 {
4124 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4125 return (long) vma;
4126 }
4127
4128 for (seg = program_headers;
4129 seg < program_headers + elf_header.e_phnum;
4130 ++seg)
4131 {
4132 if (seg->p_type != PT_LOAD)
4133 continue;
4134
4135 if (vma >= (seg->p_vaddr & -seg->p_align)
4136 && vma + size <= seg->p_vaddr + seg->p_filesz)
4137 return vma - seg->p_vaddr + seg->p_offset;
4138 }
4139
4140 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4141 (unsigned long) vma);
d93f0186
NC		 4142 return (long) vma;
4143}
4144
4145
252b5132 4146static int
2cf0635d 4147get_32bit_section_headers (FILE * file, unsigned int num)
252b5132 4148{
2cf0635d
NC		 4149 Elf32_External_Shdr * shdrs;
4150 Elf_Internal_Shdr * internal;
b34976b6 4151 unsigned int i;
252b5132 4152
3f5e193b
NC		 4153 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4154 elf_header.e_shentsize, num,
4155 _("section headers"));
a6e9f9df
AM		 4156 if (!shdrs)
4157 return 0;
252b5132 4158
3f5e193b
NC		 4159 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4160 sizeof (Elf_Internal_Shdr));
252b5132
RH		 4161
4162 if (section_headers == NULL)
4163 {
4164 error (_("Out of memory\n"));
4165 return 0;
4166 }
4167
4168 for (i = 0, internal = section_headers;
560f3c1c 4169 i < num;
b34976b6 4170 i++, internal++)
252b5132
RH		 4171 {
4172 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4173 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4174 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4175 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4176 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4177 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4178 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4179 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4180 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4181 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4182 }
4183
4184 free (shdrs);
4185
4186 return 1;
4187}
4188
9ea033b2 4189static int
2cf0635d 4190get_64bit_section_headers (FILE * file, unsigned int num)
9ea033b2 4191{
2cf0635d
NC		 4192 Elf64_External_Shdr * shdrs;
4193 Elf_Internal_Shdr * internal;
b34976b6 4194 unsigned int i;
9ea033b2 4195
3f5e193b
NC		 4196 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4197 elf_header.e_shentsize, num,
4198 _("section headers"));
a6e9f9df
AM		 4199 if (!shdrs)
4200 return 0;
9ea033b2 4201
3f5e193b
NC		 4202 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4203 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4204
4205 if (section_headers == NULL)
4206 {
4207 error (_("Out of memory\n"));
4208 return 0;
4209 }
4210
4211 for (i = 0, internal = section_headers;
560f3c1c 4212 i < num;
b34976b6 4213 i++, internal++)
9ea033b2
NC		 4214 {
4215 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4216 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4217 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4218 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4219 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4220 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4221 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4222 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4223 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4224 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4225 }
4226
4227 free (shdrs);
4228
4229 return 1;
4230}
4231
252b5132 4232static Elf_Internal_Sym *
ba5cdace
NC		 4233get_32bit_elf_symbols (FILE * file,
4234 Elf_Internal_Shdr * section,
4235 unsigned long * num_syms_return)
252b5132 4236{
ba5cdace 4237 unsigned long number = 0;
dd24e3da 4238 Elf32_External_Sym * esyms = NULL;
ba5cdace 4239 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 4240 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4241 Elf_Internal_Sym * psym;
b34976b6 4242 unsigned int j;
252b5132 4243
dd24e3da
NC		 4244 /* Run some sanity checks first. */
4245 if (section->sh_entsize == 0)
4246 {
4247 error (_("sh_entsize is zero\n"));
ba5cdace 4248 goto exit_point;
dd24e3da
NC		 4249 }
4250
4251 number = section->sh_size / section->sh_entsize;
4252
4253 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4254 {
4255 error (_("Invalid sh_entsize\n"));
ba5cdace 4256 goto exit_point;
dd24e3da
NC		 4257 }
4258
3f5e193b
NC		 4259 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4260 section->sh_size, _("symbols"));
dd24e3da 4261 if (esyms == NULL)
ba5cdace 4262 goto exit_point;
252b5132 4263
9ad5cbcf
AM		 4264 shndx = NULL;
4265 if (symtab_shndx_hdr != NULL
4266 && (symtab_shndx_hdr->sh_link
4fbb74a6 4267 == (unsigned long) (section - section_headers)))
9ad5cbcf 4268 {
3f5e193b
NC		 4269 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4270 symtab_shndx_hdr->sh_offset,
4271 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4272 _("symbol table section indicies"));
dd24e3da
NC		 4273 if (shndx == NULL)
4274 goto exit_point;
9ad5cbcf
AM		 4275 }
4276
3f5e193b 4277 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 4278
4279 if (isyms == NULL)
4280 {
4281 error (_("Out of memory\n"));
dd24e3da 4282 goto exit_point;
252b5132
RH		 4283 }
4284
dd24e3da 4285 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 4286 {
4287 psym->st_name = BYTE_GET (esyms[j].st_name);
4288 psym->st_value = BYTE_GET (esyms[j].st_value);
4289 psym->st_size = BYTE_GET (esyms[j].st_size);
4290 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4291 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4292 psym->st_shndx
4293 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4294 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4295 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 4296 psym->st_info = BYTE_GET (esyms[j].st_info);
4297 psym->st_other = BYTE_GET (esyms[j].st_other);
4298 }
4299
dd24e3da 4300 exit_point:
ba5cdace 4301 if (shndx != NULL)
9ad5cbcf 4302 free (shndx);
ba5cdace 4303 if (esyms != NULL)
dd24e3da 4304 free (esyms);
252b5132 4305
ba5cdace
NC		 4306 if (num_syms_return != NULL)
4307 * num_syms_return = isyms == NULL ? 0 : number;
4308
252b5132
RH		 4309 return isyms;
4310}
4311
9ea033b2 4312static Elf_Internal_Sym *
ba5cdace
NC		 4313get_64bit_elf_symbols (FILE * file,
4314 Elf_Internal_Shdr * section,
4315 unsigned long * num_syms_return)
9ea033b2 4316{
ba5cdace
NC		 4317 unsigned long number = 0;
4318 Elf64_External_Sym * esyms = NULL;
4319 Elf_External_Sym_Shndx * shndx = NULL;
4320 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4321 Elf_Internal_Sym * psym;
b34976b6 4322 unsigned int j;
9ea033b2 4323
dd24e3da
NC		 4324 /* Run some sanity checks first. */
4325 if (section->sh_entsize == 0)
4326 {
4327 error (_("sh_entsize is zero\n"));
ba5cdace 4328 goto exit_point;
dd24e3da
NC		 4329 }
4330
4331 number = section->sh_size / section->sh_entsize;
4332
4333 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4334 {
4335 error (_("Invalid sh_entsize\n"));
ba5cdace 4336 goto exit_point;
dd24e3da
NC		 4337 }
4338
3f5e193b
NC		 4339 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4340 section->sh_size, _("symbols"));
a6e9f9df 4341 if (!esyms)
ba5cdace 4342 goto exit_point;
9ea033b2 4343
9ad5cbcf
AM		 4344 if (symtab_shndx_hdr != NULL
4345 && (symtab_shndx_hdr->sh_link
4fbb74a6 4346 == (unsigned long) (section - section_headers)))
9ad5cbcf 4347 {
3f5e193b
NC		 4348 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4349 symtab_shndx_hdr->sh_offset,
4350 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4351 _("symbol table section indicies"));
ba5cdace
NC		 4352 if (shndx == NULL)
4353 goto exit_point;
9ad5cbcf
AM		 4354 }
4355
3f5e193b 4356 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 4357
4358 if (isyms == NULL)
4359 {
4360 error (_("Out of memory\n"));
ba5cdace 4361 goto exit_point;
9ea033b2
NC		 4362 }
4363
ba5cdace 4364 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 4365 {
4366 psym->st_name = BYTE_GET (esyms[j].st_name);
4367 psym->st_info = BYTE_GET (esyms[j].st_info);
4368 psym->st_other = BYTE_GET (esyms[j].st_other);
4369 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 4370
4fbb74a6 4371 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4372 psym->st_shndx
4373 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4374 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4375 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 4376
66543521
AM		 4377 psym->st_value = BYTE_GET (esyms[j].st_value);
4378 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 4379 }
4380
ba5cdace
NC		 4381 exit_point:
4382 if (shndx != NULL)
9ad5cbcf 4383 free (shndx);
ba5cdace
NC		 4384 if (esyms != NULL)
4385 free (esyms);
4386
4387 if (num_syms_return != NULL)
4388 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 4389
4390 return isyms;
4391}
4392
d1133906 4393static const char *
d3ba0551 4394get_elf_section_flags (bfd_vma sh_flags)
d1133906 4395{
5477e8a0 4396 static char buff[1024];
2cf0635d 4397 char * p = buff;
8d5ff12c 4398 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 4399 int sindex;
4400 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 4401 bfd_vma os_flags = 0;
4402 bfd_vma proc_flags = 0;
4403 bfd_vma unknown_flags = 0;
148b93f2 4404 static const struct
5477e8a0 4405 {
2cf0635d 4406 const char * str;
5477e8a0
L		 4407 int len;
4408 }
4409 flags [] =
4410 {
cfcac11d
NC		 4411 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4412 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4413 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4414 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4415 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4416 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4417 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4418 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4419 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4420 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4421 /* IA-64 specific. */
4422 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4423 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4424 /* IA-64 OpenVMS specific. */
4425 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4426 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4427 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4428 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4429 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4430 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 4431 /* Generic. */
cfcac11d 4432 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 4433 /* SPARC specific. */
cfcac11d 4434 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5477e8a0
L		 4435 };
4436
4437 if (do_section_details)
4438 {
8d5ff12c
L		 4439 sprintf (buff, "[%*.*lx]: ",
4440 field_size, field_size, (unsigned long) sh_flags);
4441 p += field_size + 4;
5477e8a0 4442 }
76da6bbe 4443
d1133906
NC		 4444 while (sh_flags)
4445 {
4446 bfd_vma flag;
4447
4448 flag = sh_flags & - sh_flags;
4449 sh_flags &= ~ flag;
76da6bbe 4450
5477e8a0 4451 if (do_section_details)
d1133906 4452 {
5477e8a0
L		 4453 switch (flag)
4454 {
91d6fa6a
NC		 4455 case SHF_WRITE: sindex = 0; break;
4456 case SHF_ALLOC: sindex = 1; break;
4457 case SHF_EXECINSTR: sindex = 2; break;
4458 case SHF_MERGE: sindex = 3; break;
4459 case SHF_STRINGS: sindex = 4; break;
4460 case SHF_INFO_LINK: sindex = 5; break;
4461 case SHF_LINK_ORDER: sindex = 6; break;
4462 case SHF_OS_NONCONFORMING: sindex = 7; break;
4463 case SHF_GROUP: sindex = 8; break;
4464 case SHF_TLS: sindex = 9; break;
18ae9cc1 4465 case SHF_EXCLUDE: sindex = 18; break;
76da6bbe 4466
5477e8a0 4467 default:
91d6fa6a 4468 sindex = -1;
cfcac11d 4469 switch (elf_header.e_machine)
148b93f2 4470 {
cfcac11d 4471 case EM_IA_64:
148b93f2 4472 if (flag == SHF_IA_64_SHORT)
91d6fa6a 4473 sindex = 10;
148b93f2 4474 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 4475 sindex = 11;
148b93f2
NC		 4476#ifdef BFD64
4477 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4478 switch (flag)
4479 {
91d6fa6a
NC		 4480 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4481 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4482 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4483 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4484 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4485 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 4486 default: break;
4487 }
4488#endif
cfcac11d
NC		 4489 break;
4490
caa83f8b
NC		 4491 case EM_386:
4492 case EM_486:
4493 case EM_X86_64:
7f502d6c 4494 case EM_L1OM:
7a9068fe 4495 case EM_K1OM:
cfcac11d
NC		 4496 case EM_OLD_SPARCV9:
4497 case EM_SPARC32PLUS:
4498 case EM_SPARCV9:
4499 case EM_SPARC:
18ae9cc1 4500 if (flag == SHF_ORDERED)
91d6fa6a 4501 sindex = 19;
cfcac11d
NC		 4502 break;
4503 default:
4504 break;
148b93f2 4505 }
5477e8a0
L		 4506 }
4507
91d6fa6a 4508 if (sindex != -1)
5477e8a0 4509 {
8d5ff12c
L		 4510 if (p != buff + field_size + 4)
4511 {
4512 if (size < (10 + 2))
4513 abort ();
4514 size -= 2;
4515 *p++ = ',';
4516 *p++ = ' ';
4517 }
4518
91d6fa6a
NC		 4519 size -= flags [sindex].len;
4520 p = stpcpy (p, flags [sindex].str);
5477e8a0 4521 }
3b22753a 4522 else if (flag & SHF_MASKOS)
8d5ff12c 4523 os_flags |= flag;
d1133906 4524 else if (flag & SHF_MASKPROC)
8d5ff12c 4525 proc_flags |= flag;
d1133906 4526 else
8d5ff12c 4527 unknown_flags |= flag;
5477e8a0
L		 4528 }
4529 else
4530 {
4531 switch (flag)
4532 {
4533 case SHF_WRITE: *p = 'W'; break;
4534 case SHF_ALLOC: *p = 'A'; break;
4535 case SHF_EXECINSTR: *p = 'X'; break;
4536 case SHF_MERGE: *p = 'M'; break;
4537 case SHF_STRINGS: *p = 'S'; break;
4538 case SHF_INFO_LINK: *p = 'I'; break;
4539 case SHF_LINK_ORDER: *p = 'L'; break;
4540 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4541 case SHF_GROUP: *p = 'G'; break;
4542 case SHF_TLS: *p = 'T'; break;
18ae9cc1 4543 case SHF_EXCLUDE: *p = 'E'; break;
5477e8a0
L		 4544
4545 default:
8a9036a4 4546 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 4547 || elf_header.e_machine == EM_L1OM
4548 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 4549 && flag == SHF_X86_64_LARGE)
4550 *p = 'l';
4551 else if (flag & SHF_MASKOS)
4552 {
4553 *p = 'o';
4554 sh_flags &= ~ SHF_MASKOS;
4555 }
4556 else if (flag & SHF_MASKPROC)
4557 {
4558 *p = 'p';
4559 sh_flags &= ~ SHF_MASKPROC;
4560 }
4561 else
4562 *p = 'x';
4563 break;
4564 }
4565 p++;
d1133906
NC		 4566 }
4567 }
76da6bbe 4568
8d5ff12c
L		 4569 if (do_section_details)
4570 {
4571 if (os_flags)
4572 {
4573 size -= 5 + field_size;
4574 if (p != buff + field_size + 4)
4575 {
4576 if (size < (2 + 1))
4577 abort ();
4578 size -= 2;
4579 *p++ = ',';
4580 *p++ = ' ';
4581 }
4582 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4583 (unsigned long) os_flags);
4584 p += 5 + field_size;
4585 }
4586 if (proc_flags)
4587 {
4588 size -= 7 + field_size;
4589 if (p != buff + field_size + 4)
4590 {
4591 if (size < (2 + 1))
4592 abort ();
4593 size -= 2;
4594 *p++ = ',';
4595 *p++ = ' ';
4596 }
4597 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4598 (unsigned long) proc_flags);
4599 p += 7 + field_size;
4600 }
4601 if (unknown_flags)
4602 {
4603 size -= 10 + field_size;
4604 if (p != buff + field_size + 4)
4605 {
4606 if (size < (2 + 1))
4607 abort ();
4608 size -= 2;
4609 *p++ = ',';
4610 *p++ = ' ';
4611 }
2b692964 4612 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 4613 (unsigned long) unknown_flags);
4614 p += 10 + field_size;
4615 }
4616 }
4617
e9e44622 4618 *p = '\0';
d1133906
NC		 4619 return buff;
4620}
4621
252b5132 4622static int
2cf0635d 4623process_section_headers (FILE * file)
252b5132 4624{
2cf0635d 4625 Elf_Internal_Shdr * section;
b34976b6 4626 unsigned int i;
252b5132
RH		 4627
4628 section_headers = NULL;
4629
4630 if (elf_header.e_shnum == 0)
4631 {
82f2dbf7
NC		 4632 /* PR binutils/12467. */
4633 if (elf_header.e_shoff != 0)
4634 warn (_("possibly corrupt ELF file header - it has a non-zero"
4635 " section header offset, but no section headers\n"));
4636 else if (do_sections)
252b5132
RH		 4637 printf (_("\nThere are no sections in this file.\n"));
4638
4639 return 1;
4640 }
4641
4642 if (do_sections && !do_header)
9ea033b2 4643 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 4644 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4645
9ea033b2
NC		 4646 if (is_32bit_elf)
4647 {
560f3c1c 4648 if (! get_32bit_section_headers (file, elf_header.e_shnum))
9ea033b2
NC		 4649 return 0;
4650 }
560f3c1c 4651 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
252b5132
RH		 4652 return 0;
4653
4654 /* Read in the string table, so that we have names to display. */
0b49d371 4655 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 4656 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 4657 {
4fbb74a6 4658 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 4659
c256ffe7
JJ		 4660 if (section->sh_size != 0)
4661 {
3f5e193b
NC		 4662 string_table = (char *) get_data (NULL, file, section->sh_offset,
4663 1, section->sh_size,
4664 _("string table"));
0de14b54 4665
c256ffe7
JJ		 4666 string_table_length = string_table != NULL ? section->sh_size : 0;
4667 }
252b5132
RH		 4668 }
4669
4670 /* Scan the sections for the dynamic symbol table
e3c8793a 4671 and dynamic string table and debug sections. */
252b5132
RH		 4672 dynamic_symbols = NULL;
4673 dynamic_strings = NULL;
4674 dynamic_syminfo = NULL;
f1ef08cb 4675 symtab_shndx_hdr = NULL;
103f02d3 4676
89fac5e3
RS		 4677 eh_addr_size = is_32bit_elf ? 4 : 8;
4678 switch (elf_header.e_machine)
4679 {
4680 case EM_MIPS:
4681 case EM_MIPS_RS3_LE:
4682 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4683 FDE addresses. However, the ABI also has a semi-official ILP32
4684 variant for which the normal FDE address size rules apply.
4685
4686 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4687 section, where XX is the size of longs in bits. Unfortunately,
4688 earlier compilers provided no way of distinguishing ILP32 objects
4689 from LP64 objects, so if there's any doubt, we should assume that
4690 the official LP64 form is being used. */
4691 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4692 && find_section (".gcc_compiled_long32") == NULL)
4693 eh_addr_size = 8;
4694 break;
0f56a26a
DD		 4695
4696 case EM_H8_300:
4697 case EM_H8_300H:
4698 switch (elf_header.e_flags & EF_H8_MACH)
4699 {
4700 case E_H8_MACH_H8300:
4701 case E_H8_MACH_H8300HN:
4702 case E_H8_MACH_H8300SN:
4703 case E_H8_MACH_H8300SXN:
4704 eh_addr_size = 2;
4705 break;
4706 case E_H8_MACH_H8300H:
4707 case E_H8_MACH_H8300S:
4708 case E_H8_MACH_H8300SX:
4709 eh_addr_size = 4;
4710 break;
4711 }
f4236fe4
DD		 4712 break;
4713
ff7eeb89 4714 case EM_M32C_OLD:
f4236fe4
DD		 4715 case EM_M32C:
4716 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4717 {
4718 case EF_M32C_CPU_M16C:
4719 eh_addr_size = 2;
4720 break;
4721 }
4722 break;
89fac5e3
RS		 4723 }
4724
08d8fa11
JJ		 4725#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4726 do \
4727 { \
4728 size_t expected_entsize \
4729 = is_32bit_elf ? size32 : size64; \
4730 if (section->sh_entsize != expected_entsize) \
4731 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4732 i, (unsigned long int) section->sh_entsize, \
4733 (unsigned long int) expected_entsize); \
4734 section->sh_entsize = expected_entsize; \
4735 } \
4736 while (0)
4737#define CHECK_ENTSIZE(section, i, type) \
4738 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4739 sizeof (Elf64_External_##type))
4740
252b5132
RH		 4741 for (i = 0, section = section_headers;
4742 i < elf_header.e_shnum;
b34976b6 4743 i++, section++)
252b5132 4744 {
2cf0635d 4745 char * name = SECTION_NAME (section);
252b5132
RH		 4746
4747 if (section->sh_type == SHT_DYNSYM)
4748 {
4749 if (dynamic_symbols != NULL)
4750 {
4751 error (_("File contains multiple dynamic symbol tables\n"));
4752 continue;
4753 }
4754
08d8fa11 4755 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 4756 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 4757 }
4758 else if (section->sh_type == SHT_STRTAB
18bd398b 4759 && streq (name, ".dynstr"))
252b5132
RH		 4760 {
4761 if (dynamic_strings != NULL)
4762 {
4763 error (_("File contains multiple dynamic string tables\n"));
4764 continue;
4765 }
4766
3f5e193b
NC		 4767 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4768 1, section->sh_size,
4769 _("dynamic strings"));
59245841 4770 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 4771 }
9ad5cbcf
AM		 4772 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4773 {
4774 if (symtab_shndx_hdr != NULL)
4775 {
4776 error (_("File contains multiple symtab shndx tables\n"));
4777 continue;
4778 }
4779 symtab_shndx_hdr = section;
4780 }
08d8fa11
JJ		 4781 else if (section->sh_type == SHT_SYMTAB)
4782 CHECK_ENTSIZE (section, i, Sym);
4783 else if (section->sh_type == SHT_GROUP)
4784 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4785 else if (section->sh_type == SHT_REL)
4786 CHECK_ENTSIZE (section, i, Rel);
4787 else if (section->sh_type == SHT_RELA)
4788 CHECK_ENTSIZE (section, i, Rela);
252b5132 4789 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 4790 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 4791 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 4792 || do_debug_str || do_debug_loc || do_debug_ranges
4793 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 4794 && (const_strneq (name, ".debug_")
4795 || const_strneq (name, ".zdebug_")))
252b5132 4796 {
1b315056
CS		 4797 if (name[1] == 'z')
4798 name += sizeof (".zdebug_") - 1;
4799 else
4800 name += sizeof (".debug_") - 1;
252b5132
RH		 4801
4802 if (do_debugging
4723351a
CC		 4803 || (do_debug_info && const_strneq (name, "info"))
4804 || (do_debug_info && const_strneq (name, "types"))
4805 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
4806 || (do_debug_lines && const_strneq (name, "line"))
4807 || (do_debug_pubnames && const_strneq (name, "pubnames"))
4808 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
4809 || (do_debug_aranges && const_strneq (name, "aranges"))
4810 || (do_debug_ranges && const_strneq (name, "ranges"))
4811 || (do_debug_frames && const_strneq (name, "frame"))
4812 || (do_debug_macinfo && const_strneq (name, "macinfo"))
4813 || (do_debug_macinfo && const_strneq (name, "macro"))
4814 || (do_debug_str && const_strneq (name, "str"))
4815 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 4816 || (do_debug_addr && const_strneq (name, "addr"))
4817 || (do_debug_cu_index && const_strneq (name, "cu_index"))
4818 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 4819 )
09c11c86 4820 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 4821 }
a262ae96 4822 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 4823 else if ((do_debugging || do_debug_info)
0112cd26 4824 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 4825 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 4826 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 4827 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 4828 else if (do_gdb_index && streq (name, ".gdb_index"))
4829 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 4830 /* Trace sections for Itanium VMS. */
4831 else if ((do_debugging || do_trace_info || do_trace_abbrevs
4832 || do_trace_aranges)
4833 && const_strneq (name, ".trace_"))
4834 {
4835 name += sizeof (".trace_") - 1;
4836
4837 if (do_debugging
4838 || (do_trace_info && streq (name, "info"))
4839 || (do_trace_abbrevs && streq (name, "abbrev"))
4840 || (do_trace_aranges && streq (name, "aranges"))
4841 )
4842 request_dump_bynumber (i, DEBUG_DUMP);
4843 }
4844
252b5132
RH		 4845 }
4846
4847 if (! do_sections)
4848 return 1;
4849
3a1a2036
NC		 4850 if (elf_header.e_shnum > 1)
4851 printf (_("\nSection Headers:\n"));
4852 else
4853 printf (_("\nSection Header:\n"));
76da6bbe 4854
f7a99963 4855 if (is_32bit_elf)
595cf52e 4856 {
5477e8a0 4857 if (do_section_details)
595cf52e
L		 4858 {
4859 printf (_(" [Nr] Name\n"));
5477e8a0 4860 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 4861 }
4862 else
4863 printf
4864 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4865 }
d974e256 4866 else if (do_wide)
595cf52e 4867 {
5477e8a0 4868 if (do_section_details)
595cf52e
L		 4869 {
4870 printf (_(" [Nr] Name\n"));
5477e8a0 4871 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 4872 }
4873 else
4874 printf
4875 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4876 }
f7a99963
NC		 4877 else
4878 {
5477e8a0 4879 if (do_section_details)
595cf52e
L		 4880 {
4881 printf (_(" [Nr] Name\n"));
5477e8a0
L		 4882 printf (_(" Type Address Offset Link\n"));
4883 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 4884 }
4885 else
4886 {
4887 printf (_(" [Nr] Name Type Address Offset\n"));
4888 printf (_(" Size EntSize Flags Link Info Align\n"));
4889 }
f7a99963 4890 }
252b5132 4891
5477e8a0
L		 4892 if (do_section_details)
4893 printf (_(" Flags\n"));
4894
252b5132
RH		 4895 for (i = 0, section = section_headers;
4896 i < elf_header.e_shnum;
b34976b6 4897 i++, section++)
252b5132 4898 {
7bfd842d 4899 printf (" [%2u] ", i);
5477e8a0 4900 if (do_section_details)
595cf52e 4901 {
7bfd842d 4902 print_symbol (INT_MAX, SECTION_NAME (section));
ea52a088 4903 printf ("\n ");
595cf52e
L		 4904 }
4905 else
7bfd842d
NC		 4906 {
4907 print_symbol (-17, SECTION_NAME (section));
7bfd842d 4908 }
ea52a088
NC		 4909
4910 printf (do_wide ? " %-15s " : " %-15.15s ",
4911 get_section_type_name (section->sh_type));
4912
f7a99963
NC		 4913 if (is_32bit_elf)
4914 {
cfcac11d
NC		 4915 const char * link_too_big = NULL;
4916
f7a99963 4917 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 4918
f7a99963
NC		 4919 printf ( " %6.6lx %6.6lx %2.2lx",
4920 (unsigned long) section->sh_offset,
4921 (unsigned long) section->sh_size,
4922 (unsigned long) section->sh_entsize);
d1133906 4923
5477e8a0
L		 4924 if (do_section_details)
4925 fputs (" ", stdout);
4926 else
4927 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 4928
cfcac11d
NC		 4929 if (section->sh_link >= elf_header.e_shnum)
4930 {
4931 link_too_big = "";
4932 /* The sh_link value is out of range. Normally this indicates
caa83f8b 4933 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 4934 switch (elf_header.e_machine)
4935 {
caa83f8b
NC		 4936 case EM_386:
4937 case EM_486:
4938 case EM_X86_64:
7f502d6c 4939 case EM_L1OM:
7a9068fe 4940 case EM_K1OM:
cfcac11d
NC		 4941 case EM_OLD_SPARCV9:
4942 case EM_SPARC32PLUS:
4943 case EM_SPARCV9:
4944 case EM_SPARC:
4945 if (section->sh_link == (SHN_BEFORE & 0xffff))
4946 link_too_big = "BEFORE";
4947 else if (section->sh_link == (SHN_AFTER & 0xffff))
4948 link_too_big = "AFTER";
4949 break;
4950 default:
4951 break;
4952 }
4953 }
4954
4955 if (do_section_details)
4956 {
4957 if (link_too_big != NULL && * link_too_big)
4958 printf ("<%s> ", link_too_big);
4959 else
4960 printf ("%2u ", section->sh_link);
4961 printf ("%3u %2lu\n", section->sh_info,
4962 (unsigned long) section->sh_addralign);
4963 }
4964 else
4965 printf ("%2u %3u %2lu\n",
4966 section->sh_link,
4967 section->sh_info,
4968 (unsigned long) section->sh_addralign);
4969
4970 if (link_too_big && ! * link_too_big)
4971 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4972 i, section->sh_link);
f7a99963 4973 }
d974e256
JJ		 4974 else if (do_wide)
4975 {
4976 print_vma (section->sh_addr, LONG_HEX);
4977
4978 if ((long) section->sh_offset == section->sh_offset)
4979 printf (" %6.6lx", (unsigned long) section->sh_offset);
4980 else
4981 {
4982 putchar (' ');
4983 print_vma (section->sh_offset, LONG_HEX);
4984 }
4985
4986 if ((unsigned long) section->sh_size == section->sh_size)
4987 printf (" %6.6lx", (unsigned long) section->sh_size);
4988 else
4989 {
4990 putchar (' ');
4991 print_vma (section->sh_size, LONG_HEX);
4992 }
4993
4994 if ((unsigned long) section->sh_entsize == section->sh_entsize)
4995 printf (" %2.2lx", (unsigned long) section->sh_entsize);
4996 else
4997 {
4998 putchar (' ');
4999 print_vma (section->sh_entsize, LONG_HEX);
5000 }
5001
5477e8a0
L		 5002 if (do_section_details)
5003 fputs (" ", stdout);
5004 else
5005 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 5006
72de5009 5007 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 5008
5009 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 5010 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 5011 else
5012 {
5013 print_vma (section->sh_addralign, DEC);
5014 putchar ('\n');
5015 }
5016 }
5477e8a0 5017 else if (do_section_details)
595cf52e 5018 {
5477e8a0 5019 printf (" %-15.15s ",
595cf52e 5020 get_section_type_name (section->sh_type));
595cf52e
L		 5021 print_vma (section->sh_addr, LONG_HEX);
5022 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 5023 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 5024 else
5025 {
5026 printf (" ");
5027 print_vma (section->sh_offset, LONG_HEX);
5028 }
72de5009 5029 printf (" %u\n ", section->sh_link);
595cf52e 5030 print_vma (section->sh_size, LONG_HEX);
5477e8a0 5031 putchar (' ');
595cf52e
L		 5032 print_vma (section->sh_entsize, LONG_HEX);
5033
72de5009
AM		 5034 printf (" %-16u %lu\n",
5035 section->sh_info,
595cf52e
L		 5036 (unsigned long) section->sh_addralign);
5037 }
f7a99963
NC		 5038 else
5039 {
5040 putchar (' ');
5041 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 5042 if ((long) section->sh_offset == section->sh_offset)
5043 printf (" %8.8lx", (unsigned long) section->sh_offset);
5044 else
5045 {
5046 printf (" ");
5047 print_vma (section->sh_offset, LONG_HEX);
5048 }
f7a99963
NC		 5049 printf ("\n ");
5050 print_vma (section->sh_size, LONG_HEX);
5051 printf (" ");
5052 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 5053
d1133906 5054 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5055
72de5009
AM		 5056 printf (" %2u %3u %lu\n",
5057 section->sh_link,
5058 section->sh_info,
f7a99963
NC		 5059 (unsigned long) section->sh_addralign);
5060 }
5477e8a0
L		 5061
5062 if (do_section_details)
5063 printf (" %s\n", get_elf_section_flags (section->sh_flags));
252b5132
RH		 5064 }
5065
5477e8a0 5066 if (!do_section_details)
3dbcc61d
NC		 5067 {
5068 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 5069 || elf_header.e_machine == EM_L1OM
5070 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 5071 printf (_("Key to Flags:\n\
5072 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5073 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5074 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5075 else
5076 printf (_("Key to Flags:\n\
e3c8793a 5077 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 5078 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 5079 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3dbcc61d 5080 }
d1133906 5081
252b5132
RH		 5082 return 1;
5083}
5084
f5842774
L		 5085static const char *
5086get_group_flags (unsigned int flags)
5087{
5088 static char buff[32];
5089 switch (flags)
5090 {
220453ec
AM		 5091 case 0:
5092 return "";
5093
f5842774 5094 case GRP_COMDAT:
220453ec 5095 return "COMDAT ";
f5842774
L		 5096
5097 default:
220453ec 5098 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 5099 break;
5100 }
5101 return buff;
5102}
5103
5104static int
2cf0635d 5105process_section_groups (FILE * file)
f5842774 5106{
2cf0635d 5107 Elf_Internal_Shdr * section;
f5842774 5108 unsigned int i;
2cf0635d
NC		 5109 struct group * group;
5110 Elf_Internal_Shdr * symtab_sec;
5111 Elf_Internal_Shdr * strtab_sec;
5112 Elf_Internal_Sym * symtab;
ba5cdace 5113 unsigned long num_syms;
2cf0635d 5114 char * strtab;
c256ffe7 5115 size_t strtab_size;
d1f5c6e3
L		 5116
5117 /* Don't process section groups unless needed. */
5118 if (!do_unwind && !do_section_groups)
5119 return 1;
f5842774
L		 5120
5121 if (elf_header.e_shnum == 0)
5122 {
5123 if (do_section_groups)
82f2dbf7 5124 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 5125
5126 return 1;
5127 }
5128
5129 if (section_headers == NULL)
5130 {
5131 error (_("Section headers are not available!\n"));
fa1908fd
NC		 5132 /* PR 13622: This can happen with a corrupt ELF header. */
5133 return 0;
f5842774
L		 5134 }
5135
3f5e193b
NC		 5136 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5137 sizeof (struct group *));
e4b17d5c
L		 5138
5139 if (section_headers_groups == NULL)
5140 {
5141 error (_("Out of memory\n"));
5142 return 0;
5143 }
5144
f5842774 5145 /* Scan the sections for the group section. */
d1f5c6e3 5146 group_count = 0;
f5842774
L		 5147 for (i = 0, section = section_headers;
5148 i < elf_header.e_shnum;
5149 i++, section++)
e4b17d5c
L		 5150 if (section->sh_type == SHT_GROUP)
5151 group_count++;
5152
d1f5c6e3
L		 5153 if (group_count == 0)
5154 {
5155 if (do_section_groups)
5156 printf (_("\nThere are no section groups in this file.\n"));
5157
5158 return 1;
5159 }
5160
3f5e193b 5161 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 5162
5163 if (section_groups == NULL)
5164 {
5165 error (_("Out of memory\n"));
5166 return 0;
5167 }
5168
d1f5c6e3
L		 5169 symtab_sec = NULL;
5170 strtab_sec = NULL;
5171 symtab = NULL;
ba5cdace 5172 num_syms = 0;
d1f5c6e3 5173 strtab = NULL;
c256ffe7 5174 strtab_size = 0;
e4b17d5c
L		 5175 for (i = 0, section = section_headers, group = section_groups;
5176 i < elf_header.e_shnum;
5177 i++, section++)
f5842774
L		 5178 {
5179 if (section->sh_type == SHT_GROUP)
5180 {
2cf0635d
NC		 5181 char * name = SECTION_NAME (section);
5182 char * group_name;
5183 unsigned char * start;
5184 unsigned char * indices;
f5842774 5185 unsigned int entry, j, size;
2cf0635d
NC		 5186 Elf_Internal_Shdr * sec;
5187 Elf_Internal_Sym * sym;
f5842774
L		 5188
5189 /* Get the symbol table. */
4fbb74a6
AM		 5190 if (section->sh_link >= elf_header.e_shnum
5191 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 5192 != SHT_SYMTAB))
f5842774
L		 5193 {
5194 error (_("Bad sh_link in group section `%s'\n"), name);
5195 continue;
5196 }
d1f5c6e3
L		 5197
5198 if (symtab_sec != sec)
5199 {
5200 symtab_sec = sec;
5201 if (symtab)
5202 free (symtab);
ba5cdace 5203 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 5204 }
f5842774 5205
dd24e3da
NC		 5206 if (symtab == NULL)
5207 {
5208 error (_("Corrupt header in group section `%s'\n"), name);
5209 continue;
5210 }
5211
ba5cdace
NC		 5212 if (section->sh_info >= num_syms)
5213 {
5214 error (_("Bad sh_info in group section `%s'\n"), name);
5215 continue;
5216 }
5217
f5842774
L		 5218 sym = symtab + section->sh_info;
5219
5220 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5221 {
4fbb74a6
AM		 5222 if (sym->st_shndx == 0
5223 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 5224 {
5225 error (_("Bad sh_info in group section `%s'\n"), name);
5226 continue;
5227 }
ba2685cc 5228
4fbb74a6 5229 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 5230 strtab_sec = NULL;
5231 if (strtab)
5232 free (strtab);
f5842774 5233 strtab = NULL;
c256ffe7 5234 strtab_size = 0;
f5842774
L		 5235 }
5236 else
5237 {
5238 /* Get the string table. */
4fbb74a6 5239 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 5240 {
5241 strtab_sec = NULL;
5242 if (strtab)
5243 free (strtab);
5244 strtab = NULL;
5245 strtab_size = 0;
5246 }
5247 else if (strtab_sec
4fbb74a6 5248 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 5249 {
5250 strtab_sec = sec;
5251 if (strtab)
5252 free (strtab);
3f5e193b
NC		 5253 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5254 1, strtab_sec->sh_size,
5255 _("string table"));
c256ffe7 5256 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 5257 }
c256ffe7 5258 group_name = sym->st_name < strtab_size
2b692964 5259 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 5260 }
5261
3f5e193b
NC		 5262 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5263 1, section->sh_size,
5264 _("section data"));
59245841
NC		 5265 if (start == NULL)
5266 continue;
f5842774
L		 5267
5268 indices = start;
5269 size = (section->sh_size / section->sh_entsize) - 1;
5270 entry = byte_get (indices, 4);
5271 indices += 4;
e4b17d5c
L		 5272
5273 if (do_section_groups)
5274 {
2b692964 5275 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 5276 get_group_flags (entry), i, name, group_name, size);
ba2685cc 5277
e4b17d5c
L		 5278 printf (_(" [Index] Name\n"));
5279 }
5280
5281 group->group_index = i;
5282
f5842774
L		 5283 for (j = 0; j < size; j++)
5284 {
2cf0635d 5285 struct group_list * g;
e4b17d5c 5286
f5842774
L		 5287 entry = byte_get (indices, 4);
5288 indices += 4;
5289
4fbb74a6 5290 if (entry >= elf_header.e_shnum)
391cb864
L		 5291 {
5292 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5293 entry, i, elf_header.e_shnum - 1);
5294 continue;
5295 }
391cb864 5296
4fbb74a6 5297 if (section_headers_groups [entry] != NULL)
e4b17d5c 5298 {
d1f5c6e3
L		 5299 if (entry)
5300 {
391cb864
L		 5301 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5302 entry, i,
4fbb74a6 5303 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5304 continue;
5305 }
5306 else
5307 {
5308 /* Intel C/C++ compiler may put section 0 in a
5309 section group. We just warn it the first time
5310 and ignore it afterwards. */
5311 static int warned = 0;
5312 if (!warned)
5313 {
5314 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 5315 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5316 warned++;
5317 }
5318 }
e4b17d5c
L		 5319 }
5320
4fbb74a6 5321 section_headers_groups [entry] = group;
e4b17d5c
L		 5322
5323 if (do_section_groups)
5324 {
4fbb74a6 5325 sec = section_headers + entry;
c256ffe7 5326 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
ba2685cc
AM		 5327 }
5328
3f5e193b 5329 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 5330 g->section_index = entry;
5331 g->next = group->root;
5332 group->root = g;
f5842774
L		 5333 }
5334
f5842774
L		 5335 if (start)
5336 free (start);
e4b17d5c
L		 5337
5338 group++;
f5842774
L		 5339 }
5340 }
5341
d1f5c6e3
L		 5342 if (symtab)
5343 free (symtab);
5344 if (strtab)
5345 free (strtab);
f5842774
L		 5346 return 1;
5347}
5348
28f997cf
TG		 5349/* Data used to display dynamic fixups. */
5350
5351struct ia64_vms_dynfixup
5352{
5353 bfd_vma needed_ident; /* Library ident number. */
5354 bfd_vma needed; /* Index in the dstrtab of the library name. */
5355 bfd_vma fixup_needed; /* Index of the library. */
5356 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5357 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5358};
5359
5360/* Data used to display dynamic relocations. */
5361
5362struct ia64_vms_dynimgrela
5363{
5364 bfd_vma img_rela_cnt; /* Number of relocations. */
5365 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5366};
5367
5368/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5369 library). */
5370
5371static void
5372dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5373 const char *strtab, unsigned int strtab_sz)
5374{
5375 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5376 long i;
5377 const char *lib_name;
5378
5379 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5380 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5381 _("dynamic section image fixups"));
5382 if (!imfs)
5383 return;
5384
5385 if (fixup->needed < strtab_sz)
5386 lib_name = strtab + fixup->needed;
5387 else
5388 {
5389 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 5390 (unsigned long) fixup->needed);
28f997cf
TG		 5391 lib_name = "???";
5392 }
5393 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5394 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5395 printf
5396 (_("Seg Offset Type SymVec DataType\n"));
5397
5398 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5399 {
5400 unsigned int type;
5401 const char *rtype;
5402
5403 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5404 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5405 type = BYTE_GET (imfs [i].type);
5406 rtype = elf_ia64_reloc_type (type);
5407 if (rtype == NULL)
5408 printf (" 0x%08x ", type);
5409 else
5410 printf (" %-32s ", rtype);
5411 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5412 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5413 }
5414
5415 free (imfs);
5416}
5417
5418/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5419
5420static void
5421dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5422{
5423 Elf64_External_VMS_IMAGE_RELA *imrs;
5424 long i;
5425
5426 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5427 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 5428 _("dynamic section image relocations"));
28f997cf
TG		 5429 if (!imrs)
5430 return;
5431
5432 printf (_("\nImage relocs\n"));
5433 printf
5434 (_("Seg Offset Type Addend Seg Sym Off\n"));
5435
5436 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5437 {
5438 unsigned int type;
5439 const char *rtype;
5440
5441 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5442 printf ("%08" BFD_VMA_FMT "x ",
5443 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5444 type = BYTE_GET (imrs [i].type);
5445 rtype = elf_ia64_reloc_type (type);
5446 if (rtype == NULL)
5447 printf ("0x%08x ", type);
5448 else
5449 printf ("%-31s ", rtype);
5450 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5451 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5452 printf ("%08" BFD_VMA_FMT "x\n",
5453 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5454 }
5455
5456 free (imrs);
5457}
5458
5459/* Display IA-64 OpenVMS dynamic relocations and fixups. */
5460
5461static int
5462process_ia64_vms_dynamic_relocs (FILE *file)
5463{
5464 struct ia64_vms_dynfixup fixup;
5465 struct ia64_vms_dynimgrela imgrela;
5466 Elf_Internal_Dyn *entry;
5467 int res = 0;
5468 bfd_vma strtab_off = 0;
5469 bfd_vma strtab_sz = 0;
5470 char *strtab = NULL;
5471
5472 memset (&fixup, 0, sizeof (fixup));
5473 memset (&imgrela, 0, sizeof (imgrela));
5474
5475 /* Note: the order of the entries is specified by the OpenVMS specs. */
5476 for (entry = dynamic_section;
5477 entry < dynamic_section + dynamic_nent;
5478 entry++)
5479 {
5480 switch (entry->d_tag)
5481 {
5482 case DT_IA_64_VMS_STRTAB_OFFSET:
5483 strtab_off = entry->d_un.d_val;
5484 break;
5485 case DT_STRSZ:
5486 strtab_sz = entry->d_un.d_val;
5487 if (strtab == NULL)
5488 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5489 1, strtab_sz, _("dynamic string section"));
5490 break;
5491
5492 case DT_IA_64_VMS_NEEDED_IDENT:
5493 fixup.needed_ident = entry->d_un.d_val;
5494 break;
5495 case DT_NEEDED:
5496 fixup.needed = entry->d_un.d_val;
5497 break;
5498 case DT_IA_64_VMS_FIXUP_NEEDED:
5499 fixup.fixup_needed = entry->d_un.d_val;
5500 break;
5501 case DT_IA_64_VMS_FIXUP_RELA_CNT:
5502 fixup.fixup_rela_cnt = entry->d_un.d_val;
5503 break;
5504 case DT_IA_64_VMS_FIXUP_RELA_OFF:
5505 fixup.fixup_rela_off = entry->d_un.d_val;
5506 res++;
5507 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5508 break;
5509
5510 case DT_IA_64_VMS_IMG_RELA_CNT:
5511 imgrela.img_rela_cnt = entry->d_un.d_val;
5512 break;
5513 case DT_IA_64_VMS_IMG_RELA_OFF:
5514 imgrela.img_rela_off = entry->d_un.d_val;
5515 res++;
5516 dump_ia64_vms_dynamic_relocs (file, &imgrela);
5517 break;
5518
5519 default:
5520 break;
5521 }
5522 }
5523
5524 if (strtab != NULL)
5525 free (strtab);
5526
5527 return res;
5528}
5529
85b1c36d 5530static struct
566b0d53 5531{
2cf0635d 5532 const char * name;
566b0d53
L		 5533 int reloc;
5534 int size;
5535 int rela;
5536} dynamic_relocations [] =
5537{
5538 { "REL", DT_REL, DT_RELSZ, FALSE },
5539 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5540 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5541};
5542
252b5132 5543/* Process the reloc section. */
18bd398b 5544
252b5132 5545static int
2cf0635d 5546process_relocs (FILE * file)
252b5132 5547{
b34976b6
AM		 5548 unsigned long rel_size;
5549 unsigned long rel_offset;
252b5132
RH		 5550
5551
5552 if (!do_reloc)
5553 return 1;
5554
5555 if (do_using_dynamic)
5556 {
566b0d53 5557 int is_rela;
2cf0635d 5558 const char * name;
566b0d53
L		 5559 int has_dynamic_reloc;
5560 unsigned int i;
0de14b54 5561
566b0d53 5562 has_dynamic_reloc = 0;
252b5132 5563
566b0d53 5564 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 5565 {
566b0d53
L		 5566 is_rela = dynamic_relocations [i].rela;
5567 name = dynamic_relocations [i].name;
5568 rel_size = dynamic_info [dynamic_relocations [i].size];
5569 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 5570
566b0d53
L		 5571 has_dynamic_reloc |= rel_size;
5572
5573 if (is_rela == UNKNOWN)
aa903cfb 5574 {
566b0d53
L		 5575 if (dynamic_relocations [i].reloc == DT_JMPREL)
5576 switch (dynamic_info[DT_PLTREL])
5577 {
5578 case DT_REL:
5579 is_rela = FALSE;
5580 break;
5581 case DT_RELA:
5582 is_rela = TRUE;
5583 break;
5584 }
aa903cfb 5585 }
252b5132 5586
566b0d53
L		 5587 if (rel_size)
5588 {
5589 printf
5590 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5591 name, rel_offset, rel_size);
252b5132 5592
d93f0186
NC		 5593 dump_relocations (file,
5594 offset_from_vma (file, rel_offset, rel_size),
5595 rel_size,
566b0d53 5596 dynamic_symbols, num_dynamic_syms,
d79b3d50 5597 dynamic_strings, dynamic_strings_length, is_rela);
566b0d53 5598 }
252b5132 5599 }
566b0d53 5600
28f997cf
TG		 5601 if (is_ia64_vms ())
5602 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5603
566b0d53 5604 if (! has_dynamic_reloc)
252b5132
RH		 5605 printf (_("\nThere are no dynamic relocations in this file.\n"));
5606 }
5607 else
5608 {
2cf0635d 5609 Elf_Internal_Shdr * section;
b34976b6
AM		 5610 unsigned long i;
5611 int found = 0;
252b5132
RH		 5612
5613 for (i = 0, section = section_headers;
5614 i < elf_header.e_shnum;
b34976b6 5615 i++, section++)
252b5132
RH		 5616 {
5617 if ( section->sh_type != SHT_RELA
5618 && section->sh_type != SHT_REL)
5619 continue;
5620
5621 rel_offset = section->sh_offset;
5622 rel_size = section->sh_size;
5623
5624 if (rel_size)
5625 {
2cf0635d 5626 Elf_Internal_Shdr * strsec;
b34976b6 5627 int is_rela;
103f02d3 5628
252b5132
RH		 5629 printf (_("\nRelocation section "));
5630
5631 if (string_table == NULL)
19936277 5632 printf ("%d", section->sh_name);
252b5132 5633 else
9cf03b7e 5634 printf ("'%s'", SECTION_NAME (section));
252b5132
RH		 5635
5636 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5637 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5638
d79b3d50
NC		 5639 is_rela = section->sh_type == SHT_RELA;
5640
4fbb74a6
AM		 5641 if (section->sh_link != 0
5642 && section->sh_link < elf_header.e_shnum)
af3fc3bc 5643 {
2cf0635d
NC		 5644 Elf_Internal_Shdr * symsec;
5645 Elf_Internal_Sym * symtab;
d79b3d50 5646 unsigned long nsyms;
c256ffe7 5647 unsigned long strtablen = 0;
2cf0635d 5648 char * strtab = NULL;
57346661 5649
4fbb74a6 5650 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 5651 if (symsec->sh_type != SHT_SYMTAB
5652 && symsec->sh_type != SHT_DYNSYM)
5653 continue;
5654
ba5cdace 5655 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 5656
af3fc3bc
AM		 5657 if (symtab == NULL)
5658 continue;
252b5132 5659
4fbb74a6
AM		 5660 if (symsec->sh_link != 0
5661 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 5662 {
4fbb74a6 5663 strsec = section_headers + symsec->sh_link;
103f02d3 5664
3f5e193b
NC		 5665 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5666 1, strsec->sh_size,
5667 _("string table"));
c256ffe7
JJ		 5668 strtablen = strtab == NULL ? 0 : strsec->sh_size;
5669 }
252b5132 5670
d79b3d50
NC		 5671 dump_relocations (file, rel_offset, rel_size,
5672 symtab, nsyms, strtab, strtablen, is_rela);
5673 if (strtab)
5674 free (strtab);
5675 free (symtab);
5676 }
5677 else
5678 dump_relocations (file, rel_offset, rel_size,
5679 NULL, 0, NULL, 0, is_rela);
252b5132
RH		 5680
5681 found = 1;
5682 }
5683 }
5684
5685 if (! found)
5686 printf (_("\nThere are no relocations in this file.\n"));
5687 }
5688
5689 return 1;
5690}
5691
57346661
AM		 5692/* Process the unwind section. */
5693
4d6ed7c8
NC		 5694#include "unwind-ia64.h"
5695
5696/* An absolute address consists of a section and an offset. If the
5697 section is NULL, the offset itself is the address, otherwise, the
5698 address equals to LOAD_ADDRESS(section) + offset. */
5699
5700struct absaddr
5701 {
5702 unsigned short section;
5703 bfd_vma offset;
5704 };
5705
1949de15
L		 5706#define ABSADDR(a) \
5707 ((a).section \
5708 ? section_headers [(a).section].sh_addr + (a).offset \
5709 : (a).offset)
5710
3f5e193b
NC		 5711struct ia64_unw_table_entry
5712 {
5713 struct absaddr start;
5714 struct absaddr end;
5715 struct absaddr info;
5716 };
5717
57346661 5718struct ia64_unw_aux_info
4d6ed7c8 5719 {
3f5e193b
NC		 5720
5721 struct ia64_unw_table_entry *table; /* Unwind table. */
b34976b6 5722 unsigned long table_len; /* Length of unwind table. */
2cf0635d 5723 unsigned char * info; /* Unwind info. */
b34976b6
AM		 5724 unsigned long info_size; /* Size of unwind info. */
5725 bfd_vma info_addr; /* starting address of unwind info. */
5726 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 5727 Elf_Internal_Sym * symtab; /* The symbol table. */
b34976b6 5728 unsigned long nsyms; /* Number of symbols. */
2cf0635d 5729 char * strtab; /* The string table. */
b34976b6 5730 unsigned long strtab_size; /* Size of string table. */
4d6ed7c8
NC		 5731 };
5732
4d6ed7c8 5733static void
2cf0635d 5734find_symbol_for_address (Elf_Internal_Sym * symtab,
57346661 5735 unsigned long nsyms,
2cf0635d 5736 const char * strtab,
57346661 5737 unsigned long strtab_size,
d3ba0551 5738 struct absaddr addr,
2cf0635d
NC		 5739 const char ** symname,
5740 bfd_vma * offset)
4d6ed7c8 5741{
d3ba0551 5742 bfd_vma dist = 0x100000;
2cf0635d
NC		 5743 Elf_Internal_Sym * sym;
5744 Elf_Internal_Sym * best = NULL;
4d6ed7c8
NC		 5745 unsigned long i;
5746
0b6ae522
DJ		 5747 REMOVE_ARCH_BITS (addr.offset);
5748
57346661 5749 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4d6ed7c8 5750 {
0b6ae522
DJ		 5751 bfd_vma value = sym->st_value;
5752
5753 REMOVE_ARCH_BITS (value);
5754
4d6ed7c8
NC		 5755 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5756 && sym->st_name != 0
5757 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 5758 && addr.offset >= value
5759 && addr.offset - value < dist)
4d6ed7c8
NC		 5760 {
5761 best = sym;
0b6ae522 5762 dist = addr.offset - value;
4d6ed7c8
NC		 5763 if (!dist)
5764 break;
5765 }
5766 }
1b31d05e 5767
4d6ed7c8
NC		 5768 if (best)
5769 {
57346661 5770 *symname = (best->st_name >= strtab_size
2b692964 5771 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 5772 *offset = dist;
5773 return;
5774 }
1b31d05e 5775
4d6ed7c8
NC		 5776 *symname = NULL;
5777 *offset = addr.offset;
5778}
5779
5780static void
2cf0635d 5781dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 5782{
2cf0635d 5783 struct ia64_unw_table_entry * tp;
4d6ed7c8 5784 int in_body;
7036c0e1 5785
4d6ed7c8
NC		 5786 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5787 {
5788 bfd_vma stamp;
5789 bfd_vma offset;
2cf0635d
NC		 5790 const unsigned char * dp;
5791 const unsigned char * head;
5792 const char * procname;
4d6ed7c8 5793
57346661
AM		 5794 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5795 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 5796
5797 fputs ("\n<", stdout);
5798
5799 if (procname)
5800 {
5801 fputs (procname, stdout);
5802
5803 if (offset)
5804 printf ("+%lx", (unsigned long) offset);
5805 }
5806
5807 fputs (">: [", stdout);
5808 print_vma (tp->start.offset, PREFIX_HEX);
5809 fputc ('-', stdout);
5810 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 5811 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 5812 (unsigned long) (tp->info.offset - aux->seg_base));
5813
1949de15 5814 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 5815 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 5816
86f55779 5817 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 5818 (unsigned) UNW_VER (stamp),
5819 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5820 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5821 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 5822 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 5823
5824 if (UNW_VER (stamp) != 1)
5825 {
2b692964 5826 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 5827 continue;
5828 }
5829
5830 in_body = 0;
89fac5e3 5831 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
4d6ed7c8
NC		 5832 dp = unw_decode (dp, in_body, & in_body);
5833 }
5834}
5835
5836static int
2cf0635d
NC		 5837slurp_ia64_unwind_table (FILE * file,
5838 struct ia64_unw_aux_info * aux,
5839 Elf_Internal_Shdr * sec)
4d6ed7c8 5840{
89fac5e3 5841 unsigned long size, nrelas, i;
2cf0635d
NC		 5842 Elf_Internal_Phdr * seg;
5843 struct ia64_unw_table_entry * tep;
5844 Elf_Internal_Shdr * relsec;
5845 Elf_Internal_Rela * rela;
5846 Elf_Internal_Rela * rp;
5847 unsigned char * table;
5848 unsigned char * tp;
5849 Elf_Internal_Sym * sym;
5850 const char * relname;
4d6ed7c8 5851
4d6ed7c8
NC		 5852 /* First, find the starting address of the segment that includes
5853 this section: */
5854
5855 if (elf_header.e_phnum)
5856 {
d93f0186 5857 if (! get_program_headers (file))
4d6ed7c8 5858 return 0;
4d6ed7c8 5859
d93f0186
NC		 5860 for (seg = program_headers;
5861 seg < program_headers + elf_header.e_phnum;
5862 ++seg)
4d6ed7c8
NC		 5863 {
5864 if (seg->p_type != PT_LOAD)
5865 continue;
5866
5867 if (sec->sh_addr >= seg->p_vaddr
5868 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5869 {
5870 aux->seg_base = seg->p_vaddr;
5871 break;
5872 }
5873 }
4d6ed7c8
NC		 5874 }
5875
5876 /* Second, build the unwind table from the contents of the unwind section: */
5877 size = sec->sh_size;
3f5e193b
NC		 5878 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5879 _("unwind table"));
a6e9f9df
AM		 5880 if (!table)
5881 return 0;
4d6ed7c8 5882
3f5e193b
NC		 5883 aux->table = (struct ia64_unw_table_entry *)
5884 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
89fac5e3 5885 tep = aux->table;
c6a0c689 5886 for (tp = table; tp < table + size; ++tep)
4d6ed7c8
NC		 5887 {
5888 tep->start.section = SHN_UNDEF;
5889 tep->end.section = SHN_UNDEF;
5890 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 5891 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5892 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5893 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 5894 tep->start.offset += aux->seg_base;
5895 tep->end.offset += aux->seg_base;
5896 tep->info.offset += aux->seg_base;
5897 }
5898 free (table);
5899
41e92641 5900 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 5901 for (relsec = section_headers;
5902 relsec < section_headers + elf_header.e_shnum;
5903 ++relsec)
5904 {
5905 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 5906 || relsec->sh_info >= elf_header.e_shnum
5907 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 5908 continue;
5909
5910 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5911 & rela, & nrelas))
5912 return 0;
5913
5914 for (rp = rela; rp < rela + nrelas; ++rp)
5915 {
aca88567
NC		 5916 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5917 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 5918
0112cd26 5919 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 5920 {
e5fb9629 5921 warn (_("Skipping unexpected relocation type %s\n"), relname);
4d6ed7c8
NC		 5922 continue;
5923 }
5924
89fac5e3 5925 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 5926
89fac5e3 5927 switch (rp->r_offset/eh_addr_size % 3)
4d6ed7c8
NC		 5928 {
5929 case 0:
5930 aux->table[i].start.section = sym->st_shndx;
e466bc6e 5931 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5932 break;
5933 case 1:
5934 aux->table[i].end.section = sym->st_shndx;
e466bc6e 5935 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5936 break;
5937 case 2:
5938 aux->table[i].info.section = sym->st_shndx;
e466bc6e 5939 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5940 break;
5941 default:
5942 break;
5943 }
5944 }
5945
5946 free (rela);
5947 }
5948
89fac5e3 5949 aux->table_len = size / (3 * eh_addr_size);
4d6ed7c8
NC		 5950 return 1;
5951}
5952
1b31d05e 5953static void
2cf0635d 5954ia64_process_unwind (FILE * file)
4d6ed7c8 5955{
2cf0635d
NC		 5956 Elf_Internal_Shdr * sec;
5957 Elf_Internal_Shdr * unwsec = NULL;
5958 Elf_Internal_Shdr * strsec;
89fac5e3 5959 unsigned long i, unwcount = 0, unwstart = 0;
57346661 5960 struct ia64_unw_aux_info aux;
f1467e33 5961
4d6ed7c8
NC		 5962 memset (& aux, 0, sizeof (aux));
5963
4d6ed7c8
NC		 5964 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5965 {
c256ffe7 5966 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 5967 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 5968 {
ba5cdace 5969 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 5970
4fbb74a6 5971 strsec = section_headers + sec->sh_link;
59245841 5972 assert (aux.strtab == NULL);
3f5e193b
NC		 5973 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5974 1, strsec->sh_size,
5975 _("string table"));
c256ffe7 5976 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 5977 }
5978 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 5979 unwcount++;
5980 }
5981
5982 if (!unwcount)
5983 printf (_("\nThere are no unwind sections in this file.\n"));
5984
5985 while (unwcount-- > 0)
5986 {
2cf0635d 5987 char * suffix;
579f31ac
JJ		 5988 size_t len, len2;
5989
5990 for (i = unwstart, sec = section_headers + unwstart;
5991 i < elf_header.e_shnum; ++i, ++sec)
5992 if (sec->sh_type == SHT_IA_64_UNWIND)
5993 {
5994 unwsec = sec;
5995 break;
5996 }
5997
5998 unwstart = i + 1;
5999 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6000
e4b17d5c
L		 6001 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6002 {
6003 /* We need to find which section group it is in. */
2cf0635d 6004 struct group_list * g = section_headers_groups [i]->root;
e4b17d5c
L		 6005
6006 for (; g != NULL; g = g->next)
6007 {
4fbb74a6 6008 sec = section_headers + g->section_index;
18bd398b
NC		 6009
6010 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
57346661 6011 break;
e4b17d5c
L		 6012 }
6013
6014 if (g == NULL)
6015 i = elf_header.e_shnum;
6016 }
18bd398b 6017 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 6018 {
18bd398b 6019 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 6020 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6021 suffix = SECTION_NAME (unwsec) + len;
6022 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6023 ++i, ++sec)
18bd398b
NC		 6024 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6025 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6026 break;
6027 }
6028 else
6029 {
6030 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 6031 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 6032 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6033 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6034 suffix = "";
18bd398b 6035 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 6036 suffix = SECTION_NAME (unwsec) + len;
6037 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6038 ++i, ++sec)
18bd398b
NC		 6039 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6040 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 6041 break;
6042 }
6043
6044 if (i == elf_header.e_shnum)
6045 {
6046 printf (_("\nCould not find unwind info section for "));
6047
6048 if (string_table == NULL)
6049 printf ("%d", unwsec->sh_name);
6050 else
3a1a2036 6051 printf (_("'%s'"), SECTION_NAME (unwsec));
579f31ac
JJ		 6052 }
6053 else
4d6ed7c8 6054 {
4d6ed7c8 6055 aux.info_addr = sec->sh_addr;
3f5e193b 6056 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
59245841 6057 sec->sh_size,
3f5e193b 6058 _("unwind info"));
59245841 6059 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 6060
579f31ac 6061 printf (_("\nUnwind section "));
4d6ed7c8 6062
579f31ac
JJ		 6063 if (string_table == NULL)
6064 printf ("%d", unwsec->sh_name);
6065 else
3a1a2036 6066 printf (_("'%s'"), SECTION_NAME (unwsec));
4d6ed7c8 6067
579f31ac 6068 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 6069 (unsigned long) unwsec->sh_offset,
89fac5e3 6070 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 6071
579f31ac 6072 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4d6ed7c8 6073
579f31ac
JJ		 6074 if (aux.table_len > 0)
6075 dump_ia64_unwind (& aux);
6076
6077 if (aux.table)
6078 free ((char *) aux.table);
6079 if (aux.info)
6080 free ((char *) aux.info);
6081 aux.table = NULL;
6082 aux.info = NULL;
6083 }
4d6ed7c8 6084 }
4d6ed7c8 6085
4d6ed7c8
NC		 6086 if (aux.symtab)
6087 free (aux.symtab);
6088 if (aux.strtab)
6089 free ((char *) aux.strtab);
4d6ed7c8
NC		 6090}
6091
3f5e193b
NC		 6092struct hppa_unw_table_entry
6093 {
6094 struct absaddr start;
6095 struct absaddr end;
6096 unsigned int Cannot_unwind:1; /* 0 */
6097 unsigned int Millicode:1; /* 1 */
6098 unsigned int Millicode_save_sr0:1; /* 2 */
6099 unsigned int Region_description:2; /* 3..4 */
6100 unsigned int reserved1:1; /* 5 */
6101 unsigned int Entry_SR:1; /* 6 */
6102 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
6103 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
6104 unsigned int Args_stored:1; /* 16 */
6105 unsigned int Variable_Frame:1; /* 17 */
6106 unsigned int Separate_Package_Body:1; /* 18 */
6107 unsigned int Frame_Extension_Millicode:1; /* 19 */
6108 unsigned int Stack_Overflow_Check:1; /* 20 */
6109 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
6110 unsigned int Ada_Region:1; /* 22 */
6111 unsigned int cxx_info:1; /* 23 */
6112 unsigned int cxx_try_catch:1; /* 24 */
6113 unsigned int sched_entry_seq:1; /* 25 */
6114 unsigned int reserved2:1; /* 26 */
6115 unsigned int Save_SP:1; /* 27 */
6116 unsigned int Save_RP:1; /* 28 */
6117 unsigned int Save_MRP_in_frame:1; /* 29 */
6118 unsigned int extn_ptr_defined:1; /* 30 */
6119 unsigned int Cleanup_defined:1; /* 31 */
6120
6121 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
6122 unsigned int HP_UX_interrupt_marker:1; /* 1 */
6123 unsigned int Large_frame:1; /* 2 */
6124 unsigned int Pseudo_SP_Set:1; /* 3 */
6125 unsigned int reserved4:1; /* 4 */
6126 unsigned int Total_frame_size:27; /* 5..31 */
6127 };
6128
57346661
AM		 6129struct hppa_unw_aux_info
6130 {
3f5e193b 6131 struct hppa_unw_table_entry *table; /* Unwind table. */
57346661
AM		 6132 unsigned long table_len; /* Length of unwind table. */
6133 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 6134 Elf_Internal_Sym * symtab; /* The symbol table. */
57346661 6135 unsigned long nsyms; /* Number of symbols. */
2cf0635d 6136 char * strtab; /* The string table. */
57346661
AM		 6137 unsigned long strtab_size; /* Size of string table. */
6138 };
6139
6140static void
2cf0635d 6141dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 6142{
2cf0635d 6143 struct hppa_unw_table_entry * tp;
57346661 6144
57346661
AM		 6145 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6146 {
6147 bfd_vma offset;
2cf0635d 6148 const char * procname;
57346661
AM		 6149
6150 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6151 aux->strtab_size, tp->start, &procname,
6152 &offset);
6153
6154 fputs ("\n<", stdout);
6155
6156 if (procname)
6157 {
6158 fputs (procname, stdout);
6159
6160 if (offset)
6161 printf ("+%lx", (unsigned long) offset);
6162 }
6163
6164 fputs (">: [", stdout);
6165 print_vma (tp->start.offset, PREFIX_HEX);
6166 fputc ('-', stdout);
6167 print_vma (tp->end.offset, PREFIX_HEX);
6168 printf ("]\n\t");
6169
18bd398b
NC		 6170#define PF(_m) if (tp->_m) printf (#_m " ");
6171#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 6172 PF(Cannot_unwind);
6173 PF(Millicode);
6174 PF(Millicode_save_sr0);
18bd398b 6175 /* PV(Region_description); */
57346661
AM		 6176 PF(Entry_SR);
6177 PV(Entry_FR);
6178 PV(Entry_GR);
6179 PF(Args_stored);
6180 PF(Variable_Frame);
6181 PF(Separate_Package_Body);
6182 PF(Frame_Extension_Millicode);
6183 PF(Stack_Overflow_Check);
6184 PF(Two_Instruction_SP_Increment);
6185 PF(Ada_Region);
6186 PF(cxx_info);
6187 PF(cxx_try_catch);
6188 PF(sched_entry_seq);
6189 PF(Save_SP);
6190 PF(Save_RP);
6191 PF(Save_MRP_in_frame);
6192 PF(extn_ptr_defined);
6193 PF(Cleanup_defined);
6194 PF(MPE_XL_interrupt_marker);
6195 PF(HP_UX_interrupt_marker);
6196 PF(Large_frame);
6197 PF(Pseudo_SP_Set);
6198 PV(Total_frame_size);
6199#undef PF
6200#undef PV
6201 }
6202
18bd398b 6203 printf ("\n");
57346661
AM		 6204}
6205
6206static int
2cf0635d
NC		 6207slurp_hppa_unwind_table (FILE * file,
6208 struct hppa_unw_aux_info * aux,
6209 Elf_Internal_Shdr * sec)
57346661 6210{
1c0751b2 6211 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 6212 Elf_Internal_Phdr * seg;
6213 struct hppa_unw_table_entry * tep;
6214 Elf_Internal_Shdr * relsec;
6215 Elf_Internal_Rela * rela;
6216 Elf_Internal_Rela * rp;
6217 unsigned char * table;
6218 unsigned char * tp;
6219 Elf_Internal_Sym * sym;
6220 const char * relname;
57346661 6221
57346661
AM		 6222 /* First, find the starting address of the segment that includes
6223 this section. */
6224
6225 if (elf_header.e_phnum)
6226 {
6227 if (! get_program_headers (file))
6228 return 0;
6229
6230 for (seg = program_headers;
6231 seg < program_headers + elf_header.e_phnum;
6232 ++seg)
6233 {
6234 if (seg->p_type != PT_LOAD)
6235 continue;
6236
6237 if (sec->sh_addr >= seg->p_vaddr
6238 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6239 {
6240 aux->seg_base = seg->p_vaddr;
6241 break;
6242 }
6243 }
6244 }
6245
6246 /* Second, build the unwind table from the contents of the unwind
6247 section. */
6248 size = sec->sh_size;
3f5e193b
NC		 6249 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6250 _("unwind table"));
57346661
AM		 6251 if (!table)
6252 return 0;
6253
1c0751b2
DA		 6254 unw_ent_size = 16;
6255 nentries = size / unw_ent_size;
6256 size = unw_ent_size * nentries;
57346661 6257
3f5e193b
NC		 6258 tep = aux->table = (struct hppa_unw_table_entry *)
6259 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 6260
1c0751b2 6261 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 6262 {
6263 unsigned int tmp1, tmp2;
6264
6265 tep->start.section = SHN_UNDEF;
6266 tep->end.section = SHN_UNDEF;
6267
1c0751b2
DA		 6268 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6269 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6270 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6271 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6272
6273 tep->start.offset += aux->seg_base;
6274 tep->end.offset += aux->seg_base;
57346661
AM		 6275
6276 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6277 tep->Millicode = (tmp1 >> 30) & 0x1;
6278 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6279 tep->Region_description = (tmp1 >> 27) & 0x3;
6280 tep->reserved1 = (tmp1 >> 26) & 0x1;
6281 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6282 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6283 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6284 tep->Args_stored = (tmp1 >> 15) & 0x1;
6285 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6286 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6287 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6288 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6289 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6290 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6291 tep->cxx_info = (tmp1 >> 8) & 0x1;
6292 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6293 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6294 tep->reserved2 = (tmp1 >> 5) & 0x1;
6295 tep->Save_SP = (tmp1 >> 4) & 0x1;
6296 tep->Save_RP = (tmp1 >> 3) & 0x1;
6297 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6298 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6299 tep->Cleanup_defined = tmp1 & 0x1;
6300
6301 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6302 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6303 tep->Large_frame = (tmp2 >> 29) & 0x1;
6304 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6305 tep->reserved4 = (tmp2 >> 27) & 0x1;
6306 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 6307 }
6308 free (table);
6309
6310 /* Third, apply any relocations to the unwind table. */
57346661
AM		 6311 for (relsec = section_headers;
6312 relsec < section_headers + elf_header.e_shnum;
6313 ++relsec)
6314 {
6315 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6316 || relsec->sh_info >= elf_header.e_shnum
6317 || section_headers + relsec->sh_info != sec)
57346661
AM		 6318 continue;
6319
6320 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6321 & rela, & nrelas))
6322 return 0;
6323
6324 for (rp = rela; rp < rela + nrelas; ++rp)
6325 {
aca88567
NC		 6326 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6327 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 6328
6329 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 6330 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 6331 {
6332 warn (_("Skipping unexpected relocation type %s\n"), relname);
6333 continue;
6334 }
6335
6336 i = rp->r_offset / unw_ent_size;
6337
89fac5e3 6338 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 6339 {
6340 case 0:
6341 aux->table[i].start.section = sym->st_shndx;
1e456d54 6342 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 6343 break;
6344 case 1:
6345 aux->table[i].end.section = sym->st_shndx;
1e456d54 6346 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 6347 break;
6348 default:
6349 break;
6350 }
6351 }
6352
6353 free (rela);
6354 }
6355
1c0751b2 6356 aux->table_len = nentries;
57346661
AM		 6357
6358 return 1;
6359}
6360
1b31d05e 6361static void
2cf0635d 6362hppa_process_unwind (FILE * file)
57346661 6363{
57346661 6364 struct hppa_unw_aux_info aux;
2cf0635d
NC		 6365 Elf_Internal_Shdr * unwsec = NULL;
6366 Elf_Internal_Shdr * strsec;
6367 Elf_Internal_Shdr * sec;
18bd398b 6368 unsigned long i;
57346661 6369
c256ffe7 6370 if (string_table == NULL)
1b31d05e
NC		 6371 return;
6372
6373 memset (& aux, 0, sizeof (aux));
57346661
AM		 6374
6375 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6376 {
c256ffe7 6377 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6378 && sec->sh_link < elf_header.e_shnum)
57346661 6379 {
ba5cdace 6380 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 6381
4fbb74a6 6382 strsec = section_headers + sec->sh_link;
59245841 6383 assert (aux.strtab == NULL);
3f5e193b
NC		 6384 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6385 1, strsec->sh_size,
6386 _("string table"));
c256ffe7 6387 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 6388 }
18bd398b 6389 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 6390 unwsec = sec;
6391 }
6392
6393 if (!unwsec)
6394 printf (_("\nThere are no unwind sections in this file.\n"));
6395
6396 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6397 {
18bd398b 6398 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 6399 {
57346661
AM		 6400 printf (_("\nUnwind section "));
6401 printf (_("'%s'"), SECTION_NAME (sec));
6402
6403 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6404 (unsigned long) sec->sh_offset,
89fac5e3 6405 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 6406
6407 slurp_hppa_unwind_table (file, &aux, sec);
6408 if (aux.table_len > 0)
6409 dump_hppa_unwind (&aux);
6410
6411 if (aux.table)
6412 free ((char *) aux.table);
6413 aux.table = NULL;
6414 }
6415 }
6416
6417 if (aux.symtab)
6418 free (aux.symtab);
6419 if (aux.strtab)
6420 free ((char *) aux.strtab);
57346661
AM		 6421}
6422
0b6ae522
DJ		 6423struct arm_section
6424{
a734115a
NC		 6425 unsigned char * data; /* The unwind data. */
6426 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
6427 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
6428 unsigned long nrelas; /* The number of relocations. */
6429 unsigned int rel_type; /* REL or RELA ? */
6430 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 6431};
6432
6433struct arm_unw_aux_info
6434{
a734115a
NC		 6435 FILE * file; /* The file containing the unwind sections. */
6436 Elf_Internal_Sym * symtab; /* The file's symbol table. */
6437 unsigned long nsyms; /* Number of symbols. */
6438 char * strtab; /* The file's string table. */
6439 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 6440};
6441
6442static const char *
6443arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6444 bfd_vma fn, struct absaddr addr)
6445{
6446 const char *procname;
6447 bfd_vma sym_offset;
6448
6449 if (addr.section == SHN_UNDEF)
6450 addr.offset = fn;
6451
6452 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6453 aux->strtab_size, addr, &procname,
6454 &sym_offset);
6455
6456 print_vma (fn, PREFIX_HEX);
6457
6458 if (procname)
6459 {
6460 fputs (" <", stdout);
6461 fputs (procname, stdout);
6462
6463 if (sym_offset)
6464 printf ("+0x%lx", (unsigned long) sym_offset);
6465 fputc ('>', stdout);
6466 }
6467
6468 return procname;
6469}
6470
6471static void
6472arm_free_section (struct arm_section *arm_sec)
6473{
6474 if (arm_sec->data != NULL)
6475 free (arm_sec->data);
6476
6477 if (arm_sec->rela != NULL)
6478 free (arm_sec->rela);
6479}
6480
a734115a
NC		 6481/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6482 cached section and install SEC instead.
6483 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6484 and return its valued in * WORDP, relocating if necessary.
1b31d05e 6485 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 6486 relocation's offset in ADDR.
1b31d05e
NC		 6487 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6488 into the string table of the symbol associated with the reloc. If no
6489 reloc was applied store -1 there.
6490 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 6491
6492static bfd_boolean
1b31d05e
NC		 6493get_unwind_section_word (struct arm_unw_aux_info * aux,
6494 struct arm_section * arm_sec,
6495 Elf_Internal_Shdr * sec,
6496 bfd_vma word_offset,
6497 unsigned int * wordp,
6498 struct absaddr * addr,
6499 bfd_vma * sym_name)
0b6ae522
DJ		 6500{
6501 Elf_Internal_Rela *rp;
6502 Elf_Internal_Sym *sym;
6503 const char * relname;
6504 unsigned int word;
6505 bfd_boolean wrapped;
6506
6507 addr->section = SHN_UNDEF;
6508 addr->offset = 0;
6509
1b31d05e
NC		 6510 if (sym_name != NULL)
6511 *sym_name = (bfd_vma) -1;
6512
a734115a 6513 /* If necessary, update the section cache. */
0b6ae522
DJ		 6514 if (sec != arm_sec->sec)
6515 {
6516 Elf_Internal_Shdr *relsec;
6517
6518 arm_free_section (arm_sec);
6519
6520 arm_sec->sec = sec;
6521 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6522 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 6523 arm_sec->rela = NULL;
6524 arm_sec->nrelas = 0;
6525
6526 for (relsec = section_headers;
6527 relsec < section_headers + elf_header.e_shnum;
6528 ++relsec)
6529 {
6530 if (relsec->sh_info >= elf_header.e_shnum
6531 || section_headers + relsec->sh_info != sec)
6532 continue;
6533
a734115a 6534 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 6535 if (relsec->sh_type == SHT_REL)
6536 {
6537 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6538 relsec->sh_size,
6539 & arm_sec->rela, & arm_sec->nrelas))
a734115a 6540 return FALSE;
0b6ae522
DJ		 6541 break;
6542 }
6543 else if (relsec->sh_type == SHT_RELA)
6544 {
6545 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6546 relsec->sh_size,
6547 & arm_sec->rela, & arm_sec->nrelas))
a734115a 6548 return FALSE;
0b6ae522
DJ		 6549 break;
6550 }
a734115a
NC		 6551 else
6552 warn (_("unexpected relocation type (%d) for section %d"),
6553 relsec->sh_type, relsec->sh_info);
0b6ae522
DJ		 6554 }
6555
6556 arm_sec->next_rela = arm_sec->rela;
6557 }
6558
a734115a 6559 /* If there is no unwind data we can do nothing. */
0b6ae522 6560 if (arm_sec->data == NULL)
a734115a 6561 return FALSE;
0b6ae522 6562
a734115a 6563 /* Get the word at the required offset. */
0b6ae522
DJ		 6564 word = byte_get (arm_sec->data + word_offset, 4);
6565
a734115a 6566 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 6567 wrapped = FALSE;
6568 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6569 {
6570 bfd_vma prelval, offset;
6571
6572 if (rp->r_offset > word_offset && !wrapped)
6573 {
6574 rp = arm_sec->rela;
6575 wrapped = TRUE;
6576 }
6577 if (rp->r_offset > word_offset)
6578 break;
6579
6580 if (rp->r_offset & 3)
6581 {
6582 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6583 (unsigned long) rp->r_offset);
6584 continue;
6585 }
6586
6587 if (rp->r_offset < word_offset)
6588 continue;
6589
0b6ae522
DJ		 6590 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6591
6592 if (arm_sec->rel_type == SHT_REL)
6593 {
6594 offset = word & 0x7fffffff;
6595 if (offset & 0x40000000)
6596 offset |= ~ (bfd_vma) 0x7fffffff;
6597 }
a734115a 6598 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 6599 offset = rp->r_addend;
a734115a
NC		 6600 else
6601 abort ();
0b6ae522
DJ		 6602
6603 offset += sym->st_value;
6604 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6605
a734115a
NC		 6606 /* Check that we are processing the expected reloc type. */
6607 if (elf_header.e_machine == EM_ARM)
6608 {
6609 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6610
6611 if (streq (relname, "R_ARM_NONE"))
6612 continue;
6613
6614 if (! streq (relname, "R_ARM_PREL31"))
6615 {
6616 warn (_("Skipping unexpected relocation type %s\n"), relname);
6617 continue;
6618 }
6619 }
6620 else if (elf_header.e_machine == EM_TI_C6000)
6621 {
6622 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6623
6624 if (streq (relname, "R_C6000_NONE"))
6625 continue;
6626
6627 if (! streq (relname, "R_C6000_PREL31"))
6628 {
6629 warn (_("Skipping unexpected relocation type %s\n"), relname);
6630 continue;
6631 }
6632
6633 prelval >>= 1;
6634 }
6635 else
6636 /* This function currently only supports ARM and TI unwinders. */
6637 abort ();
fa197c1c 6638
0b6ae522
DJ		 6639 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6640 addr->section = sym->st_shndx;
6641 addr->offset = offset;
1b31d05e
NC		 6642 if (sym_name)
6643 * sym_name = sym->st_name;
0b6ae522
DJ		 6644 break;
6645 }
6646
6647 *wordp = word;
6648 arm_sec->next_rela = rp;
6649
a734115a 6650 return TRUE;
0b6ae522
DJ		 6651}
6652
a734115a
NC		 6653static const char *tic6x_unwind_regnames[16] =
6654{
6655 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6656 "A14", "A13", "A12", "A11", "A10",
6657 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6658};
fa197c1c 6659
0b6ae522 6660static void
fa197c1c 6661decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 6662{
fa197c1c
PB		 6663 int i;
6664
6665 for (i = 12; mask; mask >>= 1, i--)
6666 {
6667 if (mask & 1)
6668 {
6669 fputs (tic6x_unwind_regnames[i], stdout);
6670 if (mask > 1)
6671 fputs (", ", stdout);
6672 }
6673 }
6674}
0b6ae522
DJ		 6675
6676#define ADVANCE \
6677 if (remaining == 0 && more_words) \
6678 { \
6679 data_offset += 4; \
1b31d05e
NC		 6680 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
6681 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 6682 return; \
6683 remaining = 4; \
6684 more_words--; \
6685 } \
6686
6687#define GET_OP(OP) \
6688 ADVANCE; \
6689 if (remaining) \
6690 { \
6691 remaining--; \
6692 (OP) = word >> 24; \
6693 word <<= 8; \
6694 } \
6695 else \
6696 { \
2b692964 6697 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 6698 return; \
6699 } \
cc5914eb 6700 printf ("0x%02x ", OP)
0b6ae522 6701
fa197c1c
PB		 6702static void
6703decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
6704 unsigned int word, unsigned int remaining,
6705 unsigned int more_words,
6706 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6707 struct arm_section *data_arm_sec)
6708{
6709 struct absaddr addr;
0b6ae522
DJ		 6710
6711 /* Decode the unwinding instructions. */
6712 while (1)
6713 {
6714 unsigned int op, op2;
6715
6716 ADVANCE;
6717 if (remaining == 0)
6718 break;
6719 remaining--;
6720 op = word >> 24;
6721 word <<= 8;
6722
cc5914eb 6723 printf (" 0x%02x ", op);
0b6ae522
DJ		 6724
6725 if ((op & 0xc0) == 0x00)
6726 {
6727 int offset = ((op & 0x3f) << 2) + 4;
61865e30 6728
cc5914eb 6729 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 6730 }
6731 else if ((op & 0xc0) == 0x40)
6732 {
6733 int offset = ((op & 0x3f) << 2) + 4;
61865e30 6734
cc5914eb 6735 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 6736 }
6737 else if ((op & 0xf0) == 0x80)
6738 {
6739 GET_OP (op2);
6740 if (op == 0x80 && op2 == 0)
6741 printf (_("Refuse to unwind"));
6742 else
6743 {
6744 unsigned int mask = ((op & 0x0f) << 8) | op2;
6745 int first = 1;
6746 int i;
2b692964 6747
0b6ae522
DJ		 6748 printf ("pop {");
6749 for (i = 0; i < 12; i++)
6750 if (mask & (1 << i))
6751 {
6752 if (first)
6753 first = 0;
6754 else
6755 printf (", ");
6756 printf ("r%d", 4 + i);
6757 }
6758 printf ("}");
6759 }
6760 }
6761 else if ((op & 0xf0) == 0x90)
6762 {
6763 if (op == 0x9d || op == 0x9f)
6764 printf (_(" [Reserved]"));
6765 else
cc5914eb 6766 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 6767 }
6768 else if ((op & 0xf0) == 0xa0)
6769 {
6770 int end = 4 + (op & 0x07);
6771 int first = 1;
6772 int i;
61865e30 6773
0b6ae522
DJ		 6774 printf (" pop {");
6775 for (i = 4; i <= end; i++)
6776 {
6777 if (first)
6778 first = 0;
6779 else
6780 printf (", ");
6781 printf ("r%d", i);
6782 }
6783 if (op & 0x08)
6784 {
1b31d05e 6785 if (!first)
0b6ae522
DJ		 6786 printf (", ");
6787 printf ("r14");
6788 }
6789 printf ("}");
6790 }
6791 else if (op == 0xb0)
6792 printf (_(" finish"));
6793 else if (op == 0xb1)
6794 {
6795 GET_OP (op2);
6796 if (op2 == 0 || (op2 & 0xf0) != 0)
6797 printf (_("[Spare]"));
6798 else
6799 {
6800 unsigned int mask = op2 & 0x0f;
6801 int first = 1;
6802 int i;
61865e30 6803
0b6ae522
DJ		 6804 printf ("pop {");
6805 for (i = 0; i < 12; i++)
6806 if (mask & (1 << i))
6807 {
6808 if (first)
6809 first = 0;
6810 else
6811 printf (", ");
6812 printf ("r%d", i);
6813 }
6814 printf ("}");
6815 }
6816 }
6817 else if (op == 0xb2)
6818 {
b115cf96 6819 unsigned char buf[9];
0b6ae522
DJ		 6820 unsigned int i, len;
6821 unsigned long offset;
61865e30 6822
b115cf96 6823 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 6824 {
6825 GET_OP (buf[i]);
6826 if ((buf[i] & 0x80) == 0)
6827 break;
6828 }
6829 assert (i < sizeof (buf));
6830 offset = read_uleb128 (buf, &len);
6831 assert (len == i + 1);
6832 offset = offset * 4 + 0x204;
cc5914eb 6833 printf ("vsp = vsp + %ld", offset);
0b6ae522 6834 }
61865e30 6835 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 6836 {
61865e30
NC		 6837 unsigned int first, last;
6838
6839 GET_OP (op2);
6840 first = op2 >> 4;
6841 last = op2 & 0x0f;
6842 if (op == 0xc8)
6843 first = first + 16;
6844 printf ("pop {D%d", first);
6845 if (last)
6846 printf ("-D%d", first + last);
6847 printf ("}");
6848 }
6849 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
6850 {
6851 unsigned int count = op & 0x07;
6852
6853 printf ("pop {D8");
6854 if (count)
6855 printf ("-D%d", 8 + count);
6856 printf ("}");
6857 }
6858 else if (op >= 0xc0 && op <= 0xc5)
6859 {
6860 unsigned int count = op & 0x07;
6861
6862 printf (" pop {wR10");
6863 if (count)
6864 printf ("-wR%d", 10 + count);
6865 printf ("}");
6866 }
6867 else if (op == 0xc6)
6868 {
6869 unsigned int first, last;
6870
6871 GET_OP (op2);
6872 first = op2 >> 4;
6873 last = op2 & 0x0f;
6874 printf ("pop {wR%d", first);
6875 if (last)
6876 printf ("-wR%d", first + last);
6877 printf ("}");
6878 }
6879 else if (op == 0xc7)
6880 {
6881 GET_OP (op2);
6882 if (op2 == 0 || (op2 & 0xf0) != 0)
6883 printf (_("[Spare]"));
0b6ae522
DJ		 6884 else
6885 {
61865e30
NC		 6886 unsigned int mask = op2 & 0x0f;
6887 int first = 1;
6888 int i;
6889
6890 printf ("pop {");
6891 for (i = 0; i < 4; i++)
6892 if (mask & (1 << i))
6893 {
6894 if (first)
6895 first = 0;
6896 else
6897 printf (", ");
6898 printf ("wCGR%d", i);
6899 }
6900 printf ("}");
0b6ae522
DJ		 6901 }
6902 }
61865e30
NC		 6903 else
6904 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 6905 printf ("\n");
6906 }
fa197c1c
PB		 6907}
6908
6909static void
6910decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
6911 unsigned int word, unsigned int remaining,
6912 unsigned int more_words,
6913 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6914 struct arm_section *data_arm_sec)
6915{
6916 struct absaddr addr;
6917
6918 /* Decode the unwinding instructions. */
6919 while (1)
6920 {
6921 unsigned int op, op2;
6922
6923 ADVANCE;
6924 if (remaining == 0)
6925 break;
6926 remaining--;
6927 op = word >> 24;
6928 word <<= 8;
6929
9cf03b7e 6930 printf (" 0x%02x ", op);
fa197c1c
PB		 6931
6932 if ((op & 0xc0) == 0x00)
6933 {
6934 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 6935 printf (" sp = sp + %d", offset);
fa197c1c
PB		 6936 }
6937 else if ((op & 0xc0) == 0x80)
6938 {
6939 GET_OP (op2);
6940 if (op == 0x80 && op2 == 0)
6941 printf (_("Refuse to unwind"));
6942 else
6943 {
6944 unsigned int mask = ((op & 0x1f) << 8) | op2;
6945 if (op & 0x20)
6946 printf ("pop compact {");
6947 else
6948 printf ("pop {");
6949
6950 decode_tic6x_unwind_regmask (mask);
6951 printf("}");
6952 }
6953 }
6954 else if ((op & 0xf0) == 0xc0)
6955 {
6956 unsigned int reg;
6957 unsigned int nregs;
6958 unsigned int i;
6959 const char *name;
a734115a
NC		 6960 struct
6961 {
fa197c1c
PB		 6962 unsigned int offset;
6963 unsigned int reg;
6964 } regpos[16];
6965
6966 /* Scan entire instruction first so that GET_OP output is not
6967 interleaved with disassembly. */
6968 nregs = 0;
6969 for (i = 0; nregs < (op & 0xf); i++)
6970 {
6971 GET_OP (op2);
6972 reg = op2 >> 4;
6973 if (reg != 0xf)
6974 {
6975 regpos[nregs].offset = i * 2;
6976 regpos[nregs].reg = reg;
6977 nregs++;
6978 }
6979
6980 reg = op2 & 0xf;
6981 if (reg != 0xf)
6982 {
6983 regpos[nregs].offset = i * 2 + 1;
6984 regpos[nregs].reg = reg;
6985 nregs++;
6986 }
6987 }
6988
6989 printf (_("pop frame {"));
6990 reg = nregs - 1;
6991 for (i = i * 2; i > 0; i--)
6992 {
6993 if (regpos[reg].offset == i - 1)
6994 {
6995 name = tic6x_unwind_regnames[regpos[reg].reg];
6996 if (reg > 0)
6997 reg--;
6998 }
6999 else
7000 name = _("[pad]");
7001
7002 fputs (name, stdout);
7003 if (i > 1)
7004 printf (", ");
7005 }
7006
7007 printf ("}");
7008 }
7009 else if (op == 0xd0)
7010 printf (" MOV FP, SP");
7011 else if (op == 0xd1)
7012 printf (" __c6xabi_pop_rts");
7013 else if (op == 0xd2)
7014 {
7015 unsigned char buf[9];
7016 unsigned int i, len;
7017 unsigned long offset;
a734115a 7018
fa197c1c
PB		 7019 for (i = 0; i < sizeof (buf); i++)
7020 {
7021 GET_OP (buf[i]);
7022 if ((buf[i] & 0x80) == 0)
7023 break;
7024 }
7025 assert (i < sizeof (buf));
7026 offset = read_uleb128 (buf, &len);
7027 assert (len == i + 1);
7028 offset = offset * 8 + 0x408;
7029 printf (_("sp = sp + %ld"), offset);
7030 }
7031 else if ((op & 0xf0) == 0xe0)
7032 {
7033 if ((op & 0x0f) == 7)
7034 printf (" RETURN");
7035 else
7036 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7037 }
7038 else
7039 {
7040 printf (_(" [unsupported opcode]"));
7041 }
7042 putchar ('\n');
7043 }
7044}
7045
7046static bfd_vma
a734115a 7047arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 7048{
7049 bfd_vma offset;
7050
7051 offset = word & 0x7fffffff;
7052 if (offset & 0x40000000)
7053 offset |= ~ (bfd_vma) 0x7fffffff;
7054
7055 if (elf_header.e_machine == EM_TI_C6000)
7056 offset <<= 1;
7057
7058 return offset + where;
7059}
7060
7061static void
1b31d05e
NC		 7062decode_arm_unwind (struct arm_unw_aux_info * aux,
7063 unsigned int word,
7064 unsigned int remaining,
7065 bfd_vma data_offset,
7066 Elf_Internal_Shdr * data_sec,
7067 struct arm_section * data_arm_sec)
fa197c1c
PB		 7068{
7069 int per_index;
7070 unsigned int more_words = 0;
7071 struct absaddr addr;
1b31d05e 7072 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 7073
7074 if (remaining == 0)
7075 {
1b31d05e
NC		 7076 /* Fetch the first word.
7077 Note - when decoding an object file the address extracted
7078 here will always be 0. So we also pass in the sym_name
7079 parameter so that we can find the symbol associated with
7080 the personality routine. */
7081 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7082 & word, & addr, & sym_name))
fa197c1c 7083 return;
1b31d05e 7084
fa197c1c
PB		 7085 remaining = 4;
7086 }
7087
7088 if ((word & 0x80000000) == 0)
7089 {
7090 /* Expand prel31 for personality routine. */
7091 bfd_vma fn;
7092 const char *procname;
7093
a734115a 7094 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 7095 printf (_(" Personality routine: "));
1b31d05e
NC		 7096 if (fn == 0
7097 && addr.section == SHN_UNDEF && addr.offset == 0
7098 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7099 {
7100 procname = aux->strtab + sym_name;
7101 print_vma (fn, PREFIX_HEX);
7102 if (procname)
7103 {
7104 fputs (" <", stdout);
7105 fputs (procname, stdout);
7106 fputc ('>', stdout);
7107 }
7108 }
7109 else
7110 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 7111 fputc ('\n', stdout);
7112
7113 /* The GCC personality routines use the standard compact
7114 encoding, starting with one byte giving the number of
7115 words. */
7116 if (procname != NULL
7117 && (const_strneq (procname, "__gcc_personality_v0")
7118 || const_strneq (procname, "__gxx_personality_v0")
7119 || const_strneq (procname, "__gcj_personality_v0")
7120 || const_strneq (procname, "__gnu_objc_personality_v0")))
7121 {
7122 remaining = 0;
7123 more_words = 1;
7124 ADVANCE;
7125 if (!remaining)
7126 {
7127 printf (_(" [Truncated data]\n"));
7128 return;
7129 }
7130 more_words = word >> 24;
7131 word <<= 8;
7132 remaining--;
7133 per_index = -1;
7134 }
7135 else
7136 return;
7137 }
7138 else
7139 {
1b31d05e
NC		 7140 /* ARM EHABI Section 6.3:
7141
7142 An exception-handling table entry for the compact model looks like:
7143
7144 31 30-28 27-24 23-0
7145 -- ----- ----- ----
7146 1 0 index Data for personalityRoutine[index] */
7147
7148 if (elf_header.e_machine == EM_ARM
7149 && (word & 0x70000000))
83c257ca 7150 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 7151
fa197c1c 7152 per_index = (word >> 24) & 0x7f;
1b31d05e 7153 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 7154 if (per_index == 0)
7155 {
7156 more_words = 0;
7157 word <<= 8;
7158 remaining--;
7159 }
7160 else if (per_index < 3)
7161 {
7162 more_words = (word >> 16) & 0xff;
7163 word <<= 16;
7164 remaining -= 2;
7165 }
7166 }
7167
7168 switch (elf_header.e_machine)
7169 {
7170 case EM_ARM:
7171 if (per_index < 3)
7172 {
7173 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7174 data_offset, data_sec, data_arm_sec);
7175 }
7176 else
1b31d05e
NC		 7177 {
7178 warn (_("Unknown ARM compact model index encountered\n"));
7179 printf (_(" [reserved]\n"));
7180 }
fa197c1c
PB		 7181 break;
7182
7183 case EM_TI_C6000:
7184 if (per_index < 3)
7185 {
7186 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 7187 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 7188 }
7189 else if (per_index < 5)
7190 {
7191 if (((word >> 17) & 0x7f) == 0x7f)
7192 printf (_(" Restore stack from frame pointer\n"));
7193 else
7194 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
7195 printf (_(" Registers restored: "));
7196 if (per_index == 4)
7197 printf (" (compact) ");
7198 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7199 putchar ('\n');
7200 printf (_(" Return register: %s\n"),
7201 tic6x_unwind_regnames[word & 0xf]);
7202 }
7203 else
1b31d05e 7204 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 7205 break;
7206
7207 default:
1b31d05e
NC		 7208 error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7209 elf_header.e_machine);
fa197c1c 7210 }
0b6ae522
DJ		 7211
7212 /* Decode the descriptors. Not implemented. */
7213}
7214
7215static void
7216dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7217{
7218 struct arm_section exidx_arm_sec, extab_arm_sec;
7219 unsigned int i, exidx_len;
7220
7221 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7222 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7223 exidx_len = exidx_sec->sh_size / 8;
7224
7225 for (i = 0; i < exidx_len; i++)
7226 {
7227 unsigned int exidx_fn, exidx_entry;
7228 struct absaddr fn_addr, entry_addr;
7229 bfd_vma fn;
7230
7231 fputc ('\n', stdout);
7232
1b31d05e
NC		 7233 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7234 8 * i, & exidx_fn, & fn_addr, NULL)
7235 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7236 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 7237 {
1b31d05e
NC		 7238 arm_free_section (& exidx_arm_sec);
7239 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 7240 return;
7241 }
7242
83c257ca
NC		 7243 /* ARM EHABI, Section 5:
7244 An index table entry consists of 2 words.
7245 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7246 if (exidx_fn & 0x80000000)
7247 warn (_("corrupt index table entry: %x\n"), exidx_fn);
7248
a734115a 7249 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 7250
a734115a 7251 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 7252 fputs (": ", stdout);
7253
7254 if (exidx_entry == 1)
7255 {
7256 print_vma (exidx_entry, PREFIX_HEX);
7257 fputs (" [cantunwind]\n", stdout);
7258 }
7259 else if (exidx_entry & 0x80000000)
7260 {
7261 print_vma (exidx_entry, PREFIX_HEX);
7262 fputc ('\n', stdout);
7263 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7264 }
7265 else
7266 {
8f73510c 7267 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 7268 Elf_Internal_Shdr *table_sec;
7269
7270 fputs ("@", stdout);
a734115a 7271 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 7272 print_vma (table, PREFIX_HEX);
7273 printf ("\n");
7274
7275 /* Locate the matching .ARM.extab. */
7276 if (entry_addr.section != SHN_UNDEF
7277 && entry_addr.section < elf_header.e_shnum)
7278 {
7279 table_sec = section_headers + entry_addr.section;
7280 table_offset = entry_addr.offset;
7281 }
7282 else
7283 {
7284 table_sec = find_section_by_address (table);
7285 if (table_sec != NULL)
7286 table_offset = table - table_sec->sh_addr;
7287 }
7288 if (table_sec == NULL)
7289 {
7290 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7291 (unsigned long) table);
7292 continue;
7293 }
7294 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7295 &extab_arm_sec);
7296 }
7297 }
7298
7299 printf ("\n");
7300
7301 arm_free_section (&exidx_arm_sec);
7302 arm_free_section (&extab_arm_sec);
7303}
7304
fa197c1c 7305/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 7306
7307static void
0b6ae522
DJ		 7308arm_process_unwind (FILE *file)
7309{
7310 struct arm_unw_aux_info aux;
7311 Elf_Internal_Shdr *unwsec = NULL;
7312 Elf_Internal_Shdr *strsec;
7313 Elf_Internal_Shdr *sec;
7314 unsigned long i;
fa197c1c 7315 unsigned int sec_type;
0b6ae522 7316
fa197c1c
PB		 7317 switch (elf_header.e_machine)
7318 {
7319 case EM_ARM:
7320 sec_type = SHT_ARM_EXIDX;
7321 break;
7322
7323 case EM_TI_C6000:
7324 sec_type = SHT_C6000_UNWIND;
7325 break;
7326
1b31d05e
NC		 7327 default:
7328 error (_("Unsupported architecture type %d encountered when processing unwind table"),
7329 elf_header.e_machine);
7330 return;
fa197c1c
PB		 7331 }
7332
0b6ae522 7333 if (string_table == NULL)
1b31d05e
NC		 7334 return;
7335
7336 memset (& aux, 0, sizeof (aux));
7337 aux.file = file;
0b6ae522
DJ		 7338
7339 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7340 {
7341 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7342 {
ba5cdace 7343 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 7344
7345 strsec = section_headers + sec->sh_link;
59245841 7346 assert (aux.strtab == NULL);
0b6ae522
DJ		 7347 aux.strtab = get_data (NULL, file, strsec->sh_offset,
7348 1, strsec->sh_size, _("string table"));
7349 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7350 }
fa197c1c 7351 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 7352 unwsec = sec;
7353 }
7354
1b31d05e 7355 if (unwsec == NULL)
0b6ae522 7356 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 7357 else
7358 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7359 {
7360 if (sec->sh_type == sec_type)
7361 {
7362 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7363 SECTION_NAME (sec),
7364 (unsigned long) sec->sh_offset,
7365 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 7366
1b31d05e
NC		 7367 dump_arm_unwind (&aux, sec);
7368 }
7369 }
0b6ae522
DJ		 7370
7371 if (aux.symtab)
7372 free (aux.symtab);
7373 if (aux.strtab)
7374 free ((char *) aux.strtab);
0b6ae522
DJ		 7375}
7376
1b31d05e 7377static void
2cf0635d 7378process_unwind (FILE * file)
57346661 7379{
2cf0635d
NC		 7380 struct unwind_handler
7381 {
57346661 7382 int machtype;
1b31d05e 7383 void (* handler)(FILE *);
2cf0635d
NC		 7384 } handlers[] =
7385 {
0b6ae522 7386 { EM_ARM, arm_process_unwind },
57346661
AM		 7387 { EM_IA_64, ia64_process_unwind },
7388 { EM_PARISC, hppa_process_unwind },
fa197c1c 7389 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 7390 { 0, 0 }
7391 };
7392 int i;
7393
7394 if (!do_unwind)
1b31d05e 7395 return;
57346661
AM		 7396
7397 for (i = 0; handlers[i].handler != NULL; i++)
7398 if (elf_header.e_machine == handlers[i].machtype)
18bd398b 7399 return handlers[i].handler (file);
57346661 7400
1b31d05e
NC		 7401 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7402 get_machine_name (elf_header.e_machine));
57346661
AM		 7403}
7404
252b5132 7405static void
2cf0635d 7406dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 7407{
7408 switch (entry->d_tag)
7409 {
7410 case DT_MIPS_FLAGS:
7411 if (entry->d_un.d_val == 0)
4b68bca3 7412 printf (_("NONE"));
252b5132
RH		 7413 else
7414 {
7415 static const char * opts[] =
7416 {
7417 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7418 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7419 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7420 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7421 "RLD_ORDER_SAFE"
7422 };
7423 unsigned int cnt;
7424 int first = 1;
2b692964 7425
60bca95a 7426 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 7427 if (entry->d_un.d_val & (1 << cnt))
7428 {
7429 printf ("%s%s", first ? "" : " ", opts[cnt]);
7430 first = 0;
7431 }
252b5132
RH		 7432 }
7433 break;
103f02d3 7434
252b5132 7435 case DT_MIPS_IVERSION:
d79b3d50 7436 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 7437 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 7438 else
4b68bca3 7439 printf (_("<corrupt: %" BFD_VMA_FMT "d>"), entry->d_un.d_ptr);
252b5132 7440 break;
103f02d3 7441
252b5132
RH		 7442 case DT_MIPS_TIME_STAMP:
7443 {
7444 char timebuf[20];
2cf0635d 7445 struct tm * tmp;
50da7a9c 7446
91d6fa6a
NC		 7447 time_t atime = entry->d_un.d_val;
7448 tmp = gmtime (&atime);
e9e44622
JJ		 7449 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7450 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7451 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 7452 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 7453 }
7454 break;
103f02d3 7455
252b5132
RH		 7456 case DT_MIPS_RLD_VERSION:
7457 case DT_MIPS_LOCAL_GOTNO:
7458 case DT_MIPS_CONFLICTNO:
7459 case DT_MIPS_LIBLISTNO:
7460 case DT_MIPS_SYMTABNO:
7461 case DT_MIPS_UNREFEXTNO:
7462 case DT_MIPS_HIPAGENO:
7463 case DT_MIPS_DELTA_CLASS_NO:
7464 case DT_MIPS_DELTA_INSTANCE_NO:
7465 case DT_MIPS_DELTA_RELOC_NO:
7466 case DT_MIPS_DELTA_SYM_NO:
7467 case DT_MIPS_DELTA_CLASSSYM_NO:
7468 case DT_MIPS_COMPACT_SIZE:
4b68bca3 7469 print_vma (entry->d_un.d_ptr, DEC);
252b5132 7470 break;
103f02d3
UD		 7471
7472 default:
4b68bca3 7473 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 7474 }
4b68bca3 7475 putchar ('\n');
103f02d3
UD		 7476}
7477
103f02d3 7478static void
2cf0635d 7479dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 7480{
7481 switch (entry->d_tag)
7482 {
7483 case DT_HP_DLD_FLAGS:
7484 {
7485 static struct
7486 {
7487 long int bit;
2cf0635d 7488 const char * str;
5e220199
NC		 7489 }
7490 flags[] =
7491 {
7492 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7493 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7494 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7495 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7496 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7497 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7498 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7499 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7500 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7501 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 7502 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7503 { DT_HP_GST, "HP_GST" },
7504 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7505 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7506 { DT_HP_NODELETE, "HP_NODELETE" },
7507 { DT_HP_GROUP, "HP_GROUP" },
7508 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 7509 };
103f02d3 7510 int first = 1;
5e220199 7511 size_t cnt;
f7a99963 7512 bfd_vma val = entry->d_un.d_val;
103f02d3 7513
60bca95a 7514 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 7515 if (val & flags[cnt].bit)
30800947
NC		 7516 {
7517 if (! first)
7518 putchar (' ');
7519 fputs (flags[cnt].str, stdout);
7520 first = 0;
7521 val ^= flags[cnt].bit;
7522 }
76da6bbe 7523
103f02d3 7524 if (val != 0 || first)
f7a99963
NC		 7525 {
7526 if (! first)
7527 putchar (' ');
7528 print_vma (val, HEX);
7529 }
103f02d3
UD		 7530 }
7531 break;
76da6bbe 7532
252b5132 7533 default:
f7a99963
NC		 7534 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7535 break;
252b5132 7536 }
35b1837e 7537 putchar ('\n');
252b5132
RH		 7538}
7539
28f997cf
TG		 7540#ifdef BFD64
7541
7542/* VMS vs Unix time offset and factor. */
7543
7544#define VMS_EPOCH_OFFSET 35067168000000000LL
7545#define VMS_GRANULARITY_FACTOR 10000000
7546
7547/* Display a VMS time in a human readable format. */
7548
7549static void
7550print_vms_time (bfd_int64_t vmstime)
7551{
7552 struct tm *tm;
7553 time_t unxtime;
7554
7555 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7556 tm = gmtime (&unxtime);
7557 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7558 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7559 tm->tm_hour, tm->tm_min, tm->tm_sec);
7560}
7561#endif /* BFD64 */
7562
ecc51f48 7563static void
2cf0635d 7564dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 7565{
7566 switch (entry->d_tag)
7567 {
0de14b54 7568 case DT_IA_64_PLT_RESERVE:
bdf4d63a 7569 /* First 3 slots reserved. */
ecc51f48
NC		 7570 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7571 printf (" -- ");
7572 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 7573 break;
7574
28f997cf
TG		 7575 case DT_IA_64_VMS_LINKTIME:
7576#ifdef BFD64
7577 print_vms_time (entry->d_un.d_val);
7578#endif
7579 break;
7580
7581 case DT_IA_64_VMS_LNKFLAGS:
7582 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7583 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7584 printf (" CALL_DEBUG");
7585 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7586 printf (" NOP0BUFS");
7587 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7588 printf (" P0IMAGE");
7589 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7590 printf (" MKTHREADS");
7591 if (entry->d_un.d_val & VMS_LF_UPCALLS)
7592 printf (" UPCALLS");
7593 if (entry->d_un.d_val & VMS_LF_IMGSTA)
7594 printf (" IMGSTA");
7595 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7596 printf (" INITIALIZE");
7597 if (entry->d_un.d_val & VMS_LF_MAIN)
7598 printf (" MAIN");
7599 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7600 printf (" EXE_INIT");
7601 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7602 printf (" TBK_IN_IMG");
7603 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7604 printf (" DBG_IN_IMG");
7605 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7606 printf (" TBK_IN_DSF");
7607 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7608 printf (" DBG_IN_DSF");
7609 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7610 printf (" SIGNATURES");
7611 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7612 printf (" REL_SEG_OFF");
7613 break;
7614
bdf4d63a
JJ		 7615 default:
7616 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7617 break;
ecc51f48 7618 }
bdf4d63a 7619 putchar ('\n');
ecc51f48
NC		 7620}
7621
252b5132 7622static int
2cf0635d 7623get_32bit_dynamic_section (FILE * file)
252b5132 7624{
2cf0635d
NC		 7625 Elf32_External_Dyn * edyn;
7626 Elf32_External_Dyn * ext;
7627 Elf_Internal_Dyn * entry;
103f02d3 7628
3f5e193b
NC		 7629 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7630 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 7631 if (!edyn)
7632 return 0;
103f02d3 7633
ba2685cc
AM		 7634/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7635 might not have the luxury of section headers. Look for the DT_NULL
7636 terminator to determine the number of entries. */
7637 for (ext = edyn, dynamic_nent = 0;
7638 (char *) ext < (char *) edyn + dynamic_size;
7639 ext++)
7640 {
7641 dynamic_nent++;
7642 if (BYTE_GET (ext->d_tag) == DT_NULL)
7643 break;
7644 }
252b5132 7645
3f5e193b
NC		 7646 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7647 sizeof (* entry));
b2d38a17 7648 if (dynamic_section == NULL)
252b5132 7649 {
9ea033b2
NC		 7650 error (_("Out of memory\n"));
7651 free (edyn);
7652 return 0;
7653 }
252b5132 7654
fb514b26 7655 for (ext = edyn, entry = dynamic_section;
ba2685cc 7656 entry < dynamic_section + dynamic_nent;
fb514b26 7657 ext++, entry++)
9ea033b2 7658 {
fb514b26
AM		 7659 entry->d_tag = BYTE_GET (ext->d_tag);
7660 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 7661 }
7662
9ea033b2
NC		 7663 free (edyn);
7664
7665 return 1;
7666}
7667
7668static int
2cf0635d 7669get_64bit_dynamic_section (FILE * file)
9ea033b2 7670{
2cf0635d
NC		 7671 Elf64_External_Dyn * edyn;
7672 Elf64_External_Dyn * ext;
7673 Elf_Internal_Dyn * entry;
103f02d3 7674
3f5e193b
NC		 7675 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7676 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 7677 if (!edyn)
7678 return 0;
103f02d3 7679
ba2685cc
AM		 7680/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7681 might not have the luxury of section headers. Look for the DT_NULL
7682 terminator to determine the number of entries. */
7683 for (ext = edyn, dynamic_nent = 0;
7684 (char *) ext < (char *) edyn + dynamic_size;
7685 ext++)
7686 {
7687 dynamic_nent++;
66543521 7688 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 7689 break;
7690 }
252b5132 7691
3f5e193b
NC		 7692 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7693 sizeof (* entry));
b2d38a17 7694 if (dynamic_section == NULL)
252b5132
RH		 7695 {
7696 error (_("Out of memory\n"));
7697 free (edyn);
7698 return 0;
7699 }
7700
fb514b26 7701 for (ext = edyn, entry = dynamic_section;
ba2685cc 7702 entry < dynamic_section + dynamic_nent;
fb514b26 7703 ext++, entry++)
252b5132 7704 {
66543521
AM		 7705 entry->d_tag = BYTE_GET (ext->d_tag);
7706 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 7707 }
7708
7709 free (edyn);
7710
9ea033b2
NC		 7711 return 1;
7712}
7713
e9e44622
JJ		 7714static void
7715print_dynamic_flags (bfd_vma flags)
d1133906 7716{
e9e44622 7717 int first = 1;
13ae64f3 7718
d1133906
NC		 7719 while (flags)
7720 {
7721 bfd_vma flag;
7722
7723 flag = flags & - flags;
7724 flags &= ~ flag;
7725
e9e44622
JJ		 7726 if (first)
7727 first = 0;
7728 else
7729 putc (' ', stdout);
13ae64f3 7730
d1133906
NC		 7731 switch (flag)
7732 {
e9e44622
JJ		 7733 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
7734 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
7735 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
7736 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
7737 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 7738 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 7739 }
7740 }
e9e44622 7741 puts ("");
d1133906
NC		 7742}
7743
b2d38a17
NC		 7744/* Parse and display the contents of the dynamic section. */
7745
9ea033b2 7746static int
2cf0635d 7747process_dynamic_section (FILE * file)
9ea033b2 7748{
2cf0635d 7749 Elf_Internal_Dyn * entry;
9ea033b2
NC		 7750
7751 if (dynamic_size == 0)
7752 {
7753 if (do_dynamic)
b2d38a17 7754 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 7755
7756 return 1;
7757 }
7758
7759 if (is_32bit_elf)
7760 {
b2d38a17 7761 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 7762 return 0;
7763 }
b2d38a17 7764 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 7765 return 0;
7766
252b5132
RH		 7767 /* Find the appropriate symbol table. */
7768 if (dynamic_symbols == NULL)
7769 {
86dba8ee
AM		 7770 for (entry = dynamic_section;
7771 entry < dynamic_section + dynamic_nent;
7772 ++entry)
252b5132 7773 {
c8286bd1 7774 Elf_Internal_Shdr section;
252b5132
RH		 7775
7776 if (entry->d_tag != DT_SYMTAB)
7777 continue;
7778
7779 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7780
7781 /* Since we do not know how big the symbol table is,
7782 we default to reading in the entire file (!) and
7783 processing that. This is overkill, I know, but it
e3c8793a 7784 should work. */
d93f0186 7785 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 7786
fb52b2f4
NC		 7787 if (archive_file_offset != 0)
7788 section.sh_size = archive_file_size - section.sh_offset;
7789 else
7790 {
7791 if (fseek (file, 0, SEEK_END))
591a748a 7792 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 7793
7794 section.sh_size = ftell (file) - section.sh_offset;
7795 }
252b5132 7796
9ea033b2 7797 if (is_32bit_elf)
9ad5cbcf 7798 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 7799 else
9ad5cbcf 7800 section.sh_entsize = sizeof (Elf64_External_Sym);
252b5132 7801
ba5cdace 7802 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 7803 if (num_dynamic_syms < 1)
252b5132
RH		 7804 {
7805 error (_("Unable to determine the number of symbols to load\n"));
7806 continue;
7807 }
252b5132
RH		 7808 }
7809 }
7810
7811 /* Similarly find a string table. */
7812 if (dynamic_strings == NULL)
7813 {
86dba8ee
AM		 7814 for (entry = dynamic_section;
7815 entry < dynamic_section + dynamic_nent;
7816 ++entry)
252b5132
RH		 7817 {
7818 unsigned long offset;
b34976b6 7819 long str_tab_len;
252b5132
RH		 7820
7821 if (entry->d_tag != DT_STRTAB)
7822 continue;
7823
7824 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7825
7826 /* Since we do not know how big the string table is,
7827 we default to reading in the entire file (!) and
7828 processing that. This is overkill, I know, but it
e3c8793a 7829 should work. */
252b5132 7830
d93f0186 7831 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 7832
7833 if (archive_file_offset != 0)
7834 str_tab_len = archive_file_size - offset;
7835 else
7836 {
7837 if (fseek (file, 0, SEEK_END))
7838 error (_("Unable to seek to end of file\n"));
7839 str_tab_len = ftell (file) - offset;
7840 }
252b5132
RH		 7841
7842 if (str_tab_len < 1)
7843 {
7844 error
7845 (_("Unable to determine the length of the dynamic string table\n"));
7846 continue;
7847 }
7848
3f5e193b
NC		 7849 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7850 str_tab_len,
7851 _("dynamic string table"));
59245841 7852 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 7853 break;
7854 }
7855 }
7856
7857 /* And find the syminfo section if available. */
7858 if (dynamic_syminfo == NULL)
7859 {
3e8bba36 7860 unsigned long syminsz = 0;
252b5132 7861
86dba8ee
AM		 7862 for (entry = dynamic_section;
7863 entry < dynamic_section + dynamic_nent;
7864 ++entry)
252b5132
RH		 7865 {
7866 if (entry->d_tag == DT_SYMINENT)
7867 {
7868 /* Note: these braces are necessary to avoid a syntax
7869 error from the SunOS4 C compiler. */
7870 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7871 }
7872 else if (entry->d_tag == DT_SYMINSZ)
7873 syminsz = entry->d_un.d_val;
7874 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 7875 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7876 syminsz);
252b5132
RH		 7877 }
7878
7879 if (dynamic_syminfo_offset != 0 && syminsz != 0)
7880 {
2cf0635d
NC		 7881 Elf_External_Syminfo * extsyminfo;
7882 Elf_External_Syminfo * extsym;
7883 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 7884
7885 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 7886 extsyminfo = (Elf_External_Syminfo *)
7887 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
7888 _("symbol information"));
a6e9f9df
AM		 7889 if (!extsyminfo)
7890 return 0;
252b5132 7891
3f5e193b 7892 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 7893 if (dynamic_syminfo == NULL)
7894 {
7895 error (_("Out of memory\n"));
7896 return 0;
7897 }
7898
7899 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 7900 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
7901 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
7902 ++syminfo, ++extsym)
252b5132 7903 {
86dba8ee
AM		 7904 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
7905 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 7906 }
7907
7908 free (extsyminfo);
7909 }
7910 }
7911
7912 if (do_dynamic && dynamic_addr)
86dba8ee
AM		 7913 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7914 dynamic_addr, dynamic_nent);
252b5132
RH		 7915 if (do_dynamic)
7916 printf (_(" Tag Type Name/Value\n"));
7917
86dba8ee
AM		 7918 for (entry = dynamic_section;
7919 entry < dynamic_section + dynamic_nent;
7920 entry++)
252b5132
RH		 7921 {
7922 if (do_dynamic)
f7a99963 7923 {
2cf0635d 7924 const char * dtype;
e699b9ff 7925
f7a99963
NC		 7926 putchar (' ');
7927 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 7928 dtype = get_dynamic_type (entry->d_tag);
7929 printf (" (%s)%*s", dtype,
7930 ((is_32bit_elf ? 27 : 19)
7931 - (int) strlen (dtype)),
f7a99963
NC		 7932 " ");
7933 }
252b5132
RH		 7934
7935 switch (entry->d_tag)
7936 {
d1133906
NC		 7937 case DT_FLAGS:
7938 if (do_dynamic)
e9e44622 7939 print_dynamic_flags (entry->d_un.d_val);
d1133906 7940 break;
76da6bbe 7941
252b5132
RH		 7942 case DT_AUXILIARY:
7943 case DT_FILTER:
019148e4
L		 7944 case DT_CONFIG:
7945 case DT_DEPAUDIT:
7946 case DT_AUDIT:
252b5132
RH		 7947 if (do_dynamic)
7948 {
019148e4 7949 switch (entry->d_tag)
b34976b6 7950 {
019148e4
L		 7951 case DT_AUXILIARY:
7952 printf (_("Auxiliary library"));
7953 break;
7954
7955 case DT_FILTER:
7956 printf (_("Filter library"));
7957 break;
7958
b34976b6 7959 case DT_CONFIG:
019148e4
L		 7960 printf (_("Configuration file"));
7961 break;
7962
7963 case DT_DEPAUDIT:
7964 printf (_("Dependency audit library"));
7965 break;
7966
7967 case DT_AUDIT:
7968 printf (_("Audit library"));
7969 break;
7970 }
252b5132 7971
d79b3d50
NC		 7972 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7973 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 7974 else
f7a99963
NC		 7975 {
7976 printf (": ");
7977 print_vma (entry->d_un.d_val, PREFIX_HEX);
7978 putchar ('\n');
7979 }
252b5132
RH		 7980 }
7981 break;
7982
dcefbbbd 7983 case DT_FEATURE:
252b5132
RH		 7984 if (do_dynamic)
7985 {
7986 printf (_("Flags:"));
86f55779 7987
252b5132
RH		 7988 if (entry->d_un.d_val == 0)
7989 printf (_(" None\n"));
7990 else
7991 {
7992 unsigned long int val = entry->d_un.d_val;
86f55779 7993
252b5132
RH		 7994 if (val & DTF_1_PARINIT)
7995 {
7996 printf (" PARINIT");
7997 val ^= DTF_1_PARINIT;
7998 }
dcefbbbd
L		 7999 if (val & DTF_1_CONFEXP)
8000 {
8001 printf (" CONFEXP");
8002 val ^= DTF_1_CONFEXP;
8003 }
252b5132
RH		 8004 if (val != 0)
8005 printf (" %lx", val);
8006 puts ("");
8007 }
8008 }
8009 break;
8010
8011 case DT_POSFLAG_1:
8012 if (do_dynamic)
8013 {
8014 printf (_("Flags:"));
86f55779 8015
252b5132
RH		 8016 if (entry->d_un.d_val == 0)
8017 printf (_(" None\n"));
8018 else
8019 {
8020 unsigned long int val = entry->d_un.d_val;
86f55779 8021
252b5132
RH		 8022 if (val & DF_P1_LAZYLOAD)
8023 {
8024 printf (" LAZYLOAD");
8025 val ^= DF_P1_LAZYLOAD;
8026 }
8027 if (val & DF_P1_GROUPPERM)
8028 {
8029 printf (" GROUPPERM");
8030 val ^= DF_P1_GROUPPERM;
8031 }
8032 if (val != 0)
8033 printf (" %lx", val);
8034 puts ("");
8035 }
8036 }
8037 break;
8038
8039 case DT_FLAGS_1:
8040 if (do_dynamic)
8041 {
8042 printf (_("Flags:"));
8043 if (entry->d_un.d_val == 0)
8044 printf (_(" None\n"));
8045 else
8046 {
8047 unsigned long int val = entry->d_un.d_val;
86f55779 8048
252b5132
RH		 8049 if (val & DF_1_NOW)
8050 {
8051 printf (" NOW");
8052 val ^= DF_1_NOW;
8053 }
8054 if (val & DF_1_GLOBAL)
8055 {
8056 printf (" GLOBAL");
8057 val ^= DF_1_GLOBAL;
8058 }
8059 if (val & DF_1_GROUP)
8060 {
8061 printf (" GROUP");
8062 val ^= DF_1_GROUP;
8063 }
8064 if (val & DF_1_NODELETE)
8065 {
8066 printf (" NODELETE");
8067 val ^= DF_1_NODELETE;
8068 }
8069 if (val & DF_1_LOADFLTR)
8070 {
8071 printf (" LOADFLTR");
8072 val ^= DF_1_LOADFLTR;
8073 }
8074 if (val & DF_1_INITFIRST)
8075 {
8076 printf (" INITFIRST");
8077 val ^= DF_1_INITFIRST;
8078 }
8079 if (val & DF_1_NOOPEN)
8080 {
8081 printf (" NOOPEN");
8082 val ^= DF_1_NOOPEN;
8083 }
8084 if (val & DF_1_ORIGIN)
8085 {
8086 printf (" ORIGIN");
8087 val ^= DF_1_ORIGIN;
8088 }
8089 if (val & DF_1_DIRECT)
8090 {
8091 printf (" DIRECT");
8092 val ^= DF_1_DIRECT;
8093 }
8094 if (val & DF_1_TRANS)
8095 {
8096 printf (" TRANS");
8097 val ^= DF_1_TRANS;
8098 }
8099 if (val & DF_1_INTERPOSE)
8100 {
8101 printf (" INTERPOSE");
8102 val ^= DF_1_INTERPOSE;
8103 }
f7db6139 8104 if (val & DF_1_NODEFLIB)
dcefbbbd 8105 {
f7db6139
L		 8106 printf (" NODEFLIB");
8107 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 8108 }
8109 if (val & DF_1_NODUMP)
8110 {
8111 printf (" NODUMP");
8112 val ^= DF_1_NODUMP;
8113 }
8114 if (val & DF_1_CONLFAT)
8115 {
8116 printf (" CONLFAT");
8117 val ^= DF_1_CONLFAT;
8118 }
252b5132
RH		 8119 if (val != 0)
8120 printf (" %lx", val);
8121 puts ("");
8122 }
8123 }
8124 break;
8125
8126 case DT_PLTREL:
566b0d53 8127 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 8128 if (do_dynamic)
8129 puts (get_dynamic_type (entry->d_un.d_val));
8130 break;
8131
8132 case DT_NULL :
8133 case DT_NEEDED :
8134 case DT_PLTGOT :
8135 case DT_HASH :
8136 case DT_STRTAB :
8137 case DT_SYMTAB :
8138 case DT_RELA :
8139 case DT_INIT :
8140 case DT_FINI :
8141 case DT_SONAME :
8142 case DT_RPATH :
8143 case DT_SYMBOLIC:
8144 case DT_REL :
8145 case DT_DEBUG :
8146 case DT_TEXTREL :
8147 case DT_JMPREL :
019148e4 8148 case DT_RUNPATH :
252b5132
RH		 8149 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8150
8151 if (do_dynamic)
8152 {
2cf0635d 8153 char * name;
252b5132 8154
d79b3d50
NC		 8155 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8156 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 8157 else
d79b3d50 8158 name = NULL;
252b5132
RH		 8159
8160 if (name)
8161 {
8162 switch (entry->d_tag)
8163 {
8164 case DT_NEEDED:
8165 printf (_("Shared library: [%s]"), name);
8166
18bd398b 8167 if (streq (name, program_interpreter))
f7a99963 8168 printf (_(" program interpreter"));
252b5132
RH		 8169 break;
8170
8171 case DT_SONAME:
f7a99963 8172 printf (_("Library soname: [%s]"), name);
252b5132
RH		 8173 break;
8174
8175 case DT_RPATH:
f7a99963 8176 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 8177 break;
8178
019148e4
L		 8179 case DT_RUNPATH:
8180 printf (_("Library runpath: [%s]"), name);
8181 break;
8182
252b5132 8183 default:
f7a99963
NC		 8184 print_vma (entry->d_un.d_val, PREFIX_HEX);
8185 break;
252b5132
RH		 8186 }
8187 }
8188 else
f7a99963
NC		 8189 print_vma (entry->d_un.d_val, PREFIX_HEX);
8190
8191 putchar ('\n');
252b5132
RH		 8192 }
8193 break;
8194
8195 case DT_PLTRELSZ:
8196 case DT_RELASZ :
8197 case DT_STRSZ :
8198 case DT_RELSZ :
8199 case DT_RELAENT :
8200 case DT_SYMENT :
8201 case DT_RELENT :
566b0d53 8202 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 8203 case DT_PLTPADSZ:
8204 case DT_MOVEENT :
8205 case DT_MOVESZ :
8206 case DT_INIT_ARRAYSZ:
8207 case DT_FINI_ARRAYSZ:
047b2264
JJ		 8208 case DT_GNU_CONFLICTSZ:
8209 case DT_GNU_LIBLISTSZ:
252b5132 8210 if (do_dynamic)
f7a99963
NC		 8211 {
8212 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 8213 printf (_(" (bytes)\n"));
f7a99963 8214 }
252b5132
RH		 8215 break;
8216
8217 case DT_VERDEFNUM:
8218 case DT_VERNEEDNUM:
8219 case DT_RELACOUNT:
8220 case DT_RELCOUNT:
8221 if (do_dynamic)
f7a99963
NC		 8222 {
8223 print_vma (entry->d_un.d_val, UNSIGNED);
8224 putchar ('\n');
8225 }
252b5132
RH		 8226 break;
8227
8228 case DT_SYMINSZ:
8229 case DT_SYMINENT:
8230 case DT_SYMINFO:
8231 case DT_USED:
8232 case DT_INIT_ARRAY:
8233 case DT_FINI_ARRAY:
8234 if (do_dynamic)
8235 {
d79b3d50
NC		 8236 if (entry->d_tag == DT_USED
8237 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 8238 {
2cf0635d 8239 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 8240
b34976b6 8241 if (*name)
252b5132
RH		 8242 {
8243 printf (_("Not needed object: [%s]\n"), name);
8244 break;
8245 }
8246 }
103f02d3 8247
f7a99963
NC		 8248 print_vma (entry->d_un.d_val, PREFIX_HEX);
8249 putchar ('\n');
252b5132
RH		 8250 }
8251 break;
8252
8253 case DT_BIND_NOW:
8254 /* The value of this entry is ignored. */
35b1837e
AM		 8255 if (do_dynamic)
8256 putchar ('\n');
252b5132 8257 break;
103f02d3 8258
047b2264
JJ		 8259 case DT_GNU_PRELINKED:
8260 if (do_dynamic)
8261 {
2cf0635d 8262 struct tm * tmp;
91d6fa6a 8263 time_t atime = entry->d_un.d_val;
047b2264 8264
91d6fa6a 8265 tmp = gmtime (&atime);
047b2264
JJ		 8266 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8267 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8268 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8269
8270 }
8271 break;
8272
fdc90cb4
JJ		 8273 case DT_GNU_HASH:
8274 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8275 if (do_dynamic)
8276 {
8277 print_vma (entry->d_un.d_val, PREFIX_HEX);
8278 putchar ('\n');
8279 }
8280 break;
8281
252b5132
RH		 8282 default:
8283 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 8284 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 8285 entry->d_un.d_val;
8286
8287 if (do_dynamic)
8288 {
8289 switch (elf_header.e_machine)
8290 {
8291 case EM_MIPS:
4fe85591 8292 case EM_MIPS_RS3_LE:
b2d38a17 8293 dynamic_section_mips_val (entry);
252b5132 8294 break;
103f02d3 8295 case EM_PARISC:
b2d38a17 8296 dynamic_section_parisc_val (entry);
103f02d3 8297 break;
ecc51f48 8298 case EM_IA_64:
b2d38a17 8299 dynamic_section_ia64_val (entry);
ecc51f48 8300 break;
252b5132 8301 default:
f7a99963
NC		 8302 print_vma (entry->d_un.d_val, PREFIX_HEX);
8303 putchar ('\n');
252b5132
RH		 8304 }
8305 }
8306 break;
8307 }
8308 }
8309
8310 return 1;
8311}
8312
8313static char *
d3ba0551 8314get_ver_flags (unsigned int flags)
252b5132 8315{
b34976b6 8316 static char buff[32];
252b5132
RH		 8317
8318 buff[0] = 0;
8319
8320 if (flags == 0)
8321 return _("none");
8322
8323 if (flags & VER_FLG_BASE)
8324 strcat (buff, "BASE ");
8325
8326 if (flags & VER_FLG_WEAK)
8327 {
8328 if (flags & VER_FLG_BASE)
8329 strcat (buff, "| ");
8330
8331 strcat (buff, "WEAK ");
8332 }
8333
44ec90b9
RO		 8334 if (flags & VER_FLG_INFO)
8335 {
8336 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8337 strcat (buff, "| ");
8338
8339 strcat (buff, "INFO ");
8340 }
8341
8342 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 8343 strcat (buff, _("| <unknown>"));
252b5132
RH		 8344
8345 return buff;
8346}
8347
8348/* Display the contents of the version sections. */
98fb390a 8349
252b5132 8350static int
2cf0635d 8351process_version_sections (FILE * file)
252b5132 8352{
2cf0635d 8353 Elf_Internal_Shdr * section;
b34976b6
AM		 8354 unsigned i;
8355 int found = 0;
252b5132
RH		 8356
8357 if (! do_version)
8358 return 1;
8359
8360 for (i = 0, section = section_headers;
8361 i < elf_header.e_shnum;
b34976b6 8362 i++, section++)
252b5132
RH		 8363 {
8364 switch (section->sh_type)
8365 {
8366 case SHT_GNU_verdef:
8367 {
2cf0635d 8368 Elf_External_Verdef * edefs;
b34976b6
AM		 8369 unsigned int idx;
8370 unsigned int cnt;
2cf0635d 8371 char * endbuf;
252b5132
RH		 8372
8373 found = 1;
8374
8375 printf
72de5009 8376 (_("\nVersion definition section '%s' contains %u entries:\n"),
252b5132
RH		 8377 SECTION_NAME (section), section->sh_info);
8378
8379 printf (_(" Addr: 0x"));
8380 printf_vma (section->sh_addr);
72de5009 8381 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8382 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8383 section->sh_link < elf_header.e_shnum
8384 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8385 : _("<corrupt>"));
252b5132 8386
3f5e193b
NC		 8387 edefs = (Elf_External_Verdef *)
8388 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8389 _("version definition section"));
a6e9f9df
AM		 8390 if (!edefs)
8391 break;
59245841 8392 endbuf = (char *) edefs + section->sh_size;
252b5132 8393
b34976b6 8394 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 8395 {
2cf0635d
NC		 8396 char * vstart;
8397 Elf_External_Verdef * edef;
b34976b6 8398 Elf_Internal_Verdef ent;
2cf0635d 8399 Elf_External_Verdaux * eaux;
b34976b6
AM		 8400 Elf_Internal_Verdaux aux;
8401 int j;
8402 int isum;
103f02d3 8403
dd24e3da
NC		 8404 /* Check for negative or very large indicies. */
8405 if ((unsigned char *) edefs + idx < (unsigned char *) edefs)
8406 break;
8407
252b5132 8408 vstart = ((char *) edefs) + idx;
54806181
AM		 8409 if (vstart + sizeof (*edef) > endbuf)
8410 break;
252b5132
RH		 8411
8412 edef = (Elf_External_Verdef *) vstart;
8413
8414 ent.vd_version = BYTE_GET (edef->vd_version);
8415 ent.vd_flags = BYTE_GET (edef->vd_flags);
8416 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
8417 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
8418 ent.vd_hash = BYTE_GET (edef->vd_hash);
8419 ent.vd_aux = BYTE_GET (edef->vd_aux);
8420 ent.vd_next = BYTE_GET (edef->vd_next);
8421
8422 printf (_(" %#06x: Rev: %d Flags: %s"),
8423 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8424
8425 printf (_(" Index: %d Cnt: %d "),
8426 ent.vd_ndx, ent.vd_cnt);
8427
dd24e3da
NC		 8428 /* Check for overflow. */
8429 if ((unsigned char *)(vstart + ent.vd_aux) < (unsigned char *) vstart
8430 || (unsigned char *)(vstart + ent.vd_aux) > (unsigned char *) endbuf)
8431 break;
8432
252b5132
RH		 8433 vstart += ent.vd_aux;
8434
8435 eaux = (Elf_External_Verdaux *) vstart;
8436
8437 aux.vda_name = BYTE_GET (eaux->vda_name);
8438 aux.vda_next = BYTE_GET (eaux->vda_next);
8439
d79b3d50
NC		 8440 if (VALID_DYNAMIC_NAME (aux.vda_name))
8441 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8442 else
8443 printf (_("Name index: %ld\n"), aux.vda_name);
8444
8445 isum = idx + ent.vd_aux;
8446
b34976b6 8447 for (j = 1; j < ent.vd_cnt; j++)
252b5132 8448 {
dd24e3da
NC		 8449 /* Check for overflow. */
8450 if ((unsigned char *)(vstart + aux.vda_next) < (unsigned char *) vstart
8451 || (unsigned char *)(vstart + aux.vda_next) > (unsigned char *) endbuf)
8452 break;
8453
252b5132
RH		 8454 isum += aux.vda_next;
8455 vstart += aux.vda_next;
8456
8457 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 8458 if (vstart + sizeof (*eaux) > endbuf)
8459 break;
252b5132
RH		 8460
8461 aux.vda_name = BYTE_GET (eaux->vda_name);
8462 aux.vda_next = BYTE_GET (eaux->vda_next);
8463
d79b3d50 8464 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 8465 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 8466 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8467 else
8468 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8469 isum, j, aux.vda_name);
8470 }
dd24e3da 8471
54806181
AM		 8472 if (j < ent.vd_cnt)
8473 printf (_(" Version def aux past end of section\n"));
252b5132
RH		 8474
8475 idx += ent.vd_next;
8476 }
dd24e3da 8477
54806181
AM		 8478 if (cnt < section->sh_info)
8479 printf (_(" Version definition past end of section\n"));
252b5132
RH		 8480
8481 free (edefs);
8482 }
8483 break;
103f02d3 8484
252b5132
RH		 8485 case SHT_GNU_verneed:
8486 {
2cf0635d 8487 Elf_External_Verneed * eneed;
b34976b6
AM		 8488 unsigned int idx;
8489 unsigned int cnt;
2cf0635d 8490 char * endbuf;
252b5132
RH		 8491
8492 found = 1;
8493
72de5009 8494 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
252b5132
RH		 8495 SECTION_NAME (section), section->sh_info);
8496
8497 printf (_(" Addr: 0x"));
8498 printf_vma (section->sh_addr);
72de5009 8499 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8500 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8501 section->sh_link < elf_header.e_shnum
8502 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8503 : _("<corrupt>"));
252b5132 8504
3f5e193b
NC		 8505 eneed = (Elf_External_Verneed *) get_data (NULL, file,
8506 section->sh_offset, 1,
8507 section->sh_size,
9cf03b7e 8508 _("Version Needs section"));
a6e9f9df
AM		 8509 if (!eneed)
8510 break;
59245841 8511 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 8512
8513 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8514 {
2cf0635d 8515 Elf_External_Verneed * entry;
b34976b6
AM		 8516 Elf_Internal_Verneed ent;
8517 int j;
8518 int isum;
2cf0635d 8519 char * vstart;
252b5132 8520
dd24e3da
NC		 8521 if ((unsigned char *) eneed + idx < (unsigned char *) eneed)
8522 break;
8523
252b5132 8524 vstart = ((char *) eneed) + idx;
54806181
AM		 8525 if (vstart + sizeof (*entry) > endbuf)
8526 break;
252b5132
RH		 8527
8528 entry = (Elf_External_Verneed *) vstart;
8529
8530 ent.vn_version = BYTE_GET (entry->vn_version);
8531 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
8532 ent.vn_file = BYTE_GET (entry->vn_file);
8533 ent.vn_aux = BYTE_GET (entry->vn_aux);
8534 ent.vn_next = BYTE_GET (entry->vn_next);
8535
8536 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
8537
d79b3d50
NC		 8538 if (VALID_DYNAMIC_NAME (ent.vn_file))
8539 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 8540 else
8541 printf (_(" File: %lx"), ent.vn_file);
8542
8543 printf (_(" Cnt: %d\n"), ent.vn_cnt);
8544
dd24e3da
NC		 8545 /* Check for overflow. */
8546 if ((unsigned char *)(vstart + ent.vn_aux) < (unsigned char *) vstart
8547 || (unsigned char *)(vstart + ent.vn_aux) > (unsigned char *) endbuf)
8548 break;
8549
252b5132
RH		 8550 vstart += ent.vn_aux;
8551
8552 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8553 {
2cf0635d 8554 Elf_External_Vernaux * eaux;
b34976b6 8555 Elf_Internal_Vernaux aux;
252b5132 8556
54806181
AM		 8557 if (vstart + sizeof (*eaux) > endbuf)
8558 break;
252b5132
RH		 8559 eaux = (Elf_External_Vernaux *) vstart;
8560
8561 aux.vna_hash = BYTE_GET (eaux->vna_hash);
8562 aux.vna_flags = BYTE_GET (eaux->vna_flags);
8563 aux.vna_other = BYTE_GET (eaux->vna_other);
8564 aux.vna_name = BYTE_GET (eaux->vna_name);
8565 aux.vna_next = BYTE_GET (eaux->vna_next);
8566
d79b3d50 8567 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 8568 printf (_(" %#06x: Name: %s"),
d79b3d50 8569 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 8570 else
ecc2063b 8571 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 8572 isum, aux.vna_name);
8573
8574 printf (_(" Flags: %s Version: %d\n"),
8575 get_ver_flags (aux.vna_flags), aux.vna_other);
8576
dd24e3da
NC		 8577 /* Check for overflow. */
8578 if ((unsigned char *)(vstart + aux.vna_next) < (unsigned char *) vstart
8579 || (unsigned char *)(vstart + aux.vna_next) > (unsigned char *) endbuf)
8580 break;
8581
252b5132
RH		 8582 isum += aux.vna_next;
8583 vstart += aux.vna_next;
8584 }
9cf03b7e 8585
54806181 8586 if (j < ent.vn_cnt)
9cf03b7e 8587 warn (_("Missing Version Needs auxillary information\n"));
252b5132
RH		 8588
8589 idx += ent.vn_next;
8590 }
9cf03b7e 8591
54806181 8592 if (cnt < section->sh_info)
9cf03b7e 8593 warn (_("Missing Version Needs information\n"));
103f02d3 8594
252b5132
RH		 8595 free (eneed);
8596 }
8597 break;
8598
8599 case SHT_GNU_versym:
8600 {
2cf0635d 8601 Elf_Internal_Shdr * link_section;
b34976b6
AM		 8602 int total;
8603 int cnt;
2cf0635d
NC		 8604 unsigned char * edata;
8605 unsigned short * data;
8606 char * strtab;
8607 Elf_Internal_Sym * symbols;
8608 Elf_Internal_Shdr * string_sec;
ba5cdace 8609 unsigned long num_syms;
d3ba0551 8610 long off;
252b5132 8611
4fbb74a6 8612 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 8613 break;
8614
4fbb74a6 8615 link_section = section_headers + section->sh_link;
08d8fa11 8616 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 8617
4fbb74a6 8618 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 8619 break;
8620
252b5132
RH		 8621 found = 1;
8622
ba5cdace 8623 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 8624 if (symbols == NULL)
8625 break;
252b5132 8626
4fbb74a6 8627 string_sec = section_headers + link_section->sh_link;
252b5132 8628
3f5e193b
NC		 8629 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8630 string_sec->sh_size,
8631 _("version string table"));
a6e9f9df 8632 if (!strtab)
0429c154
MS		 8633 {
8634 free (symbols);
8635 break;
8636 }
252b5132
RH		 8637
8638 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8639 SECTION_NAME (section), total);
8640
8641 printf (_(" Addr: "));
8642 printf_vma (section->sh_addr);
72de5009 8643 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8644 (unsigned long) section->sh_offset, section->sh_link,
252b5132
RH		 8645 SECTION_NAME (link_section));
8646
d3ba0551
AM		 8647 off = offset_from_vma (file,
8648 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8649 total * sizeof (short));
3f5e193b
NC		 8650 edata = (unsigned char *) get_data (NULL, file, off, total,
8651 sizeof (short),
8652 _("version symbol data"));
a6e9f9df
AM		 8653 if (!edata)
8654 {
8655 free (strtab);
0429c154 8656 free (symbols);
a6e9f9df
AM		 8657 break;
8658 }
252b5132 8659
3f5e193b 8660 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 8661
8662 for (cnt = total; cnt --;)
b34976b6
AM		 8663 data[cnt] = byte_get (edata + cnt * sizeof (short),
8664 sizeof (short));
252b5132
RH		 8665
8666 free (edata);
8667
8668 for (cnt = 0; cnt < total; cnt += 4)
8669 {
8670 int j, nn;
00d93f34 8671 int check_def, check_need;
2cf0635d 8672 char * name;
252b5132
RH		 8673
8674 printf (" %03x:", cnt);
8675
8676 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 8677 switch (data[cnt + j])
252b5132
RH		 8678 {
8679 case 0:
8680 fputs (_(" 0 (*local*) "), stdout);
8681 break;
8682
8683 case 1:
8684 fputs (_(" 1 (*global*) "), stdout);
8685 break;
8686
8687 default:
c244d050
NC		 8688 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8689 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 8690
dd24e3da 8691 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 8692 array, break to avoid an out-of-bounds read. */
8693 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 8694 {
8695 warn (_("invalid index into symbol array\n"));
8696 break;
8697 }
8698
00d93f34
JJ		 8699 check_def = 1;
8700 check_need = 1;
4fbb74a6
AM		 8701 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8702 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 8703 != SHT_NOBITS)
252b5132 8704 {
b34976b6 8705 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 8706 check_def = 0;
8707 else
8708 check_need = 0;
252b5132 8709 }
00d93f34
JJ		 8710
8711 if (check_need
b34976b6 8712 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 8713 {
b34976b6
AM		 8714 Elf_Internal_Verneed ivn;
8715 unsigned long offset;
252b5132 8716
d93f0186
NC		 8717 offset = offset_from_vma
8718 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8719 sizeof (Elf_External_Verneed));
252b5132 8720
b34976b6 8721 do
252b5132 8722 {
b34976b6
AM		 8723 Elf_Internal_Vernaux ivna;
8724 Elf_External_Verneed evn;
8725 Elf_External_Vernaux evna;
8726 unsigned long a_off;
252b5132 8727
59245841
NC		 8728 if (get_data (&evn, file, offset, sizeof (evn), 1,
8729 _("version need")) == NULL)
8730 break;
8731
252b5132
RH		 8732 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8733 ivn.vn_next = BYTE_GET (evn.vn_next);
8734
8735 a_off = offset + ivn.vn_aux;
8736
8737 do
8738 {
59245841
NC		 8739 if (get_data (&evna, file, a_off, sizeof (evna),
8740 1, _("version need aux (2)")) == NULL)
8741 {
8742 ivna.vna_next = 0;
8743 ivna.vna_other = 0;
8744 }
8745 else
8746 {
8747 ivna.vna_next = BYTE_GET (evna.vna_next);
8748 ivna.vna_other = BYTE_GET (evna.vna_other);
8749 }
252b5132
RH		 8750
8751 a_off += ivna.vna_next;
8752 }
b34976b6 8753 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 8754 && ivna.vna_next != 0);
8755
b34976b6 8756 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 8757 {
8758 ivna.vna_name = BYTE_GET (evna.vna_name);
8759
54806181
AM		 8760 if (ivna.vna_name >= string_sec->sh_size)
8761 name = _("*invalid*");
8762 else
8763 name = strtab + ivna.vna_name;
252b5132 8764 nn += printf ("(%s%-*s",
16062207
ILT		 8765 name,
8766 12 - (int) strlen (name),
252b5132 8767 ")");
00d93f34 8768 check_def = 0;
252b5132
RH		 8769 break;
8770 }
8771
8772 offset += ivn.vn_next;
8773 }
8774 while (ivn.vn_next);
8775 }
00d93f34 8776
b34976b6
AM		 8777 if (check_def && data[cnt + j] != 0x8001
8778 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 8779 {
b34976b6
AM		 8780 Elf_Internal_Verdef ivd;
8781 Elf_External_Verdef evd;
8782 unsigned long offset;
252b5132 8783
d93f0186
NC		 8784 offset = offset_from_vma
8785 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8786 sizeof evd);
252b5132
RH		 8787
8788 do
8789 {
59245841
NC		 8790 if (get_data (&evd, file, offset, sizeof (evd), 1,
8791 _("version def")) == NULL)
8792 {
8793 ivd.vd_next = 0;
8794 ivd.vd_ndx = 0;
8795 }
8796 else
8797 {
8798 ivd.vd_next = BYTE_GET (evd.vd_next);
8799 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8800 }
252b5132
RH		 8801
8802 offset += ivd.vd_next;
8803 }
c244d050 8804 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 8805 && ivd.vd_next != 0);
8806
c244d050 8807 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 8808 {
b34976b6
AM		 8809 Elf_External_Verdaux evda;
8810 Elf_Internal_Verdaux ivda;
252b5132
RH		 8811
8812 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8813
59245841
NC		 8814 if (get_data (&evda, file,
8815 offset - ivd.vd_next + ivd.vd_aux,
8816 sizeof (evda), 1,
8817 _("version def aux")) == NULL)
8818 break;
252b5132
RH		 8819
8820 ivda.vda_name = BYTE_GET (evda.vda_name);
8821
54806181
AM		 8822 if (ivda.vda_name >= string_sec->sh_size)
8823 name = _("*invalid*");
8824 else
8825 name = strtab + ivda.vda_name;
252b5132 8826 nn += printf ("(%s%-*s",
16062207
ILT		 8827 name,
8828 12 - (int) strlen (name),
252b5132
RH		 8829 ")");
8830 }
8831 }
8832
8833 if (nn < 18)
8834 printf ("%*c", 18 - nn, ' ');
8835 }
8836
8837 putchar ('\n');
8838 }
8839
8840 free (data);
8841 free (strtab);
8842 free (symbols);
8843 }
8844 break;
103f02d3 8845
252b5132
RH		 8846 default:
8847 break;
8848 }
8849 }
8850
8851 if (! found)
8852 printf (_("\nNo version information found in this file.\n"));
8853
8854 return 1;
8855}
8856
d1133906 8857static const char *
d3ba0551 8858get_symbol_binding (unsigned int binding)
252b5132 8859{
b34976b6 8860 static char buff[32];
252b5132
RH		 8861
8862 switch (binding)
8863 {
b34976b6
AM		 8864 case STB_LOCAL: return "LOCAL";
8865 case STB_GLOBAL: return "GLOBAL";
8866 case STB_WEAK: return "WEAK";
252b5132
RH		 8867 default:
8868 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 8869 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
8870 binding);
252b5132 8871 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 8872 {
8873 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 8874 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
8875 /* GNU is still using the default value 0. */
3e7a7d11
NC		 8876 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8877 return "UNIQUE";
8878 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
8879 }
252b5132 8880 else
e9e44622 8881 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 8882 return buff;
8883 }
8884}
8885
d1133906 8886static const char *
d3ba0551 8887get_symbol_type (unsigned int type)
252b5132 8888{
b34976b6 8889 static char buff[32];
252b5132
RH		 8890
8891 switch (type)
8892 {
b34976b6
AM		 8893 case STT_NOTYPE: return "NOTYPE";
8894 case STT_OBJECT: return "OBJECT";
8895 case STT_FUNC: return "FUNC";
8896 case STT_SECTION: return "SECTION";
8897 case STT_FILE: return "FILE";
8898 case STT_COMMON: return "COMMON";
8899 case STT_TLS: return "TLS";
15ab5209
DB		 8900 case STT_RELC: return "RELC";
8901 case STT_SRELC: return "SRELC";
252b5132
RH		 8902 default:
8903 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af
NC		 8904 {
8905 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
103f02d3
UD		 8906 return "THUMB_FUNC";
8907
351b4b40 8908 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 8909 return "REGISTER";
8910
8911 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
8912 return "PARISC_MILLI";
8913
e9e44622 8914 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 8915 }
252b5132 8916 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 8917 {
8918 if (elf_header.e_machine == EM_PARISC)
8919 {
8920 if (type == STT_HP_OPAQUE)
8921 return "HP_OPAQUE";
8922 if (type == STT_HP_STUB)
8923 return "HP_STUB";
8924 }
8925
d8045f23 8926 if (type == STT_GNU_IFUNC
9c55345c 8927 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 8928 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 8929 /* GNU is still using the default value 0. */
d8045f23
NC		 8930 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8931 return "IFUNC";
8932
e9e44622 8933 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 8934 }
252b5132 8935 else
e9e44622 8936 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 8937 return buff;
8938 }
8939}
8940
d1133906 8941static const char *
d3ba0551 8942get_symbol_visibility (unsigned int visibility)
d1133906
NC		 8943{
8944 switch (visibility)
8945 {
b34976b6
AM		 8946 case STV_DEFAULT: return "DEFAULT";
8947 case STV_INTERNAL: return "INTERNAL";
8948 case STV_HIDDEN: return "HIDDEN";
d1133906
NC		 8949 case STV_PROTECTED: return "PROTECTED";
8950 default: abort ();
8951 }
8952}
8953
5e2b0d47
NC		 8954static const char *
8955get_mips_symbol_other (unsigned int other)
8956{
8957 switch (other)
8958 {
df58fc94
RS		 8959 case STO_OPTIONAL:
8960 return "OPTIONAL";
8961 case STO_MIPS_PLT:
8962 return "MIPS PLT";
8963 case STO_MIPS_PIC:
8964 return "MIPS PIC";
8965 case STO_MICROMIPS:
8966 return "MICROMIPS";
8967 case STO_MICROMIPS | STO_MIPS_PIC:
8968 return "MICROMIPS, MIPS PIC";
8969 case STO_MIPS16:
8970 return "MIPS16";
8971 default:
8972 return NULL;
5e2b0d47
NC		 8973 }
8974}
8975
28f997cf
TG		 8976static const char *
8977get_ia64_symbol_other (unsigned int other)
8978{
8979 if (is_ia64_vms ())
8980 {
8981 static char res[32];
8982
8983 res[0] = 0;
8984
8985 /* Function types is for images and .STB files only. */
8986 switch (elf_header.e_type)
8987 {
8988 case ET_DYN:
8989 case ET_EXEC:
8990 switch (VMS_ST_FUNC_TYPE (other))
8991 {
8992 case VMS_SFT_CODE_ADDR:
8993 strcat (res, " CA");
8994 break;
8995 case VMS_SFT_SYMV_IDX:
8996 strcat (res, " VEC");
8997 break;
8998 case VMS_SFT_FD:
8999 strcat (res, " FD");
9000 break;
9001 case VMS_SFT_RESERVE:
9002 strcat (res, " RSV");
9003 break;
9004 default:
9005 abort ();
9006 }
9007 break;
9008 default:
9009 break;
9010 }
9011 switch (VMS_ST_LINKAGE (other))
9012 {
9013 case VMS_STL_IGNORE:
9014 strcat (res, " IGN");
9015 break;
9016 case VMS_STL_RESERVE:
9017 strcat (res, " RSV");
9018 break;
9019 case VMS_STL_STD:
9020 strcat (res, " STD");
9021 break;
9022 case VMS_STL_LNK:
9023 strcat (res, " LNK");
9024 break;
9025 default:
9026 abort ();
9027 }
9028
9029 if (res[0] != 0)
9030 return res + 1;
9031 else
9032 return res;
9033 }
9034 return NULL;
9035}
9036
5e2b0d47
NC		 9037static const char *
9038get_symbol_other (unsigned int other)
9039{
9040 const char * result = NULL;
9041 static char buff [32];
9042
9043 if (other == 0)
9044 return "";
9045
9046 switch (elf_header.e_machine)
9047 {
9048 case EM_MIPS:
9049 result = get_mips_symbol_other (other);
28f997cf
TG		 9050 break;
9051 case EM_IA_64:
9052 result = get_ia64_symbol_other (other);
9053 break;
5e2b0d47
NC		 9054 default:
9055 break;
9056 }
9057
9058 if (result)
9059 return result;
9060
9061 snprintf (buff, sizeof buff, _("<other>: %x"), other);
9062 return buff;
9063}
9064
d1133906 9065static const char *
d3ba0551 9066get_symbol_index_type (unsigned int type)
252b5132 9067{
b34976b6 9068 static char buff[32];
5cf1065c 9069
252b5132
RH		 9070 switch (type)
9071 {
b34976b6
AM		 9072 case SHN_UNDEF: return "UND";
9073 case SHN_ABS: return "ABS";
9074 case SHN_COMMON: return "COM";
252b5132 9075 default:
9ce701e2
L		 9076 if (type == SHN_IA_64_ANSI_COMMON
9077 && elf_header.e_machine == EM_IA_64
9078 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
9079 return "ANSI_COM";
8a9036a4 9080 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 9081 || elf_header.e_machine == EM_L1OM
9082 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 9083 && type == SHN_X86_64_LCOMMON)
9084 return "LARGE_COM";
ac145307
BS		 9085 else if ((type == SHN_MIPS_SCOMMON
9086 && elf_header.e_machine == EM_MIPS)
9087 || (type == SHN_TIC6X_SCOMMON
9088 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 9089 return "SCOM";
9090 else if (type == SHN_MIPS_SUNDEFINED
9091 && elf_header.e_machine == EM_MIPS)
9092 return "SUND";
9ce701e2 9093 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 9094 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 9095 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 9096 sprintf (buff, "OS [0x%04x]", type & 0xffff);
9097 else if (type >= SHN_LORESERVE)
9098 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4
L		 9099 else if (type >= elf_header.e_shnum)
9100 sprintf (buff, "bad section index[%3d]", type);
252b5132 9101 else
232e7cb8 9102 sprintf (buff, "%3d", type);
5cf1065c 9103 break;
252b5132 9104 }
5cf1065c
NC		 9105
9106 return buff;
252b5132
RH		 9107}
9108
66543521 9109static bfd_vma *
2cf0635d 9110get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
252b5132 9111{
2cf0635d
NC		 9112 unsigned char * e_data;
9113 bfd_vma * i_data;
252b5132 9114
3f5e193b 9115 e_data = (unsigned char *) cmalloc (number, ent_size);
252b5132
RH		 9116
9117 if (e_data == NULL)
9118 {
9119 error (_("Out of memory\n"));
9120 return NULL;
9121 }
9122
66543521 9123 if (fread (e_data, ent_size, number, file) != number)
252b5132
RH		 9124 {
9125 error (_("Unable to read in dynamic data\n"));
9126 return NULL;
9127 }
9128
3f5e193b 9129 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
252b5132
RH		 9130
9131 if (i_data == NULL)
9132 {
9133 error (_("Out of memory\n"));
9134 free (e_data);
9135 return NULL;
9136 }
9137
9138 while (number--)
66543521 9139 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 9140
9141 free (e_data);
9142
9143 return i_data;
9144}
9145
6bd1a22c
L		 9146static void
9147print_dynamic_symbol (bfd_vma si, unsigned long hn)
9148{
2cf0635d 9149 Elf_Internal_Sym * psym;
6bd1a22c
L		 9150 int n;
9151
9152 psym = dynamic_symbols + si;
9153
9154 n = print_vma (si, DEC_5);
9155 if (n < 5)
9156 fputs (" " + n, stdout);
9157 printf (" %3lu: ", hn);
9158 print_vma (psym->st_value, LONG_HEX);
9159 putchar (' ');
9160 print_vma (psym->st_size, DEC_5);
9161
f4be36b3
AM		 9162 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9163 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9164 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 9165 /* Check to see if any other bits in the st_other field are set.
9166 Note - displaying this information disrupts the layout of the
9167 table being generated, but for the moment this case is very
9168 rare. */
9169 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9170 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9171 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9172 if (VALID_DYNAMIC_NAME (psym->st_name))
9173 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9174 else
2b692964 9175 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 9176 putchar ('\n');
9177}
9178
e3c8793a 9179/* Dump the symbol table. */
252b5132 9180static int
2cf0635d 9181process_symbol_table (FILE * file)
252b5132 9182{
2cf0635d 9183 Elf_Internal_Shdr * section;
66543521
AM		 9184 bfd_vma nbuckets = 0;
9185 bfd_vma nchains = 0;
2cf0635d
NC		 9186 bfd_vma * buckets = NULL;
9187 bfd_vma * chains = NULL;
fdc90cb4 9188 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 9189 bfd_vma * gnubuckets = NULL;
9190 bfd_vma * gnuchains = NULL;
6bd1a22c 9191 bfd_vma gnusymidx = 0;
252b5132 9192
2c610e4b 9193 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 9194 return 1;
9195
6bd1a22c
L		 9196 if (dynamic_info[DT_HASH]
9197 && (do_histogram
2c610e4b
L		 9198 || (do_using_dynamic
9199 && !do_dyn_syms
9200 && dynamic_strings != NULL)))
252b5132 9201 {
66543521
AM		 9202 unsigned char nb[8];
9203 unsigned char nc[8];
9204 int hash_ent_size = 4;
9205
9206 if ((elf_header.e_machine == EM_ALPHA
9207 || elf_header.e_machine == EM_S390
9208 || elf_header.e_machine == EM_S390_OLD)
9209 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
9210 hash_ent_size = 8;
9211
fb52b2f4
NC		 9212 if (fseek (file,
9213 (archive_file_offset
9214 + offset_from_vma (file, dynamic_info[DT_HASH],
9215 sizeof nb + sizeof nc)),
d93f0186 9216 SEEK_SET))
252b5132 9217 {
591a748a 9218 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9219 goto no_hash;
252b5132
RH		 9220 }
9221
66543521 9222 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 9223 {
9224 error (_("Failed to read in number of buckets\n"));
d3a44ec6 9225 goto no_hash;
252b5132
RH		 9226 }
9227
66543521 9228 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 9229 {
9230 error (_("Failed to read in number of chains\n"));
d3a44ec6 9231 goto no_hash;
252b5132
RH		 9232 }
9233
66543521
AM		 9234 nbuckets = byte_get (nb, hash_ent_size);
9235 nchains = byte_get (nc, hash_ent_size);
252b5132 9236
66543521
AM		 9237 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
9238 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 9239
d3a44ec6 9240 no_hash:
252b5132 9241 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 9242 {
9243 if (do_using_dynamic)
9244 return 0;
9245 free (buckets);
9246 free (chains);
9247 buckets = NULL;
9248 chains = NULL;
9249 nbuckets = 0;
9250 nchains = 0;
9251 }
252b5132
RH		 9252 }
9253
6bd1a22c
L		 9254 if (dynamic_info_DT_GNU_HASH
9255 && (do_histogram
2c610e4b
L		 9256 || (do_using_dynamic
9257 && !do_dyn_syms
9258 && dynamic_strings != NULL)))
252b5132 9259 {
6bd1a22c
L		 9260 unsigned char nb[16];
9261 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
9262 bfd_vma buckets_vma;
9263
9264 if (fseek (file,
9265 (archive_file_offset
9266 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
9267 sizeof nb)),
9268 SEEK_SET))
9269 {
9270 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9271 goto no_gnu_hash;
6bd1a22c 9272 }
252b5132 9273
6bd1a22c
L		 9274 if (fread (nb, 16, 1, file) != 1)
9275 {
9276 error (_("Failed to read in number of buckets\n"));
d3a44ec6 9277 goto no_gnu_hash;
6bd1a22c
L		 9278 }
9279
9280 ngnubuckets = byte_get (nb, 4);
9281 gnusymidx = byte_get (nb + 4, 4);
9282 bitmaskwords = byte_get (nb + 8, 4);
9283 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 9284 if (is_32bit_elf)
6bd1a22c 9285 buckets_vma += bitmaskwords * 4;
f7a99963 9286 else
6bd1a22c 9287 buckets_vma += bitmaskwords * 8;
252b5132 9288
6bd1a22c
L		 9289 if (fseek (file,
9290 (archive_file_offset
9291 + offset_from_vma (file, buckets_vma, 4)),
9292 SEEK_SET))
252b5132 9293 {
6bd1a22c 9294 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9295 goto no_gnu_hash;
6bd1a22c
L		 9296 }
9297
9298 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 9299
6bd1a22c 9300 if (gnubuckets == NULL)
d3a44ec6 9301 goto no_gnu_hash;
6bd1a22c
L		 9302
9303 for (i = 0; i < ngnubuckets; i++)
9304 if (gnubuckets[i] != 0)
9305 {
9306 if (gnubuckets[i] < gnusymidx)
9307 return 0;
9308
9309 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9310 maxchain = gnubuckets[i];
9311 }
9312
9313 if (maxchain == 0xffffffff)
d3a44ec6 9314 goto no_gnu_hash;
6bd1a22c
L		 9315
9316 maxchain -= gnusymidx;
9317
9318 if (fseek (file,
9319 (archive_file_offset
9320 + offset_from_vma (file, buckets_vma
9321 + 4 * (ngnubuckets + maxchain), 4)),
9322 SEEK_SET))
9323 {
9324 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9325 goto no_gnu_hash;
6bd1a22c
L		 9326 }
9327
9328 do
9329 {
9330 if (fread (nb, 4, 1, file) != 1)
252b5132 9331 {
6bd1a22c 9332 error (_("Failed to determine last chain length\n"));
d3a44ec6 9333 goto no_gnu_hash;
6bd1a22c 9334 }
252b5132 9335
6bd1a22c 9336 if (maxchain + 1 == 0)
d3a44ec6 9337 goto no_gnu_hash;
252b5132 9338
6bd1a22c
L		 9339 ++maxchain;
9340 }
9341 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 9342
6bd1a22c
L		 9343 if (fseek (file,
9344 (archive_file_offset
9345 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9346 SEEK_SET))
9347 {
9348 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9349 goto no_gnu_hash;
6bd1a22c
L		 9350 }
9351
9352 gnuchains = get_dynamic_data (file, maxchain, 4);
9353
d3a44ec6 9354 no_gnu_hash:
6bd1a22c 9355 if (gnuchains == NULL)
d3a44ec6
JJ		 9356 {
9357 free (gnubuckets);
d3a44ec6
JJ		 9358 gnubuckets = NULL;
9359 ngnubuckets = 0;
f64fddf1
NC		 9360 if (do_using_dynamic)
9361 return 0;
d3a44ec6 9362 }
6bd1a22c
L		 9363 }
9364
9365 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9366 && do_syms
9367 && do_using_dynamic
9368 && dynamic_strings != NULL)
9369 {
9370 unsigned long hn;
9371
9372 if (dynamic_info[DT_HASH])
9373 {
9374 bfd_vma si;
9375
9376 printf (_("\nSymbol table for image:\n"));
9377 if (is_32bit_elf)
9378 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9379 else
9380 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9381
9382 for (hn = 0; hn < nbuckets; hn++)
9383 {
9384 if (! buckets[hn])
9385 continue;
9386
9387 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9388 print_dynamic_symbol (si, hn);
252b5132
RH		 9389 }
9390 }
6bd1a22c
L		 9391
9392 if (dynamic_info_DT_GNU_HASH)
9393 {
9394 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9395 if (is_32bit_elf)
9396 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9397 else
9398 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9399
9400 for (hn = 0; hn < ngnubuckets; ++hn)
9401 if (gnubuckets[hn] != 0)
9402 {
9403 bfd_vma si = gnubuckets[hn];
9404 bfd_vma off = si - gnusymidx;
9405
9406 do
9407 {
9408 print_dynamic_symbol (si, hn);
9409 si++;
9410 }
9411 while ((gnuchains[off++] & 1) == 0);
9412 }
9413 }
252b5132 9414 }
2c610e4b 9415 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
252b5132 9416 {
b34976b6 9417 unsigned int i;
252b5132
RH		 9418
9419 for (i = 0, section = section_headers;
9420 i < elf_header.e_shnum;
9421 i++, section++)
9422 {
b34976b6 9423 unsigned int si;
2cf0635d 9424 char * strtab = NULL;
c256ffe7 9425 unsigned long int strtab_size = 0;
2cf0635d
NC		 9426 Elf_Internal_Sym * symtab;
9427 Elf_Internal_Sym * psym;
ba5cdace 9428 unsigned long num_syms;
252b5132 9429
2c610e4b
L		 9430 if ((section->sh_type != SHT_SYMTAB
9431 && section->sh_type != SHT_DYNSYM)
9432 || (!do_syms
9433 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 9434 continue;
9435
dd24e3da
NC		 9436 if (section->sh_entsize == 0)
9437 {
9438 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9439 SECTION_NAME (section));
9440 continue;
9441 }
9442
252b5132
RH		 9443 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9444 SECTION_NAME (section),
9445 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 9446
f7a99963 9447 if (is_32bit_elf)
ca47b30c 9448 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 9449 else
ca47b30c 9450 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 9451
ba5cdace 9452 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 9453 if (symtab == NULL)
9454 continue;
9455
9456 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 9457 {
9458 strtab = string_table;
9459 strtab_size = string_table_length;
9460 }
4fbb74a6 9461 else if (section->sh_link < elf_header.e_shnum)
252b5132 9462 {
2cf0635d 9463 Elf_Internal_Shdr * string_sec;
252b5132 9464
4fbb74a6 9465 string_sec = section_headers + section->sh_link;
252b5132 9466
3f5e193b
NC		 9467 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9468 1, string_sec->sh_size,
9469 _("string table"));
c256ffe7 9470 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 9471 }
9472
ba5cdace 9473 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 9474 {
5e220199 9475 printf ("%6d: ", si);
f7a99963
NC		 9476 print_vma (psym->st_value, LONG_HEX);
9477 putchar (' ');
9478 print_vma (psym->st_size, DEC_5);
d1133906
NC		 9479 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9480 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 9481 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 9482 /* Check to see if any other bits in the st_other field are set.
9483 Note - displaying this information disrupts the layout of the
9484 table being generated, but for the moment this case is very rare. */
9485 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9486 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 9487 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 9488 print_symbol (25, psym->st_name < strtab_size
2b692964 9489 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 9490
59245841
NC		 9491 if (section->sh_type == SHT_DYNSYM
9492 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
252b5132 9493 {
b34976b6
AM		 9494 unsigned char data[2];
9495 unsigned short vers_data;
9496 unsigned long offset;
9497 int is_nobits;
9498 int check_def;
252b5132 9499
d93f0186
NC		 9500 offset = offset_from_vma
9501 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9502 sizeof data + si * sizeof (vers_data));
252b5132 9503
59245841
NC		 9504 if (get_data (&data, file, offset + si * sizeof (vers_data),
9505 sizeof (data), 1, _("version data")) == NULL)
9506 break;
252b5132
RH		 9507
9508 vers_data = byte_get (data, 2);
9509
4fbb74a6
AM		 9510 is_nobits = (psym->st_shndx < elf_header.e_shnum
9511 && section_headers[psym->st_shndx].sh_type
c256ffe7 9512 == SHT_NOBITS);
252b5132
RH		 9513
9514 check_def = (psym->st_shndx != SHN_UNDEF);
9515
c244d050 9516 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
252b5132 9517 {
b34976b6 9518 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
00d93f34 9519 && (is_nobits || ! check_def))
252b5132 9520 {
b34976b6
AM		 9521 Elf_External_Verneed evn;
9522 Elf_Internal_Verneed ivn;
9523 Elf_Internal_Vernaux ivna;
252b5132
RH		 9524
9525 /* We must test both. */
d93f0186
NC		 9526 offset = offset_from_vma
9527 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9528 sizeof evn);
252b5132 9529
252b5132
RH		 9530 do
9531 {
b34976b6 9532 unsigned long vna_off;
252b5132 9533
59245841
NC		 9534 if (get_data (&evn, file, offset, sizeof (evn), 1,
9535 _("version need")) == NULL)
9536 {
9537 ivna.vna_next = 0;
9538 ivna.vna_other = 0;
9539 ivna.vna_name = 0;
9540 break;
9541 }
dd27201e
L		 9542
9543 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9544 ivn.vn_next = BYTE_GET (evn.vn_next);
9545
252b5132
RH		 9546 vna_off = offset + ivn.vn_aux;
9547
9548 do
9549 {
b34976b6 9550 Elf_External_Vernaux evna;
252b5132 9551
59245841
NC		 9552 if (get_data (&evna, file, vna_off,
9553 sizeof (evna), 1,
9554 _("version need aux (3)")) == NULL)
9555 {
9556 ivna.vna_next = 0;
9557 ivna.vna_other = 0;
9558 ivna.vna_name = 0;
9559 }
9560 else
9561 {
9562 ivna.vna_other = BYTE_GET (evna.vna_other);
9563 ivna.vna_next = BYTE_GET (evna.vna_next);
9564 ivna.vna_name = BYTE_GET (evna.vna_name);
9565 }
252b5132
RH		 9566
9567 vna_off += ivna.vna_next;
9568 }
9569 while (ivna.vna_other != vers_data
9570 && ivna.vna_next != 0);
9571
9572 if (ivna.vna_other == vers_data)
9573 break;
9574
9575 offset += ivn.vn_next;
9576 }
9577 while (ivn.vn_next != 0);
9578
9579 if (ivna.vna_other == vers_data)
9580 {
9581 printf ("@%s (%d)",
c256ffe7 9582 ivna.vna_name < strtab_size
2b692964 9583 ? strtab + ivna.vna_name : _("<corrupt>"),
c256ffe7 9584 ivna.vna_other);
252b5132
RH		 9585 check_def = 0;
9586 }
9587 else if (! is_nobits)
591a748a 9588 error (_("bad dynamic symbol\n"));
252b5132
RH		 9589 else
9590 check_def = 1;
9591 }
9592
9593 if (check_def)
9594 {
00d93f34 9595 if (vers_data != 0x8001
b34976b6 9596 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9597 {
b34976b6
AM		 9598 Elf_Internal_Verdef ivd;
9599 Elf_Internal_Verdaux ivda;
9600 Elf_External_Verdaux evda;
91d6fa6a 9601 unsigned long off;
252b5132 9602
91d6fa6a 9603 off = offset_from_vma
d93f0186
NC		 9604 (file,
9605 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9606 sizeof (Elf_External_Verdef));
252b5132
RH		 9607
9608 do
9609 {
b34976b6 9610 Elf_External_Verdef evd;
252b5132 9611
59245841
NC		 9612 if (get_data (&evd, file, off, sizeof (evd),
9613 1, _("version def")) == NULL)
9614 {
9615 ivd.vd_ndx = 0;
9616 ivd.vd_aux = 0;
9617 ivd.vd_next = 0;
9618 }
9619 else
9620 {
9621 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9622 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9623 ivd.vd_next = BYTE_GET (evd.vd_next);
9624 }
252b5132 9625
91d6fa6a 9626 off += ivd.vd_next;
252b5132 9627 }
c244d050 9628 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
252b5132
RH		 9629 && ivd.vd_next != 0);
9630
91d6fa6a
NC		 9631 off -= ivd.vd_next;
9632 off += ivd.vd_aux;
252b5132 9633
59245841
NC		 9634 if (get_data (&evda, file, off, sizeof (evda),
9635 1, _("version def aux")) == NULL)
9636 break;
252b5132
RH		 9637
9638 ivda.vda_name = BYTE_GET (evda.vda_name);
9639
9640 if (psym->st_name != ivda.vda_name)
c244d050 9641 printf ((vers_data & VERSYM_HIDDEN)
252b5132 9642 ? "@%s" : "@@%s",
c256ffe7 9643 ivda.vda_name < strtab_size
2b692964 9644 ? strtab + ivda.vda_name : _("<corrupt>"));
252b5132
RH		 9645 }
9646 }
9647 }
9648 }
9649
9650 putchar ('\n');
9651 }
9652
9653 free (symtab);
9654 if (strtab != string_table)
9655 free (strtab);
9656 }
9657 }
9658 else if (do_syms)
9659 printf
9660 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9661
9662 if (do_histogram && buckets != NULL)
9663 {
2cf0635d
NC		 9664 unsigned long * lengths;
9665 unsigned long * counts;
66543521
AM		 9666 unsigned long hn;
9667 bfd_vma si;
9668 unsigned long maxlength = 0;
9669 unsigned long nzero_counts = 0;
9670 unsigned long nsyms = 0;
252b5132 9671
66543521
AM		 9672 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9673 (unsigned long) nbuckets);
252b5132
RH		 9674 printf (_(" Length Number %% of total Coverage\n"));
9675
3f5e193b 9676 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 9677 if (lengths == NULL)
9678 {
591a748a 9679 error (_("Out of memory\n"));
252b5132
RH		 9680 return 0;
9681 }
9682 for (hn = 0; hn < nbuckets; ++hn)
9683 {
f7a99963 9684 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
252b5132 9685 {
b34976b6 9686 ++nsyms;
252b5132 9687 if (maxlength < ++lengths[hn])
b34976b6 9688 ++maxlength;
252b5132
RH		 9689 }
9690 }
9691
3f5e193b 9692 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 9693 if (counts == NULL)
9694 {
591a748a 9695 error (_("Out of memory\n"));
252b5132
RH		 9696 return 0;
9697 }
9698
9699 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 9700 ++counts[lengths[hn]];
252b5132 9701
103f02d3 9702 if (nbuckets > 0)
252b5132 9703 {
66543521
AM		 9704 unsigned long i;
9705 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 9706 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 9707 for (i = 1; i <= maxlength; ++i)
103f02d3 9708 {
66543521
AM		 9709 nzero_counts += counts[i] * i;
9710 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9711 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 9712 (nzero_counts * 100.0) / nsyms);
9713 }
252b5132
RH		 9714 }
9715
9716 free (counts);
9717 free (lengths);
9718 }
9719
9720 if (buckets != NULL)
9721 {
9722 free (buckets);
9723 free (chains);
9724 }
9725
d3a44ec6 9726 if (do_histogram && gnubuckets != NULL)
fdc90cb4 9727 {
2cf0635d
NC		 9728 unsigned long * lengths;
9729 unsigned long * counts;
fdc90cb4
JJ		 9730 unsigned long hn;
9731 unsigned long maxlength = 0;
9732 unsigned long nzero_counts = 0;
9733 unsigned long nsyms = 0;
fdc90cb4 9734
3f5e193b 9735 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 9736 if (lengths == NULL)
9737 {
591a748a 9738 error (_("Out of memory\n"));
fdc90cb4
JJ		 9739 return 0;
9740 }
9741
9742 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9743 (unsigned long) ngnubuckets);
9744 printf (_(" Length Number %% of total Coverage\n"));
9745
9746 for (hn = 0; hn < ngnubuckets; ++hn)
9747 if (gnubuckets[hn] != 0)
9748 {
9749 bfd_vma off, length = 1;
9750
6bd1a22c 9751 for (off = gnubuckets[hn] - gnusymidx;
fdc90cb4
JJ		 9752 (gnuchains[off] & 1) == 0; ++off)
9753 ++length;
9754 lengths[hn] = length;
9755 if (length > maxlength)
9756 maxlength = length;
9757 nsyms += length;
9758 }
9759
3f5e193b 9760 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 9761 if (counts == NULL)
9762 {
591a748a 9763 error (_("Out of memory\n"));
fdc90cb4
JJ		 9764 return 0;
9765 }
9766
9767 for (hn = 0; hn < ngnubuckets; ++hn)
9768 ++counts[lengths[hn]];
9769
9770 if (ngnubuckets > 0)
9771 {
9772 unsigned long j;
9773 printf (" 0 %-10lu (%5.1f%%)\n",
9774 counts[0], (counts[0] * 100.0) / ngnubuckets);
9775 for (j = 1; j <= maxlength; ++j)
9776 {
9777 nzero_counts += counts[j] * j;
9778 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9779 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9780 (nzero_counts * 100.0) / nsyms);
9781 }
9782 }
9783
9784 free (counts);
9785 free (lengths);
9786 free (gnubuckets);
9787 free (gnuchains);
9788 }
9789
252b5132
RH		 9790 return 1;
9791}
9792
9793static int
2cf0635d 9794process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 9795{
b4c96d0d 9796 unsigned int i;
252b5132
RH		 9797
9798 if (dynamic_syminfo == NULL
9799 || !do_dynamic)
9800 /* No syminfo, this is ok. */
9801 return 1;
9802
9803 /* There better should be a dynamic symbol section. */
9804 if (dynamic_symbols == NULL || dynamic_strings == NULL)
9805 return 0;
9806
9807 if (dynamic_addr)
9808 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9809 dynamic_syminfo_offset, dynamic_syminfo_nent);
9810
9811 printf (_(" Num: Name BoundTo Flags\n"));
9812 for (i = 0; i < dynamic_syminfo_nent; ++i)
9813 {
9814 unsigned short int flags = dynamic_syminfo[i].si_flags;
9815
31104126 9816 printf ("%4d: ", i);
d79b3d50
NC		 9817 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9818 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9819 else
2b692964 9820 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 9821 putchar (' ');
252b5132
RH		 9822
9823 switch (dynamic_syminfo[i].si_boundto)
9824 {
9825 case SYMINFO_BT_SELF:
9826 fputs ("SELF ", stdout);
9827 break;
9828 case SYMINFO_BT_PARENT:
9829 fputs ("PARENT ", stdout);
9830 break;
9831 default:
9832 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 9833 && dynamic_syminfo[i].si_boundto < dynamic_nent
9834 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 9835 {
d79b3d50 9836 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 9837 putchar (' ' );
9838 }
252b5132
RH		 9839 else
9840 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
9841 break;
9842 }
9843
9844 if (flags & SYMINFO_FLG_DIRECT)
9845 printf (" DIRECT");
9846 if (flags & SYMINFO_FLG_PASSTHRU)
9847 printf (" PASSTHRU");
9848 if (flags & SYMINFO_FLG_COPY)
9849 printf (" COPY");
9850 if (flags & SYMINFO_FLG_LAZYLOAD)
9851 printf (" LAZYLOAD");
9852
9853 puts ("");
9854 }
9855
9856 return 1;
9857}
9858
cf13d699
NC		 9859/* Check to see if the given reloc needs to be handled in a target specific
9860 manner. If so then process the reloc and return TRUE otherwise return
9861 FALSE. */
09c11c86 9862
cf13d699
NC		 9863static bfd_boolean
9864target_specific_reloc_handling (Elf_Internal_Rela * reloc,
9865 unsigned char * start,
9866 Elf_Internal_Sym * symtab)
252b5132 9867{
cf13d699 9868 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 9869
cf13d699 9870 switch (elf_header.e_machine)
252b5132 9871 {
cf13d699
NC		 9872 case EM_MN10300:
9873 case EM_CYGNUS_MN10300:
9874 {
9875 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 9876
cf13d699
NC		 9877 switch (reloc_type)
9878 {
9879 case 34: /* R_MN10300_ALIGN */
9880 return TRUE;
9881 case 33: /* R_MN10300_SYM_DIFF */
9882 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
9883 return TRUE;
9884 case 1: /* R_MN10300_32 */
9885 case 2: /* R_MN10300_16 */
9886 if (saved_sym != NULL)
9887 {
9888 bfd_vma value;
252b5132 9889
cf13d699
NC		 9890 value = reloc->r_addend
9891 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
9892 - saved_sym->st_value);
252b5132 9893
cf13d699 9894 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 9895
cf13d699
NC		 9896 saved_sym = NULL;
9897 return TRUE;
9898 }
9899 break;
9900 default:
9901 if (saved_sym != NULL)
9902 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9903 break;
9904 }
9905 break;
9906 }
252b5132
RH		 9907 }
9908
cf13d699 9909 return FALSE;
252b5132
RH		 9910}
9911
aca88567
NC		 9912/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9913 DWARF debug sections. This is a target specific test. Note - we do not
9914 go through the whole including-target-headers-multiple-times route, (as
9915 we have already done with <elf/h8.h>) because this would become very
9916 messy and even then this function would have to contain target specific
9917 information (the names of the relocs instead of their numeric values).
9918 FIXME: This is not the correct way to solve this problem. The proper way
9919 is to have target specific reloc sizing and typing functions created by
9920 the reloc-macros.h header, in the same way that it already creates the
9921 reloc naming functions. */
9922
9923static bfd_boolean
9924is_32bit_abs_reloc (unsigned int reloc_type)
9925{
9926 switch (elf_header.e_machine)
9927 {
41e92641
NC		 9928 case EM_386:
9929 case EM_486:
9930 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 9931 case EM_68K:
9932 return reloc_type == 1; /* R_68K_32. */
9933 case EM_860:
9934 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 9935 case EM_960:
9936 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 9937 case EM_AARCH64:
9938 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 9939 case EM_ALPHA:
137b6b5f 9940 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 9941 case EM_ARC:
9942 return reloc_type == 1; /* R_ARC_32. */
9943 case EM_ARM:
9944 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 9945 case EM_AVR_OLD:
aca88567
NC		 9946 case EM_AVR:
9947 return reloc_type == 1;
cfb8c092
NC		 9948 case EM_ADAPTEVA_EPIPHANY:
9949 return reloc_type == 3;
aca88567
NC		 9950 case EM_BLACKFIN:
9951 return reloc_type == 0x12; /* R_byte4_data. */
9952 case EM_CRIS:
9953 return reloc_type == 3; /* R_CRIS_32. */
9954 case EM_CR16:
9955 return reloc_type == 3; /* R_CR16_NUM32. */
9956 case EM_CRX:
9957 return reloc_type == 15; /* R_CRX_NUM32. */
9958 case EM_CYGNUS_FRV:
9959 return reloc_type == 1;
41e92641
NC		 9960 case EM_CYGNUS_D10V:
9961 case EM_D10V:
9962 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 9963 case EM_CYGNUS_D30V:
9964 case EM_D30V:
9965 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 9966 case EM_DLX:
9967 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 9968 case EM_CYGNUS_FR30:
9969 case EM_FR30:
9970 return reloc_type == 3; /* R_FR30_32. */
9971 case EM_H8S:
9972 case EM_H8_300:
9973 case EM_H8_300H:
9974 return reloc_type == 1; /* R_H8_DIR32. */
3730236a
NC		 9975 case EM_IA_64:
9976 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
aca88567
NC		 9977 case EM_IP2K_OLD:
9978 case EM_IP2K:
9979 return reloc_type == 2; /* R_IP2K_32. */
9980 case EM_IQ2000:
9981 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 9982 case EM_LATTICEMICO32:
9983 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 9984 case EM_M32C_OLD:
aca88567
NC		 9985 case EM_M32C:
9986 return reloc_type == 3; /* R_M32C_32. */
9987 case EM_M32R:
9988 return reloc_type == 34; /* R_M32R_32_RELA. */
9989 case EM_MCORE:
9990 return reloc_type == 1; /* R_MCORE_ADDR32. */
9991 case EM_CYGNUS_MEP:
9992 return reloc_type == 4; /* R_MEP_32. */
137b6b5f
AM		 9993 case EM_MICROBLAZE:
9994 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 9995 case EM_MIPS:
9996 return reloc_type == 2; /* R_MIPS_32. */
9997 case EM_MMIX:
9998 return reloc_type == 4; /* R_MMIX_32. */
9999 case EM_CYGNUS_MN10200:
10000 case EM_MN10200:
10001 return reloc_type == 1; /* R_MN10200_32. */
10002 case EM_CYGNUS_MN10300:
10003 case EM_MN10300:
10004 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 10005 case EM_MOXIE:
10006 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 10007 case EM_MSP430_OLD:
10008 case EM_MSP430:
10009 return reloc_type == 1; /* R_MSP43_32. */
10010 case EM_MT:
10011 return reloc_type == 2; /* R_MT_32. */
3e0873ac
NC		 10012 case EM_ALTERA_NIOS2:
10013 case EM_NIOS32:
10014 return reloc_type == 1; /* R_NIOS_32. */
41e92641
NC		 10015 case EM_OPENRISC:
10016 case EM_OR32:
10017 return reloc_type == 1; /* R_OR32_32. */
aca88567 10018 case EM_PARISC:
5fda8eca
NC		 10019 return (reloc_type == 1 /* R_PARISC_DIR32. */
10020 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 10021 case EM_PJ:
10022 case EM_PJ_OLD:
10023 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
10024 case EM_PPC64:
10025 return reloc_type == 1; /* R_PPC64_ADDR32. */
10026 case EM_PPC:
10027 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 10028 case EM_RL78:
10029 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 10030 case EM_RX:
10031 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 10032 case EM_S370:
10033 return reloc_type == 1; /* R_I370_ADDR31. */
10034 case EM_S390_OLD:
10035 case EM_S390:
10036 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 10037 case EM_SCORE:
10038 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 10039 case EM_SH:
10040 return reloc_type == 1; /* R_SH_DIR32. */
10041 case EM_SPARC32PLUS:
10042 case EM_SPARCV9:
10043 case EM_SPARC:
10044 return reloc_type == 3 /* R_SPARC_32. */
10045 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 10046 case EM_SPU:
10047 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 10048 case EM_TI_C6000:
10049 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 10050 case EM_TILEGX:
10051 return reloc_type == 2; /* R_TILEGX_32. */
10052 case EM_TILEPRO:
10053 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 10054 case EM_CYGNUS_V850:
10055 case EM_V850:
10056 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 10057 case EM_V800:
10058 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 10059 case EM_VAX:
10060 return reloc_type == 1; /* R_VAX_32. */
10061 case EM_X86_64:
8a9036a4 10062 case EM_L1OM:
7a9068fe 10063 case EM_K1OM:
aca88567 10064 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 10065 case EM_XC16X:
10066 case EM_C166:
10067 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 10068 case EM_XGATE:
10069 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 10070 case EM_XSTORMY16:
10071 return reloc_type == 1; /* R_XSTROMY16_32. */
10072 case EM_XTENSA_OLD:
10073 case EM_XTENSA:
10074 return reloc_type == 1; /* R_XTENSA_32. */
aca88567
NC		 10075 default:
10076 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10077 elf_header.e_machine);
10078 abort ();
10079 }
10080}
10081
10082/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10083 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10084
10085static bfd_boolean
10086is_32bit_pcrel_reloc (unsigned int reloc_type)
10087{
10088 switch (elf_header.e_machine)
10089 {
41e92641
NC		 10090 case EM_386:
10091 case EM_486:
3e0873ac 10092 return reloc_type == 2; /* R_386_PC32. */
aca88567 10093 case EM_68K:
3e0873ac 10094 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 10095 case EM_AARCH64:
10096 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 10097 case EM_ADAPTEVA_EPIPHANY:
10098 return reloc_type == 6;
aca88567
NC		 10099 case EM_ALPHA:
10100 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 10101 case EM_ARM:
3e0873ac 10102 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 10103 case EM_MICROBLAZE:
10104 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
aca88567 10105 case EM_PARISC:
85acf597 10106 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 10107 case EM_PPC:
10108 return reloc_type == 26; /* R_PPC_REL32. */
10109 case EM_PPC64:
3e0873ac 10110 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 10111 case EM_S390_OLD:
10112 case EM_S390:
3e0873ac 10113 return reloc_type == 5; /* R_390_PC32. */
aca88567 10114 case EM_SH:
3e0873ac 10115 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 10116 case EM_SPARC32PLUS:
10117 case EM_SPARCV9:
10118 case EM_SPARC:
3e0873ac 10119 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 10120 case EM_SPU:
10121 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 10122 case EM_TILEGX:
10123 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
10124 case EM_TILEPRO:
10125 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
aca88567 10126 case EM_X86_64:
8a9036a4 10127 case EM_L1OM:
7a9068fe 10128 case EM_K1OM:
3e0873ac 10129 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 10130 case EM_XTENSA_OLD:
10131 case EM_XTENSA:
10132 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 10133 default:
10134 /* Do not abort or issue an error message here. Not all targets use
10135 pc-relative 32-bit relocs in their DWARF debug information and we
10136 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 10137 more helpful warning message will be generated by apply_relocations
10138 anyway, so just return. */
aca88567
NC		 10139 return FALSE;
10140 }
10141}
10142
10143/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10144 a 64-bit absolute RELA relocation used in DWARF debug sections. */
10145
10146static bfd_boolean
10147is_64bit_abs_reloc (unsigned int reloc_type)
10148{
10149 switch (elf_header.e_machine)
10150 {
a06ea964
NC		 10151 case EM_AARCH64:
10152 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 10153 case EM_ALPHA:
10154 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 10155 case EM_IA_64:
10156 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 10157 case EM_PARISC:
10158 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 10159 case EM_PPC64:
10160 return reloc_type == 38; /* R_PPC64_ADDR64. */
10161 case EM_SPARC32PLUS:
10162 case EM_SPARCV9:
10163 case EM_SPARC:
10164 return reloc_type == 54; /* R_SPARC_UA64. */
10165 case EM_X86_64:
8a9036a4 10166 case EM_L1OM:
7a9068fe 10167 case EM_K1OM:
aca88567 10168 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 10169 case EM_S390_OLD:
10170 case EM_S390:
aa137e4d
NC		 10171 return reloc_type == 22; /* R_S390_64. */
10172 case EM_TILEGX:
10173 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 10174 case EM_MIPS:
aa137e4d 10175 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 10176 default:
10177 return FALSE;
10178 }
10179}
10180
85acf597
RH		 10181/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10182 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10183
10184static bfd_boolean
10185is_64bit_pcrel_reloc (unsigned int reloc_type)
10186{
10187 switch (elf_header.e_machine)
10188 {
a06ea964
NC		 10189 case EM_AARCH64:
10190 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 10191 case EM_ALPHA:
aa137e4d 10192 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 10193 case EM_IA_64:
aa137e4d 10194 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 10195 case EM_PARISC:
aa137e4d 10196 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 10197 case EM_PPC64:
aa137e4d 10198 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 10199 case EM_SPARC32PLUS:
10200 case EM_SPARCV9:
10201 case EM_SPARC:
aa137e4d 10202 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 10203 case EM_X86_64:
8a9036a4 10204 case EM_L1OM:
7a9068fe 10205 case EM_K1OM:
aa137e4d 10206 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 10207 case EM_S390_OLD:
10208 case EM_S390:
aa137e4d
NC		 10209 return reloc_type == 23; /* R_S390_PC64. */
10210 case EM_TILEGX:
10211 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 10212 default:
10213 return FALSE;
10214 }
10215}
10216
4dc3c23d
AM		 10217/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10218 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10219
10220static bfd_boolean
10221is_24bit_abs_reloc (unsigned int reloc_type)
10222{
10223 switch (elf_header.e_machine)
10224 {
10225 case EM_CYGNUS_MN10200:
10226 case EM_MN10200:
10227 return reloc_type == 4; /* R_MN10200_24. */
10228 default:
10229 return FALSE;
10230 }
10231}
10232
aca88567
NC		 10233/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10234 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10235
10236static bfd_boolean
10237is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 10238{
10239 switch (elf_header.e_machine)
10240 {
aca88567
NC		 10241 case EM_AVR_OLD:
10242 case EM_AVR:
10243 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 10244 case EM_ADAPTEVA_EPIPHANY:
10245 return reloc_type == 5;
41e92641
NC		 10246 case EM_CYGNUS_D10V:
10247 case EM_D10V:
10248 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 10249 case EM_H8S:
10250 case EM_H8_300:
10251 case EM_H8_300H:
aca88567
NC		 10252 return reloc_type == R_H8_DIR16;
10253 case EM_IP2K_OLD:
10254 case EM_IP2K:
10255 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 10256 case EM_M32C_OLD:
f4236fe4
DD		 10257 case EM_M32C:
10258 return reloc_type == 1; /* R_M32C_16 */
aca88567
NC		 10259 case EM_MSP430_OLD:
10260 case EM_MSP430:
10261 return reloc_type == 5; /* R_MSP430_16_BYTE. */
3e0873ac
NC		 10262 case EM_ALTERA_NIOS2:
10263 case EM_NIOS32:
10264 return reloc_type == 9; /* R_NIOS_16. */
40b36596
JM		 10265 case EM_TI_C6000:
10266 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 10267 case EM_XC16X:
10268 case EM_C166:
10269 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 10270 case EM_CYGNUS_MN10200:
10271 case EM_MN10200:
10272 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 10273 case EM_CYGNUS_MN10300:
10274 case EM_MN10300:
10275 return reloc_type == 2; /* R_MN10300_16. */
f6c1a2d5
NC		 10276 case EM_XGATE:
10277 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 10278 default:
aca88567 10279 return FALSE;
4b78141a
NC		 10280 }
10281}
10282
2a7b2e88
JK		 10283/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10284 relocation entries (possibly formerly used for SHT_GROUP sections). */
10285
10286static bfd_boolean
10287is_none_reloc (unsigned int reloc_type)
10288{
10289 switch (elf_header.e_machine)
10290 {
cb8f3167
NC		 10291 case EM_68K: /* R_68K_NONE. */
10292 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 10293 case EM_SPARC32PLUS:
10294 case EM_SPARCV9:
cb8f3167
NC		 10295 case EM_SPARC: /* R_SPARC_NONE. */
10296 case EM_MIPS: /* R_MIPS_NONE. */
10297 case EM_PARISC: /* R_PARISC_NONE. */
10298 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 10299 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 10300 case EM_PPC: /* R_PPC_NONE. */
10301 case EM_PPC64: /* R_PPC64_NONE. */
10302 case EM_ARM: /* R_ARM_NONE. */
10303 case EM_IA_64: /* R_IA64_NONE. */
10304 case EM_SH: /* R_SH_NONE. */
2a7b2e88 10305 case EM_S390_OLD:
cb8f3167
NC		 10306 case EM_S390: /* R_390_NONE. */
10307 case EM_CRIS: /* R_CRIS_NONE. */
10308 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 10309 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 10310 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 10311 case EM_MN10300: /* R_MN10300_NONE. */
5506d11a 10312 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 10313 case EM_M32R: /* R_M32R_NONE. */
40b36596 10314 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 10315 case EM_TILEGX: /* R_TILEGX_NONE. */
10316 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 10317 case EM_XC16X:
10318 case EM_C166: /* R_XC16X_NONE. */
cb8f3167 10319 return reloc_type == 0;
a06ea964
NC		 10320 case EM_AARCH64:
10321 return reloc_type == 0 || reloc_type == 256;
58332dda
JK		 10322 case EM_XTENSA_OLD:
10323 case EM_XTENSA:
4dc3c23d
AM		 10324 return (reloc_type == 0 /* R_XTENSA_NONE. */
10325 || reloc_type == 17 /* R_XTENSA_DIFF8. */
10326 || reloc_type == 18 /* R_XTENSA_DIFF16. */
10327 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
2a7b2e88
JK		 10328 }
10329 return FALSE;
10330}
10331
cf13d699
NC		 10332/* Apply relocations to a section.
10333 Note: So far support has been added only for those relocations
10334 which can be found in debug sections.
10335 FIXME: Add support for more relocations ? */
1b315056 10336
cf13d699
NC		 10337static void
10338apply_relocations (void * file,
10339 Elf_Internal_Shdr * section,
10340 unsigned char * start)
1b315056 10341{
cf13d699
NC		 10342 Elf_Internal_Shdr * relsec;
10343 unsigned char * end = start + section->sh_size;
cb8f3167 10344
cf13d699
NC		 10345 if (elf_header.e_type != ET_REL)
10346 return;
1b315056 10347
cf13d699 10348 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 10349 for (relsec = section_headers;
10350 relsec < section_headers + elf_header.e_shnum;
10351 ++relsec)
252b5132 10352 {
41e92641
NC		 10353 bfd_boolean is_rela;
10354 unsigned long num_relocs;
2cf0635d
NC		 10355 Elf_Internal_Rela * relocs;
10356 Elf_Internal_Rela * rp;
10357 Elf_Internal_Shdr * symsec;
10358 Elf_Internal_Sym * symtab;
ba5cdace 10359 unsigned long num_syms;
2cf0635d 10360 Elf_Internal_Sym * sym;
252b5132 10361
41e92641 10362 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 10363 || relsec->sh_info >= elf_header.e_shnum
10364 || section_headers + relsec->sh_info != section
c256ffe7 10365 || relsec->sh_size == 0
4fbb74a6 10366 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 10367 continue;
428409d5 10368
41e92641
NC		 10369 is_rela = relsec->sh_type == SHT_RELA;
10370
10371 if (is_rela)
10372 {
3f5e193b
NC		 10373 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10374 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10375 return;
10376 }
10377 else
10378 {
3f5e193b
NC		 10379 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10380 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10381 return;
10382 }
10383
10384 /* SH uses RELA but uses in place value instead of the addend field. */
10385 if (elf_header.e_machine == EM_SH)
10386 is_rela = FALSE;
428409d5 10387
4fbb74a6 10388 symsec = section_headers + relsec->sh_link;
ba5cdace 10389 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 10390
41e92641 10391 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 10392 {
41e92641
NC		 10393 bfd_vma addend;
10394 unsigned int reloc_type;
10395 unsigned int reloc_size;
91d6fa6a 10396 unsigned char * rloc;
ba5cdace 10397 unsigned long sym_index;
4b78141a 10398
aca88567 10399 reloc_type = get_reloc_type (rp->r_info);
41e92641 10400
98fb390a 10401 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 10402 continue;
98fb390a
NC		 10403 else if (is_none_reloc (reloc_type))
10404 continue;
10405 else if (is_32bit_abs_reloc (reloc_type)
10406 || is_32bit_pcrel_reloc (reloc_type))
aca88567 10407 reloc_size = 4;
85acf597
RH		 10408 else if (is_64bit_abs_reloc (reloc_type)
10409 || is_64bit_pcrel_reloc (reloc_type))
aca88567 10410 reloc_size = 8;
4dc3c23d
AM		 10411 else if (is_24bit_abs_reloc (reloc_type))
10412 reloc_size = 3;
aca88567
NC		 10413 else if (is_16bit_abs_reloc (reloc_type))
10414 reloc_size = 2;
10415 else
4b78141a 10416 {
41e92641 10417 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
aca88567 10418 reloc_type, SECTION_NAME (section));
4b78141a
NC		 10419 continue;
10420 }
103f02d3 10421
91d6fa6a
NC		 10422 rloc = start + rp->r_offset;
10423 if ((rloc + reloc_size) > end)
700dd8b7
L		 10424 {
10425 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10426 (unsigned long) rp->r_offset,
10427 SECTION_NAME (section));
10428 continue;
10429 }
103f02d3 10430
ba5cdace
NC		 10431 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
10432 if (sym_index >= num_syms)
10433 {
10434 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10435 sym_index, SECTION_NAME (section));
10436 continue;
10437 }
10438 sym = symtab + sym_index;
41e92641
NC		 10439
10440 /* If the reloc has a symbol associated with it,
55f25fc3
L		 10441 make sure that it is of an appropriate type.
10442
10443 Relocations against symbols without type can happen.
10444 Gcc -feliminate-dwarf2-dups may generate symbols
10445 without type for debug info.
10446
10447 Icc generates relocations against function symbols
10448 instead of local labels.
10449
10450 Relocations against object symbols can happen, eg when
10451 referencing a global array. For an example of this see
10452 the _clz.o binary in libgcc.a. */
aca88567 10453 if (sym != symtab
55f25fc3 10454 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 10455 {
41e92641 10456 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 10457 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 10458 (long int)(rp - relocs),
41e92641 10459 SECTION_NAME (relsec));
aca88567 10460 continue;
5b18a4bc 10461 }
252b5132 10462
4dc3c23d
AM		 10463 addend = 0;
10464 if (is_rela)
10465 addend += rp->r_addend;
c47320c3
AM		 10466 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10467 partial_inplace. */
4dc3c23d
AM		 10468 if (!is_rela
10469 || (elf_header.e_machine == EM_XTENSA
10470 && reloc_type == 1)
10471 || ((elf_header.e_machine == EM_PJ
10472 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 10473 && reloc_type == 1)
10474 || ((elf_header.e_machine == EM_D30V
10475 || elf_header.e_machine == EM_CYGNUS_D30V)
10476 && reloc_type == 12))
91d6fa6a 10477 addend += byte_get (rloc, reloc_size);
cb8f3167 10478
85acf597
RH		 10479 if (is_32bit_pcrel_reloc (reloc_type)
10480 || is_64bit_pcrel_reloc (reloc_type))
10481 {
10482 /* On HPPA, all pc-relative relocations are biased by 8. */
10483 if (elf_header.e_machine == EM_PARISC)
10484 addend -= 8;
91d6fa6a 10485 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 10486 reloc_size);
10487 }
41e92641 10488 else
91d6fa6a 10489 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 10490 }
252b5132 10491
5b18a4bc 10492 free (symtab);
41e92641 10493 free (relocs);
5b18a4bc
NC		 10494 break;
10495 }
5b18a4bc 10496}
103f02d3 10497
cf13d699
NC		 10498#ifdef SUPPORT_DISASSEMBLY
10499static int
10500disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10501{
10502 printf (_("\nAssembly dump of section %s\n"),
10503 SECTION_NAME (section));
10504
10505 /* XXX -- to be done --- XXX */
10506
10507 return 1;
10508}
10509#endif
10510
10511/* Reads in the contents of SECTION from FILE, returning a pointer
10512 to a malloc'ed buffer or NULL if something went wrong. */
10513
10514static char *
10515get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10516{
10517 bfd_size_type num_bytes;
10518
10519 num_bytes = section->sh_size;
10520
10521 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
10522 {
10523 printf (_("\nSection '%s' has no data to dump.\n"),
10524 SECTION_NAME (section));
10525 return NULL;
10526 }
10527
3f5e193b
NC		 10528 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
10529 _("section contents"));
cf13d699
NC		 10530}
10531
dd24e3da 10532
cf13d699
NC		 10533static void
10534dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
10535{
10536 Elf_Internal_Shdr * relsec;
10537 bfd_size_type num_bytes;
cf13d699
NC		 10538 char * data;
10539 char * end;
10540 char * start;
10541 char * name = SECTION_NAME (section);
10542 bfd_boolean some_strings_shown;
10543
10544 start = get_section_contents (section, file);
10545 if (start == NULL)
10546 return;
10547
10548 printf (_("\nString dump of section '%s':\n"), name);
10549
10550 /* If the section being dumped has relocations against it the user might
10551 be expecting these relocations to have been applied. Check for this
10552 case and issue a warning message in order to avoid confusion.
10553 FIXME: Maybe we ought to have an option that dumps a section with
10554 relocs applied ? */
10555 for (relsec = section_headers;
10556 relsec < section_headers + elf_header.e_shnum;
10557 ++relsec)
10558 {
10559 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10560 || relsec->sh_info >= elf_header.e_shnum
10561 || section_headers + relsec->sh_info != section
10562 || relsec->sh_size == 0
10563 || relsec->sh_link >= elf_header.e_shnum)
10564 continue;
10565
10566 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10567 break;
10568 }
10569
10570 num_bytes = section->sh_size;
cf13d699
NC		 10571 data = start;
10572 end = start + num_bytes;
10573 some_strings_shown = FALSE;
10574
10575 while (data < end)
10576 {
10577 while (!ISPRINT (* data))
10578 if (++ data >= end)
10579 break;
10580
10581 if (data < end)
10582 {
10583#ifndef __MSVCRT__
c975cc98
NC		 10584 /* PR 11128: Use two separate invocations in order to work
10585 around bugs in the Solaris 8 implementation of printf. */
10586 printf (" [%6tx] ", data - start);
10587 printf ("%s\n", data);
cf13d699
NC		 10588#else
10589 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
10590#endif
10591 data += strlen (data);
10592 some_strings_shown = TRUE;
10593 }
10594 }
10595
10596 if (! some_strings_shown)
10597 printf (_(" No strings found in this section."));
10598
10599 free (start);
10600
10601 putchar ('\n');
10602}
10603
10604static void
10605dump_section_as_bytes (Elf_Internal_Shdr * section,
10606 FILE * file,
10607 bfd_boolean relocate)
10608{
10609 Elf_Internal_Shdr * relsec;
10610 bfd_size_type bytes;
10611 bfd_vma addr;
10612 unsigned char * data;
10613 unsigned char * start;
10614
10615 start = (unsigned char *) get_section_contents (section, file);
10616 if (start == NULL)
10617 return;
10618
10619 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
10620
10621 if (relocate)
10622 {
10623 apply_relocations (file, section, start);
10624 }
10625 else
10626 {
10627 /* If the section being dumped has relocations against it the user might
10628 be expecting these relocations to have been applied. Check for this
10629 case and issue a warning message in order to avoid confusion.
10630 FIXME: Maybe we ought to have an option that dumps a section with
10631 relocs applied ? */
10632 for (relsec = section_headers;
10633 relsec < section_headers + elf_header.e_shnum;
10634 ++relsec)
10635 {
10636 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10637 || relsec->sh_info >= elf_header.e_shnum
10638 || section_headers + relsec->sh_info != section
10639 || relsec->sh_size == 0
10640 || relsec->sh_link >= elf_header.e_shnum)
10641 continue;
10642
10643 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10644 break;
10645 }
10646 }
10647
10648 addr = section->sh_addr;
10649 bytes = section->sh_size;
10650 data = start;
10651
10652 while (bytes)
10653 {
10654 int j;
10655 int k;
10656 int lbytes;
10657
10658 lbytes = (bytes > 16 ? 16 : bytes);
10659
10660 printf (" 0x%8.8lx ", (unsigned long) addr);
10661
10662 for (j = 0; j < 16; j++)
10663 {
10664 if (j < lbytes)
10665 printf ("%2.2x", data[j]);
10666 else
10667 printf (" ");
10668
10669 if ((j & 3) == 3)
10670 printf (" ");
10671 }
10672
10673 for (j = 0; j < lbytes; j++)
10674 {
10675 k = data[j];
10676 if (k >= ' ' && k < 0x7f)
10677 printf ("%c", k);
10678 else
10679 printf (".");
10680 }
10681
10682 putchar ('\n');
10683
10684 data += lbytes;
10685 addr += lbytes;
10686 bytes -= lbytes;
10687 }
10688
10689 free (start);
10690
10691 putchar ('\n');
10692}
10693
4a114e3e 10694/* Uncompresses a section that was compressed using zlib, in place. */
cf13d699
NC		 10695
10696static int
d3dbc530
AM		 10697uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10698 dwarf_size_type *size ATTRIBUTE_UNUSED)
cf13d699
NC		 10699{
10700#ifndef HAVE_ZLIB_H
cf13d699
NC		 10701 return FALSE;
10702#else
10703 dwarf_size_type compressed_size = *size;
10704 unsigned char * compressed_buffer = *buffer;
10705 dwarf_size_type uncompressed_size;
10706 unsigned char * uncompressed_buffer;
10707 z_stream strm;
10708 int rc;
10709 dwarf_size_type header_size = 12;
10710
10711 /* Read the zlib header. In this case, it should be "ZLIB" followed
10712 by the uncompressed section size, 8 bytes in big-endian order. */
10713 if (compressed_size < header_size
10714 || ! streq ((char *) compressed_buffer, "ZLIB"))
10715 return 0;
10716
10717 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10718 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10719 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10720 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10721 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10722 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10723 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10724 uncompressed_size += compressed_buffer[11];
10725
10726 /* It is possible the section consists of several compressed
10727 buffers concatenated together, so we uncompress in a loop. */
10728 strm.zalloc = NULL;
10729 strm.zfree = NULL;
10730 strm.opaque = NULL;
10731 strm.avail_in = compressed_size - header_size;
10732 strm.next_in = (Bytef *) compressed_buffer + header_size;
10733 strm.avail_out = uncompressed_size;
3f5e193b 10734 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
cf13d699
NC		 10735
10736 rc = inflateInit (& strm);
10737 while (strm.avail_in > 0)
10738 {
10739 if (rc != Z_OK)
10740 goto fail;
10741 strm.next_out = ((Bytef *) uncompressed_buffer
10742 + (uncompressed_size - strm.avail_out));
10743 rc = inflate (&strm, Z_FINISH);
10744 if (rc != Z_STREAM_END)
10745 goto fail;
10746 rc = inflateReset (& strm);
10747 }
10748 rc = inflateEnd (& strm);
10749 if (rc != Z_OK
10750 || strm.avail_out != 0)
10751 goto fail;
10752
10753 free (compressed_buffer);
10754 *buffer = uncompressed_buffer;
10755 *size = uncompressed_size;
10756 return 1;
10757
10758 fail:
10759 free (uncompressed_buffer);
4a114e3e
L		 10760 /* Indicate decompression failure. */
10761 *buffer = NULL;
cf13d699
NC		 10762 return 0;
10763#endif /* HAVE_ZLIB_H */
10764}
10765
d966045b
DJ		 10766static int
10767load_specific_debug_section (enum dwarf_section_display_enum debug,
2cf0635d 10768 Elf_Internal_Shdr * sec, void * file)
1007acb3 10769{
2cf0635d 10770 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 10771 char buf [64];
1007acb3 10772
19e6b90e
L		 10773 /* If it is already loaded, do nothing. */
10774 if (section->start != NULL)
10775 return 1;
1007acb3 10776
19e6b90e
L		 10777 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
10778 section->address = sec->sh_addr;
3f5e193b
NC		 10779 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
10780 sec->sh_offset, 1,
10781 sec->sh_size, buf);
59245841
NC		 10782 if (section->start == NULL)
10783 section->size = 0;
10784 else
10785 {
10786 section->size = sec->sh_size;
10787 if (uncompress_section_contents (&section->start, &section->size))
10788 sec->sh_size = section->size;
10789 }
4a114e3e 10790
1b315056
CS		 10791 if (section->start == NULL)
10792 return 0;
10793
19e6b90e 10794 if (debug_displays [debug].relocate)
3f5e193b 10795 apply_relocations ((FILE *) file, sec, section->start);
1007acb3 10796
1b315056 10797 return 1;
1007acb3
L		 10798}
10799
657d0d47
CC		 10800/* If this is not NULL, load_debug_section will only look for sections
10801 within the list of sections given here. */
10802unsigned int *section_subset = NULL;
10803
d966045b 10804int
2cf0635d 10805load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 10806{
2cf0635d
NC		 10807 struct dwarf_section * section = &debug_displays [debug].section;
10808 Elf_Internal_Shdr * sec;
d966045b
DJ		 10809
10810 /* Locate the debug section. */
657d0d47 10811 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 10812 if (sec != NULL)
10813 section->name = section->uncompressed_name;
10814 else
10815 {
657d0d47 10816 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 10817 if (sec != NULL)
10818 section->name = section->compressed_name;
10819 }
10820 if (sec == NULL)
10821 return 0;
10822
657d0d47
CC		 10823 /* If we're loading from a subset of sections, and we've loaded
10824 a section matching this name before, it's likely that it's a
10825 different one. */
10826 if (section_subset != NULL)
10827 free_debug_section (debug);
10828
3f5e193b 10829 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 10830}
10831
19e6b90e
L		 10832void
10833free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 10834{
2cf0635d 10835 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 10836
19e6b90e
L		 10837 if (section->start == NULL)
10838 return;
1007acb3 10839
19e6b90e
L		 10840 free ((char *) section->start);
10841 section->start = NULL;
10842 section->address = 0;
10843 section->size = 0;
1007acb3
L		 10844}
10845
1007acb3 10846static int
657d0d47 10847display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 10848{
2cf0635d 10849 char * name = SECTION_NAME (section);
19e6b90e
L		 10850 bfd_size_type length;
10851 int result = 1;
3f5e193b 10852 int i;
1007acb3 10853
19e6b90e
L		 10854 length = section->sh_size;
10855 if (length == 0)
1007acb3 10856 {
19e6b90e
L		 10857 printf (_("\nSection '%s' has no debugging data.\n"), name);
10858 return 0;
1007acb3 10859 }
5dff79d8
NC		 10860 if (section->sh_type == SHT_NOBITS)
10861 {
10862 /* There is no point in dumping the contents of a debugging section
10863 which has the NOBITS type - the bits in the file will be random.
10864 This can happen when a file containing a .eh_frame section is
10865 stripped with the --only-keep-debug command line option. */
10866 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
10867 return 0;
10868 }
1007acb3 10869
0112cd26 10870 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 10871 name = ".debug_info";
1007acb3 10872
19e6b90e
L		 10873 /* See if we know how to display the contents of this section. */
10874 for (i = 0; i < max; i++)
1b315056
CS		 10875 if (streq (debug_displays[i].section.uncompressed_name, name)
10876 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 10877 {
2cf0635d 10878 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 10879 int secondary = (section != find_section (name));
10880
10881 if (secondary)
3f5e193b 10882 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 10883
2b6f5997 10884 if (streq (sec->uncompressed_name, name))
d966045b
DJ		 10885 sec->name = sec->uncompressed_name;
10886 else
10887 sec->name = sec->compressed_name;
3f5e193b
NC		 10888 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
10889 section, file))
19e6b90e 10890 {
657d0d47
CC		 10891 /* If this debug section is part of a CU/TU set in a .dwp file,
10892 restrict load_debug_section to the sections in that set. */
10893 section_subset = find_cu_tu_set (file, shndx);
10894
19e6b90e 10895 result &= debug_displays[i].display (sec, file);
1007acb3 10896
657d0d47
CC		 10897 section_subset = NULL;
10898
d966045b 10899 if (secondary || (i != info && i != abbrev))
3f5e193b 10900 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 10901 }
1007acb3 10902
19e6b90e
L		 10903 break;
10904 }
1007acb3 10905
19e6b90e 10906 if (i == max)
1007acb3 10907 {
19e6b90e
L		 10908 printf (_("Unrecognized debug section: %s\n"), name);
10909 result = 0;
1007acb3
L		 10910 }
10911
19e6b90e 10912 return result;
5b18a4bc 10913}
103f02d3 10914
aef1f6d0
DJ		 10915/* Set DUMP_SECTS for all sections where dumps were requested
10916 based on section name. */
10917
10918static void
10919initialise_dumps_byname (void)
10920{
2cf0635d 10921 struct dump_list_entry * cur;
aef1f6d0
DJ		 10922
10923 for (cur = dump_sects_byname; cur; cur = cur->next)
10924 {
10925 unsigned int i;
10926 int any;
10927
10928 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
10929 if (streq (SECTION_NAME (section_headers + i), cur->name))
10930 {
09c11c86 10931 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 10932 any = 1;
10933 }
10934
10935 if (!any)
10936 warn (_("Section '%s' was not dumped because it does not exist!\n"),
10937 cur->name);
10938 }
10939}
10940
5b18a4bc 10941static void
2cf0635d 10942process_section_contents (FILE * file)
5b18a4bc 10943{
2cf0635d 10944 Elf_Internal_Shdr * section;
19e6b90e 10945 unsigned int i;
103f02d3 10946
19e6b90e
L		 10947 if (! do_dump)
10948 return;
103f02d3 10949
aef1f6d0
DJ		 10950 initialise_dumps_byname ();
10951
19e6b90e
L		 10952 for (i = 0, section = section_headers;
10953 i < elf_header.e_shnum && i < num_dump_sects;
10954 i++, section++)
10955 {
10956#ifdef SUPPORT_DISASSEMBLY
10957 if (dump_sects[i] & DISASS_DUMP)
10958 disassemble_section (section, file);
10959#endif
10960 if (dump_sects[i] & HEX_DUMP)
cf13d699 10961 dump_section_as_bytes (section, file, FALSE);
103f02d3 10962
cf13d699
NC		 10963 if (dump_sects[i] & RELOC_DUMP)
10964 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 10965
10966 if (dump_sects[i] & STRING_DUMP)
10967 dump_section_as_strings (section, file);
cf13d699
NC		 10968
10969 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 10970 display_debug_section (i, section, file);
5b18a4bc 10971 }
103f02d3 10972
19e6b90e
L		 10973 /* Check to see if the user requested a
10974 dump of a section that does not exist. */
10975 while (i++ < num_dump_sects)
10976 if (dump_sects[i])
10977 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 10978}
103f02d3 10979
5b18a4bc 10980static void
19e6b90e 10981process_mips_fpe_exception (int mask)
5b18a4bc 10982{
19e6b90e
L		 10983 if (mask)
10984 {
10985 int first = 1;
10986 if (mask & OEX_FPU_INEX)
10987 fputs ("INEX", stdout), first = 0;
10988 if (mask & OEX_FPU_UFLO)
10989 printf ("%sUFLO", first ? "" : "|"), first = 0;
10990 if (mask & OEX_FPU_OFLO)
10991 printf ("%sOFLO", first ? "" : "|"), first = 0;
10992 if (mask & OEX_FPU_DIV0)
10993 printf ("%sDIV0", first ? "" : "|"), first = 0;
10994 if (mask & OEX_FPU_INVAL)
10995 printf ("%sINVAL", first ? "" : "|");
10996 }
5b18a4bc 10997 else
19e6b90e 10998 fputs ("0", stdout);
5b18a4bc 10999}
103f02d3 11000
11c1ff18
PB		 11001/* ARM EABI attributes section. */
11002typedef struct
11003{
11004 int tag;
2cf0635d 11005 const char * name;
11c1ff18
PB		 11006 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
11007 int type;
2cf0635d 11008 const char ** table;
11c1ff18
PB		 11009} arm_attr_public_tag;
11010
2cf0635d 11011static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 11012 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 11013 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 11014static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
11015static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 11016 {"No", "Thumb-1", "Thumb-2"};
75375b3e 11017static const char * arm_attr_tag_FP_arch[] =
bca38921
MGD		 11018 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11019 "FP for ARMv8"};
2cf0635d 11020static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 11021static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 11022 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 11023static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 11024 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11025 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 11026static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 11027 {"V6", "SB", "TLS", "Unused"};
2cf0635d 11028static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 11029 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 11030static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 11031 {"Absolute", "PC-relative", "None"};
2cf0635d 11032static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 11033 {"None", "direct", "GOT-indirect"};
2cf0635d 11034static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 11035 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 11036static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
11037static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 11038 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 11039static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
11040static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
11041static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 11042 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 11043static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 11044 {"Unused", "small", "int", "forced to int"};
2cf0635d 11045static const char * arm_attr_tag_ABI_HardFP_use[] =
75375b3e 11046 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
2cf0635d 11047static const char * arm_attr_tag_ABI_VFP_args[] =
11c1ff18 11048 {"AAPCS", "VFP registers", "custom"};
2cf0635d 11049static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 11050 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 11051static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 11052 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11053 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 11054static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 11055 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11056 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 11057static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 11058static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 11059 {"Not Allowed", "Allowed"};
2cf0635d 11060static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 11061 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 11062static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 11063 {"Not Allowed", "Allowed"};
11064static const char * arm_attr_tag_DIV_use[] =
dd24e3da 11065 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 11066 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 11067static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
11068static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 11069 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 11070 "TrustZone and Virtualization Extensions"};
dd24e3da 11071static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 11072 {"Not Allowed", "Allowed"};
11c1ff18
PB		 11073
11074#define LOOKUP(id, name) \
11075 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 11076static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 11077{
11078 {4, "CPU_raw_name", 1, NULL},
11079 {5, "CPU_name", 1, NULL},
11080 LOOKUP(6, CPU_arch),
11081 {7, "CPU_arch_profile", 0, NULL},
11082 LOOKUP(8, ARM_ISA_use),
11083 LOOKUP(9, THUMB_ISA_use),
75375b3e 11084 LOOKUP(10, FP_arch),
11c1ff18 11085 LOOKUP(11, WMMX_arch),
f5f53991
AS		 11086 LOOKUP(12, Advanced_SIMD_arch),
11087 LOOKUP(13, PCS_config),
11c1ff18
PB		 11088 LOOKUP(14, ABI_PCS_R9_use),
11089 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 11090 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 11091 LOOKUP(17, ABI_PCS_GOT_use),
11092 LOOKUP(18, ABI_PCS_wchar_t),
11093 LOOKUP(19, ABI_FP_rounding),
11094 LOOKUP(20, ABI_FP_denormal),
11095 LOOKUP(21, ABI_FP_exceptions),
11096 LOOKUP(22, ABI_FP_user_exceptions),
11097 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 11098 {24, "ABI_align_needed", 0, NULL},
11099 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 11100 LOOKUP(26, ABI_enum_size),
11101 LOOKUP(27, ABI_HardFP_use),
11102 LOOKUP(28, ABI_VFP_args),
11103 LOOKUP(29, ABI_WMMX_args),
11104 LOOKUP(30, ABI_optimization_goals),
11105 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 11106 {32, "compatibility", 0, NULL},
f5f53991 11107 LOOKUP(34, CPU_unaligned_access),
75375b3e 11108 LOOKUP(36, FP_HP_extension),
8e79c3df 11109 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 11110 LOOKUP(42, MPextension_use),
11111 LOOKUP(44, DIV_use),
f5f53991
AS		 11112 {64, "nodefaults", 0, NULL},
11113 {65, "also_compatible_with", 0, NULL},
11114 LOOKUP(66, T2EE_use),
11115 {67, "conformance", 1, NULL},
11116 LOOKUP(68, Virtualization_use),
cd21e546 11117 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 11118};
11119#undef LOOKUP
11120
11c1ff18 11121static unsigned char *
2cf0635d 11122display_arm_attribute (unsigned char * p)
11c1ff18
PB		 11123{
11124 int tag;
11125 unsigned int len;
11126 int val;
2cf0635d 11127 arm_attr_public_tag * attr;
11c1ff18
PB		 11128 unsigned i;
11129 int type;
11130
11131 tag = read_uleb128 (p, &len);
11132 p += len;
11133 attr = NULL;
2cf0635d 11134 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 11135 {
11136 if (arm_attr_public_tags[i].tag == tag)
11137 {
11138 attr = &arm_attr_public_tags[i];
11139 break;
11140 }
11141 }
11142
11143 if (attr)
11144 {
11145 printf (" Tag_%s: ", attr->name);
11146 switch (attr->type)
11147 {
11148 case 0:
11149 switch (tag)
11150 {
11151 case 7: /* Tag_CPU_arch_profile. */
11152 val = read_uleb128 (p, &len);
11153 p += len;
11154 switch (val)
11155 {
2b692964
NC		 11156 case 0: printf (_("None\n")); break;
11157 case 'A': printf (_("Application\n")); break;
11158 case 'R': printf (_("Realtime\n")); break;
11159 case 'M': printf (_("Microcontroller\n")); break;
11160 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 11161 default: printf ("??? (%d)\n", val); break;
11162 }
11163 break;
11164
75375b3e
MGD		 11165 case 24: /* Tag_align_needed. */
11166 val = read_uleb128 (p, &len);
11167 p += len;
11168 switch (val)
11169 {
2b692964
NC		 11170 case 0: printf (_("None\n")); break;
11171 case 1: printf (_("8-byte\n")); break;
11172 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 11173 case 3: printf ("??? 3\n"); break;
11174 default:
11175 if (val <= 12)
dd24e3da 11176 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 11177 1 << val);
11178 else
11179 printf ("??? (%d)\n", val);
11180 break;
11181 }
11182 break;
11183
11184 case 25: /* Tag_align_preserved. */
11185 val = read_uleb128 (p, &len);
11186 p += len;
11187 switch (val)
11188 {
2b692964
NC		 11189 case 0: printf (_("None\n")); break;
11190 case 1: printf (_("8-byte, except leaf SP\n")); break;
11191 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 11192 case 3: printf ("??? 3\n"); break;
11193 default:
11194 if (val <= 12)
dd24e3da 11195 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 11196 1 << val);
11197 else
11198 printf ("??? (%d)\n", val);
11199 break;
11200 }
11201 break;
11202
11c1ff18
PB		 11203 case 32: /* Tag_compatibility. */
11204 val = read_uleb128 (p, &len);
11205 p += len;
2b692964 11206 printf (_("flag = %d, vendor = %s\n"), val, p);
2cf0635d 11207 p += strlen ((char *) p) + 1;
11c1ff18
PB		 11208 break;
11209
f5f53991
AS		 11210 case 64: /* Tag_nodefaults. */
11211 p++;
2b692964 11212 printf (_("True\n"));
f5f53991
AS		 11213 break;
11214
11215 case 65: /* Tag_also_compatible_with. */
11216 val = read_uleb128 (p, &len);
11217 p += len;
11218 if (val == 6 /* Tag_CPU_arch. */)
11219 {
11220 val = read_uleb128 (p, &len);
11221 p += len;
2cf0635d 11222 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 11223 printf ("??? (%d)\n", val);
11224 else
11225 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
11226 }
11227 else
11228 printf ("???\n");
11229 while (*(p++) != '\0' /* NUL terminator. */);
11230 break;
11231
11c1ff18 11232 default:
2cf0635d 11233 abort ();
11c1ff18
PB		 11234 }
11235 return p;
11236
11237 case 1:
11238 case 2:
11239 type = attr->type;
11240 break;
11241
11242 default:
11243 assert (attr->type & 0x80);
11244 val = read_uleb128 (p, &len);
11245 p += len;
11246 type = attr->type & 0x7f;
11247 if (val >= type)
11248 printf ("??? (%d)\n", val);
11249 else
11250 printf ("%s\n", attr->table[val]);
11251 return p;
11252 }
11253 }
11254 else
11255 {
11256 if (tag & 1)
11257 type = 1; /* String. */
11258 else
11259 type = 2; /* uleb128. */
11260 printf (" Tag_unknown_%d: ", tag);
11261 }
11262
11263 if (type == 1)
11264 {
11265 printf ("\"%s\"\n", p);
2cf0635d 11266 p += strlen ((char *) p) + 1;
11c1ff18
PB		 11267 }
11268 else
11269 {
11270 val = read_uleb128 (p, &len);
11271 p += len;
11272 printf ("%d (0x%x)\n", val, val);
11273 }
11274
11275 return p;
11276}
11277
104d59d1 11278static unsigned char *
60bca95a
NC		 11279display_gnu_attribute (unsigned char * p,
11280 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
104d59d1
JM		 11281{
11282 int tag;
11283 unsigned int len;
11284 int val;
11285 int type;
11286
11287 tag = read_uleb128 (p, &len);
11288 p += len;
11289
11290 /* Tag_compatibility is the only generic GNU attribute defined at
11291 present. */
11292 if (tag == 32)
11293 {
11294 val = read_uleb128 (p, &len);
11295 p += len;
2b692964 11296 printf (_("flag = %d, vendor = %s\n"), val, p);
60bca95a 11297 p += strlen ((char *) p) + 1;
104d59d1
JM		 11298 return p;
11299 }
11300
11301 if ((tag & 2) == 0 && display_proc_gnu_attribute)
11302 return display_proc_gnu_attribute (p, tag);
11303
11304 if (tag & 1)
11305 type = 1; /* String. */
11306 else
11307 type = 2; /* uleb128. */
11308 printf (" Tag_unknown_%d: ", tag);
11309
11310 if (type == 1)
11311 {
11312 printf ("\"%s\"\n", p);
60bca95a 11313 p += strlen ((char *) p) + 1;
104d59d1
JM		 11314 }
11315 else
11316 {
11317 val = read_uleb128 (p, &len);
11318 p += len;
11319 printf ("%d (0x%x)\n", val, val);
11320 }
11321
11322 return p;
11323}
11324
34c8bcba 11325static unsigned char *
2cf0635d 11326display_power_gnu_attribute (unsigned char * p, int tag)
34c8bcba
JM		 11327{
11328 int type;
11329 unsigned int len;
11330 int val;
11331
11332 if (tag == Tag_GNU_Power_ABI_FP)
11333 {
11334 val = read_uleb128 (p, &len);
11335 p += len;
11336 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 11337
34c8bcba
JM		 11338 switch (val)
11339 {
11340 case 0:
2b692964 11341 printf (_("Hard or soft float\n"));
34c8bcba
JM		 11342 break;
11343 case 1:
2b692964 11344 printf (_("Hard float\n"));
34c8bcba
JM		 11345 break;
11346 case 2:
2b692964 11347 printf (_("Soft float\n"));
34c8bcba 11348 break;
3c7b9897 11349 case 3:
2b692964 11350 printf (_("Single-precision hard float\n"));
3c7b9897 11351 break;
34c8bcba
JM		 11352 default:
11353 printf ("??? (%d)\n", val);
11354 break;
11355 }
11356 return p;
11357 }
11358
c6e65352
DJ		 11359 if (tag == Tag_GNU_Power_ABI_Vector)
11360 {
11361 val = read_uleb128 (p, &len);
11362 p += len;
11363 printf (" Tag_GNU_Power_ABI_Vector: ");
11364 switch (val)
11365 {
11366 case 0:
2b692964 11367 printf (_("Any\n"));
c6e65352
DJ		 11368 break;
11369 case 1:
2b692964 11370 printf (_("Generic\n"));
c6e65352
DJ		 11371 break;
11372 case 2:
11373 printf ("AltiVec\n");
11374 break;
11375 case 3:
11376 printf ("SPE\n");
11377 break;
11378 default:
11379 printf ("??? (%d)\n", val);
11380 break;
11381 }
11382 return p;
11383 }
11384
f82e0623
NF		 11385 if (tag == Tag_GNU_Power_ABI_Struct_Return)
11386 {
11387 val = read_uleb128 (p, &len);
11388 p += len;
11389 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11390 switch (val)
11391 {
11392 case 0:
2b692964 11393 printf (_("Any\n"));
f82e0623
NF		 11394 break;
11395 case 1:
11396 printf ("r3/r4\n");
11397 break;
11398 case 2:
2b692964 11399 printf (_("Memory\n"));
f82e0623
NF		 11400 break;
11401 default:
11402 printf ("??? (%d)\n", val);
11403 break;
11404 }
11405 return p;
11406 }
11407
34c8bcba
JM		 11408 if (tag & 1)
11409 type = 1; /* String. */
11410 else
11411 type = 2; /* uleb128. */
11412 printf (" Tag_unknown_%d: ", tag);
11413
11414 if (type == 1)
11415 {
11416 printf ("\"%s\"\n", p);
60bca95a 11417 p += strlen ((char *) p) + 1;
34c8bcba
JM		 11418 }
11419 else
11420 {
11421 val = read_uleb128 (p, &len);
11422 p += len;
11423 printf ("%d (0x%x)\n", val, val);
11424 }
11425
11426 return p;
11427}
11428
9e8c70f9
DM		 11429static void
11430display_sparc_hwcaps (int mask)
11431{
11432 if (mask)
11433 {
11434 int first = 1;
11435 if (mask & ELF_SPARC_HWCAP_MUL32)
11436 fputs ("mul32", stdout), first = 0;
11437 if (mask & ELF_SPARC_HWCAP_DIV32)
11438 printf ("%sdiv32", first ? "" : "|"), first = 0;
11439 if (mask & ELF_SPARC_HWCAP_FSMULD)
11440 printf ("%sfsmuld", first ? "" : "|"), first = 0;
11441 if (mask & ELF_SPARC_HWCAP_V8PLUS)
11442 printf ("%sv8plus", first ? "" : "|"), first = 0;
11443 if (mask & ELF_SPARC_HWCAP_POPC)
11444 printf ("%spopc", first ? "" : "|"), first = 0;
11445 if (mask & ELF_SPARC_HWCAP_VIS)
11446 printf ("%svis", first ? "" : "|"), first = 0;
11447 if (mask & ELF_SPARC_HWCAP_VIS2)
11448 printf ("%svis2", first ? "" : "|"), first = 0;
11449 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
11450 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
11451 if (mask & ELF_SPARC_HWCAP_FMAF)
11452 printf ("%sfmaf", first ? "" : "|"), first = 0;
11453 if (mask & ELF_SPARC_HWCAP_VIS3)
11454 printf ("%svis3", first ? "" : "|"), first = 0;
11455 if (mask & ELF_SPARC_HWCAP_HPC)
11456 printf ("%shpc", first ? "" : "|"), first = 0;
11457 if (mask & ELF_SPARC_HWCAP_RANDOM)
11458 printf ("%srandom", first ? "" : "|"), first = 0;
11459 if (mask & ELF_SPARC_HWCAP_TRANS)
11460 printf ("%strans", first ? "" : "|"), first = 0;
11461 if (mask & ELF_SPARC_HWCAP_FJFMAU)
11462 printf ("%sfjfmau", first ? "" : "|"), first = 0;
11463 if (mask & ELF_SPARC_HWCAP_IMA)
11464 printf ("%sima", first ? "" : "|"), first = 0;
11465 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
11466 printf ("%scspare", first ? "" : "|"), first = 0;
11467 }
11468 else
11469 fputc('0', stdout);
11470 fputc('\n', stdout);
11471}
11472
11473static unsigned char *
11474display_sparc_gnu_attribute (unsigned char * p, int tag)
11475{
11476 int type;
11477 unsigned int len;
11478 int val;
11479
11480 if (tag == Tag_GNU_Sparc_HWCAPS)
11481 {
11482 val = read_uleb128 (p, &len);
11483 p += len;
11484 printf (" Tag_GNU_Sparc_HWCAPS: ");
11485
11486 display_sparc_hwcaps (val);
11487 return p;
11488 }
11489
11490 if (tag & 1)
11491 type = 1; /* String. */
11492 else
11493 type = 2; /* uleb128. */
11494 printf (" Tag_unknown_%d: ", tag);
11495
11496 if (type == 1)
11497 {
11498 printf ("\"%s\"\n", p);
11499 p += strlen ((char *) p) + 1;
11500 }
11501 else
11502 {
11503 val = read_uleb128 (p, &len);
11504 p += len;
11505 printf ("%d (0x%x)\n", val, val);
11506 }
11507
11508 return p;
11509}
11510
2cf19d5c 11511static unsigned char *
2cf0635d 11512display_mips_gnu_attribute (unsigned char * p, int tag)
2cf19d5c
JM		 11513{
11514 int type;
11515 unsigned int len;
11516 int val;
11517
11518 if (tag == Tag_GNU_MIPS_ABI_FP)
11519 {
11520 val = read_uleb128 (p, &len);
11521 p += len;
11522 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 11523
2cf19d5c
JM		 11524 switch (val)
11525 {
11526 case 0:
2b692964 11527 printf (_("Hard or soft float\n"));
2cf19d5c
JM		 11528 break;
11529 case 1:
2b692964 11530 printf (_("Hard float (double precision)\n"));
2cf19d5c
JM		 11531 break;
11532 case 2:
2b692964 11533 printf (_("Hard float (single precision)\n"));
2cf19d5c
JM		 11534 break;
11535 case 3:
2b692964 11536 printf (_("Soft float\n"));
2cf19d5c 11537 break;
42554f6a 11538 case 4:
9eeefea8 11539 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
42554f6a 11540 break;
2cf19d5c
JM		 11541 default:
11542 printf ("??? (%d)\n", val);
11543 break;
11544 }
11545 return p;
11546 }
11547
11548 if (tag & 1)
11549 type = 1; /* String. */
11550 else
11551 type = 2; /* uleb128. */
11552 printf (" Tag_unknown_%d: ", tag);
11553
11554 if (type == 1)
11555 {
11556 printf ("\"%s\"\n", p);
60bca95a 11557 p += strlen ((char *) p) + 1;
2cf19d5c
JM		 11558 }
11559 else
11560 {
11561 val = read_uleb128 (p, &len);
11562 p += len;
11563 printf ("%d (0x%x)\n", val, val);
11564 }
11565
11566 return p;
11567}
11568
59e6276b
JM		 11569static unsigned char *
11570display_tic6x_attribute (unsigned char * p)
11571{
11572 int tag;
11573 unsigned int len;
11574 int val;
11575
11576 tag = read_uleb128 (p, &len);
11577 p += len;
11578
11579 switch (tag)
11580 {
75fa6dc1 11581 case Tag_ISA:
59e6276b
JM		 11582 val = read_uleb128 (p, &len);
11583 p += len;
75fa6dc1 11584 printf (" Tag_ISA: ");
59e6276b
JM		 11585
11586 switch (val)
11587 {
75fa6dc1 11588 case C6XABI_Tag_ISA_none:
59e6276b
JM		 11589 printf (_("None\n"));
11590 break;
75fa6dc1 11591 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 11592 printf ("C62x\n");
11593 break;
75fa6dc1 11594 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 11595 printf ("C67x\n");
11596 break;
75fa6dc1 11597 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 11598 printf ("C67x+\n");
11599 break;
75fa6dc1 11600 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 11601 printf ("C64x\n");
11602 break;
75fa6dc1 11603 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 11604 printf ("C64x+\n");
11605 break;
75fa6dc1 11606 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 11607 printf ("C674x\n");
11608 break;
11609 default:
11610 printf ("??? (%d)\n", val);
11611 break;
11612 }
11613 return p;
11614
87779176
JM		 11615 case Tag_ABI_wchar_t:
11616 val = read_uleb128 (p, &len);
11617 p += len;
11618 printf (" Tag_ABI_wchar_t: ");
11619 switch (val)
11620 {
11621 case 0:
11622 printf (_("Not used\n"));
11623 break;
11624 case 1:
11625 printf (_("2 bytes\n"));
11626 break;
11627 case 2:
11628 printf (_("4 bytes\n"));
11629 break;
11630 default:
11631 printf ("??? (%d)\n", val);
11632 break;
11633 }
11634 return p;
11635
11636 case Tag_ABI_stack_align_needed:
11637 val = read_uleb128 (p, &len);
11638 p += len;
11639 printf (" Tag_ABI_stack_align_needed: ");
11640 switch (val)
11641 {
11642 case 0:
11643 printf (_("8-byte\n"));
11644 break;
11645 case 1:
11646 printf (_("16-byte\n"));
11647 break;
11648 default:
11649 printf ("??? (%d)\n", val);
11650 break;
11651 }
11652 return p;
11653
11654 case Tag_ABI_stack_align_preserved:
11655 val = read_uleb128 (p, &len);
11656 p += len;
11657 printf (" Tag_ABI_stack_align_preserved: ");
11658 switch (val)
11659 {
11660 case 0:
11661 printf (_("8-byte\n"));
11662 break;
11663 case 1:
11664 printf (_("16-byte\n"));
11665 break;
11666 default:
11667 printf ("??? (%d)\n", val);
11668 break;
11669 }
11670 return p;
11671
b5593623
JM		 11672 case Tag_ABI_DSBT:
11673 val = read_uleb128 (p, &len);
11674 p += len;
11675 printf (" Tag_ABI_DSBT: ");
11676 switch (val)
11677 {
11678 case 0:
11679 printf (_("DSBT addressing not used\n"));
11680 break;
11681 case 1:
11682 printf (_("DSBT addressing used\n"));
11683 break;
11684 default:
11685 printf ("??? (%d)\n", val);
11686 break;
11687 }
11688 return p;
11689
87779176
JM		 11690 case Tag_ABI_PID:
11691 val = read_uleb128 (p, &len);
11692 p += len;
11693 printf (" Tag_ABI_PID: ");
11694 switch (val)
11695 {
11696 case 0:
11697 printf (_("Data addressing position-dependent\n"));
11698 break;
11699 case 1:
11700 printf (_("Data addressing position-independent, GOT near DP\n"));
11701 break;
11702 case 2:
11703 printf (_("Data addressing position-independent, GOT far from DP\n"));
11704 break;
11705 default:
11706 printf ("??? (%d)\n", val);
11707 break;
11708 }
11709 return p;
11710
11711 case Tag_ABI_PIC:
11712 val = read_uleb128 (p, &len);
11713 p += len;
11714 printf (" Tag_ABI_PIC: ");
11715 switch (val)
11716 {
11717 case 0:
11718 printf (_("Code addressing position-dependent\n"));
11719 break;
11720 case 1:
11721 printf (_("Code addressing position-independent\n"));
11722 break;
11723 default:
11724 printf ("??? (%d)\n", val);
11725 break;
11726 }
11727 return p;
11728
11729 case Tag_ABI_array_object_alignment:
11730 val = read_uleb128 (p, &len);
11731 p += len;
11732 printf (" Tag_ABI_array_object_alignment: ");
11733 switch (val)
11734 {
11735 case 0:
11736 printf (_("8-byte\n"));
11737 break;
11738 case 1:
11739 printf (_("4-byte\n"));
11740 break;
11741 case 2:
11742 printf (_("16-byte\n"));
11743 break;
11744 default:
11745 printf ("??? (%d)\n", val);
11746 break;
11747 }
11748 return p;
11749
11750 case Tag_ABI_array_object_align_expected:
11751 val = read_uleb128 (p, &len);
11752 p += len;
11753 printf (" Tag_ABI_array_object_align_expected: ");
11754 switch (val)
11755 {
11756 case 0:
11757 printf (_("8-byte\n"));
11758 break;
11759 case 1:
11760 printf (_("4-byte\n"));
11761 break;
11762 case 2:
11763 printf (_("16-byte\n"));
11764 break;
11765 default:
11766 printf ("??? (%d)\n", val);
11767 break;
11768 }
11769 return p;
11770
3cbd1c06 11771 case Tag_ABI_compatibility:
59e6276b
JM		 11772 val = read_uleb128 (p, &len);
11773 p += len;
3cbd1c06 11774 printf (" Tag_ABI_compatibility: ");
59e6276b
JM		 11775 printf (_("flag = %d, vendor = %s\n"), val, p);
11776 p += strlen ((char *) p) + 1;
11777 return p;
87779176
JM		 11778
11779 case Tag_ABI_conformance:
11780 printf (" Tag_ABI_conformance: ");
11781 printf ("\"%s\"\n", p);
11782 p += strlen ((char *) p) + 1;
11783 return p;
59e6276b
JM		 11784 }
11785
11786 printf (" Tag_unknown_%d: ", tag);
11787
87779176
JM		 11788 if (tag & 1)
11789 {
11790 printf ("\"%s\"\n", p);
11791 p += strlen ((char *) p) + 1;
11792 }
11793 else
11794 {
11795 val = read_uleb128 (p, &len);
11796 p += len;
11797 printf ("%d (0x%x)\n", val, val);
11798 }
59e6276b
JM		 11799
11800 return p;
11801}
11802
11c1ff18 11803static int
60bca95a
NC		 11804process_attributes (FILE * file,
11805 const char * public_name,
104d59d1 11806 unsigned int proc_type,
60bca95a
NC		 11807 unsigned char * (* display_pub_attribute) (unsigned char *),
11808 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11c1ff18 11809{
2cf0635d
NC		 11810 Elf_Internal_Shdr * sect;
11811 unsigned char * contents;
11812 unsigned char * p;
11813 unsigned char * end;
11c1ff18
PB		 11814 bfd_vma section_len;
11815 bfd_vma len;
11816 unsigned i;
11817
11818 /* Find the section header so that we get the size. */
11819 for (i = 0, sect = section_headers;
11820 i < elf_header.e_shnum;
11821 i++, sect++)
11822 {
104d59d1 11823 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 11824 continue;
11825
3f5e193b
NC		 11826 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
11827 sect->sh_size, _("attributes"));
60bca95a 11828 if (contents == NULL)
11c1ff18 11829 continue;
60bca95a 11830
11c1ff18
PB		 11831 p = contents;
11832 if (*p == 'A')
11833 {
11834 len = sect->sh_size - 1;
11835 p++;
60bca95a 11836
11c1ff18
PB		 11837 while (len > 0)
11838 {
11839 int namelen;
11840 bfd_boolean public_section;
104d59d1 11841 bfd_boolean gnu_section;
11c1ff18
PB		 11842
11843 section_len = byte_get (p, 4);
11844 p += 4;
60bca95a 11845
11c1ff18
PB		 11846 if (section_len > len)
11847 {
11848 printf (_("ERROR: Bad section length (%d > %d)\n"),
60bca95a 11849 (int) section_len, (int) len);
11c1ff18
PB		 11850 section_len = len;
11851 }
60bca95a 11852
11c1ff18 11853 len -= section_len;
2b692964 11854 printf (_("Attribute Section: %s\n"), p);
60bca95a
NC		 11855
11856 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 11857 public_section = TRUE;
11858 else
11859 public_section = FALSE;
60bca95a
NC		 11860
11861 if (streq ((char *) p, "gnu"))
104d59d1
JM		 11862 gnu_section = TRUE;
11863 else
11864 gnu_section = FALSE;
60bca95a
NC		 11865
11866 namelen = strlen ((char *) p) + 1;
11c1ff18
PB		 11867 p += namelen;
11868 section_len -= namelen + 4;
60bca95a 11869
11c1ff18
PB		 11870 while (section_len > 0)
11871 {
11872 int tag = *(p++);
11873 int val;
11874 bfd_vma size;
60bca95a 11875
11c1ff18
PB		 11876 size = byte_get (p, 4);
11877 if (size > section_len)
11878 {
11879 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
60bca95a 11880 (int) size, (int) section_len);
11c1ff18
PB		 11881 size = section_len;
11882 }
60bca95a 11883
11c1ff18
PB		 11884 section_len -= size;
11885 end = p + size - 1;
11886 p += 4;
60bca95a 11887
11c1ff18
PB		 11888 switch (tag)
11889 {
11890 case 1:
2b692964 11891 printf (_("File Attributes\n"));
11c1ff18
PB		 11892 break;
11893 case 2:
2b692964 11894 printf (_("Section Attributes:"));
11c1ff18
PB		 11895 goto do_numlist;
11896 case 3:
2b692964 11897 printf (_("Symbol Attributes:"));
11c1ff18
PB		 11898 do_numlist:
11899 for (;;)
11900 {
91d6fa6a 11901 unsigned int j;
60bca95a 11902
91d6fa6a
NC		 11903 val = read_uleb128 (p, &j);
11904 p += j;
11c1ff18
PB		 11905 if (val == 0)
11906 break;
11907 printf (" %d", val);
11908 }
11909 printf ("\n");
11910 break;
11911 default:
2b692964 11912 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 11913 public_section = FALSE;
11914 break;
11915 }
60bca95a 11916
11c1ff18
PB		 11917 if (public_section)
11918 {
11919 while (p < end)
104d59d1
JM		 11920 p = display_pub_attribute (p);
11921 }
11922 else if (gnu_section)
11923 {
11924 while (p < end)
11925 p = display_gnu_attribute (p,
11926 display_proc_gnu_attribute);
11c1ff18
PB		 11927 }
11928 else
11929 {
11930 /* ??? Do something sensible, like dump hex. */
2b692964 11931 printf (_(" Unknown section contexts\n"));
11c1ff18
PB		 11932 p = end;
11933 }
11934 }
11935 }
11936 }
11937 else
60bca95a 11938 printf (_("Unknown format '%c'\n"), *p);
d70c5fc7 11939
60bca95a 11940 free (contents);
11c1ff18
PB		 11941 }
11942 return 1;
11943}
11944
104d59d1 11945static int
2cf0635d 11946process_arm_specific (FILE * file)
104d59d1
JM		 11947{
11948 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
11949 display_arm_attribute, NULL);
11950}
11951
34c8bcba 11952static int
2cf0635d 11953process_power_specific (FILE * file)
34c8bcba
JM		 11954{
11955 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11956 display_power_gnu_attribute);
11957}
11958
9e8c70f9
DM		 11959static int
11960process_sparc_specific (FILE * file)
11961{
11962 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11963 display_sparc_gnu_attribute);
11964}
11965
59e6276b
JM		 11966static int
11967process_tic6x_specific (FILE * file)
11968{
11969 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
11970 display_tic6x_attribute, NULL);
11971}
11972
ccb4c951
RS		 11973/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
11974 Print the Address, Access and Initial fields of an entry at VMA ADDR
11975 and return the VMA of the next entry. */
11976
11977static bfd_vma
2cf0635d 11978print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
ccb4c951
RS		 11979{
11980 printf (" ");
11981 print_vma (addr, LONG_HEX);
11982 printf (" ");
11983 if (addr < pltgot + 0xfff0)
11984 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
11985 else
11986 printf ("%10s", "");
11987 printf (" ");
11988 if (data == NULL)
2b692964 11989 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 11990 else
11991 {
11992 bfd_vma entry;
11993
11994 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11995 print_vma (entry, LONG_HEX);
11996 }
11997 return addr + (is_32bit_elf ? 4 : 8);
11998}
11999
861fb55a
DJ		 12000/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12001 PLTGOT. Print the Address and Initial fields of an entry at VMA
12002 ADDR and return the VMA of the next entry. */
12003
12004static bfd_vma
2cf0635d 12005print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 12006{
12007 printf (" ");
12008 print_vma (addr, LONG_HEX);
12009 printf (" ");
12010 if (data == NULL)
2b692964 12011 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 12012 else
12013 {
12014 bfd_vma entry;
12015
12016 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12017 print_vma (entry, LONG_HEX);
12018 }
12019 return addr + (is_32bit_elf ? 4 : 8);
12020}
12021
19e6b90e 12022static int
2cf0635d 12023process_mips_specific (FILE * file)
5b18a4bc 12024{
2cf0635d 12025 Elf_Internal_Dyn * entry;
19e6b90e
L		 12026 size_t liblist_offset = 0;
12027 size_t liblistno = 0;
12028 size_t conflictsno = 0;
12029 size_t options_offset = 0;
12030 size_t conflicts_offset = 0;
861fb55a
DJ		 12031 size_t pltrelsz = 0;
12032 size_t pltrel = 0;
ccb4c951 12033 bfd_vma pltgot = 0;
861fb55a
DJ		 12034 bfd_vma mips_pltgot = 0;
12035 bfd_vma jmprel = 0;
ccb4c951
RS		 12036 bfd_vma local_gotno = 0;
12037 bfd_vma gotsym = 0;
12038 bfd_vma symtabno = 0;
103f02d3 12039
2cf19d5c
JM		 12040 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12041 display_mips_gnu_attribute);
12042
19e6b90e
L		 12043 /* We have a lot of special sections. Thanks SGI! */
12044 if (dynamic_section == NULL)
12045 /* No information available. */
12046 return 0;
252b5132 12047
b2d38a17 12048 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
252b5132
RH		 12049 switch (entry->d_tag)
12050 {
12051 case DT_MIPS_LIBLIST:
d93f0186
NC		 12052 liblist_offset
12053 = offset_from_vma (file, entry->d_un.d_val,
12054 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 12055 break;
12056 case DT_MIPS_LIBLISTNO:
12057 liblistno = entry->d_un.d_val;
12058 break;
12059 case DT_MIPS_OPTIONS:
d93f0186 12060 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 12061 break;
12062 case DT_MIPS_CONFLICT:
d93f0186
NC		 12063 conflicts_offset
12064 = offset_from_vma (file, entry->d_un.d_val,
12065 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 12066 break;
12067 case DT_MIPS_CONFLICTNO:
12068 conflictsno = entry->d_un.d_val;
12069 break;
ccb4c951 12070 case DT_PLTGOT:
861fb55a
DJ		 12071 pltgot = entry->d_un.d_ptr;
12072 break;
ccb4c951
RS		 12073 case DT_MIPS_LOCAL_GOTNO:
12074 local_gotno = entry->d_un.d_val;
12075 break;
12076 case DT_MIPS_GOTSYM:
12077 gotsym = entry->d_un.d_val;
12078 break;
12079 case DT_MIPS_SYMTABNO:
12080 symtabno = entry->d_un.d_val;
12081 break;
861fb55a
DJ		 12082 case DT_MIPS_PLTGOT:
12083 mips_pltgot = entry->d_un.d_ptr;
12084 break;
12085 case DT_PLTREL:
12086 pltrel = entry->d_un.d_val;
12087 break;
12088 case DT_PLTRELSZ:
12089 pltrelsz = entry->d_un.d_val;
12090 break;
12091 case DT_JMPREL:
12092 jmprel = entry->d_un.d_ptr;
12093 break;
252b5132
RH		 12094 default:
12095 break;
12096 }
12097
12098 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
12099 {
2cf0635d 12100 Elf32_External_Lib * elib;
252b5132
RH		 12101 size_t cnt;
12102
3f5e193b
NC		 12103 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
12104 liblistno,
12105 sizeof (Elf32_External_Lib),
9cf03b7e 12106 _("liblist section data"));
a6e9f9df 12107 if (elib)
252b5132 12108 {
2b692964 12109 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 12110 (unsigned long) liblistno);
2b692964 12111 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 12112 stdout);
12113
12114 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 12115 {
a6e9f9df 12116 Elf32_Lib liblist;
91d6fa6a 12117 time_t atime;
a6e9f9df 12118 char timebuf[20];
2cf0635d 12119 struct tm * tmp;
a6e9f9df
AM		 12120
12121 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 12122 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 12123 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12124 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12125 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12126
91d6fa6a 12127 tmp = gmtime (&atime);
e9e44622
JJ		 12128 snprintf (timebuf, sizeof (timebuf),
12129 "%04u-%02u-%02uT%02u:%02u:%02u",
12130 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12131 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 12132
31104126 12133 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 12134 if (VALID_DYNAMIC_NAME (liblist.l_name))
12135 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
12136 else
2b692964 12137 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 12138 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
12139 liblist.l_version);
a6e9f9df
AM		 12140
12141 if (liblist.l_flags == 0)
2b692964 12142 puts (_(" NONE"));
a6e9f9df
AM		 12143 else
12144 {
12145 static const struct
252b5132 12146 {
2cf0635d 12147 const char * name;
a6e9f9df 12148 int bit;
252b5132 12149 }
a6e9f9df
AM		 12150 l_flags_vals[] =
12151 {
12152 { " EXACT_MATCH", LL_EXACT_MATCH },
12153 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
12154 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
12155 { " EXPORTS", LL_EXPORTS },
12156 { " DELAY_LOAD", LL_DELAY_LOAD },
12157 { " DELTA", LL_DELTA }
12158 };
12159 int flags = liblist.l_flags;
12160 size_t fcnt;
12161
60bca95a 12162 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 12163 if ((flags & l_flags_vals[fcnt].bit) != 0)
12164 {
12165 fputs (l_flags_vals[fcnt].name, stdout);
12166 flags ^= l_flags_vals[fcnt].bit;
12167 }
12168 if (flags != 0)
12169 printf (" %#x", (unsigned int) flags);
252b5132 12170
a6e9f9df
AM		 12171 puts ("");
12172 }
252b5132 12173 }
252b5132 12174
a6e9f9df
AM		 12175 free (elib);
12176 }
252b5132
RH		 12177 }
12178
12179 if (options_offset != 0)
12180 {
2cf0635d
NC		 12181 Elf_External_Options * eopt;
12182 Elf_Internal_Shdr * sect = section_headers;
12183 Elf_Internal_Options * iopt;
12184 Elf_Internal_Options * option;
252b5132
RH		 12185 size_t offset;
12186 int cnt;
12187
12188 /* Find the section header so that we get the size. */
12189 while (sect->sh_type != SHT_MIPS_OPTIONS)
b34976b6 12190 ++sect;
252b5132 12191
3f5e193b
NC		 12192 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
12193 sect->sh_size, _("options"));
a6e9f9df 12194 if (eopt)
252b5132 12195 {
3f5e193b
NC		 12196 iopt = (Elf_Internal_Options *)
12197 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 12198 if (iopt == NULL)
12199 {
591a748a 12200 error (_("Out of memory\n"));
a6e9f9df
AM		 12201 return 0;
12202 }
76da6bbe 12203
a6e9f9df
AM		 12204 offset = cnt = 0;
12205 option = iopt;
252b5132 12206
a6e9f9df
AM		 12207 while (offset < sect->sh_size)
12208 {
2cf0635d 12209 Elf_External_Options * eoption;
252b5132 12210
a6e9f9df 12211 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 12212
a6e9f9df
AM		 12213 option->kind = BYTE_GET (eoption->kind);
12214 option->size = BYTE_GET (eoption->size);
12215 option->section = BYTE_GET (eoption->section);
12216 option->info = BYTE_GET (eoption->info);
76da6bbe 12217
a6e9f9df 12218 offset += option->size;
252b5132 12219
a6e9f9df
AM		 12220 ++option;
12221 ++cnt;
12222 }
252b5132 12223
a6e9f9df
AM		 12224 printf (_("\nSection '%s' contains %d entries:\n"),
12225 SECTION_NAME (sect), cnt);
76da6bbe 12226
a6e9f9df 12227 option = iopt;
252b5132 12228
a6e9f9df 12229 while (cnt-- > 0)
252b5132 12230 {
a6e9f9df
AM		 12231 size_t len;
12232
12233 switch (option->kind)
252b5132 12234 {
a6e9f9df
AM		 12235 case ODK_NULL:
12236 /* This shouldn't happen. */
12237 printf (" NULL %d %lx", option->section, option->info);
12238 break;
12239 case ODK_REGINFO:
12240 printf (" REGINFO ");
12241 if (elf_header.e_machine == EM_MIPS)
12242 {
12243 /* 32bit form. */
2cf0635d 12244 Elf32_External_RegInfo * ereg;
b34976b6 12245 Elf32_RegInfo reginfo;
a6e9f9df
AM		 12246
12247 ereg = (Elf32_External_RegInfo *) (option + 1);
12248 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12249 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12250 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12251 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12252 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12253 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
12254
12255 printf ("GPR %08lx GP 0x%lx\n",
12256 reginfo.ri_gprmask,
12257 (unsigned long) reginfo.ri_gp_value);
12258 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12259 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12260 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12261 }
12262 else
12263 {
12264 /* 64 bit form. */
2cf0635d 12265 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 12266 Elf64_Internal_RegInfo reginfo;
12267
12268 ereg = (Elf64_External_RegInfo *) (option + 1);
12269 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12270 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12271 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12272 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12273 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 12274 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 12275
12276 printf ("GPR %08lx GP 0x",
12277 reginfo.ri_gprmask);
12278 printf_vma (reginfo.ri_gp_value);
12279 printf ("\n");
12280
12281 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12282 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12283 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12284 }
12285 ++option;
12286 continue;
12287 case ODK_EXCEPTIONS:
12288 fputs (" EXCEPTIONS fpe_min(", stdout);
12289 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
12290 fputs (") fpe_max(", stdout);
12291 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
12292 fputs (")", stdout);
12293
12294 if (option->info & OEX_PAGE0)
12295 fputs (" PAGE0", stdout);
12296 if (option->info & OEX_SMM)
12297 fputs (" SMM", stdout);
12298 if (option->info & OEX_FPDBUG)
12299 fputs (" FPDBUG", stdout);
12300 if (option->info & OEX_DISMISS)
12301 fputs (" DISMISS", stdout);
12302 break;
12303 case ODK_PAD:
12304 fputs (" PAD ", stdout);
12305 if (option->info & OPAD_PREFIX)
12306 fputs (" PREFIX", stdout);
12307 if (option->info & OPAD_POSTFIX)
12308 fputs (" POSTFIX", stdout);
12309 if (option->info & OPAD_SYMBOL)
12310 fputs (" SYMBOL", stdout);
12311 break;
12312 case ODK_HWPATCH:
12313 fputs (" HWPATCH ", stdout);
12314 if (option->info & OHW_R4KEOP)
12315 fputs (" R4KEOP", stdout);
12316 if (option->info & OHW_R8KPFETCH)
12317 fputs (" R8KPFETCH", stdout);
12318 if (option->info & OHW_R5KEOP)
12319 fputs (" R5KEOP", stdout);
12320 if (option->info & OHW_R5KCVTL)
12321 fputs (" R5KCVTL", stdout);
12322 break;
12323 case ODK_FILL:
12324 fputs (" FILL ", stdout);
12325 /* XXX Print content of info word? */
12326 break;
12327 case ODK_TAGS:
12328 fputs (" TAGS ", stdout);
12329 /* XXX Print content of info word? */
12330 break;
12331 case ODK_HWAND:
12332 fputs (" HWAND ", stdout);
12333 if (option->info & OHWA0_R4KEOP_CHECKED)
12334 fputs (" R4KEOP_CHECKED", stdout);
12335 if (option->info & OHWA0_R4KEOP_CLEAN)
12336 fputs (" R4KEOP_CLEAN", stdout);
12337 break;
12338 case ODK_HWOR:
12339 fputs (" HWOR ", stdout);
12340 if (option->info & OHWA0_R4KEOP_CHECKED)
12341 fputs (" R4KEOP_CHECKED", stdout);
12342 if (option->info & OHWA0_R4KEOP_CLEAN)
12343 fputs (" R4KEOP_CLEAN", stdout);
12344 break;
12345 case ODK_GP_GROUP:
12346 printf (" GP_GROUP %#06lx self-contained %#06lx",
12347 option->info & OGP_GROUP,
12348 (option->info & OGP_SELF) >> 16);
12349 break;
12350 case ODK_IDENT:
12351 printf (" IDENT %#06lx self-contained %#06lx",
12352 option->info & OGP_GROUP,
12353 (option->info & OGP_SELF) >> 16);
12354 break;
12355 default:
12356 /* This shouldn't happen. */
12357 printf (" %3d ??? %d %lx",
12358 option->kind, option->section, option->info);
12359 break;
252b5132 12360 }
a6e9f9df 12361
2cf0635d 12362 len = sizeof (* eopt);
a6e9f9df
AM		 12363 while (len < option->size)
12364 if (((char *) option)[len] >= ' '
12365 && ((char *) option)[len] < 0x7f)
12366 printf ("%c", ((char *) option)[len++]);
12367 else
12368 printf ("\\%03o", ((char *) option)[len++]);
12369
12370 fputs ("\n", stdout);
252b5132 12371 ++option;
252b5132
RH		 12372 }
12373
a6e9f9df 12374 free (eopt);
252b5132 12375 }
252b5132
RH		 12376 }
12377
12378 if (conflicts_offset != 0 && conflictsno != 0)
12379 {
2cf0635d 12380 Elf32_Conflict * iconf;
252b5132
RH		 12381 size_t cnt;
12382
12383 if (dynamic_symbols == NULL)
12384 {
591a748a 12385 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 12386 return 0;
12387 }
12388
3f5e193b 12389 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 12390 if (iconf == NULL)
12391 {
591a748a 12392 error (_("Out of memory\n"));
252b5132
RH		 12393 return 0;
12394 }
12395
9ea033b2 12396 if (is_32bit_elf)
252b5132 12397 {
2cf0635d 12398 Elf32_External_Conflict * econf32;
a6e9f9df 12399
3f5e193b
NC		 12400 econf32 = (Elf32_External_Conflict *)
12401 get_data (NULL, file, conflicts_offset, conflictsno,
12402 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 12403 if (!econf32)
12404 return 0;
252b5132
RH		 12405
12406 for (cnt = 0; cnt < conflictsno; ++cnt)
12407 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 12408
12409 free (econf32);
252b5132
RH		 12410 }
12411 else
12412 {
2cf0635d 12413 Elf64_External_Conflict * econf64;
a6e9f9df 12414
3f5e193b
NC		 12415 econf64 = (Elf64_External_Conflict *)
12416 get_data (NULL, file, conflicts_offset, conflictsno,
12417 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 12418 if (!econf64)
12419 return 0;
252b5132
RH		 12420
12421 for (cnt = 0; cnt < conflictsno; ++cnt)
12422 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 12423
12424 free (econf64);
252b5132
RH		 12425 }
12426
c7e7ca54
NC		 12427 printf (_("\nSection '.conflict' contains %lu entries:\n"),
12428 (unsigned long) conflictsno);
252b5132
RH		 12429 puts (_(" Num: Index Value Name"));
12430
12431 for (cnt = 0; cnt < conflictsno; ++cnt)
12432 {
2cf0635d 12433 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
252b5132 12434
b34976b6 12435 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
f7a99963 12436 print_vma (psym->st_value, FULL_HEX);
31104126 12437 putchar (' ');
d79b3d50
NC		 12438 if (VALID_DYNAMIC_NAME (psym->st_name))
12439 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
12440 else
2b692964 12441 printf (_("<corrupt: %14ld>"), psym->st_name);
31104126 12442 putchar ('\n');
252b5132
RH		 12443 }
12444
252b5132
RH		 12445 free (iconf);
12446 }
12447
ccb4c951
RS		 12448 if (pltgot != 0 && local_gotno != 0)
12449 {
91d6fa6a 12450 bfd_vma ent, local_end, global_end;
bbeee7ea 12451 size_t i, offset;
2cf0635d 12452 unsigned char * data;
bbeee7ea 12453 int addr_size;
ccb4c951 12454
91d6fa6a 12455 ent = pltgot;
ccb4c951
RS		 12456 addr_size = (is_32bit_elf ? 4 : 8);
12457 local_end = pltgot + local_gotno * addr_size;
12458 global_end = local_end + (symtabno - gotsym) * addr_size;
12459
12460 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 12461 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 12462 global_end - pltgot, 1,
12463 _("Global Offset Table data"));
59245841
NC		 12464 if (data == NULL)
12465 return 0;
12466
ccb4c951
RS		 12467 printf (_("\nPrimary GOT:\n"));
12468 printf (_(" Canonical gp value: "));
12469 print_vma (pltgot + 0x7ff0, LONG_HEX);
12470 printf ("\n\n");
12471
12472 printf (_(" Reserved entries:\n"));
12473 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 12474 addr_size * 2, _("Address"), _("Access"),
12475 addr_size * 2, _("Initial"));
91d6fa6a 12476 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 12477 printf (_(" Lazy resolver\n"));
ccb4c951 12478 if (data
91d6fa6a 12479 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 12480 >> (addr_size * 8 - 1)) != 0)
12481 {
91d6fa6a 12482 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 12483 printf (_(" Module pointer (GNU extension)\n"));
ccb4c951
RS		 12484 }
12485 printf ("\n");
12486
91d6fa6a 12487 if (ent < local_end)
ccb4c951
RS		 12488 {
12489 printf (_(" Local entries:\n"));
cc5914eb 12490 printf (" %*s %10s %*s\n",
2b692964
NC		 12491 addr_size * 2, _("Address"), _("Access"),
12492 addr_size * 2, _("Initial"));
91d6fa6a 12493 while (ent < local_end)
ccb4c951 12494 {
91d6fa6a 12495 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 12496 printf ("\n");
12497 }
12498 printf ("\n");
12499 }
12500
12501 if (gotsym < symtabno)
12502 {
12503 int sym_width;
12504
12505 printf (_(" Global entries:\n"));
cc5914eb 12506 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 12507 addr_size * 2, _("Address"),
12508 _("Access"),
2b692964 12509 addr_size * 2, _("Initial"),
9cf03b7e
NC		 12510 addr_size * 2, _("Sym.Val."),
12511 _("Type"),
12512 /* Note for translators: "Ndx" = abbreviated form of "Index". */
12513 _("Ndx"), _("Name"));
12514
ccb4c951
RS		 12515 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
12516 for (i = gotsym; i < symtabno; i++)
12517 {
2cf0635d 12518 Elf_Internal_Sym * psym;
ccb4c951
RS		 12519
12520 psym = dynamic_symbols + i;
91d6fa6a 12521 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 12522 printf (" ");
12523 print_vma (psym->st_value, LONG_HEX);
12524 printf (" %-7s %3s ",
12525 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12526 get_symbol_index_type (psym->st_shndx));
12527 if (VALID_DYNAMIC_NAME (psym->st_name))
12528 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12529 else
2b692964 12530 printf (_("<corrupt: %14ld>"), psym->st_name);
ccb4c951
RS		 12531 printf ("\n");
12532 }
12533 printf ("\n");
12534 }
12535
12536 if (data)
12537 free (data);
12538 }
12539
861fb55a
DJ		 12540 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
12541 {
91d6fa6a 12542 bfd_vma ent, end;
861fb55a
DJ		 12543 size_t offset, rel_offset;
12544 unsigned long count, i;
2cf0635d 12545 unsigned char * data;
861fb55a 12546 int addr_size, sym_width;
2cf0635d 12547 Elf_Internal_Rela * rels;
861fb55a
DJ		 12548
12549 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
12550 if (pltrel == DT_RELA)
12551 {
12552 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
12553 return 0;
12554 }
12555 else
12556 {
12557 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
12558 return 0;
12559 }
12560
91d6fa6a 12561 ent = mips_pltgot;
861fb55a
DJ		 12562 addr_size = (is_32bit_elf ? 4 : 8);
12563 end = mips_pltgot + (2 + count) * addr_size;
12564
12565 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 12566 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 12567 1, _("Procedure Linkage Table data"));
59245841
NC		 12568 if (data == NULL)
12569 return 0;
12570
9cf03b7e 12571 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 12572 printf (_(" Reserved entries:\n"));
12573 printf (_(" %*s %*s Purpose\n"),
2b692964 12574 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 12575 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 12576 printf (_(" PLT lazy resolver\n"));
91d6fa6a 12577 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 12578 printf (_(" Module pointer\n"));
861fb55a
DJ		 12579 printf ("\n");
12580
12581 printf (_(" Entries:\n"));
cc5914eb 12582 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 12583 addr_size * 2, _("Address"),
12584 addr_size * 2, _("Initial"),
12585 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 12586 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
12587 for (i = 0; i < count; i++)
12588 {
2cf0635d 12589 Elf_Internal_Sym * psym;
861fb55a
DJ		 12590
12591 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
91d6fa6a 12592 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a
DJ		 12593 printf (" ");
12594 print_vma (psym->st_value, LONG_HEX);
12595 printf (" %-7s %3s ",
12596 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12597 get_symbol_index_type (psym->st_shndx));
12598 if (VALID_DYNAMIC_NAME (psym->st_name))
12599 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12600 else
2b692964 12601 printf (_("<corrupt: %14ld>"), psym->st_name);
861fb55a
DJ		 12602 printf ("\n");
12603 }
12604 printf ("\n");
12605
12606 if (data)
12607 free (data);
12608 free (rels);
12609 }
12610
252b5132
RH		 12611 return 1;
12612}
12613
047b2264 12614static int
2cf0635d 12615process_gnu_liblist (FILE * file)
047b2264 12616{
2cf0635d
NC		 12617 Elf_Internal_Shdr * section;
12618 Elf_Internal_Shdr * string_sec;
12619 Elf32_External_Lib * elib;
12620 char * strtab;
c256ffe7 12621 size_t strtab_size;
047b2264
JJ		 12622 size_t cnt;
12623 unsigned i;
12624
12625 if (! do_arch)
12626 return 0;
12627
12628 for (i = 0, section = section_headers;
12629 i < elf_header.e_shnum;
b34976b6 12630 i++, section++)
047b2264
JJ		 12631 {
12632 switch (section->sh_type)
12633 {
12634 case SHT_GNU_LIBLIST:
4fbb74a6 12635 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 12636 break;
12637
3f5e193b
NC		 12638 elib = (Elf32_External_Lib *)
12639 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 12640 _("liblist section data"));
047b2264
JJ		 12641
12642 if (elib == NULL)
12643 break;
4fbb74a6 12644 string_sec = section_headers + section->sh_link;
047b2264 12645
3f5e193b
NC		 12646 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
12647 string_sec->sh_size,
12648 _("liblist string table"));
047b2264
JJ		 12649 if (strtab == NULL
12650 || section->sh_entsize != sizeof (Elf32_External_Lib))
12651 {
12652 free (elib);
2842702f 12653 free (strtab);
047b2264
JJ		 12654 break;
12655 }
59245841 12656 strtab_size = string_sec->sh_size;
047b2264
JJ		 12657
12658 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12659 SECTION_NAME (section),
0af1713e 12660 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 12661
2b692964 12662 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 12663
12664 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
12665 ++cnt)
12666 {
12667 Elf32_Lib liblist;
91d6fa6a 12668 time_t atime;
047b2264 12669 char timebuf[20];
2cf0635d 12670 struct tm * tmp;
047b2264
JJ		 12671
12672 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 12673 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 12674 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12675 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12676 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12677
91d6fa6a 12678 tmp = gmtime (&atime);
e9e44622
JJ		 12679 snprintf (timebuf, sizeof (timebuf),
12680 "%04u-%02u-%02uT%02u:%02u:%02u",
12681 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12682 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 12683
12684 printf ("%3lu: ", (unsigned long) cnt);
12685 if (do_wide)
c256ffe7 12686 printf ("%-20s", liblist.l_name < strtab_size
2b692964 12687 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 12688 else
c256ffe7 12689 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 12690 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 12691 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
12692 liblist.l_version, liblist.l_flags);
12693 }
12694
12695 free (elib);
2842702f 12696 free (strtab);
047b2264
JJ		 12697 }
12698 }
12699
12700 return 1;
12701}
12702
9437c45b 12703static const char *
d3ba0551 12704get_note_type (unsigned e_type)
779fe533
NC		 12705{
12706 static char buff[64];
103f02d3 12707
1ec5cd37
NC		 12708 if (elf_header.e_type == ET_CORE)
12709 switch (e_type)
12710 {
57346661 12711 case NT_AUXV:
1ec5cd37 12712 return _("NT_AUXV (auxiliary vector)");
57346661 12713 case NT_PRSTATUS:
1ec5cd37 12714 return _("NT_PRSTATUS (prstatus structure)");
57346661 12715 case NT_FPREGSET:
1ec5cd37 12716 return _("NT_FPREGSET (floating point registers)");
57346661 12717 case NT_PRPSINFO:
1ec5cd37 12718 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 12719 case NT_TASKSTRUCT:
1ec5cd37 12720 return _("NT_TASKSTRUCT (task structure)");
57346661 12721 case NT_PRXFPREG:
1ec5cd37 12722 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 12723 case NT_PPC_VMX:
12724 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 12725 case NT_PPC_VSX:
12726 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 12727 case NT_386_TLS:
12728 return _("NT_386_TLS (x86 TLS information)");
12729 case NT_386_IOPERM:
12730 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 12731 case NT_X86_XSTATE:
12732 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 12733 case NT_S390_HIGH_GPRS:
12734 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 12735 case NT_S390_TIMER:
12736 return _("NT_S390_TIMER (s390 timer register)");
12737 case NT_S390_TODCMP:
12738 return _("NT_S390_TODCMP (s390 TOD comparator register)");
12739 case NT_S390_TODPREG:
12740 return _("NT_S390_TODPREG (s390 TOD programmable register)");
12741 case NT_S390_CTRS:
12742 return _("NT_S390_CTRS (s390 control registers)");
12743 case NT_S390_PREFIX:
12744 return _("NT_S390_PREFIX (s390 prefix register)");
faa9a424
UW		 12745 case NT_ARM_VFP:
12746 return _("NT_ARM_VFP (arm VFP registers)");
57346661 12747 case NT_PSTATUS:
1ec5cd37 12748 return _("NT_PSTATUS (pstatus structure)");
57346661 12749 case NT_FPREGS:
1ec5cd37 12750 return _("NT_FPREGS (floating point registers)");
57346661 12751 case NT_PSINFO:
1ec5cd37 12752 return _("NT_PSINFO (psinfo structure)");
57346661 12753 case NT_LWPSTATUS:
1ec5cd37 12754 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 12755 case NT_LWPSINFO:
1ec5cd37 12756 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 12757 case NT_WIN32PSTATUS:
1ec5cd37 12758 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 12759 case NT_SIGINFO:
12760 return _("NT_SIGINFO (siginfo_t data)");
12761 case NT_FILE:
12762 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 12763 default:
12764 break;
12765 }
12766 else
12767 switch (e_type)
12768 {
12769 case NT_VERSION:
12770 return _("NT_VERSION (version)");
12771 case NT_ARCH:
12772 return _("NT_ARCH (architecture)");
12773 default:
12774 break;
12775 }
12776
e9e44622 12777 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 12778 return buff;
779fe533
NC		 12779}
12780
9ece1fa9
TT		 12781static int
12782print_core_note (Elf_Internal_Note *pnote)
12783{
12784 unsigned int addr_size = is_32bit_elf ? 4 : 8;
12785 bfd_vma count, page_size;
12786 unsigned char *descdata, *filenames, *descend;
12787
12788 if (pnote->type != NT_FILE)
12789 return 1;
12790
12791#ifndef BFD64
12792 if (!is_32bit_elf)
12793 {
12794 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
12795 /* Still "successful". */
12796 return 1;
12797 }
12798#endif
12799
12800 if (pnote->descsz < 2 * addr_size)
12801 {
12802 printf (_(" Malformed note - too short for header\n"));
12803 return 0;
12804 }
12805
12806 descdata = (unsigned char *) pnote->descdata;
12807 descend = descdata + pnote->descsz;
12808
12809 if (descdata[pnote->descsz - 1] != '\0')
12810 {
12811 printf (_(" Malformed note - does not end with \\0\n"));
12812 return 0;
12813 }
12814
12815 count = byte_get (descdata, addr_size);
12816 descdata += addr_size;
12817
12818 page_size = byte_get (descdata, addr_size);
12819 descdata += addr_size;
12820
12821 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
12822 {
12823 printf (_(" Malformed note - too short for supplied file count\n"));
12824 return 0;
12825 }
12826
12827 printf (_(" Page size: "));
12828 print_vma (page_size, DEC);
12829 printf ("\n");
12830
12831 printf (_(" %*s%*s%*s\n"),
12832 (int) (2 + 2 * addr_size), _("Start"),
12833 (int) (4 + 2 * addr_size), _("End"),
12834 (int) (4 + 2 * addr_size), _("Page Offset"));
12835 filenames = descdata + count * 3 * addr_size;
12836 while (--count > 0)
12837 {
12838 bfd_vma start, end, file_ofs;
12839
12840 if (filenames == descend)
12841 {
12842 printf (_(" Malformed note - filenames end too early\n"));
12843 return 0;
12844 }
12845
12846 start = byte_get (descdata, addr_size);
12847 descdata += addr_size;
12848 end = byte_get (descdata, addr_size);
12849 descdata += addr_size;
12850 file_ofs = byte_get (descdata, addr_size);
12851 descdata += addr_size;
12852
12853 printf (" ");
12854 print_vma (start, FULL_HEX);
12855 printf (" ");
12856 print_vma (end, FULL_HEX);
12857 printf (" ");
12858 print_vma (file_ofs, FULL_HEX);
12859 printf ("\n %s\n", filenames);
12860
12861 filenames += 1 + strlen ((char *) filenames);
12862 }
12863
12864 return 1;
12865}
12866
1118d252
RM		 12867static const char *
12868get_gnu_elf_note_type (unsigned e_type)
12869{
12870 static char buff[64];
12871
12872 switch (e_type)
12873 {
12874 case NT_GNU_ABI_TAG:
12875 return _("NT_GNU_ABI_TAG (ABI version tag)");
12876 case NT_GNU_HWCAP:
12877 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
12878 case NT_GNU_BUILD_ID:
12879 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 12880 case NT_GNU_GOLD_VERSION:
12881 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 12882 default:
12883 break;
12884 }
12885
12886 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12887 return buff;
12888}
12889
664f90a3
TT		 12890static int
12891print_gnu_note (Elf_Internal_Note *pnote)
12892{
12893 switch (pnote->type)
12894 {
12895 case NT_GNU_BUILD_ID:
12896 {
12897 unsigned long i;
12898
12899 printf (_(" Build ID: "));
12900 for (i = 0; i < pnote->descsz; ++i)
12901 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 12902 printf ("\n");
664f90a3
TT		 12903 }
12904 break;
12905
12906 case NT_GNU_ABI_TAG:
12907 {
12908 unsigned long os, major, minor, subminor;
12909 const char *osname;
12910
12911 os = byte_get ((unsigned char *) pnote->descdata, 4);
12912 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
12913 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
12914 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
12915
12916 switch (os)
12917 {
12918 case GNU_ABI_TAG_LINUX:
12919 osname = "Linux";
12920 break;
12921 case GNU_ABI_TAG_HURD:
12922 osname = "Hurd";
12923 break;
12924 case GNU_ABI_TAG_SOLARIS:
12925 osname = "Solaris";
12926 break;
12927 case GNU_ABI_TAG_FREEBSD:
12928 osname = "FreeBSD";
12929 break;
12930 case GNU_ABI_TAG_NETBSD:
12931 osname = "NetBSD";
12932 break;
12933 default:
12934 osname = "Unknown";
12935 break;
12936 }
12937
12938 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
12939 major, minor, subminor);
12940 }
12941 break;
12942 }
12943
12944 return 1;
12945}
12946
9437c45b 12947static const char *
d3ba0551 12948get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 12949{
12950 static char buff[64];
12951
b4db1224 12952 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 12953 {
12954 /* NetBSD core "procinfo" structure. */
12955 return _("NetBSD procinfo structure");
12956 }
12957
12958 /* As of Jan 2002 there are no other machine-independent notes
12959 defined for NetBSD core files. If the note type is less
12960 than the start of the machine-dependent note types, we don't
12961 understand it. */
12962
b4db1224 12963 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 12964 {
e9e44622 12965 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 12966 return buff;
12967 }
12968
12969 switch (elf_header.e_machine)
12970 {
12971 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
12972 and PT_GETFPREGS == mach+2. */
12973
12974 case EM_OLD_ALPHA:
12975 case EM_ALPHA:
12976 case EM_SPARC:
12977 case EM_SPARC32PLUS:
12978 case EM_SPARCV9:
12979 switch (e_type)
12980 {
2b692964 12981 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 12982 return _("PT_GETREGS (reg structure)");
2b692964 12983 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 12984 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 12985 default:
12986 break;
12987 }
12988 break;
12989
12990 /* On all other arch's, PT_GETREGS == mach+1 and
12991 PT_GETFPREGS == mach+3. */
12992 default:
12993 switch (e_type)
12994 {
2b692964 12995 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 12996 return _("PT_GETREGS (reg structure)");
2b692964 12997 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 12998 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 12999 default:
13000 break;
13001 }
13002 }
13003
9cf03b7e 13004 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 13005 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 13006 return buff;
13007}
13008
70616151
TT		 13009static const char *
13010get_stapsdt_note_type (unsigned e_type)
13011{
13012 static char buff[64];
13013
13014 switch (e_type)
13015 {
13016 case NT_STAPSDT:
13017 return _("NT_STAPSDT (SystemTap probe descriptors)");
13018
13019 default:
13020 break;
13021 }
13022
13023 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13024 return buff;
13025}
13026
c6a9fc58
TT		 13027static int
13028print_stapsdt_note (Elf_Internal_Note *pnote)
13029{
13030 int addr_size = is_32bit_elf ? 4 : 8;
13031 char *data = pnote->descdata;
13032 char *data_end = pnote->descdata + pnote->descsz;
13033 bfd_vma pc, base_addr, semaphore;
13034 char *provider, *probe, *arg_fmt;
13035
13036 pc = byte_get ((unsigned char *) data, addr_size);
13037 data += addr_size;
13038 base_addr = byte_get ((unsigned char *) data, addr_size);
13039 data += addr_size;
13040 semaphore = byte_get ((unsigned char *) data, addr_size);
13041 data += addr_size;
13042
13043 provider = data;
13044 data += strlen (data) + 1;
13045 probe = data;
13046 data += strlen (data) + 1;
13047 arg_fmt = data;
13048 data += strlen (data) + 1;
13049
13050 printf (_(" Provider: %s\n"), provider);
13051 printf (_(" Name: %s\n"), probe);
13052 printf (_(" Location: "));
13053 print_vma (pc, FULL_HEX);
13054 printf (_(", Base: "));
13055 print_vma (base_addr, FULL_HEX);
13056 printf (_(", Semaphore: "));
13057 print_vma (semaphore, FULL_HEX);
9cf03b7e 13058 printf ("\n");
c6a9fc58
TT		 13059 printf (_(" Arguments: %s\n"), arg_fmt);
13060
13061 return data == data_end;
13062}
13063
00e98fc7
TG		 13064static const char *
13065get_ia64_vms_note_type (unsigned e_type)
13066{
13067 static char buff[64];
13068
13069 switch (e_type)
13070 {
13071 case NT_VMS_MHD:
13072 return _("NT_VMS_MHD (module header)");
13073 case NT_VMS_LNM:
13074 return _("NT_VMS_LNM (language name)");
13075 case NT_VMS_SRC:
13076 return _("NT_VMS_SRC (source files)");
13077 case NT_VMS_TITLE:
9cf03b7e 13078 return "NT_VMS_TITLE";
00e98fc7
TG		 13079 case NT_VMS_EIDC:
13080 return _("NT_VMS_EIDC (consistency check)");
13081 case NT_VMS_FPMODE:
13082 return _("NT_VMS_FPMODE (FP mode)");
13083 case NT_VMS_LINKTIME:
9cf03b7e 13084 return "NT_VMS_LINKTIME";
00e98fc7
TG		 13085 case NT_VMS_IMGNAM:
13086 return _("NT_VMS_IMGNAM (image name)");
13087 case NT_VMS_IMGID:
13088 return _("NT_VMS_IMGID (image id)");
13089 case NT_VMS_LINKID:
13090 return _("NT_VMS_LINKID (link id)");
13091 case NT_VMS_IMGBID:
13092 return _("NT_VMS_IMGBID (build id)");
13093 case NT_VMS_GSTNAM:
13094 return _("NT_VMS_GSTNAM (sym table name)");
13095 case NT_VMS_ORIG_DYN:
9cf03b7e 13096 return "NT_VMS_ORIG_DYN";
00e98fc7 13097 case NT_VMS_PATCHTIME:
9cf03b7e 13098 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 13099 default:
13100 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13101 return buff;
13102 }
13103}
13104
13105static int
13106print_ia64_vms_note (Elf_Internal_Note * pnote)
13107{
13108 switch (pnote->type)
13109 {
13110 case NT_VMS_MHD:
13111 if (pnote->descsz > 36)
13112 {
13113 size_t l = strlen (pnote->descdata + 34);
13114 printf (_(" Creation date : %.17s\n"), pnote->descdata);
13115 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
13116 printf (_(" Module name : %s\n"), pnote->descdata + 34);
13117 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
13118 }
13119 else
13120 printf (_(" Invalid size\n"));
13121 break;
13122 case NT_VMS_LNM:
13123 printf (_(" Language: %s\n"), pnote->descdata);
13124 break;
13125#ifdef BFD64
13126 case NT_VMS_FPMODE:
9cf03b7e 13127 printf (_(" Floating Point mode: "));
4a5cb34f 13128 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 13129 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
13130 break;
13131 case NT_VMS_LINKTIME:
13132 printf (_(" Link time: "));
13133 print_vms_time
13134 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13135 printf ("\n");
13136 break;
13137 case NT_VMS_PATCHTIME:
13138 printf (_(" Patch time: "));
13139 print_vms_time
13140 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13141 printf ("\n");
13142 break;
13143 case NT_VMS_ORIG_DYN:
13144 printf (_(" Major id: %u, minor id: %u\n"),
13145 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
13146 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 13147 printf (_(" Last modified : "));
00e98fc7
TG		 13148 print_vms_time
13149 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 13150 printf (_("\n Link flags : "));
4a5cb34f 13151 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 13152 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
13153 printf (_(" Header flags: 0x%08x\n"),
13154 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
13155 printf (_(" Image id : %s\n"), pnote->descdata + 32);
13156 break;
13157#endif
13158 case NT_VMS_IMGNAM:
13159 printf (_(" Image name: %s\n"), pnote->descdata);
13160 break;
13161 case NT_VMS_GSTNAM:
13162 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
13163 break;
13164 case NT_VMS_IMGID:
13165 printf (_(" Image id: %s\n"), pnote->descdata);
13166 break;
13167 case NT_VMS_LINKID:
13168 printf (_(" Linker id: %s\n"), pnote->descdata);
13169 break;
13170 default:
13171 break;
13172 }
13173 return 1;
13174}
13175
6d118b09
NC		 13176/* Note that by the ELF standard, the name field is already null byte
13177 terminated, and namesz includes the terminating null byte.
13178 I.E. the value of namesz for the name "FSF" is 4.
13179
e3c8793a 13180 If the value of namesz is zero, there is no name present. */
779fe533 13181static int
2cf0635d 13182process_note (Elf_Internal_Note * pnote)
779fe533 13183{
2cf0635d
NC		 13184 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
13185 const char * nt;
9437c45b
JT		 13186
13187 if (pnote->namesz == 0)
1ec5cd37
NC		 13188 /* If there is no note name, then use the default set of
13189 note type strings. */
13190 nt = get_note_type (pnote->type);
13191
1118d252
RM		 13192 else if (const_strneq (pnote->namedata, "GNU"))
13193 /* GNU-specific object file notes. */
13194 nt = get_gnu_elf_note_type (pnote->type);
13195
0112cd26 13196 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 13197 /* NetBSD-specific core file notes. */
13198 nt = get_netbsd_elfcore_note_type (pnote->type);
13199
b15fa79e
AM		 13200 else if (strneq (pnote->namedata, "SPU/", 4))
13201 {
13202 /* SPU-specific core file notes. */
13203 nt = pnote->namedata + 4;
13204 name = "SPU";
13205 }
13206
00e98fc7
TG		 13207 else if (const_strneq (pnote->namedata, "IPF/VMS"))
13208 /* VMS/ia64-specific file notes. */
13209 nt = get_ia64_vms_note_type (pnote->type);
13210
70616151
TT		 13211 else if (const_strneq (pnote->namedata, "stapsdt"))
13212 nt = get_stapsdt_note_type (pnote->type);
13213
9437c45b 13214 else
1ec5cd37
NC		 13215 /* Don't recognize this note name; just use the default set of
13216 note type strings. */
00e98fc7 13217 nt = get_note_type (pnote->type);
9437c45b 13218
2aee03ae 13219 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 13220
13221 if (const_strneq (pnote->namedata, "IPF/VMS"))
13222 return print_ia64_vms_note (pnote);
664f90a3
TT		 13223 else if (const_strneq (pnote->namedata, "GNU"))
13224 return print_gnu_note (pnote);
c6a9fc58
TT		 13225 else if (const_strneq (pnote->namedata, "stapsdt"))
13226 return print_stapsdt_note (pnote);
9ece1fa9
TT		 13227 else if (const_strneq (pnote->namedata, "CORE"))
13228 return print_core_note (pnote);
00e98fc7
TG		 13229 else
13230 return 1;
779fe533
NC		 13231}
13232
6d118b09 13233
779fe533 13234static int
2cf0635d 13235process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 13236{
2cf0635d
NC		 13237 Elf_External_Note * pnotes;
13238 Elf_External_Note * external;
b34976b6 13239 int res = 1;
103f02d3 13240
779fe533
NC		 13241 if (length <= 0)
13242 return 0;
103f02d3 13243
3f5e193b
NC		 13244 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
13245 _("notes"));
dd24e3da 13246 if (pnotes == NULL)
a6e9f9df 13247 return 0;
779fe533 13248
103f02d3 13249 external = pnotes;
103f02d3 13250
305c7206 13251 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 13252 (unsigned long) offset, (unsigned long) length);
2aee03ae 13253 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 13254
2cf0635d 13255 while (external < (Elf_External_Note *) ((char *) pnotes + length))
779fe533 13256 {
2cf0635d 13257 Elf_External_Note * next;
b34976b6 13258 Elf_Internal_Note inote;
2cf0635d 13259 char * temp = NULL;
6d118b09 13260
00e98fc7
TG		 13261 if (!is_ia64_vms ())
13262 {
13263 inote.type = BYTE_GET (external->type);
13264 inote.namesz = BYTE_GET (external->namesz);
13265 inote.namedata = external->name;
13266 inote.descsz = BYTE_GET (external->descsz);
13267 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
13268 inote.descpos = offset + (inote.descdata - (char *) pnotes);
13269
13270 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
13271 }
13272 else
13273 {
13274 Elf64_External_VMS_Note *vms_external;
13275
13276 vms_external = (Elf64_External_VMS_Note *)external;
13277 inote.type = BYTE_GET (vms_external->type);
13278 inote.namesz = BYTE_GET (vms_external->namesz);
13279 inote.namedata = vms_external->name;
13280 inote.descsz = BYTE_GET (vms_external->descsz);
13281 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
13282 inote.descpos = offset + (inote.descdata - (char *) pnotes);
13283
13284 next = (Elf_External_Note *)
13285 (inote.descdata + align_power (inote.descsz, 3));
13286 }
3e55a963 13287
dd24e3da
NC		 13288 if ( ((char *) next > ((char *) pnotes) + length)
13289 || ((char *) next < (char *) pnotes))
3e55a963 13290 {
0fd3a477 13291 warn (_("corrupt note found at offset %lx into core notes\n"),
0af1713e 13292 (unsigned long) ((char *) external - (char *) pnotes));
0fd3a477 13293 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
3e55a963
NC		 13294 inote.type, inote.namesz, inote.descsz);
13295 break;
13296 }
13297
13298 external = next;
6d118b09 13299
dd24e3da 13300 /* Prevent out-of-bounds indexing. */
8b971f9f 13301 if (inote.namedata + inote.namesz > (char *) pnotes + length
dd24e3da
NC		 13302 || inote.namedata + inote.namesz < inote.namedata)
13303 {
13304 warn (_("corrupt note found at offset %lx into core notes\n"),
13305 (unsigned long) ((char *) external - (char *) pnotes));
13306 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
13307 inote.type, inote.namesz, inote.descsz);
13308 break;
13309 }
13310
6d118b09
NC		 13311 /* Verify that name is null terminated. It appears that at least
13312 one version of Linux (RedHat 6.0) generates corefiles that don't
13313 comply with the ELF spec by failing to include the null byte in
13314 namesz. */
8b971f9f 13315 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 13316 {
3f5e193b 13317 temp = (char *) malloc (inote.namesz + 1);
76da6bbe 13318
6d118b09
NC		 13319 if (temp == NULL)
13320 {
13321 error (_("Out of memory\n"));
13322 res = 0;
13323 break;
13324 }
76da6bbe 13325
6d118b09
NC		 13326 strncpy (temp, inote.namedata, inote.namesz);
13327 temp[inote.namesz] = 0;
76da6bbe 13328
6d118b09
NC		 13329 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
13330 inote.namedata = temp;
13331 }
13332
13333 res &= process_note (& inote);
103f02d3 13334
6d118b09
NC		 13335 if (temp != NULL)
13336 {
13337 free (temp);
13338 temp = NULL;
13339 }
779fe533
NC		 13340 }
13341
13342 free (pnotes);
103f02d3 13343
779fe533
NC		 13344 return res;
13345}
13346
13347static int
2cf0635d 13348process_corefile_note_segments (FILE * file)
779fe533 13349{
2cf0635d 13350 Elf_Internal_Phdr * segment;
b34976b6
AM		 13351 unsigned int i;
13352 int res = 1;
103f02d3 13353
d93f0186 13354 if (! get_program_headers (file))
779fe533 13355 return 0;
103f02d3 13356
779fe533
NC		 13357 for (i = 0, segment = program_headers;
13358 i < elf_header.e_phnum;
b34976b6 13359 i++, segment++)
779fe533
NC		 13360 {
13361 if (segment->p_type == PT_NOTE)
103f02d3 13362 res &= process_corefile_note_segment (file,
30800947
NC		 13363 (bfd_vma) segment->p_offset,
13364 (bfd_vma) segment->p_filesz);
779fe533 13365 }
103f02d3 13366
779fe533
NC		 13367 return res;
13368}
13369
13370static int
2cf0635d 13371process_note_sections (FILE * file)
1ec5cd37 13372{
2cf0635d 13373 Elf_Internal_Shdr * section;
1ec5cd37
NC		 13374 unsigned long i;
13375 int res = 1;
13376
13377 for (i = 0, section = section_headers;
fa1908fd 13378 i < elf_header.e_shnum && section != NULL;
1ec5cd37
NC		 13379 i++, section++)
13380 if (section->sh_type == SHT_NOTE)
13381 res &= process_corefile_note_segment (file,
13382 (bfd_vma) section->sh_offset,
13383 (bfd_vma) section->sh_size);
13384
13385 return res;
13386}
13387
13388static int
2cf0635d 13389process_notes (FILE * file)
779fe533
NC		 13390{
13391 /* If we have not been asked to display the notes then do nothing. */
13392 if (! do_notes)
13393 return 1;
103f02d3 13394
779fe533 13395 if (elf_header.e_type != ET_CORE)
1ec5cd37 13396 return process_note_sections (file);
103f02d3 13397
779fe533 13398 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 13399 if (elf_header.e_phnum > 0)
13400 return process_corefile_note_segments (file);
779fe533 13401
1ec5cd37
NC		 13402 printf (_("No note segments present in the core file.\n"));
13403 return 1;
779fe533
NC		 13404}
13405
252b5132 13406static int
2cf0635d 13407process_arch_specific (FILE * file)
252b5132 13408{
a952a375
NC		 13409 if (! do_arch)
13410 return 1;
13411
252b5132
RH		 13412 switch (elf_header.e_machine)
13413 {
11c1ff18
PB		 13414 case EM_ARM:
13415 return process_arm_specific (file);
252b5132 13416 case EM_MIPS:
4fe85591 13417 case EM_MIPS_RS3_LE:
252b5132
RH		 13418 return process_mips_specific (file);
13419 break;
34c8bcba
JM		 13420 case EM_PPC:
13421 return process_power_specific (file);
13422 break;
9e8c70f9
DM		 13423 case EM_SPARC:
13424 case EM_SPARC32PLUS:
13425 case EM_SPARCV9:
13426 return process_sparc_specific (file);
13427 break;
59e6276b
JM		 13428 case EM_TI_C6000:
13429 return process_tic6x_specific (file);
13430 break;
252b5132
RH		 13431 default:
13432 break;
13433 }
13434 return 1;
13435}
13436
13437static int
2cf0635d 13438get_file_header (FILE * file)
252b5132 13439{
9ea033b2
NC		 13440 /* Read in the identity array. */
13441 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 13442 return 0;
13443
9ea033b2 13444 /* Determine how to read the rest of the header. */
b34976b6 13445 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 13446 {
13447 default: /* fall through */
13448 case ELFDATANONE: /* fall through */
adab8cdc
AO		 13449 case ELFDATA2LSB:
13450 byte_get = byte_get_little_endian;
13451 byte_put = byte_put_little_endian;
13452 break;
13453 case ELFDATA2MSB:
13454 byte_get = byte_get_big_endian;
13455 byte_put = byte_put_big_endian;
13456 break;
9ea033b2
NC		 13457 }
13458
13459 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 13460 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 13461
13462 /* Read in the rest of the header. */
13463 if (is_32bit_elf)
13464 {
13465 Elf32_External_Ehdr ehdr32;
252b5132 13466
9ea033b2
NC		 13467 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
13468 return 0;
103f02d3 13469
9ea033b2
NC		 13470 elf_header.e_type = BYTE_GET (ehdr32.e_type);
13471 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
13472 elf_header.e_version = BYTE_GET (ehdr32.e_version);
13473 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
13474 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
13475 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
13476 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
13477 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
13478 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
13479 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
13480 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
13481 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
13482 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
13483 }
252b5132 13484 else
9ea033b2
NC		 13485 {
13486 Elf64_External_Ehdr ehdr64;
a952a375
NC		 13487
13488 /* If we have been compiled with sizeof (bfd_vma) == 4, then
13489 we will not be able to cope with the 64bit data found in
13490 64 ELF files. Detect this now and abort before we start
50c2245b 13491 overwriting things. */
a952a375
NC		 13492 if (sizeof (bfd_vma) < 8)
13493 {
e3c8793a
NC		 13494 error (_("This instance of readelf has been built without support for a\n\
1349564 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 13496 return 0;
13497 }
103f02d3 13498
9ea033b2
NC		 13499 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
13500 return 0;
103f02d3 13501
9ea033b2
NC		 13502 elf_header.e_type = BYTE_GET (ehdr64.e_type);
13503 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
13504 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 13505 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
13506 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
13507 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 13508 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
13509 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
13510 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
13511 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
13512 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
13513 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
13514 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
13515 }
252b5132 13516
7ece0d85
JJ		 13517 if (elf_header.e_shoff)
13518 {
13519 /* There may be some extensions in the first section header. Don't
13520 bomb if we can't read it. */
13521 if (is_32bit_elf)
13522 get_32bit_section_headers (file, 1);
13523 else
13524 get_64bit_section_headers (file, 1);
13525 }
560f3c1c 13526
252b5132
RH		 13527 return 1;
13528}
13529
fb52b2f4
NC		 13530/* Process one ELF object file according to the command line options.
13531 This file may actually be stored in an archive. The file is
13532 positioned at the start of the ELF object. */
13533
ff78d6d6 13534static int
2cf0635d 13535process_object (char * file_name, FILE * file)
252b5132 13536{
252b5132
RH		 13537 unsigned int i;
13538
252b5132
RH		 13539 if (! get_file_header (file))
13540 {
13541 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 13542 return 1;
252b5132
RH		 13543 }
13544
13545 /* Initialise per file variables. */
60bca95a 13546 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 13547 version_info[i] = 0;
13548
60bca95a 13549 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 13550 dynamic_info[i] = 0;
5115b233 13551 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 13552
13553 /* Process the file. */
13554 if (show_name)
13555 printf (_("\nFile: %s\n"), file_name);
13556
18bd398b
NC		 13557 /* Initialise the dump_sects array from the cmdline_dump_sects array.
13558 Note we do this even if cmdline_dump_sects is empty because we
13559 must make sure that the dump_sets array is zeroed out before each
13560 object file is processed. */
13561 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 13562 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 13563
13564 if (num_cmdline_dump_sects > 0)
13565 {
13566 if (num_dump_sects == 0)
13567 /* A sneaky way of allocating the dump_sects array. */
09c11c86 13568 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 13569
13570 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 13571 memcpy (dump_sects, cmdline_dump_sects,
13572 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 13573 }
d70c5fc7 13574
252b5132 13575 if (! process_file_header ())
fb52b2f4 13576 return 1;
252b5132 13577
d1f5c6e3 13578 if (! process_section_headers (file))
2f62977e 13579 {
d1f5c6e3
L		 13580 /* Without loaded section headers we cannot process lots of
13581 things. */
2f62977e 13582 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 13583
2f62977e 13584 if (! do_using_dynamic)
2c610e4b 13585 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 13586 }
252b5132 13587
d1f5c6e3
L		 13588 if (! process_section_groups (file))
13589 {
13590 /* Without loaded section groups we cannot process unwind. */
13591 do_unwind = 0;
13592 }
13593
2f62977e 13594 if (process_program_headers (file))
b2d38a17 13595 process_dynamic_section (file);
252b5132
RH		 13596
13597 process_relocs (file);
13598
4d6ed7c8
NC		 13599 process_unwind (file);
13600
252b5132
RH		 13601 process_symbol_table (file);
13602
13603 process_syminfo (file);
13604
13605 process_version_sections (file);
13606
13607 process_section_contents (file);
f5842774 13608
1ec5cd37 13609 process_notes (file);
103f02d3 13610
047b2264
JJ		 13611 process_gnu_liblist (file);
13612
252b5132
RH		 13613 process_arch_specific (file);
13614
d93f0186
NC		 13615 if (program_headers)
13616 {
13617 free (program_headers);
13618 program_headers = NULL;
13619 }
13620
252b5132
RH		 13621 if (section_headers)
13622 {
13623 free (section_headers);
13624 section_headers = NULL;
13625 }
13626
13627 if (string_table)
13628 {
13629 free (string_table);
13630 string_table = NULL;
d40ac9bd 13631 string_table_length = 0;
252b5132
RH		 13632 }
13633
13634 if (dynamic_strings)
13635 {
13636 free (dynamic_strings);
13637 dynamic_strings = NULL;
d79b3d50 13638 dynamic_strings_length = 0;
252b5132
RH		 13639 }
13640
13641 if (dynamic_symbols)
13642 {
13643 free (dynamic_symbols);
13644 dynamic_symbols = NULL;
19936277 13645 num_dynamic_syms = 0;
252b5132
RH		 13646 }
13647
13648 if (dynamic_syminfo)
13649 {
13650 free (dynamic_syminfo);
13651 dynamic_syminfo = NULL;
13652 }
ff78d6d6 13653
293c573e
MR		 13654 if (dynamic_section)
13655 {
13656 free (dynamic_section);
13657 dynamic_section = NULL;
13658 }
13659
e4b17d5c
L		 13660 if (section_headers_groups)
13661 {
13662 free (section_headers_groups);
13663 section_headers_groups = NULL;
13664 }
13665
13666 if (section_groups)
13667 {
2cf0635d
NC		 13668 struct group_list * g;
13669 struct group_list * next;
e4b17d5c
L		 13670
13671 for (i = 0; i < group_count; i++)
13672 {
13673 for (g = section_groups [i].root; g != NULL; g = next)
13674 {
13675 next = g->next;
13676 free (g);
13677 }
13678 }
13679
13680 free (section_groups);
13681 section_groups = NULL;
13682 }
13683
19e6b90e 13684 free_debug_memory ();
18bd398b 13685
ff78d6d6 13686 return 0;
252b5132
RH		 13687}
13688
2cf0635d
NC		 13689/* Process an ELF archive.
13690 On entry the file is positioned just after the ARMAG string. */
13691
13692static int
13693process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
13694{
13695 struct archive_info arch;
13696 struct archive_info nested_arch;
13697 size_t got;
2cf0635d
NC		 13698 int ret;
13699
13700 show_name = 1;
13701
13702 /* The ARCH structure is used to hold information about this archive. */
13703 arch.file_name = NULL;
13704 arch.file = NULL;
13705 arch.index_array = NULL;
13706 arch.sym_table = NULL;
13707 arch.longnames = NULL;
13708
13709 /* The NESTED_ARCH structure is used as a single-item cache of information
13710 about a nested archive (when members of a thin archive reside within
13711 another regular archive file). */
13712 nested_arch.file_name = NULL;
13713 nested_arch.file = NULL;
13714 nested_arch.index_array = NULL;
13715 nested_arch.sym_table = NULL;
13716 nested_arch.longnames = NULL;
13717
13718 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
13719 {
13720 ret = 1;
13721 goto out;
4145f1d5 13722 }
fb52b2f4 13723
4145f1d5
NC		 13724 if (do_archive_index)
13725 {
2cf0635d 13726 if (arch.sym_table == NULL)
4145f1d5
NC		 13727 error (_("%s: unable to dump the index as none was found\n"), file_name);
13728 else
13729 {
2cf0635d 13730 unsigned int i, l;
4145f1d5
NC		 13731 unsigned long current_pos;
13732
13733 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
c2a7d3f5 13734 file_name, (long) arch.index_num, arch.sym_size);
4145f1d5
NC		 13735 current_pos = ftell (file);
13736
2cf0635d 13737 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 13738 {
2cf0635d
NC		 13739 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
13740 {
13741 char * member_name;
4145f1d5 13742
2cf0635d
NC		 13743 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
13744
13745 if (member_name != NULL)
13746 {
13747 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
13748
13749 if (qualified_name != NULL)
13750 {
c2a7d3f5
NC		 13751 printf (_("Contents of binary %s at offset "), qualified_name);
13752 (void) print_vma (arch.index_array[i], PREFIX_HEX);
13753 putchar ('\n');
2cf0635d
NC		 13754 free (qualified_name);
13755 }
4145f1d5
NC		 13756 }
13757 }
2cf0635d
NC		 13758
13759 if (l >= arch.sym_size)
4145f1d5
NC		 13760 {
13761 error (_("%s: end of the symbol table reached before the end of the index\n"),
13762 file_name);
cb8f3167 13763 break;
4145f1d5 13764 }
2cf0635d
NC		 13765 printf ("\t%s\n", arch.sym_table + l);
13766 l += strlen (arch.sym_table + l) + 1;
4145f1d5
NC		 13767 }
13768
c2a7d3f5
NC		 13769 if (arch.uses_64bit_indicies)
13770 l = (l + 7) & ~ 7;
13771 else
13772 l += l & 1;
13773
2cf0635d 13774 if (l < arch.sym_size)
c2a7d3f5
NC		 13775 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
13776 file_name, arch.sym_size - l);
4145f1d5 13777
4145f1d5
NC		 13778 if (fseek (file, current_pos, SEEK_SET) != 0)
13779 {
13780 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 13781 ret = 1;
13782 goto out;
4145f1d5 13783 }
fb52b2f4 13784 }
4145f1d5
NC		 13785
13786 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
13787 && !do_segments && !do_header && !do_dump && !do_version
13788 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 13789 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 13790 {
13791 ret = 0; /* Archive index only. */
13792 goto out;
13793 }
fb52b2f4
NC		 13794 }
13795
d989285c 13796 ret = 0;
fb52b2f4
NC		 13797
13798 while (1)
13799 {
2cf0635d
NC		 13800 char * name;
13801 size_t namelen;
13802 char * qualified_name;
13803
13804 /* Read the next archive header. */
13805 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
13806 {
13807 error (_("%s: failed to seek to next archive header\n"), file_name);
13808 return 1;
13809 }
13810 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
13811 if (got != sizeof arch.arhdr)
13812 {
13813 if (got == 0)
13814 break;
13815 error (_("%s: failed to read archive header\n"), file_name);
13816 ret = 1;
13817 break;
13818 }
13819 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
13820 {
13821 error (_("%s: did not find a valid archive header\n"), arch.file_name);
13822 ret = 1;
13823 break;
13824 }
13825
13826 arch.next_arhdr_offset += sizeof arch.arhdr;
13827
13828 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
13829 if (archive_file_size & 01)
13830 ++archive_file_size;
13831
13832 name = get_archive_member_name (&arch, &nested_arch);
13833 if (name == NULL)
fb52b2f4 13834 {
0fd3a477 13835 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 13836 ret = 1;
13837 break;
fb52b2f4 13838 }
2cf0635d 13839 namelen = strlen (name);
fb52b2f4 13840
2cf0635d
NC		 13841 qualified_name = make_qualified_name (&arch, &nested_arch, name);
13842 if (qualified_name == NULL)
fb52b2f4 13843 {
2cf0635d 13844 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 13845 ret = 1;
13846 break;
fb52b2f4
NC		 13847 }
13848
2cf0635d
NC		 13849 if (is_thin_archive && arch.nested_member_origin == 0)
13850 {
13851 /* This is a proxy for an external member of a thin archive. */
13852 FILE * member_file;
13853 char * member_file_name = adjust_relative_path (file_name, name, namelen);
13854 if (member_file_name == NULL)
13855 {
13856 ret = 1;
13857 break;
13858 }
13859
13860 member_file = fopen (member_file_name, "rb");
13861 if (member_file == NULL)
13862 {
13863 error (_("Input file '%s' is not readable.\n"), member_file_name);
13864 free (member_file_name);
13865 ret = 1;
13866 break;
13867 }
13868
13869 archive_file_offset = arch.nested_member_origin;
13870
13871 ret |= process_object (qualified_name, member_file);
13872
13873 fclose (member_file);
13874 free (member_file_name);
13875 }
13876 else if (is_thin_archive)
13877 {
13878 /* This is a proxy for a member of a nested archive. */
13879 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
13880
13881 /* The nested archive file will have been opened and setup by
13882 get_archive_member_name. */
13883 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
13884 {
13885 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
13886 ret = 1;
13887 break;
13888 }
13889
13890 ret |= process_object (qualified_name, nested_arch.file);
13891 }
13892 else
13893 {
13894 archive_file_offset = arch.next_arhdr_offset;
13895 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 13896
2cf0635d
NC		 13897 ret |= process_object (qualified_name, file);
13898 }
fb52b2f4 13899
2b52916e
L		 13900 if (dump_sects != NULL)
13901 {
13902 free (dump_sects);
13903 dump_sects = NULL;
13904 num_dump_sects = 0;
13905 }
13906
2cf0635d 13907 free (qualified_name);
fb52b2f4
NC		 13908 }
13909
4145f1d5 13910 out:
2cf0635d
NC		 13911 if (nested_arch.file != NULL)
13912 fclose (nested_arch.file);
13913 release_archive (&nested_arch);
13914 release_archive (&arch);
fb52b2f4 13915
d989285c 13916 return ret;
fb52b2f4
NC		 13917}
13918
13919static int
2cf0635d 13920process_file (char * file_name)
fb52b2f4 13921{
2cf0635d 13922 FILE * file;
fb52b2f4
NC		 13923 struct stat statbuf;
13924 char armag[SARMAG];
13925 int ret;
13926
13927 if (stat (file_name, &statbuf) < 0)
13928 {
f24ddbdd
NC		 13929 if (errno == ENOENT)
13930 error (_("'%s': No such file\n"), file_name);
13931 else
13932 error (_("Could not locate '%s'. System error message: %s\n"),
13933 file_name, strerror (errno));
13934 return 1;
13935 }
13936
13937 if (! S_ISREG (statbuf.st_mode))
13938 {
13939 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 13940 return 1;
13941 }
13942
13943 file = fopen (file_name, "rb");
13944 if (file == NULL)
13945 {
f24ddbdd 13946 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 13947 return 1;
13948 }
13949
13950 if (fread (armag, SARMAG, 1, file) != 1)
13951 {
4145f1d5 13952 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 13953 fclose (file);
13954 return 1;
13955 }
13956
13957 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 13958 ret = process_archive (file_name, file, FALSE);
13959 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
13960 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 13961 else
13962 {
4145f1d5
NC		 13963 if (do_archive_index)
13964 error (_("File %s is not an archive so its index cannot be displayed.\n"),
13965 file_name);
13966
fb52b2f4
NC		 13967 rewind (file);
13968 archive_file_size = archive_file_offset = 0;
13969 ret = process_object (file_name, file);
13970 }
13971
13972 fclose (file);
13973
13974 return ret;
13975}
13976
252b5132
RH		 13977#ifdef SUPPORT_DISASSEMBLY
13978/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 13979 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 13980 symbols. */
252b5132
RH		 13981
13982void
2cf0635d 13983print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 13984{
13985 fprintf (outfile,"0x%8.8x", addr);
13986}
13987
e3c8793a 13988/* Needed by the i386 disassembler. */
252b5132
RH		 13989void
13990db_task_printsym (unsigned int addr)
13991{
13992 print_address (addr, stderr);
13993}
13994#endif
13995
13996int
2cf0635d 13997main (int argc, char ** argv)
252b5132 13998{
ff78d6d6
L		 13999 int err;
14000
252b5132
RH		 14001#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
14002 setlocale (LC_MESSAGES, "");
3882b010
L		 14003#endif
14004#if defined (HAVE_SETLOCALE)
14005 setlocale (LC_CTYPE, "");
252b5132
RH		 14006#endif
14007 bindtextdomain (PACKAGE, LOCALEDIR);
14008 textdomain (PACKAGE);
14009
869b9d07
MM		 14010 expandargv (&argc, &argv);
14011
252b5132
RH		 14012 parse_args (argc, argv);
14013
18bd398b 14014 if (num_dump_sects > 0)
59f14fc0 14015 {
18bd398b 14016 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 14017 cmdline_dump_sects = (dump_type *)
14018 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 14019 if (cmdline_dump_sects == NULL)
591a748a 14020 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 14021 else
14022 {
09c11c86
NC		 14023 memcpy (cmdline_dump_sects, dump_sects,
14024 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 14025 num_cmdline_dump_sects = num_dump_sects;
14026 }
14027 }
14028
18bd398b
NC		 14029 if (optind < (argc - 1))
14030 show_name = 1;
14031
ff78d6d6 14032 err = 0;
252b5132 14033 while (optind < argc)
18bd398b 14034 err |= process_file (argv[optind++]);
252b5132
RH		 14035
14036 if (dump_sects != NULL)
14037 free (dump_sects);
59f14fc0
AS		 14038 if (cmdline_dump_sects != NULL)
14039 free (cmdline_dump_sects);
252b5132 14040
ff78d6d6 14041 return err;
252b5132 14042}
A mirror of the official binutils-gdb repository