projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* powerpc.cc (do_make_elf_object): Allow ET_EXEC files with
[deliverable/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
7bfd842d 51#include <wchar.h>
252b5132 52
a952a375 53#if __GNUC__ >= 2
19936277 54/* Define BFD64 here, even if our default architecture is 32 bit ELF
a952a375 55 as this will allow us to read in and parse 64bit and 32bit ELF files.
b34976b6 56 Only do this if we believe that the compiler can support a 64 bit
a952a375 57 data type. For now we only rely on GCC being able to do this. */
19936277 58#define BFD64
a952a375
NC		 59#endif
60
3db64b00
AM		 61#include "bfd.h"
62#include "bucomm.h"
3284fe0c 63#include "elfcomm.h"
19e6b90e 64#include "dwarf.h"
252b5132
RH		 65
66#include "elf/common.h"
67#include "elf/external.h"
68#include "elf/internal.h"
252b5132 69
4b78141a
NC		 70
71/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
72 we can obtain the H8 reloc numbers. We need these for the
73 get_reloc_size() function. We include h8.h again after defining
74 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
75
76#include "elf/h8.h"
77#undef _ELF_H8_H
78
79/* Undo the effects of #including reloc-macros.h. */
80
81#undef START_RELOC_NUMBERS
82#undef RELOC_NUMBER
83#undef FAKE_RELOC
84#undef EMPTY_RELOC
85#undef END_RELOC_NUMBERS
86#undef _RELOC_MACROS_H
87
252b5132
RH		 88/* The following headers use the elf/reloc-macros.h file to
89 automatically generate relocation recognition functions
90 such as elf_mips_reloc_type() */
91
92#define RELOC_MACROS_GEN_FUNC
93
a06ea964 94#include "elf/aarch64.h"
252b5132 95#include "elf/alpha.h"
3b16e843 96#include "elf/arc.h"
252b5132 97#include "elf/arm.h"
3b16e843 98#include "elf/avr.h"
1d65ded4 99#include "elf/bfin.h"
60bca95a 100#include "elf/cr16.h"
3b16e843 101#include "elf/cris.h"
1c0d3aa6 102#include "elf/crx.h"
252b5132
RH		 103#include "elf/d10v.h"
104#include "elf/d30v.h"
d172d4ba 105#include "elf/dlx.h"
cfb8c092 106#include "elf/epiphany.h"
252b5132 107#include "elf/fr30.h"
5c70f934 108#include "elf/frv.h"
3b16e843
NC		 109#include "elf/h8.h"
110#include "elf/hppa.h"
111#include "elf/i386.h"
35b1837e 112#include "elf/i370.h"
3b16e843
NC		 113#include "elf/i860.h"
114#include "elf/i960.h"
115#include "elf/ia64.h"
1e4cf259 116#include "elf/ip2k.h"
84e94c90 117#include "elf/lm32.h"
1c0d3aa6 118#include "elf/iq2000.h"
49f58d10 119#include "elf/m32c.h"
3b16e843
NC		 120#include "elf/m32r.h"
121#include "elf/m68k.h"
75751cd9 122#include "elf/m68hc11.h"
252b5132 123#include "elf/mcore.h"
15ab5209 124#include "elf/mep.h"
7ba29e2a 125#include "elf/microblaze.h"
3b16e843 126#include "elf/mips.h"
3c3bdf30 127#include "elf/mmix.h"
3b16e843
NC		 128#include "elf/mn10200.h"
129#include "elf/mn10300.h"
5506d11a 130#include "elf/moxie.h"
4970f871 131#include "elf/mt.h"
2469cfa2 132#include "elf/msp430.h"
3b16e843 133#include "elf/or32.h"
7d466069 134#include "elf/pj.h"
3b16e843 135#include "elf/ppc.h"
c833c019 136#include "elf/ppc64.h"
99c513f6 137#include "elf/rl78.h"
c7927a3c 138#include "elf/rx.h"
a85d7ed0 139#include "elf/s390.h"
1c0d3aa6 140#include "elf/score.h"
3b16e843
NC		 141#include "elf/sh.h"
142#include "elf/sparc.h"
e9f53129 143#include "elf/spu.h"
40b36596 144#include "elf/tic6x.h"
aa137e4d
NC		 145#include "elf/tilegx.h"
146#include "elf/tilepro.h"
3b16e843 147#include "elf/v850.h"
179d3252 148#include "elf/vax.h"
3b16e843 149#include "elf/x86-64.h"
c29aca4a 150#include "elf/xc16x.h"
f6c1a2d5 151#include "elf/xgate.h"
93fbbb04 152#include "elf/xstormy16.h"
88da6820 153#include "elf/xtensa.h"
252b5132 154
252b5132 155#include "getopt.h"
566b0d53 156#include "libiberty.h"
09c11c86 157#include "safe-ctype.h"
2cf0635d 158#include "filenames.h"
252b5132 159
2cf0635d 160char * program_name = "readelf";
85b1c36d
BE		 161static long archive_file_offset;
162static unsigned long archive_file_size;
163static unsigned long dynamic_addr;
164static bfd_size_type dynamic_size;
165static unsigned int dynamic_nent;
2cf0635d 166static char * dynamic_strings;
85b1c36d 167static unsigned long dynamic_strings_length;
2cf0635d 168static char * string_table;
85b1c36d
BE		 169static unsigned long string_table_length;
170static unsigned long num_dynamic_syms;
2cf0635d
NC		 171static Elf_Internal_Sym * dynamic_symbols;
172static Elf_Internal_Syminfo * dynamic_syminfo;
85b1c36d
BE		 173static unsigned long dynamic_syminfo_offset;
174static unsigned int dynamic_syminfo_nent;
f8eae8b2 175static char program_interpreter[PATH_MAX];
bb8a0291 176static bfd_vma dynamic_info[DT_ENCODING];
fdc90cb4 177static bfd_vma dynamic_info_DT_GNU_HASH;
85b1c36d
BE		 178static bfd_vma version_info[16];
179static Elf_Internal_Ehdr elf_header;
2cf0635d
NC		 180static Elf_Internal_Shdr * section_headers;
181static Elf_Internal_Phdr * program_headers;
182static Elf_Internal_Dyn * dynamic_section;
183static Elf_Internal_Shdr * symtab_shndx_hdr;
85b1c36d
BE		 184static int show_name;
185static int do_dynamic;
186static int do_syms;
2c610e4b 187static int do_dyn_syms;
85b1c36d
BE		 188static int do_reloc;
189static int do_sections;
190static int do_section_groups;
5477e8a0 191static int do_section_details;
85b1c36d
BE		 192static int do_segments;
193static int do_unwind;
194static int do_using_dynamic;
195static int do_header;
196static int do_dump;
197static int do_version;
85b1c36d
BE		 198static int do_histogram;
199static int do_debugging;
85b1c36d
BE		 200static int do_arch;
201static int do_notes;
4145f1d5 202static int do_archive_index;
85b1c36d 203static int is_32bit_elf;
252b5132 204
e4b17d5c
L		 205struct group_list
206{
2cf0635d 207 struct group_list * next;
e4b17d5c
L		 208 unsigned int section_index;
209};
210
211struct group
212{
2cf0635d 213 struct group_list * root;
e4b17d5c
L		 214 unsigned int group_index;
215};
216
85b1c36d 217static size_t group_count;
2cf0635d
NC		 218static struct group * section_groups;
219static struct group ** section_headers_groups;
e4b17d5c 220
09c11c86
NC		 221
222/* Flag bits indicating particular types of dump. */
223#define HEX_DUMP (1 << 0) /* The -x command line switch. */
224#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
225#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
226#define STRING_DUMP (1 << 3) /* The -p command line switch. */
cf13d699 227#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
09c11c86
NC		 228
229typedef unsigned char dump_type;
230
231/* A linked list of the section names for which dumps were requested. */
aef1f6d0
DJ		 232struct dump_list_entry
233{
2cf0635d 234 char * name;
09c11c86 235 dump_type type;
2cf0635d 236 struct dump_list_entry * next;
aef1f6d0 237};
2cf0635d 238static struct dump_list_entry * dump_sects_byname;
aef1f6d0 239
09c11c86
NC		 240/* A dynamic array of flags indicating for which sections a dump
241 has been requested via command line switches. */
242static dump_type * cmdline_dump_sects = NULL;
243static unsigned int num_cmdline_dump_sects = 0;
18bd398b
NC		 244
245/* A dynamic array of flags indicating for which sections a dump of
246 some kind has been requested. It is reset on a per-object file
aef1f6d0
DJ		 247 basis and then initialised from the cmdline_dump_sects array,
248 the results of interpreting the -w switch, and the
249 dump_sects_byname list. */
09c11c86
NC		 250static dump_type * dump_sects = NULL;
251static unsigned int num_dump_sects = 0;
252b5132 252
252b5132 253
c256ffe7 254/* How to print a vma value. */
843dd992
NC		 255typedef enum print_mode
256{
257 HEX,
258 DEC,
259 DEC_5,
260 UNSIGNED,
261 PREFIX_HEX,
262 FULL_HEX,
263 LONG_HEX
264}
265print_mode;
266
9c19a809
NC		 267#define UNKNOWN -1
268
2b692964
NC		 269#define SECTION_NAME(X) \
270 ((X) == NULL ? _("<none>") \
271 : string_table == NULL ? _("<no-name>") \
272 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
0b49d371 273 : string_table + (X)->sh_name))
252b5132 274
ee42cf8c 275#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
252b5132 276
ba5cdace
NC		 277#define GET_ELF_SYMBOLS(file, section, sym_count) \
278 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
279 : get_64bit_elf_symbols (file, section, sym_count))
9ea033b2 280
d79b3d50
NC		 281#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
282/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
283 already been called and verified that the string exists. */
284#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
18bd398b 285
61865e30
NC		 286#define REMOVE_ARCH_BITS(ADDR) \
287 do \
288 { \
289 if (elf_header.e_machine == EM_ARM) \
290 (ADDR) &= ~1; \
291 } \
292 while (0)
d79b3d50 293\f
59245841
NC		 294/* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
295 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
296 using malloc and fill that. In either case return the pointer to the start of
297 the retrieved data or NULL if something went wrong. If something does go wrong
298 emit an error message using REASON as part of the context. */
299
c256ffe7 300static void *
2cf0635d
NC		 301get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
302 const char * reason)
a6e9f9df 303{
2cf0635d 304 void * mvar;
a6e9f9df 305
c256ffe7 306 if (size == 0 || nmemb == 0)
a6e9f9df
AM		 307 return NULL;
308
fb52b2f4 309 if (fseek (file, archive_file_offset + offset, SEEK_SET))
a6e9f9df 310 {
0fd3a477 311 error (_("Unable to seek to 0x%lx for %s\n"),
0af1713e 312 (unsigned long) archive_file_offset + offset, reason);
a6e9f9df
AM		 313 return NULL;
314 }
315
316 mvar = var;
317 if (mvar == NULL)
318 {
c256ffe7
JJ		 319 /* Check for overflow. */
320 if (nmemb < (~(size_t) 0 - 1) / size)
321 /* + 1 so that we can '\0' terminate invalid string table sections. */
322 mvar = malloc (size * nmemb + 1);
a6e9f9df
AM		 323
324 if (mvar == NULL)
325 {
0fd3a477
JW		 326 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
327 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM		 328 return NULL;
329 }
c256ffe7
JJ		 330
331 ((char *) mvar)[size * nmemb] = '\0';
a6e9f9df
AM		 332 }
333
c256ffe7 334 if (fread (mvar, size, nmemb, file) != nmemb)
a6e9f9df 335 {
0fd3a477
JW		 336 error (_("Unable to read in 0x%lx bytes of %s\n"),
337 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM		 338 if (mvar != var)
339 free (mvar);
340 return NULL;
341 }
342
343 return mvar;
344}
345
14a91970 346/* Print a VMA value. */
cb8f3167 347
66543521 348static int
14a91970 349print_vma (bfd_vma vma, print_mode mode)
66543521 350{
66543521
AM		 351 int nc = 0;
352
14a91970 353 switch (mode)
66543521 354 {
14a91970
AM		 355 case FULL_HEX:
356 nc = printf ("0x");
357 /* Drop through. */
66543521 358
14a91970 359 case LONG_HEX:
f7a99963 360#ifdef BFD64
14a91970 361 if (is_32bit_elf)
437c2fb7 362 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
f7a99963 363#endif
14a91970
AM		 364 printf_vma (vma);
365 return nc + 16;
b19aac67 366
14a91970
AM		 367 case DEC_5:
368 if (vma <= 99999)
369 return printf ("%5" BFD_VMA_FMT "d", vma);
370 /* Drop through. */
66543521 371
14a91970
AM		 372 case PREFIX_HEX:
373 nc = printf ("0x");
374 /* Drop through. */
66543521 375
14a91970
AM		 376 case HEX:
377 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 378
14a91970
AM		 379 case DEC:
380 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 381
14a91970
AM		 382 case UNSIGNED:
383 return printf ("%" BFD_VMA_FMT "u", vma);
f7a99963 384 }
66543521 385 return 0;
f7a99963
NC		 386}
387
7bfd842d
NC		 388/* Display a symbol on stdout. Handles the display of control characters and
389 multibye characters.
31104126 390
7bfd842d
NC		 391 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
392
393 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
394 padding as necessary.
171191ba
NC		 395
396 Returns the number of emitted characters. */
397
398static unsigned int
7a88bc9c 399print_symbol (int width, const char *symbol)
31104126 400{
171191ba 401 bfd_boolean extra_padding = FALSE;
7bfd842d
NC		 402 int num_printed = 0;
403 mbstate_t state;
404 int width_remaining;
961c521f 405
7bfd842d 406 if (width < 0)
961c521f 407 {
961c521f
NC		 408 /* Keep the width positive. This also helps. */
409 width = - width;
171191ba 410 extra_padding = TRUE;
7bfd842d 411 }
961c521f 412
7bfd842d
NC		 413 if (do_wide)
414 /* Set the remaining width to a very large value.
415 This simplifies the code below. */
416 width_remaining = INT_MAX;
417 else
418 width_remaining = width;
cb8f3167 419
7bfd842d
NC		 420 /* Initialise the multibyte conversion state. */
421 memset (& state, 0, sizeof (state));
961c521f 422
7bfd842d
NC		 423 while (width_remaining)
424 {
425 size_t n;
426 wchar_t w;
427 const char c = *symbol++;
961c521f 428
7bfd842d 429 if (c == 0)
961c521f
NC		 430 break;
431
7bfd842d
NC		 432 /* Do not print control characters directly as they can affect terminal
433 settings. Such characters usually appear in the names generated
434 by the assembler for local labels. */
435 if (ISCNTRL (c))
961c521f 436 {
7bfd842d 437 if (width_remaining < 2)
961c521f
NC		 438 break;
439
7bfd842d
NC		 440 printf ("^%c", c + 0x40);
441 width_remaining -= 2;
171191ba 442 num_printed += 2;
961c521f 443 }
7bfd842d
NC		 444 else if (ISPRINT (c))
445 {
446 putchar (c);
447 width_remaining --;
448 num_printed ++;
449 }
961c521f
NC		 450 else
451 {
7bfd842d
NC		 452 /* Let printf do the hard work of displaying multibyte characters. */
453 printf ("%.1s", symbol - 1);
454 width_remaining --;
455 num_printed ++;
456
457 /* Try to find out how many bytes made up the character that was
458 just printed. Advance the symbol pointer past the bytes that
459 were displayed. */
460 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
461 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
462 symbol += (n - 1);
961c521f 463 }
961c521f 464 }
171191ba 465
7bfd842d 466 if (extra_padding && num_printed < width)
171191ba
NC		 467 {
468 /* Fill in the remaining spaces. */
7bfd842d
NC		 469 printf ("%-*s", width - num_printed, " ");
470 num_printed = width;
171191ba
NC		 471 }
472
473 return num_printed;
31104126
NC		 474}
475
89fac5e3
RS		 476/* Return a pointer to section NAME, or NULL if no such section exists. */
477
478static Elf_Internal_Shdr *
2cf0635d 479find_section (const char * name)
89fac5e3
RS		 480{
481 unsigned int i;
482
483 for (i = 0; i < elf_header.e_shnum; i++)
484 if (streq (SECTION_NAME (section_headers + i), name))
485 return section_headers + i;
486
487 return NULL;
488}
489
0b6ae522
DJ		 490/* Return a pointer to a section containing ADDR, or NULL if no such
491 section exists. */
492
493static Elf_Internal_Shdr *
494find_section_by_address (bfd_vma addr)
495{
496 unsigned int i;
497
498 for (i = 0; i < elf_header.e_shnum; i++)
499 {
500 Elf_Internal_Shdr *sec = section_headers + i;
501 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
502 return sec;
503 }
504
505 return NULL;
506}
507
508/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
509 bytes read. */
510
511static unsigned long
512read_uleb128 (unsigned char *data, unsigned int *length_return)
513{
514 return read_leb128 (data, length_return, 0);
515}
516
28f997cf
TG		 517/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
518 This OS has so many departures from the ELF standard that we test it at
519 many places. */
520
521static inline int
522is_ia64_vms (void)
523{
524 return elf_header.e_machine == EM_IA_64
525 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
526}
527
bcedfee6 528/* Guess the relocation size commonly used by the specific machines. */
252b5132 529
252b5132 530static int
2dc4cec1 531guess_is_rela (unsigned int e_machine)
252b5132 532{
9c19a809 533 switch (e_machine)
252b5132
RH		 534 {
535 /* Targets that use REL relocations. */
252b5132
RH		 536 case EM_386:
537 case EM_486:
63fcb9e9 538 case EM_960:
e9f53129 539 case EM_ARM:
2b0337b0 540 case EM_D10V:
252b5132 541 case EM_CYGNUS_D10V:
e9f53129 542 case EM_DLX:
252b5132 543 case EM_MIPS:
4fe85591 544 case EM_MIPS_RS3_LE:
e9f53129
AM		 545 case EM_CYGNUS_M32R:
546 case EM_OPENRISC:
547 case EM_OR32:
1c0d3aa6 548 case EM_SCORE:
f6c1a2d5 549 case EM_XGATE:
9c19a809 550 return FALSE;
103f02d3 551
252b5132
RH		 552 /* Targets that use RELA relocations. */
553 case EM_68K:
e9f53129 554 case EM_860:
a06ea964 555 case EM_AARCH64:
cfb8c092 556 case EM_ADAPTEVA_EPIPHANY:
e9f53129
AM		 557 case EM_ALPHA:
558 case EM_ALTERA_NIOS2:
559 case EM_AVR:
560 case EM_AVR_OLD:
561 case EM_BLACKFIN:
60bca95a 562 case EM_CR16:
e9f53129
AM		 563 case EM_CRIS:
564 case EM_CRX:
2b0337b0 565 case EM_D30V:
252b5132 566 case EM_CYGNUS_D30V:
2b0337b0 567 case EM_FR30:
252b5132 568 case EM_CYGNUS_FR30:
5c70f934 569 case EM_CYGNUS_FRV:
e9f53129
AM		 570 case EM_H8S:
571 case EM_H8_300:
572 case EM_H8_300H:
800eeca4 573 case EM_IA_64:
1e4cf259
NC		 574 case EM_IP2K:
575 case EM_IP2K_OLD:
3b36097d 576 case EM_IQ2000:
84e94c90 577 case EM_LATTICEMICO32:
ff7eeb89 578 case EM_M32C_OLD:
49f58d10 579 case EM_M32C:
e9f53129
AM		 580 case EM_M32R:
581 case EM_MCORE:
15ab5209 582 case EM_CYGNUS_MEP:
e9f53129
AM		 583 case EM_MMIX:
584 case EM_MN10200:
585 case EM_CYGNUS_MN10200:
586 case EM_MN10300:
587 case EM_CYGNUS_MN10300:
5506d11a 588 case EM_MOXIE:
e9f53129
AM		 589 case EM_MSP430:
590 case EM_MSP430_OLD:
d031aafb 591 case EM_MT:
64fd6348 592 case EM_NIOS32:
e9f53129
AM		 593 case EM_PPC64:
594 case EM_PPC:
99c513f6 595 case EM_RL78:
c7927a3c 596 case EM_RX:
e9f53129
AM		 597 case EM_S390:
598 case EM_S390_OLD:
599 case EM_SH:
600 case EM_SPARC:
601 case EM_SPARC32PLUS:
602 case EM_SPARCV9:
603 case EM_SPU:
40b36596 604 case EM_TI_C6000:
aa137e4d
NC		 605 case EM_TILEGX:
606 case EM_TILEPRO:
e9f53129
AM		 607 case EM_V850:
608 case EM_CYGNUS_V850:
609 case EM_VAX:
610 case EM_X86_64:
8a9036a4 611 case EM_L1OM:
7a9068fe 612 case EM_K1OM:
e9f53129
AM		 613 case EM_XSTORMY16:
614 case EM_XTENSA:
615 case EM_XTENSA_OLD:
7ba29e2a
NC		 616 case EM_MICROBLAZE:
617 case EM_MICROBLAZE_OLD:
9c19a809 618 return TRUE;
103f02d3 619
e9f53129
AM		 620 case EM_68HC05:
621 case EM_68HC08:
622 case EM_68HC11:
623 case EM_68HC16:
624 case EM_FX66:
625 case EM_ME16:
d1133906 626 case EM_MMA:
d1133906
NC		 627 case EM_NCPU:
628 case EM_NDR1:
e9f53129 629 case EM_PCP:
d1133906 630 case EM_ST100:
e9f53129 631 case EM_ST19:
d1133906 632 case EM_ST7:
e9f53129
AM		 633 case EM_ST9PLUS:
634 case EM_STARCORE:
d1133906 635 case EM_SVX:
e9f53129 636 case EM_TINYJ:
9c19a809
NC		 637 default:
638 warn (_("Don't know about relocations on this machine architecture\n"));
639 return FALSE;
640 }
641}
252b5132 642
9c19a809 643static int
2cf0635d 644slurp_rela_relocs (FILE * file,
d3ba0551
AM		 645 unsigned long rel_offset,
646 unsigned long rel_size,
2cf0635d
NC		 647 Elf_Internal_Rela ** relasp,
648 unsigned long * nrelasp)
9c19a809 649{
2cf0635d 650 Elf_Internal_Rela * relas;
4d6ed7c8
NC		 651 unsigned long nrelas;
652 unsigned int i;
252b5132 653
4d6ed7c8
NC		 654 if (is_32bit_elf)
655 {
2cf0635d 656 Elf32_External_Rela * erelas;
103f02d3 657
3f5e193b 658 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 659 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 660 if (!erelas)
661 return 0;
252b5132 662
4d6ed7c8 663 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 664
3f5e193b
NC		 665 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
666 sizeof (Elf_Internal_Rela));
103f02d3 667
4d6ed7c8
NC		 668 if (relas == NULL)
669 {
c256ffe7 670 free (erelas);
591a748a 671 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 672 return 0;
673 }
103f02d3 674
4d6ed7c8
NC		 675 for (i = 0; i < nrelas; i++)
676 {
677 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
678 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 679 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 680 }
103f02d3 681
4d6ed7c8
NC		 682 free (erelas);
683 }
684 else
685 {
2cf0635d 686 Elf64_External_Rela * erelas;
103f02d3 687
3f5e193b 688 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 689 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 690 if (!erelas)
691 return 0;
4d6ed7c8
NC		 692
693 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 694
3f5e193b
NC		 695 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
696 sizeof (Elf_Internal_Rela));
103f02d3 697
4d6ed7c8
NC		 698 if (relas == NULL)
699 {
c256ffe7 700 free (erelas);
591a748a 701 error (_("out of memory parsing relocs\n"));
4d6ed7c8 702 return 0;
9c19a809 703 }
4d6ed7c8
NC		 704
705 for (i = 0; i < nrelas; i++)
9c19a809 706 {
66543521
AM		 707 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
708 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 709 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 710
711 /* The #ifdef BFD64 below is to prevent a compile time
712 warning. We know that if we do not have a 64 bit data
713 type that we will never execute this code anyway. */
714#ifdef BFD64
715 if (elf_header.e_machine == EM_MIPS
716 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
717 {
718 /* In little-endian objects, r_info isn't really a
719 64-bit little-endian value: it has a 32-bit
720 little-endian symbol index followed by four
721 individual byte fields. Reorder INFO
722 accordingly. */
91d6fa6a
NC		 723 bfd_vma inf = relas[i].r_info;
724 inf = (((inf & 0xffffffff) << 32)
725 | ((inf >> 56) & 0xff)
726 | ((inf >> 40) & 0xff00)
727 | ((inf >> 24) & 0xff0000)
728 | ((inf >> 8) & 0xff000000));
729 relas[i].r_info = inf;
861fb55a
DJ		 730 }
731#endif /* BFD64 */
4d6ed7c8 732 }
103f02d3 733
4d6ed7c8
NC		 734 free (erelas);
735 }
736 *relasp = relas;
737 *nrelasp = nrelas;
738 return 1;
739}
103f02d3 740
4d6ed7c8 741static int
2cf0635d 742slurp_rel_relocs (FILE * file,
d3ba0551
AM		 743 unsigned long rel_offset,
744 unsigned long rel_size,
2cf0635d
NC		 745 Elf_Internal_Rela ** relsp,
746 unsigned long * nrelsp)
4d6ed7c8 747{
2cf0635d 748 Elf_Internal_Rela * rels;
4d6ed7c8
NC		 749 unsigned long nrels;
750 unsigned int i;
103f02d3 751
4d6ed7c8
NC		 752 if (is_32bit_elf)
753 {
2cf0635d 754 Elf32_External_Rel * erels;
103f02d3 755
3f5e193b 756 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 757 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 758 if (!erels)
759 return 0;
103f02d3 760
4d6ed7c8 761 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 762
3f5e193b 763 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 764
4d6ed7c8
NC		 765 if (rels == NULL)
766 {
c256ffe7 767 free (erels);
591a748a 768 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 769 return 0;
770 }
771
772 for (i = 0; i < nrels; i++)
773 {
774 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
775 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 776 rels[i].r_addend = 0;
9ea033b2 777 }
4d6ed7c8
NC		 778
779 free (erels);
9c19a809
NC		 780 }
781 else
782 {
2cf0635d 783 Elf64_External_Rel * erels;
9ea033b2 784
3f5e193b 785 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 786 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 787 if (!erels)
788 return 0;
103f02d3 789
4d6ed7c8 790 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 791
3f5e193b 792 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 793
4d6ed7c8 794 if (rels == NULL)
9c19a809 795 {
c256ffe7 796 free (erels);
591a748a 797 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 798 return 0;
799 }
103f02d3 800
4d6ed7c8
NC		 801 for (i = 0; i < nrels; i++)
802 {
66543521
AM		 803 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
804 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 805 rels[i].r_addend = 0;
861fb55a
DJ		 806
807 /* The #ifdef BFD64 below is to prevent a compile time
808 warning. We know that if we do not have a 64 bit data
809 type that we will never execute this code anyway. */
810#ifdef BFD64
811 if (elf_header.e_machine == EM_MIPS
812 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
813 {
814 /* In little-endian objects, r_info isn't really a
815 64-bit little-endian value: it has a 32-bit
816 little-endian symbol index followed by four
817 individual byte fields. Reorder INFO
818 accordingly. */
91d6fa6a
NC		 819 bfd_vma inf = rels[i].r_info;
820 inf = (((inf & 0xffffffff) << 32)
821 | ((inf >> 56) & 0xff)
822 | ((inf >> 40) & 0xff00)
823 | ((inf >> 24) & 0xff0000)
824 | ((inf >> 8) & 0xff000000));
825 rels[i].r_info = inf;
861fb55a
DJ		 826 }
827#endif /* BFD64 */
4d6ed7c8 828 }
103f02d3 829
4d6ed7c8
NC		 830 free (erels);
831 }
832 *relsp = rels;
833 *nrelsp = nrels;
834 return 1;
835}
103f02d3 836
aca88567
NC		 837/* Returns the reloc type extracted from the reloc info field. */
838
839static unsigned int
840get_reloc_type (bfd_vma reloc_info)
841{
842 if (is_32bit_elf)
843 return ELF32_R_TYPE (reloc_info);
844
845 switch (elf_header.e_machine)
846 {
847 case EM_MIPS:
848 /* Note: We assume that reloc_info has already been adjusted for us. */
849 return ELF64_MIPS_R_TYPE (reloc_info);
850
851 case EM_SPARCV9:
852 return ELF64_R_TYPE_ID (reloc_info);
853
854 default:
855 return ELF64_R_TYPE (reloc_info);
856 }
857}
858
859/* Return the symbol index extracted from the reloc info field. */
860
861static bfd_vma
862get_reloc_symindex (bfd_vma reloc_info)
863{
864 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
865}
866
d3ba0551
AM		 867/* Display the contents of the relocation data found at the specified
868 offset. */
ee42cf8c 869
41e92641 870static void
2cf0635d 871dump_relocations (FILE * file,
d3ba0551
AM		 872 unsigned long rel_offset,
873 unsigned long rel_size,
2cf0635d 874 Elf_Internal_Sym * symtab,
d3ba0551 875 unsigned long nsyms,
2cf0635d 876 char * strtab,
d79b3d50 877 unsigned long strtablen,
d3ba0551 878 int is_rela)
4d6ed7c8 879{
b34976b6 880 unsigned int i;
2cf0635d 881 Elf_Internal_Rela * rels;
103f02d3 882
4d6ed7c8
NC		 883 if (is_rela == UNKNOWN)
884 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 885
4d6ed7c8
NC		 886 if (is_rela)
887 {
c8286bd1 888 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 889 return;
4d6ed7c8
NC		 890 }
891 else
892 {
893 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 894 return;
252b5132
RH		 895 }
896
410f7a12
L		 897 if (is_32bit_elf)
898 {
899 if (is_rela)
2c71103e
NC		 900 {
901 if (do_wide)
902 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
903 else
904 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
905 }
410f7a12 906 else
2c71103e
NC		 907 {
908 if (do_wide)
909 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
910 else
911 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
912 }
410f7a12 913 }
252b5132 914 else
410f7a12
L		 915 {
916 if (is_rela)
2c71103e
NC		 917 {
918 if (do_wide)
8beeaeb7 919 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 920 else
921 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
922 }
410f7a12 923 else
2c71103e
NC		 924 {
925 if (do_wide)
8beeaeb7 926 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 927 else
928 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
929 }
410f7a12 930 }
252b5132
RH		 931
932 for (i = 0; i < rel_size; i++)
933 {
2cf0635d 934 const char * rtype;
b34976b6 935 bfd_vma offset;
91d6fa6a 936 bfd_vma inf;
b34976b6
AM		 937 bfd_vma symtab_index;
938 bfd_vma type;
103f02d3 939
b34976b6 940 offset = rels[i].r_offset;
91d6fa6a 941 inf = rels[i].r_info;
103f02d3 942
91d6fa6a
NC		 943 type = get_reloc_type (inf);
944 symtab_index = get_reloc_symindex (inf);
252b5132 945
410f7a12
L		 946 if (is_32bit_elf)
947 {
39dbeff8
AM		 948 printf ("%8.8lx %8.8lx ",
949 (unsigned long) offset & 0xffffffff,
91d6fa6a 950 (unsigned long) inf & 0xffffffff);
410f7a12
L		 951 }
952 else
953 {
39dbeff8
AM		 954#if BFD_HOST_64BIT_LONG
955 printf (do_wide
956 ? "%16.16lx %16.16lx "
957 : "%12.12lx %12.12lx ",
91d6fa6a 958 offset, inf);
39dbeff8 959#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 960#ifndef __MSVCRT__
39dbeff8
AM		 961 printf (do_wide
962 ? "%16.16llx %16.16llx "
963 : "%12.12llx %12.12llx ",
91d6fa6a 964 offset, inf);
6e3d6dc1
NC		 965#else
966 printf (do_wide
967 ? "%16.16I64x %16.16I64x "
968 : "%12.12I64x %12.12I64x ",
91d6fa6a 969 offset, inf);
6e3d6dc1 970#endif
39dbeff8 971#else
2c71103e
NC		 972 printf (do_wide
973 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
974 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 975 _bfd_int64_high (offset),
976 _bfd_int64_low (offset),
91d6fa6a
NC		 977 _bfd_int64_high (inf),
978 _bfd_int64_low (inf));
9ea033b2 979#endif
410f7a12 980 }
103f02d3 981
252b5132
RH		 982 switch (elf_header.e_machine)
983 {
984 default:
985 rtype = NULL;
986 break;
987
a06ea964
NC		 988 case EM_AARCH64:
989 rtype = elf_aarch64_reloc_type (type);
990 break;
991
2b0337b0 992 case EM_M32R:
252b5132 993 case EM_CYGNUS_M32R:
9ea033b2 994 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 995 break;
996
997 case EM_386:
998 case EM_486:
9ea033b2 999 rtype = elf_i386_reloc_type (type);
252b5132
RH		 1000 break;
1001
ba2685cc
AM		 1002 case EM_68HC11:
1003 case EM_68HC12:
1004 rtype = elf_m68hc11_reloc_type (type);
1005 break;
75751cd9 1006
252b5132 1007 case EM_68K:
9ea033b2 1008 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1009 break;
1010
63fcb9e9 1011 case EM_960:
9ea033b2 1012 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1013 break;
1014
adde6300 1015 case EM_AVR:
2b0337b0 1016 case EM_AVR_OLD:
adde6300
AM		 1017 rtype = elf_avr_reloc_type (type);
1018 break;
1019
9ea033b2
NC		 1020 case EM_OLD_SPARCV9:
1021 case EM_SPARC32PLUS:
1022 case EM_SPARCV9:
252b5132 1023 case EM_SPARC:
9ea033b2 1024 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1025 break;
1026
e9f53129
AM		 1027 case EM_SPU:
1028 rtype = elf_spu_reloc_type (type);
1029 break;
1030
2b0337b0 1031 case EM_V850:
252b5132 1032 case EM_CYGNUS_V850:
9ea033b2 1033 rtype = v850_reloc_type (type);
252b5132
RH		 1034 break;
1035
2b0337b0 1036 case EM_D10V:
252b5132 1037 case EM_CYGNUS_D10V:
9ea033b2 1038 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1039 break;
1040
2b0337b0 1041 case EM_D30V:
252b5132 1042 case EM_CYGNUS_D30V:
9ea033b2 1043 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1044 break;
1045
d172d4ba
NC		 1046 case EM_DLX:
1047 rtype = elf_dlx_reloc_type (type);
1048 break;
1049
252b5132 1050 case EM_SH:
9ea033b2 1051 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1052 break;
1053
2b0337b0 1054 case EM_MN10300:
252b5132 1055 case EM_CYGNUS_MN10300:
9ea033b2 1056 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1057 break;
1058
2b0337b0 1059 case EM_MN10200:
252b5132 1060 case EM_CYGNUS_MN10200:
9ea033b2 1061 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1062 break;
1063
2b0337b0 1064 case EM_FR30:
252b5132 1065 case EM_CYGNUS_FR30:
9ea033b2 1066 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1067 break;
1068
ba2685cc
AM		 1069 case EM_CYGNUS_FRV:
1070 rtype = elf_frv_reloc_type (type);
1071 break;
5c70f934 1072
252b5132 1073 case EM_MCORE:
9ea033b2 1074 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1075 break;
1076
3c3bdf30
NC		 1077 case EM_MMIX:
1078 rtype = elf_mmix_reloc_type (type);
1079 break;
1080
5506d11a
AM		 1081 case EM_MOXIE:
1082 rtype = elf_moxie_reloc_type (type);
1083 break;
1084
2469cfa2
NC		 1085 case EM_MSP430:
1086 case EM_MSP430_OLD:
1087 rtype = elf_msp430_reloc_type (type);
1088 break;
1089
252b5132 1090 case EM_PPC:
9ea033b2 1091 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1092 break;
1093
c833c019
AM		 1094 case EM_PPC64:
1095 rtype = elf_ppc64_reloc_type (type);
1096 break;
1097
252b5132 1098 case EM_MIPS:
4fe85591 1099 case EM_MIPS_RS3_LE:
9ea033b2 1100 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1101 break;
1102
1103 case EM_ALPHA:
9ea033b2 1104 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1105 break;
1106
1107 case EM_ARM:
9ea033b2 1108 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1109 break;
1110
584da044 1111 case EM_ARC:
9ea033b2 1112 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1113 break;
1114
1115 case EM_PARISC:
69e617ca 1116 rtype = elf_hppa_reloc_type (type);
252b5132 1117 break;
7d466069 1118
b8720f9d
JL		 1119 case EM_H8_300:
1120 case EM_H8_300H:
1121 case EM_H8S:
1122 rtype = elf_h8_reloc_type (type);
1123 break;
1124
3b16e843
NC		 1125 case EM_OPENRISC:
1126 case EM_OR32:
1127 rtype = elf_or32_reloc_type (type);
1128 break;
1129
7d466069 1130 case EM_PJ:
2b0337b0 1131 case EM_PJ_OLD:
7d466069
ILT		 1132 rtype = elf_pj_reloc_type (type);
1133 break;
800eeca4
JW		 1134 case EM_IA_64:
1135 rtype = elf_ia64_reloc_type (type);
1136 break;
1b61cf92
HPN		 1137
1138 case EM_CRIS:
1139 rtype = elf_cris_reloc_type (type);
1140 break;
535c37ff
JE		 1141
1142 case EM_860:
1143 rtype = elf_i860_reloc_type (type);
1144 break;
bcedfee6
NC		 1145
1146 case EM_X86_64:
8a9036a4 1147 case EM_L1OM:
7a9068fe 1148 case EM_K1OM:
bcedfee6
NC		 1149 rtype = elf_x86_64_reloc_type (type);
1150 break;
a85d7ed0 1151
35b1837e
AM		 1152 case EM_S370:
1153 rtype = i370_reloc_type (type);
1154 break;
1155
53c7db4b
KH		 1156 case EM_S390_OLD:
1157 case EM_S390:
1158 rtype = elf_s390_reloc_type (type);
1159 break;
93fbbb04 1160
1c0d3aa6
NC		 1161 case EM_SCORE:
1162 rtype = elf_score_reloc_type (type);
1163 break;
1164
93fbbb04
GK		 1165 case EM_XSTORMY16:
1166 rtype = elf_xstormy16_reloc_type (type);
1167 break;
179d3252 1168
1fe1f39c
NC		 1169 case EM_CRX:
1170 rtype = elf_crx_reloc_type (type);
1171 break;
1172
179d3252
JT		 1173 case EM_VAX:
1174 rtype = elf_vax_reloc_type (type);
1175 break;
1e4cf259 1176
cfb8c092
NC		 1177 case EM_ADAPTEVA_EPIPHANY:
1178 rtype = elf_epiphany_reloc_type (type);
1179 break;
1180
1e4cf259
NC		 1181 case EM_IP2K:
1182 case EM_IP2K_OLD:
1183 rtype = elf_ip2k_reloc_type (type);
1184 break;
3b36097d
SC		 1185
1186 case EM_IQ2000:
1187 rtype = elf_iq2000_reloc_type (type);
1188 break;
88da6820
NC		 1189
1190 case EM_XTENSA_OLD:
1191 case EM_XTENSA:
1192 rtype = elf_xtensa_reloc_type (type);
1193 break;
a34e3ecb 1194
84e94c90
NC		 1195 case EM_LATTICEMICO32:
1196 rtype = elf_lm32_reloc_type (type);
1197 break;
1198
ff7eeb89 1199 case EM_M32C_OLD:
49f58d10
JB		 1200 case EM_M32C:
1201 rtype = elf_m32c_reloc_type (type);
1202 break;
1203
d031aafb
NS		 1204 case EM_MT:
1205 rtype = elf_mt_reloc_type (type);
a34e3ecb 1206 break;
1d65ded4
CM		 1207
1208 case EM_BLACKFIN:
1209 rtype = elf_bfin_reloc_type (type);
1210 break;
15ab5209
DB		 1211
1212 case EM_CYGNUS_MEP:
1213 rtype = elf_mep_reloc_type (type);
1214 break;
60bca95a
NC		 1215
1216 case EM_CR16:
1217 rtype = elf_cr16_reloc_type (type);
1218 break;
dd24e3da 1219
7ba29e2a
NC		 1220 case EM_MICROBLAZE:
1221 case EM_MICROBLAZE_OLD:
1222 rtype = elf_microblaze_reloc_type (type);
1223 break;
c7927a3c 1224
99c513f6
DD		 1225 case EM_RL78:
1226 rtype = elf_rl78_reloc_type (type);
1227 break;
1228
c7927a3c
NC		 1229 case EM_RX:
1230 rtype = elf_rx_reloc_type (type);
1231 break;
c29aca4a
NC		 1232
1233 case EM_XC16X:
1234 case EM_C166:
1235 rtype = elf_xc16x_reloc_type (type);
1236 break;
40b36596
JM		 1237
1238 case EM_TI_C6000:
1239 rtype = elf_tic6x_reloc_type (type);
1240 break;
aa137e4d
NC		 1241
1242 case EM_TILEGX:
1243 rtype = elf_tilegx_reloc_type (type);
1244 break;
1245
1246 case EM_TILEPRO:
1247 rtype = elf_tilepro_reloc_type (type);
1248 break;
f6c1a2d5
NC		 1249
1250 case EM_XGATE:
1251 rtype = elf_xgate_reloc_type (type);
1252 break;
252b5132
RH		 1253 }
1254
1255 if (rtype == NULL)
39dbeff8 1256 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1257 else
8beeaeb7 1258 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1259
7ace3541 1260 if (elf_header.e_machine == EM_ALPHA
157c2599 1261 && rtype != NULL
7ace3541
RH		 1262 && streq (rtype, "R_ALPHA_LITUSE")
1263 && is_rela)
1264 {
1265 switch (rels[i].r_addend)
1266 {
1267 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1268 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1269 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1270 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1271 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1272 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1273 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1274 default: rtype = NULL;
1275 }
1276 if (rtype)
1277 printf (" (%s)", rtype);
1278 else
1279 {
1280 putchar (' ');
1281 printf (_("<unknown addend: %lx>"),
1282 (unsigned long) rels[i].r_addend);
1283 }
1284 }
1285 else if (symtab_index)
252b5132 1286 {
af3fc3bc 1287 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1288 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1289 else
19936277 1290 {
2cf0635d 1291 Elf_Internal_Sym * psym;
19936277 1292
af3fc3bc 1293 psym = symtab + symtab_index;
103f02d3 1294
af3fc3bc 1295 printf (" ");
171191ba 1296
d8045f23
NC		 1297 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1298 {
1299 const char * name;
1300 unsigned int len;
1301 unsigned int width = is_32bit_elf ? 8 : 14;
1302
1303 /* Relocations against GNU_IFUNC symbols do not use the value
1304 of the symbol as the address to relocate against. Instead
1305 they invoke the function named by the symbol and use its
1306 result as the address for relocation.
1307
1308 To indicate this to the user, do not display the value of
1309 the symbol in the "Symbols's Value" field. Instead show
1310 its name followed by () as a hint that the symbol is
1311 invoked. */
1312
1313 if (strtab == NULL
1314 || psym->st_name == 0
1315 || psym->st_name >= strtablen)
1316 name = "??";
1317 else
1318 name = strtab + psym->st_name;
1319
1320 len = print_symbol (width, name);
1321 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1322 }
1323 else
1324 {
1325 print_vma (psym->st_value, LONG_HEX);
171191ba 1326
d8045f23
NC		 1327 printf (is_32bit_elf ? " " : " ");
1328 }
103f02d3 1329
af3fc3bc 1330 if (psym->st_name == 0)
f1ef08cb 1331 {
2cf0635d 1332 const char * sec_name = "<null>";
f1ef08cb
AM		 1333 char name_buf[40];
1334
1335 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1336 {
4fbb74a6
AM		 1337 if (psym->st_shndx < elf_header.e_shnum)
1338 sec_name
1339 = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1340 else if (psym->st_shndx == SHN_ABS)
1341 sec_name = "ABS";
1342 else if (psym->st_shndx == SHN_COMMON)
1343 sec_name = "COMMON";
ac145307
BS		 1344 else if ((elf_header.e_machine == EM_MIPS
1345 && psym->st_shndx == SHN_MIPS_SCOMMON)
1346 || (elf_header.e_machine == EM_TI_C6000
1347 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1348 sec_name = "SCOMMON";
1349 else if (elf_header.e_machine == EM_MIPS
1350 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1351 sec_name = "SUNDEF";
8a9036a4 1352 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1353 || elf_header.e_machine == EM_L1OM
1354 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1355 && psym->st_shndx == SHN_X86_64_LCOMMON)
1356 sec_name = "LARGE_COMMON";
9ce701e2
L		 1357 else if (elf_header.e_machine == EM_IA_64
1358 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1359 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1360 sec_name = "ANSI_COM";
28f997cf 1361 else if (is_ia64_vms ()
148b93f2
NC		 1362 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1363 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1364 else
1365 {
1366 sprintf (name_buf, "<section 0x%x>",
1367 (unsigned int) psym->st_shndx);
1368 sec_name = name_buf;
1369 }
1370 }
1371 print_symbol (22, sec_name);
1372 }
af3fc3bc 1373 else if (strtab == NULL)
d79b3d50 1374 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1375 else if (psym->st_name >= strtablen)
d79b3d50 1376 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1377 else
2c71103e 1378 print_symbol (22, strtab + psym->st_name);
103f02d3 1379
af3fc3bc 1380 if (is_rela)
171191ba 1381 {
598aaa76 1382 bfd_signed_vma off = rels[i].r_addend;
171191ba 1383
91d6fa6a 1384 if (off < 0)
598aaa76 1385 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1386 else
598aaa76 1387 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1388 }
19936277 1389 }
252b5132 1390 }
1b228002 1391 else if (is_rela)
f7a99963 1392 {
e04d7088
L		 1393 bfd_signed_vma off = rels[i].r_addend;
1394
1395 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1396 if (off < 0)
1397 printf ("-%" BFD_VMA_FMT "x", - off);
1398 else
1399 printf ("%" BFD_VMA_FMT "x", off);
f7a99963 1400 }
252b5132 1401
157c2599
NC		 1402 if (elf_header.e_machine == EM_SPARCV9
1403 && rtype != NULL
1404 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1405 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1406
252b5132 1407 putchar ('\n');
2c71103e 1408
aca88567 1409#ifdef BFD64
53c7db4b 1410 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1411 {
91d6fa6a
NC		 1412 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1413 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1414 const char * rtype2 = elf_mips_reloc_type (type2);
1415 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1416
2c71103e
NC		 1417 printf (" Type2: ");
1418
1419 if (rtype2 == NULL)
39dbeff8
AM		 1420 printf (_("unrecognized: %-7lx"),
1421 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1422 else
1423 printf ("%-17.17s", rtype2);
1424
18bd398b 1425 printf ("\n Type3: ");
2c71103e
NC		 1426
1427 if (rtype3 == NULL)
39dbeff8
AM		 1428 printf (_("unrecognized: %-7lx"),
1429 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1430 else
1431 printf ("%-17.17s", rtype3);
1432
53c7db4b 1433 putchar ('\n');
2c71103e 1434 }
aca88567 1435#endif /* BFD64 */
252b5132
RH		 1436 }
1437
c8286bd1 1438 free (rels);
252b5132
RH		 1439}
1440
1441static const char *
d3ba0551 1442get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1443{
1444 switch (type)
1445 {
1446 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1447 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1448 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1449 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1450 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1451 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1452 case DT_MIPS_MSYM: return "MIPS_MSYM";
1453 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1454 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1455 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1456 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1457 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1458 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1459 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1460 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1461 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1462 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1463 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1464 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1465 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1466 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1467 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1468 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1469 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1470 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1471 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1472 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1473 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1474 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1475 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1476 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1477 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1478 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1479 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1480 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1481 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1482 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1483 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1484 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1485 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1486 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1487 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1488 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1489 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1490 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1491 default:
1492 return NULL;
1493 }
1494}
1495
9a097730 1496static const char *
d3ba0551 1497get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1498{
1499 switch (type)
1500 {
1501 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1502 default:
1503 return NULL;
1504 }
103f02d3
UD		 1505}
1506
7490d522
AM		 1507static const char *
1508get_ppc_dynamic_type (unsigned long type)
1509{
1510 switch (type)
1511 {
a7f2871e
AM		 1512 case DT_PPC_GOT: return "PPC_GOT";
1513 case DT_PPC_TLSOPT: return "PPC_TLSOPT";
7490d522
AM		 1514 default:
1515 return NULL;
1516 }
1517}
1518
f1cb7e17 1519static const char *
d3ba0551 1520get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1521{
1522 switch (type)
1523 {
a7f2871e
AM		 1524 case DT_PPC64_GLINK: return "PPC64_GLINK";
1525 case DT_PPC64_OPD: return "PPC64_OPD";
1526 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1527 case DT_PPC64_TLSOPT: return "PPC64_TLSOPT";
f1cb7e17
AM		 1528 default:
1529 return NULL;
1530 }
1531}
1532
103f02d3 1533static const char *
d3ba0551 1534get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1535{
1536 switch (type)
1537 {
1538 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1539 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1540 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1541 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1542 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1543 case DT_HP_PREINIT: return "HP_PREINIT";
1544 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1545 case DT_HP_NEEDED: return "HP_NEEDED";
1546 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1547 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1548 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1549 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1550 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1551 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1552 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1553 case DT_HP_FILTERED: return "HP_FILTERED";
1554 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1555 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1556 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1557 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1558 case DT_PLT: return "PLT";
1559 case DT_PLT_SIZE: return "PLT_SIZE";
1560 case DT_DLT: return "DLT";
1561 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1562 default:
1563 return NULL;
1564 }
1565}
9a097730 1566
ecc51f48 1567static const char *
d3ba0551 1568get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1569{
1570 switch (type)
1571 {
148b93f2
NC		 1572 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1573 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1574 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1575 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1576 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1577 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1578 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1579 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1580 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1581 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1582 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1583 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1584 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1585 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1586 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1587 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1588 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1589 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1590 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1591 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1592 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1593 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1594 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1595 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1596 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1597 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1598 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1599 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1600 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1601 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1602 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1603 default:
1604 return NULL;
1605 }
1606}
1607
fabcb361
RH		 1608static const char *
1609get_alpha_dynamic_type (unsigned long type)
1610{
1611 switch (type)
1612 {
1613 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1614 default:
1615 return NULL;
1616 }
1617}
1618
1c0d3aa6
NC		 1619static const char *
1620get_score_dynamic_type (unsigned long type)
1621{
1622 switch (type)
1623 {
1624 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1625 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1626 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1627 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1628 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1629 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1630 default:
1631 return NULL;
1632 }
1633}
1634
40b36596
JM		 1635static const char *
1636get_tic6x_dynamic_type (unsigned long type)
1637{
1638 switch (type)
1639 {
1640 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1641 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1642 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1643 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1644 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1645 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1646 default:
1647 return NULL;
1648 }
1649}
1c0d3aa6 1650
252b5132 1651static const char *
d3ba0551 1652get_dynamic_type (unsigned long type)
252b5132 1653{
e9e44622 1654 static char buff[64];
252b5132
RH		 1655
1656 switch (type)
1657 {
1658 case DT_NULL: return "NULL";
1659 case DT_NEEDED: return "NEEDED";
1660 case DT_PLTRELSZ: return "PLTRELSZ";
1661 case DT_PLTGOT: return "PLTGOT";
1662 case DT_HASH: return "HASH";
1663 case DT_STRTAB: return "STRTAB";
1664 case DT_SYMTAB: return "SYMTAB";
1665 case DT_RELA: return "RELA";
1666 case DT_RELASZ: return "RELASZ";
1667 case DT_RELAENT: return "RELAENT";
1668 case DT_STRSZ: return "STRSZ";
1669 case DT_SYMENT: return "SYMENT";
1670 case DT_INIT: return "INIT";
1671 case DT_FINI: return "FINI";
1672 case DT_SONAME: return "SONAME";
1673 case DT_RPATH: return "RPATH";
1674 case DT_SYMBOLIC: return "SYMBOLIC";
1675 case DT_REL: return "REL";
1676 case DT_RELSZ: return "RELSZ";
1677 case DT_RELENT: return "RELENT";
1678 case DT_PLTREL: return "PLTREL";
1679 case DT_DEBUG: return "DEBUG";
1680 case DT_TEXTREL: return "TEXTREL";
1681 case DT_JMPREL: return "JMPREL";
1682 case DT_BIND_NOW: return "BIND_NOW";
1683 case DT_INIT_ARRAY: return "INIT_ARRAY";
1684 case DT_FINI_ARRAY: return "FINI_ARRAY";
1685 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1686 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1687 case DT_RUNPATH: return "RUNPATH";
1688 case DT_FLAGS: return "FLAGS";
2d0e6f43 1689
d1133906
NC		 1690 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1691 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1692
05107a46 1693 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1694 case DT_PLTPADSZ: return "PLTPADSZ";
1695 case DT_MOVEENT: return "MOVEENT";
1696 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1697 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1698 case DT_POSFLAG_1: return "POSFLAG_1";
1699 case DT_SYMINSZ: return "SYMINSZ";
1700 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1701
252b5132 1702 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1703 case DT_CONFIG: return "CONFIG";
1704 case DT_DEPAUDIT: return "DEPAUDIT";
1705 case DT_AUDIT: return "AUDIT";
1706 case DT_PLTPAD: return "PLTPAD";
1707 case DT_MOVETAB: return "MOVETAB";
252b5132 1708 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1709
252b5132 1710 case DT_VERSYM: return "VERSYM";
103f02d3 1711
67a4f2b7
AO		 1712 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1713 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1714 case DT_RELACOUNT: return "RELACOUNT";
1715 case DT_RELCOUNT: return "RELCOUNT";
1716 case DT_FLAGS_1: return "FLAGS_1";
1717 case DT_VERDEF: return "VERDEF";
1718 case DT_VERDEFNUM: return "VERDEFNUM";
1719 case DT_VERNEED: return "VERNEED";
1720 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1721
019148e4 1722 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1723 case DT_USED: return "USED";
1724 case DT_FILTER: return "FILTER";
103f02d3 1725
047b2264
JJ		 1726 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1727 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1728 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1729 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1730 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1731 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1732
252b5132
RH		 1733 default:
1734 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1735 {
2cf0635d 1736 const char * result;
103f02d3 1737
252b5132
RH		 1738 switch (elf_header.e_machine)
1739 {
1740 case EM_MIPS:
4fe85591 1741 case EM_MIPS_RS3_LE:
252b5132
RH		 1742 result = get_mips_dynamic_type (type);
1743 break;
9a097730
RH		 1744 case EM_SPARCV9:
1745 result = get_sparc64_dynamic_type (type);
1746 break;
7490d522
AM		 1747 case EM_PPC:
1748 result = get_ppc_dynamic_type (type);
1749 break;
f1cb7e17
AM		 1750 case EM_PPC64:
1751 result = get_ppc64_dynamic_type (type);
1752 break;
ecc51f48
NC		 1753 case EM_IA_64:
1754 result = get_ia64_dynamic_type (type);
1755 break;
fabcb361
RH		 1756 case EM_ALPHA:
1757 result = get_alpha_dynamic_type (type);
1758 break;
1c0d3aa6
NC		 1759 case EM_SCORE:
1760 result = get_score_dynamic_type (type);
1761 break;
40b36596
JM		 1762 case EM_TI_C6000:
1763 result = get_tic6x_dynamic_type (type);
1764 break;
252b5132
RH		 1765 default:
1766 result = NULL;
1767 break;
1768 }
1769
1770 if (result != NULL)
1771 return result;
1772
e9e44622 1773 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 1774 }
eec8f817
DA		 1775 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1776 || (elf_header.e_machine == EM_PARISC
1777 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 1778 {
2cf0635d 1779 const char * result;
103f02d3
UD		 1780
1781 switch (elf_header.e_machine)
1782 {
1783 case EM_PARISC:
1784 result = get_parisc_dynamic_type (type);
1785 break;
148b93f2
NC		 1786 case EM_IA_64:
1787 result = get_ia64_dynamic_type (type);
1788 break;
103f02d3
UD		 1789 default:
1790 result = NULL;
1791 break;
1792 }
1793
1794 if (result != NULL)
1795 return result;
1796
e9e44622
JJ		 1797 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1798 type);
103f02d3 1799 }
252b5132 1800 else
e9e44622 1801 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 1802
252b5132
RH		 1803 return buff;
1804 }
1805}
1806
1807static char *
d3ba0551 1808get_file_type (unsigned e_type)
252b5132 1809{
b34976b6 1810 static char buff[32];
252b5132
RH		 1811
1812 switch (e_type)
1813 {
1814 case ET_NONE: return _("NONE (None)");
1815 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 1816 case ET_EXEC: return _("EXEC (Executable file)");
1817 case ET_DYN: return _("DYN (Shared object file)");
1818 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 1819
1820 default:
1821 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 1822 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 1823 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 1824 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 1825 else
e9e44622 1826 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 1827 return buff;
1828 }
1829}
1830
1831static char *
d3ba0551 1832get_machine_name (unsigned e_machine)
252b5132 1833{
b34976b6 1834 static char buff[64]; /* XXX */
252b5132
RH		 1835
1836 switch (e_machine)
1837 {
c45021f2 1838 case EM_NONE: return _("None");
a06ea964 1839 case EM_AARCH64: return "AArch64";
c45021f2
NC		 1840 case EM_M32: return "WE32100";
1841 case EM_SPARC: return "Sparc";
e9f53129 1842 case EM_SPU: return "SPU";
c45021f2
NC		 1843 case EM_386: return "Intel 80386";
1844 case EM_68K: return "MC68000";
1845 case EM_88K: return "MC88000";
1846 case EM_486: return "Intel 80486";
1847 case EM_860: return "Intel 80860";
1848 case EM_MIPS: return "MIPS R3000";
1849 case EM_S370: return "IBM System/370";
7036c0e1 1850 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 1851 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 1852 case EM_PARISC: return "HPPA";
252b5132 1853 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 1854 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 1855 case EM_960: return "Intel 90860";
1856 case EM_PPC: return "PowerPC";
285d1771 1857 case EM_PPC64: return "PowerPC64";
c45021f2
NC		 1858 case EM_V800: return "NEC V800";
1859 case EM_FR20: return "Fujitsu FR20";
1860 case EM_RH32: return "TRW RH32";
b34976b6 1861 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 1862 case EM_ARM: return "ARM";
1863 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 1864 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 1865 case EM_SPARCV9: return "Sparc v9";
1866 case EM_TRICORE: return "Siemens Tricore";
584da044 1867 case EM_ARC: return "ARC";
c2dcd04e
NC		 1868 case EM_H8_300: return "Renesas H8/300";
1869 case EM_H8_300H: return "Renesas H8/300H";
1870 case EM_H8S: return "Renesas H8S";
1871 case EM_H8_500: return "Renesas H8/500";
30800947 1872 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 1873 case EM_MIPS_X: return "Stanford MIPS-X";
1874 case EM_COLDFIRE: return "Motorola Coldfire";
c45021f2 1875 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 1876 case EM_CYGNUS_D10V:
1877 case EM_D10V: return "d10v";
1878 case EM_CYGNUS_D30V:
b34976b6 1879 case EM_D30V: return "d30v";
2b0337b0 1880 case EM_CYGNUS_M32R:
26597c86 1881 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 1882 case EM_CYGNUS_V850:
f6c1a2d5 1883 case EM_V850: return "Renesas V850";
2b0337b0
AO		 1884 case EM_CYGNUS_MN10300:
1885 case EM_MN10300: return "mn10300";
1886 case EM_CYGNUS_MN10200:
1887 case EM_MN10200: return "mn10200";
5506d11a 1888 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 1889 case EM_CYGNUS_FR30:
1890 case EM_FR30: return "Fujitsu FR30";
b34976b6 1891 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 1892 case EM_PJ_OLD:
b34976b6 1893 case EM_PJ: return "picoJava";
7036c0e1
AJ		 1894 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1895 case EM_PCP: return "Siemens PCP";
1896 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1897 case EM_NDR1: return "Denso NDR1 microprocesspr";
1898 case EM_STARCORE: return "Motorola Star*Core processor";
1899 case EM_ME16: return "Toyota ME16 processor";
1900 case EM_ST100: return "STMicroelectronics ST100 processor";
1901 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 1902 case EM_PDSP: return "Sony DSP processor";
1903 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
1904 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 1905 case EM_FX66: return "Siemens FX66 microcontroller";
1906 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1907 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1908 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
6927f982 1909 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ		 1910 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1911 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1912 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1913 case EM_SVX: return "Silicon Graphics SVx";
1914 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1915 case EM_VAX: return "Digital VAX";
2b0337b0 1916 case EM_AVR_OLD:
b34976b6 1917 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 1918 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 1919 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1920 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1921 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 1922 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 1923 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 1924 case EM_PRISM: return "Vitesse Prism";
bcedfee6 1925 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 1926 case EM_L1OM: return "Intel L1OM";
7a9068fe 1927 case EM_K1OM: return "Intel K1OM";
b7498e0e 1928 case EM_S390_OLD:
b34976b6 1929 case EM_S390: return "IBM S/390";
1c0d3aa6 1930 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 1931 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
3b16e843
NC		 1932 case EM_OPENRISC:
1933 case EM_OR32: return "OpenRISC";
11636f9e 1934 case EM_ARC_A5: return "ARC International ARCompact processor";
1fe1f39c 1935 case EM_CRX: return "National Semiconductor CRX microprocessor";
cfb8c092 1936 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
d172d4ba 1937 case EM_DLX: return "OpenDLX";
1e4cf259 1938 case EM_IP2K_OLD:
b34976b6 1939 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 1940 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 1941 case EM_XTENSA_OLD:
1942 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 1943 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
1944 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
1945 case EM_NS32K: return "National Semiconductor 32000 series";
1946 case EM_TPC: return "Tenor Network TPC processor";
1947 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
1948 case EM_MAX: return "MAX Processor";
1949 case EM_CR: return "National Semiconductor CompactRISC";
1950 case EM_F2MC16: return "Fujitsu F2MC16";
1951 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 1952 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 1953 case EM_M32C_OLD:
49f58d10 1954 case EM_M32C: return "Renesas M32c";
d031aafb 1955 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 1956 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 1957 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
1958 case EM_SEP: return "Sharp embedded microprocessor";
1959 case EM_ARCA: return "Arca RISC microprocessor";
1960 case EM_UNICORE: return "Unicore";
1961 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
1962 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 1963 case EM_NIOS32: return "Altera Nios";
1964 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 1965 case EM_C166:
d70c5fc7 1966 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 1967 case EM_M16C: return "Renesas M16C series microprocessors";
1968 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
1969 case EM_CE: return "Freescale Communication Engine RISC core";
1970 case EM_TSK3000: return "Altium TSK3000 core";
1971 case EM_RS08: return "Freescale RS08 embedded processor";
1972 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
1973 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
1974 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
1975 case EM_SE_C17: return "Seiko Epson C17 family";
1976 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
1977 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
1978 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
1979 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
1980 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
1981 case EM_R32C: return "Renesas R32C series microprocessors";
1982 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
1983 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
1984 case EM_8051: return "Intel 8051 and variants";
1985 case EM_STXP7X: return "STMicroelectronics STxP7x family";
1986 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
1987 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
1988 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
1989 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
1990 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
1991 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 1992 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 1993 case EM_CR16:
f6c1a2d5 1994 case EM_MICROBLAZE:
7ba29e2a 1995 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
99c513f6 1996 case EM_RL78: return "Renesas RL78";
c7927a3c 1997 case EM_RX: return "Renesas RX";
11636f9e
JM		 1998 case EM_METAG: return "Imagination Technologies META processor architecture";
1999 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2000 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2001 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2002 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2003 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2004 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2005 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2006 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 2007 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 2008 case EM_CUDA: return "NVIDIA CUDA architecture";
f6c1a2d5 2009 case EM_XGATE: return "Motorola XGATE embedded processor";
252b5132 2010 default:
35d9dd2f 2011 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2012 return buff;
2013 }
2014}
2015
f3485b74 2016static void
d3ba0551 2017decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2018{
2019 unsigned eabi;
2020 int unknown = 0;
2021
2022 eabi = EF_ARM_EABI_VERSION (e_flags);
2023 e_flags &= ~ EF_ARM_EABIMASK;
2024
2025 /* Handle "generic" ARM flags. */
2026 if (e_flags & EF_ARM_RELEXEC)
2027 {
2028 strcat (buf, ", relocatable executable");
2029 e_flags &= ~ EF_ARM_RELEXEC;
2030 }
76da6bbe 2031
f3485b74
NC		 2032 if (e_flags & EF_ARM_HASENTRY)
2033 {
2034 strcat (buf, ", has entry point");
2035 e_flags &= ~ EF_ARM_HASENTRY;
2036 }
76da6bbe 2037
f3485b74
NC		 2038 /* Now handle EABI specific flags. */
2039 switch (eabi)
2040 {
2041 default:
2c71103e 2042 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2043 if (e_flags)
2044 unknown = 1;
2045 break;
2046
2047 case EF_ARM_EABI_VER1:
a5bcd848 2048 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2049 while (e_flags)
2050 {
2051 unsigned flag;
76da6bbe 2052
f3485b74
NC		 2053 /* Process flags one bit at a time. */
2054 flag = e_flags & - e_flags;
2055 e_flags &= ~ flag;
76da6bbe 2056
f3485b74
NC		 2057 switch (flag)
2058 {
a5bcd848 2059 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2060 strcat (buf, ", sorted symbol tables");
2061 break;
76da6bbe 2062
f3485b74
NC		 2063 default:
2064 unknown = 1;
2065 break;
2066 }
2067 }
2068 break;
76da6bbe 2069
a5bcd848
PB		 2070 case EF_ARM_EABI_VER2:
2071 strcat (buf, ", Version2 EABI");
2072 while (e_flags)
2073 {
2074 unsigned flag;
2075
2076 /* Process flags one bit at a time. */
2077 flag = e_flags & - e_flags;
2078 e_flags &= ~ flag;
2079
2080 switch (flag)
2081 {
2082 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2083 strcat (buf, ", sorted symbol tables");
2084 break;
2085
2086 case EF_ARM_DYNSYMSUSESEGIDX:
2087 strcat (buf, ", dynamic symbols use segment index");
2088 break;
2089
2090 case EF_ARM_MAPSYMSFIRST:
2091 strcat (buf, ", mapping symbols precede others");
2092 break;
2093
2094 default:
2095 unknown = 1;
2096 break;
2097 }
2098 }
2099 break;
2100
d507cf36
PB		 2101 case EF_ARM_EABI_VER3:
2102 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2103 break;
2104
2105 case EF_ARM_EABI_VER4:
2106 strcat (buf, ", Version4 EABI");
3a4a14e9
PB		 2107 goto eabi;
2108
2109 case EF_ARM_EABI_VER5:
2110 strcat (buf, ", Version5 EABI");
2111 eabi:
d507cf36
PB		 2112 while (e_flags)
2113 {
2114 unsigned flag;
2115
2116 /* Process flags one bit at a time. */
2117 flag = e_flags & - e_flags;
2118 e_flags &= ~ flag;
2119
2120 switch (flag)
2121 {
2122 case EF_ARM_BE8:
2123 strcat (buf, ", BE8");
2124 break;
2125
2126 case EF_ARM_LE8:
2127 strcat (buf, ", LE8");
2128 break;
2129
2130 default:
2131 unknown = 1;
2132 break;
2133 }
2134 }
2135 break;
2136
f3485b74 2137 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2138 strcat (buf, ", GNU EABI");
f3485b74
NC		 2139 while (e_flags)
2140 {
2141 unsigned flag;
76da6bbe 2142
f3485b74
NC		 2143 /* Process flags one bit at a time. */
2144 flag = e_flags & - e_flags;
2145 e_flags &= ~ flag;
76da6bbe 2146
f3485b74
NC		 2147 switch (flag)
2148 {
a5bcd848 2149 case EF_ARM_INTERWORK:
f3485b74
NC		 2150 strcat (buf, ", interworking enabled");
2151 break;
76da6bbe 2152
a5bcd848 2153 case EF_ARM_APCS_26:
f3485b74
NC		 2154 strcat (buf, ", uses APCS/26");
2155 break;
76da6bbe 2156
a5bcd848 2157 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2158 strcat (buf, ", uses APCS/float");
2159 break;
76da6bbe 2160
a5bcd848 2161 case EF_ARM_PIC:
f3485b74
NC		 2162 strcat (buf, ", position independent");
2163 break;
76da6bbe 2164
a5bcd848 2165 case EF_ARM_ALIGN8:
f3485b74
NC		 2166 strcat (buf, ", 8 bit structure alignment");
2167 break;
76da6bbe 2168
a5bcd848 2169 case EF_ARM_NEW_ABI:
f3485b74
NC		 2170 strcat (buf, ", uses new ABI");
2171 break;
76da6bbe 2172
a5bcd848 2173 case EF_ARM_OLD_ABI:
f3485b74
NC		 2174 strcat (buf, ", uses old ABI");
2175 break;
76da6bbe 2176
a5bcd848 2177 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2178 strcat (buf, ", software FP");
2179 break;
76da6bbe 2180
90e01f86
ILT		 2181 case EF_ARM_VFP_FLOAT:
2182 strcat (buf, ", VFP");
2183 break;
2184
fde78edd
NC		 2185 case EF_ARM_MAVERICK_FLOAT:
2186 strcat (buf, ", Maverick FP");
2187 break;
2188
f3485b74
NC		 2189 default:
2190 unknown = 1;
2191 break;
2192 }
2193 }
2194 }
f3485b74
NC		 2195
2196 if (unknown)
2b692964 2197 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2198}
2199
252b5132 2200static char *
d3ba0551 2201get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2202{
b34976b6 2203 static char buf[1024];
252b5132
RH		 2204
2205 buf[0] = '\0';
76da6bbe 2206
252b5132
RH		 2207 if (e_flags)
2208 {
2209 switch (e_machine)
2210 {
2211 default:
2212 break;
2213
f3485b74
NC		 2214 case EM_ARM:
2215 decode_ARM_machine_flags (e_flags, buf);
2216 break;
76da6bbe 2217
781303ce
MF		 2218 case EM_BLACKFIN:
2219 if (e_flags & EF_BFIN_PIC)
2220 strcat (buf, ", PIC");
2221
2222 if (e_flags & EF_BFIN_FDPIC)
2223 strcat (buf, ", FDPIC");
2224
2225 if (e_flags & EF_BFIN_CODE_IN_L1)
2226 strcat (buf, ", code in L1");
2227
2228 if (e_flags & EF_BFIN_DATA_IN_L1)
2229 strcat (buf, ", data in L1");
2230
2231 break;
2232
ec2dfb42
AO		 2233 case EM_CYGNUS_FRV:
2234 switch (e_flags & EF_FRV_CPU_MASK)
2235 {
2236 case EF_FRV_CPU_GENERIC:
2237 break;
2238
2239 default:
2240 strcat (buf, ", fr???");
2241 break;
57346661 2242
ec2dfb42
AO		 2243 case EF_FRV_CPU_FR300:
2244 strcat (buf, ", fr300");
2245 break;
2246
2247 case EF_FRV_CPU_FR400:
2248 strcat (buf, ", fr400");
2249 break;
2250 case EF_FRV_CPU_FR405:
2251 strcat (buf, ", fr405");
2252 break;
2253
2254 case EF_FRV_CPU_FR450:
2255 strcat (buf, ", fr450");
2256 break;
2257
2258 case EF_FRV_CPU_FR500:
2259 strcat (buf, ", fr500");
2260 break;
2261 case EF_FRV_CPU_FR550:
2262 strcat (buf, ", fr550");
2263 break;
2264
2265 case EF_FRV_CPU_SIMPLE:
2266 strcat (buf, ", simple");
2267 break;
2268 case EF_FRV_CPU_TOMCAT:
2269 strcat (buf, ", tomcat");
2270 break;
2271 }
1c877e87 2272 break;
ec2dfb42 2273
53c7db4b 2274 case EM_68K:
425c6cb0 2275 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2276 strcat (buf, ", m68000");
425c6cb0 2277 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2278 strcat (buf, ", cpu32");
2279 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2280 strcat (buf, ", fido_a");
425c6cb0 2281 else
266abb8f 2282 {
2cf0635d
NC		 2283 char const * isa = _("unknown");
2284 char const * mac = _("unknown mac");
2285 char const * additional = NULL;
0112cd26 2286
c694fd50 2287 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2288 {
c694fd50 2289 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2290 isa = "A";
2291 additional = ", nodiv";
2292 break;
c694fd50 2293 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2294 isa = "A";
2295 break;
c694fd50 2296 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2297 isa = "A+";
2298 break;
c694fd50 2299 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2300 isa = "B";
2301 additional = ", nousp";
2302 break;
c694fd50 2303 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2304 isa = "B";
2305 break;
f608cd77
NS		 2306 case EF_M68K_CF_ISA_C:
2307 isa = "C";
2308 break;
2309 case EF_M68K_CF_ISA_C_NODIV:
2310 isa = "C";
2311 additional = ", nodiv";
2312 break;
266abb8f
NS		 2313 }
2314 strcat (buf, ", cf, isa ");
2315 strcat (buf, isa);
0b2e31dc
NS		 2316 if (additional)
2317 strcat (buf, additional);
c694fd50 2318 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2319 strcat (buf, ", float");
c694fd50 2320 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2321 {
2322 case 0:
2323 mac = NULL;
2324 break;
c694fd50 2325 case EF_M68K_CF_MAC:
266abb8f
NS		 2326 mac = "mac";
2327 break;
c694fd50 2328 case EF_M68K_CF_EMAC:
266abb8f
NS		 2329 mac = "emac";
2330 break;
f608cd77
NS		 2331 case EF_M68K_CF_EMAC_B:
2332 mac = "emac_b";
2333 break;
266abb8f
NS		 2334 }
2335 if (mac)
2336 {
2337 strcat (buf, ", ");
2338 strcat (buf, mac);
2339 }
266abb8f 2340 }
53c7db4b 2341 break;
33c63f9d 2342
252b5132
RH		 2343 case EM_PPC:
2344 if (e_flags & EF_PPC_EMB)
2345 strcat (buf, ", emb");
2346
2347 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2348 strcat (buf, _(", relocatable"));
252b5132
RH		 2349
2350 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 2351 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 2352 break;
2353
2b0337b0 2354 case EM_V850:
252b5132
RH		 2355 case EM_CYGNUS_V850:
2356 switch (e_flags & EF_V850_ARCH)
2357 {
1cd986c5
NC		 2358 case E_V850E2V3_ARCH:
2359 strcat (buf, ", v850e2v3");
2360 break;
2361 case E_V850E2_ARCH:
2362 strcat (buf, ", v850e2");
2363 break;
2364 case E_V850E1_ARCH:
2365 strcat (buf, ", v850e1");
8ad30312 2366 break;
252b5132
RH		 2367 case E_V850E_ARCH:
2368 strcat (buf, ", v850e");
2369 break;
252b5132
RH		 2370 case E_V850_ARCH:
2371 strcat (buf, ", v850");
2372 break;
2373 default:
2b692964 2374 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 2375 break;
2376 }
2377 break;
2378
2b0337b0 2379 case EM_M32R:
252b5132
RH		 2380 case EM_CYGNUS_M32R:
2381 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2382 strcat (buf, ", m32r");
252b5132
RH		 2383 break;
2384
2385 case EM_MIPS:
4fe85591 2386 case EM_MIPS_RS3_LE:
252b5132
RH		 2387 if (e_flags & EF_MIPS_NOREORDER)
2388 strcat (buf, ", noreorder");
2389
2390 if (e_flags & EF_MIPS_PIC)
2391 strcat (buf, ", pic");
2392
2393 if (e_flags & EF_MIPS_CPIC)
2394 strcat (buf, ", cpic");
2395
d1bdd336
TS		 2396 if (e_flags & EF_MIPS_UCODE)
2397 strcat (buf, ", ugen_reserved");
2398
252b5132
RH		 2399 if (e_flags & EF_MIPS_ABI2)
2400 strcat (buf, ", abi2");
2401
43521d43
TS		 2402 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2403 strcat (buf, ", odk first");
2404
a5d22d2a
TS		 2405 if (e_flags & EF_MIPS_32BITMODE)
2406 strcat (buf, ", 32bitmode");
2407
156c2f8b
NC		 2408 switch ((e_flags & EF_MIPS_MACH))
2409 {
2410 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2411 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2412 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 2413 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 2414 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2415 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2416 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2417 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 2418 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 2419 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 2420 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2421 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 2422 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 2423 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 2424 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
52b6b6b9 2425 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 2426 case 0:
2427 /* We simply ignore the field in this case to avoid confusion:
2428 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2429 extension. */
2430 break;
2b692964 2431 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 2432 }
43521d43
TS		 2433
2434 switch ((e_flags & EF_MIPS_ABI))
2435 {
2436 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2437 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2438 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2439 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2440 case 0:
2441 /* We simply ignore the field in this case to avoid confusion:
2442 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2443 This means it is likely to be an o32 file, but not for
2444 sure. */
2445 break;
2b692964 2446 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 2447 }
2448
2449 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2450 strcat (buf, ", mdmx");
2451
2452 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2453 strcat (buf, ", mips16");
2454
df58fc94
RS		 2455 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2456 strcat (buf, ", micromips");
2457
43521d43
TS		 2458 switch ((e_flags & EF_MIPS_ARCH))
2459 {
2460 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2461 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2462 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2463 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2464 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2465 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 2466 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
43521d43 2467 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 2468 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2b692964 2469 default: strcat (buf, _(", unknown ISA")); break;
43521d43
TS		 2470 }
2471
8e45593f
NC		 2472 if (e_flags & EF_SH_PIC)
2473 strcat (buf, ", pic");
2474
2475 if (e_flags & EF_SH_FDPIC)
2476 strcat (buf, ", fdpic");
252b5132 2477 break;
351b4b40 2478
ccde1100
AO		 2479 case EM_SH:
2480 switch ((e_flags & EF_SH_MACH_MASK))
2481 {
2482 case EF_SH1: strcat (buf, ", sh1"); break;
2483 case EF_SH2: strcat (buf, ", sh2"); break;
2484 case EF_SH3: strcat (buf, ", sh3"); break;
2485 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2486 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2487 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2488 case EF_SH3E: strcat (buf, ", sh3e"); break;
2489 case EF_SH4: strcat (buf, ", sh4"); break;
2490 case EF_SH5: strcat (buf, ", sh5"); break;
2491 case EF_SH2E: strcat (buf, ", sh2e"); break;
2492 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 2493 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 2494 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2495 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 2496 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 2497 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2498 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2499 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2500 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2501 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2502 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 2503 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 2504 }
2505
2506 break;
57346661 2507
351b4b40
RH		 2508 case EM_SPARCV9:
2509 if (e_flags & EF_SPARC_32PLUS)
2510 strcat (buf, ", v8+");
2511
2512 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 2513 strcat (buf, ", ultrasparcI");
2514
2515 if (e_flags & EF_SPARC_SUN_US3)
2516 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 2517
2518 if (e_flags & EF_SPARC_HAL_R1)
2519 strcat (buf, ", halr1");
2520
2521 if (e_flags & EF_SPARC_LEDATA)
2522 strcat (buf, ", ledata");
2523
2524 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2525 strcat (buf, ", tso");
2526
2527 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2528 strcat (buf, ", pso");
2529
2530 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2531 strcat (buf, ", rmo");
2532 break;
7d466069 2533
103f02d3
UD		 2534 case EM_PARISC:
2535 switch (e_flags & EF_PARISC_ARCH)
2536 {
2537 case EFA_PARISC_1_0:
2538 strcpy (buf, ", PA-RISC 1.0");
2539 break;
2540 case EFA_PARISC_1_1:
2541 strcpy (buf, ", PA-RISC 1.1");
2542 break;
2543 case EFA_PARISC_2_0:
2544 strcpy (buf, ", PA-RISC 2.0");
2545 break;
2546 default:
2547 break;
2548 }
2549 if (e_flags & EF_PARISC_TRAPNIL)
2550 strcat (buf, ", trapnil");
2551 if (e_flags & EF_PARISC_EXT)
2552 strcat (buf, ", ext");
2553 if (e_flags & EF_PARISC_LSB)
2554 strcat (buf, ", lsb");
2555 if (e_flags & EF_PARISC_WIDE)
2556 strcat (buf, ", wide");
2557 if (e_flags & EF_PARISC_NO_KABP)
2558 strcat (buf, ", no kabp");
2559 if (e_flags & EF_PARISC_LAZYSWAP)
2560 strcat (buf, ", lazyswap");
30800947 2561 break;
76da6bbe 2562
7d466069 2563 case EM_PJ:
2b0337b0 2564 case EM_PJ_OLD:
7d466069
ILT		 2565 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2566 strcat (buf, ", new calling convention");
2567
2568 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2569 strcat (buf, ", gnu calling convention");
2570 break;
4d6ed7c8
NC		 2571
2572 case EM_IA_64:
2573 if ((e_flags & EF_IA_64_ABI64))
2574 strcat (buf, ", 64-bit");
2575 else
2576 strcat (buf, ", 32-bit");
2577 if ((e_flags & EF_IA_64_REDUCEDFP))
2578 strcat (buf, ", reduced fp model");
2579 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2580 strcat (buf, ", no function descriptors, constant gp");
2581 else if ((e_flags & EF_IA_64_CONS_GP))
2582 strcat (buf, ", constant gp");
2583 if ((e_flags & EF_IA_64_ABSOLUTE))
2584 strcat (buf, ", absolute");
28f997cf
TG		 2585 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2586 {
2587 if ((e_flags & EF_IA_64_VMS_LINKAGES))
2588 strcat (buf, ", vms_linkages");
2589 switch ((e_flags & EF_IA_64_VMS_COMCOD))
2590 {
2591 case EF_IA_64_VMS_COMCOD_SUCCESS:
2592 break;
2593 case EF_IA_64_VMS_COMCOD_WARNING:
2594 strcat (buf, ", warning");
2595 break;
2596 case EF_IA_64_VMS_COMCOD_ERROR:
2597 strcat (buf, ", error");
2598 break;
2599 case EF_IA_64_VMS_COMCOD_ABORT:
2600 strcat (buf, ", abort");
2601 break;
2602 default:
2603 abort ();
2604 }
2605 }
4d6ed7c8 2606 break;
179d3252
JT		 2607
2608 case EM_VAX:
2609 if ((e_flags & EF_VAX_NONPIC))
2610 strcat (buf, ", non-PIC");
2611 if ((e_flags & EF_VAX_DFLOAT))
2612 strcat (buf, ", D-Float");
2613 if ((e_flags & EF_VAX_GFLOAT))
2614 strcat (buf, ", G-Float");
2615 break;
c7927a3c
NC		 2616
2617 case EM_RX:
2618 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2619 strcat (buf, ", 64-bit doubles");
2620 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 2621 strcat (buf, ", dsp");
d4cb0ea0
NC		 2622 if (e_flags & E_FLAG_RX_PID)
2623 strcat (buf, ", pid");
2624 break;
55786da2
AK		 2625
2626 case EM_S390:
2627 if (e_flags & EF_S390_HIGH_GPRS)
2628 strcat (buf, ", highgprs");
d4cb0ea0 2629 break;
40b36596
JM		 2630
2631 case EM_TI_C6000:
2632 if ((e_flags & EF_C6000_REL))
2633 strcat (buf, ", relocatable module");
d4cb0ea0 2634 break;
252b5132
RH		 2635 }
2636 }
2637
2638 return buf;
2639}
2640
252b5132 2641static const char *
d3ba0551
AM		 2642get_osabi_name (unsigned int osabi)
2643{
2644 static char buff[32];
2645
2646 switch (osabi)
2647 {
2648 case ELFOSABI_NONE: return "UNIX - System V";
2649 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2650 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 2651 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 2652 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2653 case ELFOSABI_AIX: return "UNIX - AIX";
2654 case ELFOSABI_IRIX: return "UNIX - IRIX";
2655 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2656 case ELFOSABI_TRU64: return "UNIX - TRU64";
2657 case ELFOSABI_MODESTO: return "Novell - Modesto";
2658 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2659 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2660 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 2661 case ELFOSABI_AROS: return "AROS";
11636f9e 2662 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 2663 default:
40b36596
JM		 2664 if (osabi >= 64)
2665 switch (elf_header.e_machine)
2666 {
2667 case EM_ARM:
2668 switch (osabi)
2669 {
2670 case ELFOSABI_ARM: return "ARM";
2671 default:
2672 break;
2673 }
2674 break;
2675
2676 case EM_MSP430:
2677 case EM_MSP430_OLD:
2678 switch (osabi)
2679 {
2680 case ELFOSABI_STANDALONE: return _("Standalone App");
2681 default:
2682 break;
2683 }
2684 break;
2685
2686 case EM_TI_C6000:
2687 switch (osabi)
2688 {
2689 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
2690 case ELFOSABI_C6000_LINUX: return "Linux C6000";
2691 default:
2692 break;
2693 }
2694 break;
2695
2696 default:
2697 break;
2698 }
e9e44622 2699 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 2700 return buff;
2701 }
2702}
2703
a06ea964
NC		 2704static const char *
2705get_aarch64_segment_type (unsigned long type)
2706{
2707 switch (type)
2708 {
2709 case PT_AARCH64_ARCHEXT:
2710 return "AARCH64_ARCHEXT";
2711 default:
2712 break;
2713 }
2714
2715 return NULL;
2716}
2717
b294bdf8
MM		 2718static const char *
2719get_arm_segment_type (unsigned long type)
2720{
2721 switch (type)
2722 {
2723 case PT_ARM_EXIDX:
2724 return "EXIDX";
2725 default:
2726 break;
2727 }
2728
2729 return NULL;
2730}
2731
d3ba0551
AM		 2732static const char *
2733get_mips_segment_type (unsigned long type)
252b5132
RH		 2734{
2735 switch (type)
2736 {
2737 case PT_MIPS_REGINFO:
2738 return "REGINFO";
2739 case PT_MIPS_RTPROC:
2740 return "RTPROC";
2741 case PT_MIPS_OPTIONS:
2742 return "OPTIONS";
2743 default:
2744 break;
2745 }
2746
2747 return NULL;
2748}
2749
103f02d3 2750static const char *
d3ba0551 2751get_parisc_segment_type (unsigned long type)
103f02d3
UD		 2752{
2753 switch (type)
2754 {
2755 case PT_HP_TLS: return "HP_TLS";
2756 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2757 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2758 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2759 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2760 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2761 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2762 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2763 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2764 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2765 case PT_HP_PARALLEL: return "HP_PARALLEL";
2766 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 2767 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
2768 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
2769 case PT_HP_STACK: return "HP_STACK";
2770 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 2771 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2772 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 2773 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 2774 default:
2775 break;
2776 }
2777
2778 return NULL;
2779}
2780
4d6ed7c8 2781static const char *
d3ba0551 2782get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 2783{
2784 switch (type)
2785 {
2786 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2787 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 2788 case PT_HP_TLS: return "HP_TLS";
2789 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2790 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2791 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 2792 default:
2793 break;
2794 }
2795
2796 return NULL;
2797}
2798
40b36596
JM		 2799static const char *
2800get_tic6x_segment_type (unsigned long type)
2801{
2802 switch (type)
2803 {
2804 case PT_C6000_PHATTR: return "C6000_PHATTR";
2805 default:
2806 break;
2807 }
2808
2809 return NULL;
2810}
2811
252b5132 2812static const char *
d3ba0551 2813get_segment_type (unsigned long p_type)
252b5132 2814{
b34976b6 2815 static char buff[32];
252b5132
RH		 2816
2817 switch (p_type)
2818 {
b34976b6
AM		 2819 case PT_NULL: return "NULL";
2820 case PT_LOAD: return "LOAD";
252b5132 2821 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 2822 case PT_INTERP: return "INTERP";
2823 case PT_NOTE: return "NOTE";
2824 case PT_SHLIB: return "SHLIB";
2825 case PT_PHDR: return "PHDR";
13ae64f3 2826 case PT_TLS: return "TLS";
252b5132 2827
65765700
JJ		 2828 case PT_GNU_EH_FRAME:
2829 return "GNU_EH_FRAME";
2b05f1b7 2830 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 2831 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 2832
252b5132
RH		 2833 default:
2834 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2835 {
2cf0635d 2836 const char * result;
103f02d3 2837
252b5132
RH		 2838 switch (elf_header.e_machine)
2839 {
a06ea964
NC		 2840 case EM_AARCH64:
2841 result = get_aarch64_segment_type (p_type);
2842 break;
b294bdf8
MM		 2843 case EM_ARM:
2844 result = get_arm_segment_type (p_type);
2845 break;
252b5132 2846 case EM_MIPS:
4fe85591 2847 case EM_MIPS_RS3_LE:
252b5132
RH		 2848 result = get_mips_segment_type (p_type);
2849 break;
103f02d3
UD		 2850 case EM_PARISC:
2851 result = get_parisc_segment_type (p_type);
2852 break;
4d6ed7c8
NC		 2853 case EM_IA_64:
2854 result = get_ia64_segment_type (p_type);
2855 break;
40b36596
JM		 2856 case EM_TI_C6000:
2857 result = get_tic6x_segment_type (p_type);
2858 break;
252b5132
RH		 2859 default:
2860 result = NULL;
2861 break;
2862 }
103f02d3 2863
252b5132
RH		 2864 if (result != NULL)
2865 return result;
103f02d3 2866
252b5132
RH		 2867 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2868 }
2869 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 2870 {
2cf0635d 2871 const char * result;
103f02d3
UD		 2872
2873 switch (elf_header.e_machine)
2874 {
2875 case EM_PARISC:
2876 result = get_parisc_segment_type (p_type);
2877 break;
00428cca
AM		 2878 case EM_IA_64:
2879 result = get_ia64_segment_type (p_type);
2880 break;
103f02d3
UD		 2881 default:
2882 result = NULL;
2883 break;
2884 }
2885
2886 if (result != NULL)
2887 return result;
2888
2889 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2890 }
252b5132 2891 else
e9e44622 2892 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 2893
2894 return buff;
2895 }
2896}
2897
2898static const char *
d3ba0551 2899get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 2900{
2901 switch (sh_type)
2902 {
b34976b6
AM		 2903 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
2904 case SHT_MIPS_MSYM: return "MIPS_MSYM";
2905 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
2906 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
2907 case SHT_MIPS_UCODE: return "MIPS_UCODE";
2908 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
2909 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
2910 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
2911 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
2912 case SHT_MIPS_RELD: return "MIPS_RELD";
2913 case SHT_MIPS_IFACE: return "MIPS_IFACE";
2914 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
2915 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
2916 case SHT_MIPS_SHDR: return "MIPS_SHDR";
2917 case SHT_MIPS_FDESC: return "MIPS_FDESC";
2918 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
2919 case SHT_MIPS_DENSE: return "MIPS_DENSE";
2920 case SHT_MIPS_PDESC: return "MIPS_PDESC";
2921 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
2922 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
2923 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
2924 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
2925 case SHT_MIPS_LINE: return "MIPS_LINE";
2926 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
2927 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
2928 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
2929 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
2930 case SHT_MIPS_DWARF: return "MIPS_DWARF";
2931 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
2932 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
2933 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
2934 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
2935 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
2936 case SHT_MIPS_XLATE: return "MIPS_XLATE";
2937 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
2938 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
2939 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
2940 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132
RH		 2941 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2942 default:
2943 break;
2944 }
2945 return NULL;
2946}
2947
103f02d3 2948static const char *
d3ba0551 2949get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 2950{
2951 switch (sh_type)
2952 {
2953 case SHT_PARISC_EXT: return "PARISC_EXT";
2954 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
2955 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 2956 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
2957 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
2958 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 2959 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 2960 default:
2961 break;
2962 }
2963 return NULL;
2964}
2965
4d6ed7c8 2966static const char *
d3ba0551 2967get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 2968{
18bd398b 2969 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 2970 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
2971 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 2972
4d6ed7c8
NC		 2973 switch (sh_type)
2974 {
148b93f2
NC		 2975 case SHT_IA_64_EXT: return "IA_64_EXT";
2976 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
2977 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
2978 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
2979 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
2980 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
2981 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
2982 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
2983 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
2984 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 2985 default:
2986 break;
2987 }
2988 return NULL;
2989}
2990
d2b2c203
DJ		 2991static const char *
2992get_x86_64_section_type_name (unsigned int sh_type)
2993{
2994 switch (sh_type)
2995 {
2996 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
2997 default:
2998 break;
2999 }
3000 return NULL;
3001}
3002
a06ea964
NC		 3003static const char *
3004get_aarch64_section_type_name (unsigned int sh_type)
3005{
3006 switch (sh_type)
3007 {
3008 case SHT_AARCH64_ATTRIBUTES:
3009 return "AARCH64_ATTRIBUTES";
3010 default:
3011 break;
3012 }
3013 return NULL;
3014}
3015
40a18ebd
NC		 3016static const char *
3017get_arm_section_type_name (unsigned int sh_type)
3018{
3019 switch (sh_type)
3020 {
7f6fed87
NC		 3021 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3022 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3023 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3024 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3025 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3026 default:
3027 break;
3028 }
3029 return NULL;
3030}
3031
40b36596
JM		 3032static const char *
3033get_tic6x_section_type_name (unsigned int sh_type)
3034{
3035 switch (sh_type)
3036 {
3037 case SHT_C6000_UNWIND:
3038 return "C6000_UNWIND";
3039 case SHT_C6000_PREEMPTMAP:
3040 return "C6000_PREEMPTMAP";
3041 case SHT_C6000_ATTRIBUTES:
3042 return "C6000_ATTRIBUTES";
3043 case SHT_TI_ICODE:
3044 return "TI_ICODE";
3045 case SHT_TI_XREF:
3046 return "TI_XREF";
3047 case SHT_TI_HANDLER:
3048 return "TI_HANDLER";
3049 case SHT_TI_INITINFO:
3050 return "TI_INITINFO";
3051 case SHT_TI_PHATTRS:
3052 return "TI_PHATTRS";
3053 default:
3054 break;
3055 }
3056 return NULL;
3057}
3058
252b5132 3059static const char *
d3ba0551 3060get_section_type_name (unsigned int sh_type)
252b5132 3061{
b34976b6 3062 static char buff[32];
252b5132
RH		 3063
3064 switch (sh_type)
3065 {
3066 case SHT_NULL: return "NULL";
3067 case SHT_PROGBITS: return "PROGBITS";
3068 case SHT_SYMTAB: return "SYMTAB";
3069 case SHT_STRTAB: return "STRTAB";
3070 case SHT_RELA: return "RELA";
3071 case SHT_HASH: return "HASH";
3072 case SHT_DYNAMIC: return "DYNAMIC";
3073 case SHT_NOTE: return "NOTE";
3074 case SHT_NOBITS: return "NOBITS";
3075 case SHT_REL: return "REL";
3076 case SHT_SHLIB: return "SHLIB";
3077 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3078 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3079 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3080 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3081 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3082 case SHT_GROUP: return "GROUP";
3083 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3084 case SHT_GNU_verdef: return "VERDEF";
3085 case SHT_GNU_verneed: return "VERNEED";
3086 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3087 case 0x6ffffff0: return "VERSYM";
3088 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3089 case 0x7ffffffd: return "AUXILIARY";
3090 case 0x7fffffff: return "FILTER";
047b2264 3091 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3092
3093 default:
3094 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3095 {
2cf0635d 3096 const char * result;
252b5132
RH		 3097
3098 switch (elf_header.e_machine)
3099 {
3100 case EM_MIPS:
4fe85591 3101 case EM_MIPS_RS3_LE:
252b5132
RH		 3102 result = get_mips_section_type_name (sh_type);
3103 break;
103f02d3
UD		 3104 case EM_PARISC:
3105 result = get_parisc_section_type_name (sh_type);
3106 break;
4d6ed7c8
NC		 3107 case EM_IA_64:
3108 result = get_ia64_section_type_name (sh_type);
3109 break;
d2b2c203 3110 case EM_X86_64:
8a9036a4 3111 case EM_L1OM:
7a9068fe 3112 case EM_K1OM:
d2b2c203
DJ		 3113 result = get_x86_64_section_type_name (sh_type);
3114 break;
a06ea964
NC		 3115 case EM_AARCH64:
3116 result = get_aarch64_section_type_name (sh_type);
3117 break;
40a18ebd
NC		 3118 case EM_ARM:
3119 result = get_arm_section_type_name (sh_type);
3120 break;
40b36596
JM		 3121 case EM_TI_C6000:
3122 result = get_tic6x_section_type_name (sh_type);
3123 break;
252b5132
RH		 3124 default:
3125 result = NULL;
3126 break;
3127 }
3128
3129 if (result != NULL)
3130 return result;
3131
c91d0dfb 3132 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3133 }
3134 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3135 {
2cf0635d 3136 const char * result;
148b93f2
NC		 3137
3138 switch (elf_header.e_machine)
3139 {
3140 case EM_IA_64:
3141 result = get_ia64_section_type_name (sh_type);
3142 break;
3143 default:
3144 result = NULL;
3145 break;
3146 }
3147
3148 if (result != NULL)
3149 return result;
3150
3151 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3152 }
252b5132 3153 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
c91d0dfb 3154 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
252b5132 3155 else
a7dbfd1c
NC		 3156 /* This message is probably going to be displayed in a 15
3157 character wide field, so put the hex value first. */
3158 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3159
252b5132
RH		 3160 return buff;
3161 }
3162}
3163
2979dc34 3164#define OPTION_DEBUG_DUMP 512
2c610e4b 3165#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3166#define OPTION_DWARF_DEPTH 514
3167#define OPTION_DWARF_START 515
4723351a 3168#define OPTION_DWARF_CHECK 516
2979dc34 3169
85b1c36d 3170static struct option options[] =
252b5132 3171{
b34976b6 3172 {"all", no_argument, 0, 'a'},
252b5132
RH		 3173 {"file-header", no_argument, 0, 'h'},
3174 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3175 {"headers", no_argument, 0, 'e'},
3176 {"histogram", no_argument, 0, 'I'},
3177 {"segments", no_argument, 0, 'l'},
3178 {"sections", no_argument, 0, 'S'},
252b5132 3179 {"section-headers", no_argument, 0, 'S'},
f5842774 3180 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3181 {"section-details", no_argument, 0, 't'},
595cf52e 3182 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3183 {"symbols", no_argument, 0, 's'},
3184 {"syms", no_argument, 0, 's'},
2c610e4b 3185 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3186 {"relocs", no_argument, 0, 'r'},
3187 {"notes", no_argument, 0, 'n'},
3188 {"dynamic", no_argument, 0, 'd'},
a952a375 3189 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3190 {"version-info", no_argument, 0, 'V'},
3191 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3192 {"unwind", no_argument, 0, 'u'},
4145f1d5 3193 {"archive-index", no_argument, 0, 'c'},
b34976b6 3194 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3195 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3196 {"string-dump", required_argument, 0, 'p'},
252b5132
RH		 3197#ifdef SUPPORT_DISASSEMBLY
3198 {"instruction-dump", required_argument, 0, 'i'},
3199#endif
cf13d699 3200 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3201
fd2f0033
TT		 3202 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3203 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 3204 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 3205
b34976b6
AM		 3206 {"version", no_argument, 0, 'v'},
3207 {"wide", no_argument, 0, 'W'},
3208 {"help", no_argument, 0, 'H'},
3209 {0, no_argument, 0, 0}
252b5132
RH		 3210};
3211
3212static void
2cf0635d 3213usage (FILE * stream)
252b5132 3214{
92f01d61
JM		 3215 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3216 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3217 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3218 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3219 -h --file-header Display the ELF file header\n\
3220 -l --program-headers Display the program headers\n\
3221 --segments An alias for --program-headers\n\
3222 -S --section-headers Display the sections' header\n\
3223 --sections An alias for --section-headers\n\
f5842774 3224 -g --section-groups Display the section groups\n\
5477e8a0 3225 -t --section-details Display the section details\n\
8b53311e
NC		 3226 -e --headers Equivalent to: -h -l -S\n\
3227 -s --syms Display the symbol table\n\
3f08eb35 3228 --symbols An alias for --syms\n\
2c610e4b 3229 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3230 -n --notes Display the core notes (if present)\n\
3231 -r --relocs Display the relocations (if present)\n\
3232 -u --unwind Display the unwind info (if present)\n\
b2d38a17 3233 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 3234 -V --version-info Display the version sections (if present)\n\
1b31d05e 3235 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 3236 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 3237 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 3238 -x --hex-dump=<number|name>\n\
3239 Dump the contents of section <number|name> as bytes\n\
3240 -p --string-dump=<number|name>\n\
3241 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 3242 -R --relocated-dump=<number|name>\n\
3243 Dump the contents of section <number|name> as relocated bytes\n\
f9f0e732 3244 -w[lLiaprmfFsoRt] or\n\
1ed06042 3245 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 3246 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
5bbdf3d5 3247 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges]\n\
8b53311e 3248 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 3249 fprintf (stream, _("\
3250 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3251 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3252 or deeper\n"));
252b5132 3253#ifdef SUPPORT_DISASSEMBLY
92f01d61 3254 fprintf (stream, _("\
09c11c86
NC		 3255 -i --instruction-dump=<number|name>\n\
3256 Disassemble the contents of section <number|name>\n"));
252b5132 3257#endif
92f01d61 3258 fprintf (stream, _("\
8b53311e
NC		 3259 -I --histogram Display histogram of bucket list lengths\n\
3260 -W --wide Allow output width to exceed 80 characters\n\
07012eee 3261 @<file> Read options from <file>\n\
8b53311e
NC		 3262 -H --help Display this information\n\
3263 -v --version Display the version number of readelf\n"));
1118d252 3264
92f01d61
JM		 3265 if (REPORT_BUGS_TO[0] && stream == stdout)
3266 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 3267
92f01d61 3268 exit (stream == stdout ? 0 : 1);
252b5132
RH		 3269}
3270
18bd398b
NC		 3271/* Record the fact that the user wants the contents of section number
3272 SECTION to be displayed using the method(s) encoded as flags bits
3273 in TYPE. Note, TYPE can be zero if we are creating the array for
3274 the first time. */
3275
252b5132 3276static void
09c11c86 3277request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 3278{
3279 if (section >= num_dump_sects)
3280 {
2cf0635d 3281 dump_type * new_dump_sects;
252b5132 3282
3f5e193b
NC		 3283 new_dump_sects = (dump_type *) calloc (section + 1,
3284 sizeof (* dump_sects));
252b5132
RH		 3285
3286 if (new_dump_sects == NULL)
591a748a 3287 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 3288 else
3289 {
3290 /* Copy current flag settings. */
09c11c86 3291 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 3292
3293 free (dump_sects);
3294
3295 dump_sects = new_dump_sects;
3296 num_dump_sects = section + 1;
3297 }
3298 }
3299
3300 if (dump_sects)
b34976b6 3301 dump_sects[section] |= type;
252b5132
RH		 3302
3303 return;
3304}
3305
aef1f6d0
DJ		 3306/* Request a dump by section name. */
3307
3308static void
2cf0635d 3309request_dump_byname (const char * section, dump_type type)
aef1f6d0 3310{
2cf0635d 3311 struct dump_list_entry * new_request;
aef1f6d0 3312
3f5e193b
NC		 3313 new_request = (struct dump_list_entry *)
3314 malloc (sizeof (struct dump_list_entry));
aef1f6d0 3315 if (!new_request)
591a748a 3316 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3317
3318 new_request->name = strdup (section);
3319 if (!new_request->name)
591a748a 3320 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3321
3322 new_request->type = type;
3323
3324 new_request->next = dump_sects_byname;
3325 dump_sects_byname = new_request;
3326}
3327
cf13d699
NC		 3328static inline void
3329request_dump (dump_type type)
3330{
3331 int section;
3332 char * cp;
3333
3334 do_dump++;
3335 section = strtoul (optarg, & cp, 0);
3336
3337 if (! *cp && section >= 0)
3338 request_dump_bynumber (section, type);
3339 else
3340 request_dump_byname (optarg, type);
3341}
3342
3343
252b5132 3344static void
2cf0635d 3345parse_args (int argc, char ** argv)
252b5132
RH		 3346{
3347 int c;
3348
3349 if (argc < 2)
92f01d61 3350 usage (stderr);
252b5132
RH		 3351
3352 while ((c = getopt_long
cf13d699 3353 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
252b5132 3354 {
252b5132
RH		 3355 switch (c)
3356 {
3357 case 0:
3358 /* Long options. */
3359 break;
3360 case 'H':
92f01d61 3361 usage (stdout);
252b5132
RH		 3362 break;
3363
3364 case 'a':
b34976b6
AM		 3365 do_syms++;
3366 do_reloc++;
3367 do_unwind++;
3368 do_dynamic++;
3369 do_header++;
3370 do_sections++;
f5842774 3371 do_section_groups++;
b34976b6
AM		 3372 do_segments++;
3373 do_version++;
3374 do_histogram++;
3375 do_arch++;
3376 do_notes++;
252b5132 3377 break;
f5842774
L		 3378 case 'g':
3379 do_section_groups++;
3380 break;
5477e8a0 3381 case 't':
595cf52e 3382 case 'N':
5477e8a0
L		 3383 do_sections++;
3384 do_section_details++;
595cf52e 3385 break;
252b5132 3386 case 'e':
b34976b6
AM		 3387 do_header++;
3388 do_sections++;
3389 do_segments++;
252b5132 3390 break;
a952a375 3391 case 'A':
b34976b6 3392 do_arch++;
a952a375 3393 break;
252b5132 3394 case 'D':
b34976b6 3395 do_using_dynamic++;
252b5132
RH		 3396 break;
3397 case 'r':
b34976b6 3398 do_reloc++;
252b5132 3399 break;
4d6ed7c8 3400 case 'u':
b34976b6 3401 do_unwind++;
4d6ed7c8 3402 break;
252b5132 3403 case 'h':
b34976b6 3404 do_header++;
252b5132
RH		 3405 break;
3406 case 'l':
b34976b6 3407 do_segments++;
252b5132
RH		 3408 break;
3409 case 's':
b34976b6 3410 do_syms++;
252b5132
RH		 3411 break;
3412 case 'S':
b34976b6 3413 do_sections++;
252b5132
RH		 3414 break;
3415 case 'd':
b34976b6 3416 do_dynamic++;
252b5132 3417 break;
a952a375 3418 case 'I':
b34976b6 3419 do_histogram++;
a952a375 3420 break;
779fe533 3421 case 'n':
b34976b6 3422 do_notes++;
779fe533 3423 break;
4145f1d5
NC		 3424 case 'c':
3425 do_archive_index++;
3426 break;
252b5132 3427 case 'x':
cf13d699 3428 request_dump (HEX_DUMP);
aef1f6d0 3429 break;
09c11c86 3430 case 'p':
cf13d699
NC		 3431 request_dump (STRING_DUMP);
3432 break;
3433 case 'R':
3434 request_dump (RELOC_DUMP);
09c11c86 3435 break;
252b5132 3436 case 'w':
b34976b6 3437 do_dump++;
252b5132 3438 if (optarg == 0)
613ff48b
CC		 3439 {
3440 do_debugging = 1;
3441 dwarf_select_sections_all ();
3442 }
252b5132
RH		 3443 else
3444 {
3445 do_debugging = 0;
4cb93e3b 3446 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 3447 }
3448 break;
2979dc34 3449 case OPTION_DEBUG_DUMP:
b34976b6 3450 do_dump++;
2979dc34
JJ		 3451 if (optarg == 0)
3452 do_debugging = 1;
3453 else
3454 {
2979dc34 3455 do_debugging = 0;
4cb93e3b 3456 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 3457 }
3458 break;
fd2f0033
TT		 3459 case OPTION_DWARF_DEPTH:
3460 {
3461 char *cp;
3462
3463 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3464 }
3465 break;
3466 case OPTION_DWARF_START:
3467 {
3468 char *cp;
3469
3470 dwarf_start_die = strtoul (optarg, & cp, 0);
3471 }
3472 break;
4723351a
CC		 3473 case OPTION_DWARF_CHECK:
3474 dwarf_check = 1;
3475 break;
2c610e4b
L		 3476 case OPTION_DYN_SYMS:
3477 do_dyn_syms++;
3478 break;
252b5132
RH		 3479#ifdef SUPPORT_DISASSEMBLY
3480 case 'i':
cf13d699
NC		 3481 request_dump (DISASS_DUMP);
3482 break;
252b5132
RH		 3483#endif
3484 case 'v':
3485 print_version (program_name);
3486 break;
3487 case 'V':
b34976b6 3488 do_version++;
252b5132 3489 break;
d974e256 3490 case 'W':
b34976b6 3491 do_wide++;
d974e256 3492 break;
252b5132 3493 default:
252b5132
RH		 3494 /* xgettext:c-format */
3495 error (_("Invalid option '-%c'\n"), c);
3496 /* Drop through. */
3497 case '?':
92f01d61 3498 usage (stderr);
252b5132
RH		 3499 }
3500 }
3501
4d6ed7c8 3502 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 3503 && !do_segments && !do_header && !do_dump && !do_version
f5842774 3504 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 3505 && !do_section_groups && !do_archive_index
3506 && !do_dyn_syms)
92f01d61 3507 usage (stderr);
252b5132
RH		 3508 else if (argc < 3)
3509 {
3510 warn (_("Nothing to do.\n"));
92f01d61 3511 usage (stderr);
252b5132
RH		 3512 }
3513}
3514
3515static const char *
d3ba0551 3516get_elf_class (unsigned int elf_class)
252b5132 3517{
b34976b6 3518 static char buff[32];
103f02d3 3519
252b5132
RH		 3520 switch (elf_class)
3521 {
3522 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 3523 case ELFCLASS32: return "ELF32";
3524 case ELFCLASS64: return "ELF64";
ab5e7794 3525 default:
e9e44622 3526 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 3527 return buff;
252b5132
RH		 3528 }
3529}
3530
3531static const char *
d3ba0551 3532get_data_encoding (unsigned int encoding)
252b5132 3533{
b34976b6 3534 static char buff[32];
103f02d3 3535
252b5132
RH		 3536 switch (encoding)
3537 {
3538 case ELFDATANONE: return _("none");
33c63f9d
CM		 3539 case ELFDATA2LSB: return _("2's complement, little endian");
3540 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 3541 default:
e9e44622 3542 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 3543 return buff;
252b5132
RH		 3544 }
3545}
3546
252b5132 3547/* Decode the data held in 'elf_header'. */
ee42cf8c 3548
252b5132 3549static int
d3ba0551 3550process_file_header (void)
252b5132 3551{
b34976b6
AM		 3552 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3553 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3554 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3555 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 3556 {
3557 error
3558 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3559 return 0;
3560 }
3561
2dc4cec1
L		 3562 init_dwarf_regnames (elf_header.e_machine);
3563
252b5132
RH		 3564 if (do_header)
3565 {
3566 int i;
3567
3568 printf (_("ELF Header:\n"));
3569 printf (_(" Magic: "));
b34976b6
AM		 3570 for (i = 0; i < EI_NIDENT; i++)
3571 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 3572 printf ("\n");
3573 printf (_(" Class: %s\n"),
b34976b6 3574 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 3575 printf (_(" Data: %s\n"),
b34976b6 3576 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 3577 printf (_(" Version: %d %s\n"),
b34976b6
AM		 3578 elf_header.e_ident[EI_VERSION],
3579 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 3580 ? "(current)"
b34976b6 3581 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 3582 ? _("<unknown: %lx>")
789be9f7 3583 : "")));
252b5132 3584 printf (_(" OS/ABI: %s\n"),
b34976b6 3585 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 3586 printf (_(" ABI Version: %d\n"),
b34976b6 3587 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 3588 printf (_(" Type: %s\n"),
3589 get_file_type (elf_header.e_type));
3590 printf (_(" Machine: %s\n"),
3591 get_machine_name (elf_header.e_machine));
3592 printf (_(" Version: 0x%lx\n"),
3593 (unsigned long) elf_header.e_version);
76da6bbe 3594
f7a99963
NC		 3595 printf (_(" Entry point address: "));
3596 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3597 printf (_("\n Start of program headers: "));
3598 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3599 printf (_(" (bytes into file)\n Start of section headers: "));
3600 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3601 printf (_(" (bytes into file)\n"));
76da6bbe 3602
252b5132
RH		 3603 printf (_(" Flags: 0x%lx%s\n"),
3604 (unsigned long) elf_header.e_flags,
3605 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3606 printf (_(" Size of this header: %ld (bytes)\n"),
3607 (long) elf_header.e_ehsize);
3608 printf (_(" Size of program headers: %ld (bytes)\n"),
3609 (long) elf_header.e_phentsize);
2046a35d 3610 printf (_(" Number of program headers: %ld"),
252b5132 3611 (long) elf_header.e_phnum);
2046a35d
AM		 3612 if (section_headers != NULL
3613 && elf_header.e_phnum == PN_XNUM
3614 && section_headers[0].sh_info != 0)
cc5914eb 3615 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 3616 putc ('\n', stdout);
252b5132
RH		 3617 printf (_(" Size of section headers: %ld (bytes)\n"),
3618 (long) elf_header.e_shentsize);
560f3c1c 3619 printf (_(" Number of section headers: %ld"),
252b5132 3620 (long) elf_header.e_shnum);
4fbb74a6 3621 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 3622 printf (" (%ld)", (long) section_headers[0].sh_size);
3623 putc ('\n', stdout);
3624 printf (_(" Section header string table index: %ld"),
252b5132 3625 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 3626 if (section_headers != NULL
3627 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 3628 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 3629 else if (elf_header.e_shstrndx != SHN_UNDEF
3630 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 3631 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 3632 putc ('\n', stdout);
3633 }
3634
3635 if (section_headers != NULL)
3636 {
2046a35d
AM		 3637 if (elf_header.e_phnum == PN_XNUM
3638 && section_headers[0].sh_info != 0)
3639 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 3640 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 3641 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 3642 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 3643 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 3644 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 3645 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 3646 free (section_headers);
3647 section_headers = NULL;
252b5132 3648 }
103f02d3 3649
9ea033b2
NC		 3650 return 1;
3651}
3652
252b5132 3653
9ea033b2 3654static int
91d6fa6a 3655get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3656{
2cf0635d
NC		 3657 Elf32_External_Phdr * phdrs;
3658 Elf32_External_Phdr * external;
3659 Elf_Internal_Phdr * internal;
b34976b6 3660 unsigned int i;
103f02d3 3661
3f5e193b
NC		 3662 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3663 elf_header.e_phentsize,
3664 elf_header.e_phnum,
3665 _("program headers"));
a6e9f9df
AM		 3666 if (!phdrs)
3667 return 0;
9ea033b2 3668
91d6fa6a 3669 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3670 i < elf_header.e_phnum;
b34976b6 3671 i++, internal++, external++)
252b5132 3672 {
9ea033b2
NC		 3673 internal->p_type = BYTE_GET (external->p_type);
3674 internal->p_offset = BYTE_GET (external->p_offset);
3675 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3676 internal->p_paddr = BYTE_GET (external->p_paddr);
3677 internal->p_filesz = BYTE_GET (external->p_filesz);
3678 internal->p_memsz = BYTE_GET (external->p_memsz);
3679 internal->p_flags = BYTE_GET (external->p_flags);
3680 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 3681 }
3682
9ea033b2
NC		 3683 free (phdrs);
3684
252b5132
RH		 3685 return 1;
3686}
3687
9ea033b2 3688static int
91d6fa6a 3689get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3690{
2cf0635d
NC		 3691 Elf64_External_Phdr * phdrs;
3692 Elf64_External_Phdr * external;
3693 Elf_Internal_Phdr * internal;
b34976b6 3694 unsigned int i;
103f02d3 3695
3f5e193b
NC		 3696 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3697 elf_header.e_phentsize,
3698 elf_header.e_phnum,
3699 _("program headers"));
a6e9f9df
AM		 3700 if (!phdrs)
3701 return 0;
9ea033b2 3702
91d6fa6a 3703 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3704 i < elf_header.e_phnum;
b34976b6 3705 i++, internal++, external++)
9ea033b2
NC		 3706 {
3707 internal->p_type = BYTE_GET (external->p_type);
3708 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 3709 internal->p_offset = BYTE_GET (external->p_offset);
3710 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3711 internal->p_paddr = BYTE_GET (external->p_paddr);
3712 internal->p_filesz = BYTE_GET (external->p_filesz);
3713 internal->p_memsz = BYTE_GET (external->p_memsz);
3714 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 3715 }
3716
3717 free (phdrs);
3718
3719 return 1;
3720}
252b5132 3721
d93f0186
NC		 3722/* Returns 1 if the program headers were read into `program_headers'. */
3723
3724static int
2cf0635d 3725get_program_headers (FILE * file)
d93f0186 3726{
2cf0635d 3727 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 3728
3729 /* Check cache of prior read. */
3730 if (program_headers != NULL)
3731 return 1;
3732
3f5e193b
NC		 3733 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3734 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 3735
3736 if (phdrs == NULL)
3737 {
3738 error (_("Out of memory\n"));
3739 return 0;
3740 }
3741
3742 if (is_32bit_elf
3743 ? get_32bit_program_headers (file, phdrs)
3744 : get_64bit_program_headers (file, phdrs))
3745 {
3746 program_headers = phdrs;
3747 return 1;
3748 }
3749
3750 free (phdrs);
3751 return 0;
3752}
3753
2f62977e
NC		 3754/* Returns 1 if the program headers were loaded. */
3755
252b5132 3756static int
2cf0635d 3757process_program_headers (FILE * file)
252b5132 3758{
2cf0635d 3759 Elf_Internal_Phdr * segment;
b34976b6 3760 unsigned int i;
252b5132
RH		 3761
3762 if (elf_header.e_phnum == 0)
3763 {
82f2dbf7
NC		 3764 /* PR binutils/12467. */
3765 if (elf_header.e_phoff != 0)
3766 warn (_("possibly corrupt ELF header - it has a non-zero program"
3767 " header offset, but no program headers"));
3768 else if (do_segments)
252b5132 3769 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 3770 return 0;
252b5132
RH		 3771 }
3772
3773 if (do_segments && !do_header)
3774 {
f7a99963
NC		 3775 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3776 printf (_("Entry point "));
3777 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3778 printf (_("\nThere are %d program headers, starting at offset "),
3779 elf_header.e_phnum);
3780 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3781 printf ("\n");
252b5132
RH		 3782 }
3783
d93f0186 3784 if (! get_program_headers (file))
252b5132 3785 return 0;
103f02d3 3786
252b5132
RH		 3787 if (do_segments)
3788 {
3a1a2036
NC		 3789 if (elf_header.e_phnum > 1)
3790 printf (_("\nProgram Headers:\n"));
3791 else
3792 printf (_("\nProgram Headers:\n"));
76da6bbe 3793
f7a99963
NC		 3794 if (is_32bit_elf)
3795 printf
3796 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 3797 else if (do_wide)
3798 printf
3799 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 3800 else
3801 {
3802 printf
3803 (_(" Type Offset VirtAddr PhysAddr\n"));
3804 printf
3805 (_(" FileSiz MemSiz Flags Align\n"));
3806 }
252b5132
RH		 3807 }
3808
252b5132 3809 dynamic_addr = 0;
1b228002 3810 dynamic_size = 0;
252b5132
RH		 3811
3812 for (i = 0, segment = program_headers;
3813 i < elf_header.e_phnum;
b34976b6 3814 i++, segment++)
252b5132
RH		 3815 {
3816 if (do_segments)
3817 {
103f02d3 3818 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 3819
3820 if (is_32bit_elf)
3821 {
3822 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3823 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3824 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3825 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3826 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3827 printf ("%c%c%c ",
3828 (segment->p_flags & PF_R ? 'R' : ' '),
3829 (segment->p_flags & PF_W ? 'W' : ' '),
3830 (segment->p_flags & PF_X ? 'E' : ' '));
3831 printf ("%#lx", (unsigned long) segment->p_align);
3832 }
d974e256
JJ		 3833 else if (do_wide)
3834 {
3835 if ((unsigned long) segment->p_offset == segment->p_offset)
3836 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3837 else
3838 {
3839 print_vma (segment->p_offset, FULL_HEX);
3840 putchar (' ');
3841 }
3842
3843 print_vma (segment->p_vaddr, FULL_HEX);
3844 putchar (' ');
3845 print_vma (segment->p_paddr, FULL_HEX);
3846 putchar (' ');
3847
3848 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3849 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3850 else
3851 {
3852 print_vma (segment->p_filesz, FULL_HEX);
3853 putchar (' ');
3854 }
3855
3856 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3857 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3858 else
3859 {
f48e6c45 3860 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 3861 }
3862
3863 printf (" %c%c%c ",
3864 (segment->p_flags & PF_R ? 'R' : ' '),
3865 (segment->p_flags & PF_W ? 'W' : ' '),
3866 (segment->p_flags & PF_X ? 'E' : ' '));
3867
3868 if ((unsigned long) segment->p_align == segment->p_align)
3869 printf ("%#lx", (unsigned long) segment->p_align);
3870 else
3871 {
3872 print_vma (segment->p_align, PREFIX_HEX);
3873 }
3874 }
f7a99963
NC		 3875 else
3876 {
3877 print_vma (segment->p_offset, FULL_HEX);
3878 putchar (' ');
3879 print_vma (segment->p_vaddr, FULL_HEX);
3880 putchar (' ');
3881 print_vma (segment->p_paddr, FULL_HEX);
3882 printf ("\n ");
3883 print_vma (segment->p_filesz, FULL_HEX);
3884 putchar (' ');
3885 print_vma (segment->p_memsz, FULL_HEX);
3886 printf (" %c%c%c ",
3887 (segment->p_flags & PF_R ? 'R' : ' '),
3888 (segment->p_flags & PF_W ? 'W' : ' '),
3889 (segment->p_flags & PF_X ? 'E' : ' '));
3890 print_vma (segment->p_align, HEX);
3891 }
252b5132
RH		 3892 }
3893
3894 switch (segment->p_type)
3895 {
252b5132
RH		 3896 case PT_DYNAMIC:
3897 if (dynamic_addr)
3898 error (_("more than one dynamic segment\n"));
3899
20737c13
AM		 3900 /* By default, assume that the .dynamic section is the first
3901 section in the DYNAMIC segment. */
3902 dynamic_addr = segment->p_offset;
3903 dynamic_size = segment->p_filesz;
3904
b2d38a17
NC		 3905 /* Try to locate the .dynamic section. If there is
3906 a section header table, we can easily locate it. */
3907 if (section_headers != NULL)
3908 {
2cf0635d 3909 Elf_Internal_Shdr * sec;
b2d38a17 3910
89fac5e3
RS		 3911 sec = find_section (".dynamic");
3912 if (sec == NULL || sec->sh_size == 0)
b2d38a17 3913 {
28f997cf
TG		 3914 /* A corresponding .dynamic section is expected, but on
3915 IA-64/OpenVMS it is OK for it to be missing. */
3916 if (!is_ia64_vms ())
3917 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 3918 break;
3919 }
3920
42bb2e33 3921 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 3922 {
3923 dynamic_size = 0;
3924 break;
3925 }
42bb2e33 3926
b2d38a17
NC		 3927 dynamic_addr = sec->sh_offset;
3928 dynamic_size = sec->sh_size;
3929
3930 if (dynamic_addr < segment->p_offset
3931 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 3932 warn (_("the .dynamic section is not contained"
3933 " within the dynamic segment\n"));
b2d38a17 3934 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 3935 warn (_("the .dynamic section is not the first section"
3936 " in the dynamic segment.\n"));
b2d38a17 3937 }
252b5132
RH		 3938 break;
3939
3940 case PT_INTERP:
fb52b2f4
NC		 3941 if (fseek (file, archive_file_offset + (long) segment->p_offset,
3942 SEEK_SET))
252b5132
RH		 3943 error (_("Unable to find program interpreter name\n"));
3944 else
3945 {
f8eae8b2
L		 3946 char fmt [32];
3947 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
3948
3949 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 3950 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 3951
252b5132 3952 program_interpreter[0] = 0;
7bd7b3ef
AM		 3953 if (fscanf (file, fmt, program_interpreter) <= 0)
3954 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 3955
3956 if (do_segments)
3957 printf (_("\n [Requesting program interpreter: %s]"),
3958 program_interpreter);
3959 }
3960 break;
3961 }
3962
3963 if (do_segments)
3964 putc ('\n', stdout);
3965 }
3966
c256ffe7 3967 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 3968 {
3969 printf (_("\n Section to Segment mapping:\n"));
3970 printf (_(" Segment Sections...\n"));
3971
252b5132
RH		 3972 for (i = 0; i < elf_header.e_phnum; i++)
3973 {
9ad5cbcf 3974 unsigned int j;
2cf0635d 3975 Elf_Internal_Shdr * section;
252b5132
RH		 3976
3977 segment = program_headers + i;
b391a3e3 3978 section = section_headers + 1;
252b5132
RH		 3979
3980 printf (" %2.2d ", i);
3981
b34976b6 3982 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 3983 {
f4638467
AM		 3984 if (!ELF_TBSS_SPECIAL (section, segment)
3985 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
252b5132
RH		 3986 printf ("%s ", SECTION_NAME (section));
3987 }
3988
3989 putc ('\n',stdout);
3990 }
3991 }
3992
252b5132
RH		 3993 return 1;
3994}
3995
3996
d93f0186
NC		 3997/* Find the file offset corresponding to VMA by using the program headers. */
3998
3999static long
2cf0635d 4000offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4001{
2cf0635d 4002 Elf_Internal_Phdr * seg;
d93f0186
NC		 4003
4004 if (! get_program_headers (file))
4005 {
4006 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4007 return (long) vma;
4008 }
4009
4010 for (seg = program_headers;
4011 seg < program_headers + elf_header.e_phnum;
4012 ++seg)
4013 {
4014 if (seg->p_type != PT_LOAD)
4015 continue;
4016
4017 if (vma >= (seg->p_vaddr & -seg->p_align)
4018 && vma + size <= seg->p_vaddr + seg->p_filesz)
4019 return vma - seg->p_vaddr + seg->p_offset;
4020 }
4021
4022 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4023 (unsigned long) vma);
d93f0186
NC		 4024 return (long) vma;
4025}
4026
4027
252b5132 4028static int
2cf0635d 4029get_32bit_section_headers (FILE * file, unsigned int num)
252b5132 4030{
2cf0635d
NC		 4031 Elf32_External_Shdr * shdrs;
4032 Elf_Internal_Shdr * internal;
b34976b6 4033 unsigned int i;
252b5132 4034
3f5e193b
NC		 4035 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4036 elf_header.e_shentsize, num,
4037 _("section headers"));
a6e9f9df
AM		 4038 if (!shdrs)
4039 return 0;
252b5132 4040
3f5e193b
NC		 4041 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4042 sizeof (Elf_Internal_Shdr));
252b5132
RH		 4043
4044 if (section_headers == NULL)
4045 {
4046 error (_("Out of memory\n"));
4047 return 0;
4048 }
4049
4050 for (i = 0, internal = section_headers;
560f3c1c 4051 i < num;
b34976b6 4052 i++, internal++)
252b5132
RH		 4053 {
4054 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4055 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4056 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4057 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4058 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4059 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4060 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4061 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4062 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4063 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4064 }
4065
4066 free (shdrs);
4067
4068 return 1;
4069}
4070
9ea033b2 4071static int
2cf0635d 4072get_64bit_section_headers (FILE * file, unsigned int num)
9ea033b2 4073{
2cf0635d
NC		 4074 Elf64_External_Shdr * shdrs;
4075 Elf_Internal_Shdr * internal;
b34976b6 4076 unsigned int i;
9ea033b2 4077
3f5e193b
NC		 4078 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4079 elf_header.e_shentsize, num,
4080 _("section headers"));
a6e9f9df
AM		 4081 if (!shdrs)
4082 return 0;
9ea033b2 4083
3f5e193b
NC		 4084 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4085 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4086
4087 if (section_headers == NULL)
4088 {
4089 error (_("Out of memory\n"));
4090 return 0;
4091 }
4092
4093 for (i = 0, internal = section_headers;
560f3c1c 4094 i < num;
b34976b6 4095 i++, internal++)
9ea033b2
NC		 4096 {
4097 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4098 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4099 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4100 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4101 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4102 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4103 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4104 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4105 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4106 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4107 }
4108
4109 free (shdrs);
4110
4111 return 1;
4112}
4113
252b5132 4114static Elf_Internal_Sym *
ba5cdace
NC		 4115get_32bit_elf_symbols (FILE * file,
4116 Elf_Internal_Shdr * section,
4117 unsigned long * num_syms_return)
252b5132 4118{
ba5cdace 4119 unsigned long number = 0;
dd24e3da 4120 Elf32_External_Sym * esyms = NULL;
ba5cdace 4121 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 4122 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4123 Elf_Internal_Sym * psym;
b34976b6 4124 unsigned int j;
252b5132 4125
dd24e3da
NC		 4126 /* Run some sanity checks first. */
4127 if (section->sh_entsize == 0)
4128 {
4129 error (_("sh_entsize is zero\n"));
ba5cdace 4130 goto exit_point;
dd24e3da
NC		 4131 }
4132
4133 number = section->sh_size / section->sh_entsize;
4134
4135 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4136 {
4137 error (_("Invalid sh_entsize\n"));
ba5cdace 4138 goto exit_point;
dd24e3da
NC		 4139 }
4140
3f5e193b
NC		 4141 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4142 section->sh_size, _("symbols"));
dd24e3da 4143 if (esyms == NULL)
ba5cdace 4144 goto exit_point;
252b5132 4145
9ad5cbcf
AM		 4146 shndx = NULL;
4147 if (symtab_shndx_hdr != NULL
4148 && (symtab_shndx_hdr->sh_link
4fbb74a6 4149 == (unsigned long) (section - section_headers)))
9ad5cbcf 4150 {
3f5e193b
NC		 4151 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4152 symtab_shndx_hdr->sh_offset,
4153 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4154 _("symbol table section indicies"));
dd24e3da
NC		 4155 if (shndx == NULL)
4156 goto exit_point;
9ad5cbcf
AM		 4157 }
4158
3f5e193b 4159 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 4160
4161 if (isyms == NULL)
4162 {
4163 error (_("Out of memory\n"));
dd24e3da 4164 goto exit_point;
252b5132
RH		 4165 }
4166
dd24e3da 4167 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 4168 {
4169 psym->st_name = BYTE_GET (esyms[j].st_name);
4170 psym->st_value = BYTE_GET (esyms[j].st_value);
4171 psym->st_size = BYTE_GET (esyms[j].st_size);
4172 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4173 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4174 psym->st_shndx
4175 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4176 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4177 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 4178 psym->st_info = BYTE_GET (esyms[j].st_info);
4179 psym->st_other = BYTE_GET (esyms[j].st_other);
4180 }
4181
dd24e3da 4182 exit_point:
ba5cdace 4183 if (shndx != NULL)
9ad5cbcf 4184 free (shndx);
ba5cdace 4185 if (esyms != NULL)
dd24e3da 4186 free (esyms);
252b5132 4187
ba5cdace
NC		 4188 if (num_syms_return != NULL)
4189 * num_syms_return = isyms == NULL ? 0 : number;
4190
252b5132
RH		 4191 return isyms;
4192}
4193
9ea033b2 4194static Elf_Internal_Sym *
ba5cdace
NC		 4195get_64bit_elf_symbols (FILE * file,
4196 Elf_Internal_Shdr * section,
4197 unsigned long * num_syms_return)
9ea033b2 4198{
ba5cdace
NC		 4199 unsigned long number = 0;
4200 Elf64_External_Sym * esyms = NULL;
4201 Elf_External_Sym_Shndx * shndx = NULL;
4202 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4203 Elf_Internal_Sym * psym;
b34976b6 4204 unsigned int j;
9ea033b2 4205
dd24e3da
NC		 4206 /* Run some sanity checks first. */
4207 if (section->sh_entsize == 0)
4208 {
4209 error (_("sh_entsize is zero\n"));
ba5cdace 4210 goto exit_point;
dd24e3da
NC		 4211 }
4212
4213 number = section->sh_size / section->sh_entsize;
4214
4215 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4216 {
4217 error (_("Invalid sh_entsize\n"));
ba5cdace 4218 goto exit_point;
dd24e3da
NC		 4219 }
4220
3f5e193b
NC		 4221 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4222 section->sh_size, _("symbols"));
a6e9f9df 4223 if (!esyms)
ba5cdace 4224 goto exit_point;
9ea033b2 4225
9ad5cbcf
AM		 4226 if (symtab_shndx_hdr != NULL
4227 && (symtab_shndx_hdr->sh_link
4fbb74a6 4228 == (unsigned long) (section - section_headers)))
9ad5cbcf 4229 {
3f5e193b
NC		 4230 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4231 symtab_shndx_hdr->sh_offset,
4232 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4233 _("symbol table section indicies"));
ba5cdace
NC		 4234 if (shndx == NULL)
4235 goto exit_point;
9ad5cbcf
AM		 4236 }
4237
3f5e193b 4238 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 4239
4240 if (isyms == NULL)
4241 {
4242 error (_("Out of memory\n"));
ba5cdace 4243 goto exit_point;
9ea033b2
NC		 4244 }
4245
ba5cdace 4246 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 4247 {
4248 psym->st_name = BYTE_GET (esyms[j].st_name);
4249 psym->st_info = BYTE_GET (esyms[j].st_info);
4250 psym->st_other = BYTE_GET (esyms[j].st_other);
4251 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 4252
4fbb74a6 4253 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4254 psym->st_shndx
4255 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4256 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4257 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 4258
66543521
AM		 4259 psym->st_value = BYTE_GET (esyms[j].st_value);
4260 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 4261 }
4262
ba5cdace
NC		 4263 exit_point:
4264 if (shndx != NULL)
9ad5cbcf 4265 free (shndx);
ba5cdace
NC		 4266 if (esyms != NULL)
4267 free (esyms);
4268
4269 if (num_syms_return != NULL)
4270 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 4271
4272 return isyms;
4273}
4274
d1133906 4275static const char *
d3ba0551 4276get_elf_section_flags (bfd_vma sh_flags)
d1133906 4277{
5477e8a0 4278 static char buff[1024];
2cf0635d 4279 char * p = buff;
8d5ff12c 4280 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 4281 int sindex;
4282 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 4283 bfd_vma os_flags = 0;
4284 bfd_vma proc_flags = 0;
4285 bfd_vma unknown_flags = 0;
148b93f2 4286 static const struct
5477e8a0 4287 {
2cf0635d 4288 const char * str;
5477e8a0
L		 4289 int len;
4290 }
4291 flags [] =
4292 {
cfcac11d
NC		 4293 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4294 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4295 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4296 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4297 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4298 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4299 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4300 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4301 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4302 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4303 /* IA-64 specific. */
4304 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4305 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4306 /* IA-64 OpenVMS specific. */
4307 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4308 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4309 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4310 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4311 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4312 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 4313 /* Generic. */
cfcac11d 4314 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 4315 /* SPARC specific. */
cfcac11d 4316 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5477e8a0
L		 4317 };
4318
4319 if (do_section_details)
4320 {
8d5ff12c
L		 4321 sprintf (buff, "[%*.*lx]: ",
4322 field_size, field_size, (unsigned long) sh_flags);
4323 p += field_size + 4;
5477e8a0 4324 }
76da6bbe 4325
d1133906
NC		 4326 while (sh_flags)
4327 {
4328 bfd_vma flag;
4329
4330 flag = sh_flags & - sh_flags;
4331 sh_flags &= ~ flag;
76da6bbe 4332
5477e8a0 4333 if (do_section_details)
d1133906 4334 {
5477e8a0
L		 4335 switch (flag)
4336 {
91d6fa6a
NC		 4337 case SHF_WRITE: sindex = 0; break;
4338 case SHF_ALLOC: sindex = 1; break;
4339 case SHF_EXECINSTR: sindex = 2; break;
4340 case SHF_MERGE: sindex = 3; break;
4341 case SHF_STRINGS: sindex = 4; break;
4342 case SHF_INFO_LINK: sindex = 5; break;
4343 case SHF_LINK_ORDER: sindex = 6; break;
4344 case SHF_OS_NONCONFORMING: sindex = 7; break;
4345 case SHF_GROUP: sindex = 8; break;
4346 case SHF_TLS: sindex = 9; break;
18ae9cc1 4347 case SHF_EXCLUDE: sindex = 18; break;
76da6bbe 4348
5477e8a0 4349 default:
91d6fa6a 4350 sindex = -1;
cfcac11d 4351 switch (elf_header.e_machine)
148b93f2 4352 {
cfcac11d 4353 case EM_IA_64:
148b93f2 4354 if (flag == SHF_IA_64_SHORT)
91d6fa6a 4355 sindex = 10;
148b93f2 4356 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 4357 sindex = 11;
148b93f2
NC		 4358#ifdef BFD64
4359 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4360 switch (flag)
4361 {
91d6fa6a
NC		 4362 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4363 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4364 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4365 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4366 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4367 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 4368 default: break;
4369 }
4370#endif
cfcac11d
NC		 4371 break;
4372
caa83f8b
NC		 4373 case EM_386:
4374 case EM_486:
4375 case EM_X86_64:
7f502d6c 4376 case EM_L1OM:
7a9068fe 4377 case EM_K1OM:
cfcac11d
NC		 4378 case EM_OLD_SPARCV9:
4379 case EM_SPARC32PLUS:
4380 case EM_SPARCV9:
4381 case EM_SPARC:
18ae9cc1 4382 if (flag == SHF_ORDERED)
91d6fa6a 4383 sindex = 19;
cfcac11d
NC		 4384 break;
4385 default:
4386 break;
148b93f2 4387 }
5477e8a0
L		 4388 }
4389
91d6fa6a 4390 if (sindex != -1)
5477e8a0 4391 {
8d5ff12c
L		 4392 if (p != buff + field_size + 4)
4393 {
4394 if (size < (10 + 2))
4395 abort ();
4396 size -= 2;
4397 *p++ = ',';
4398 *p++ = ' ';
4399 }
4400
91d6fa6a
NC		 4401 size -= flags [sindex].len;
4402 p = stpcpy (p, flags [sindex].str);
5477e8a0 4403 }
3b22753a 4404 else if (flag & SHF_MASKOS)
8d5ff12c 4405 os_flags |= flag;
d1133906 4406 else if (flag & SHF_MASKPROC)
8d5ff12c 4407 proc_flags |= flag;
d1133906 4408 else
8d5ff12c 4409 unknown_flags |= flag;
5477e8a0
L		 4410 }
4411 else
4412 {
4413 switch (flag)
4414 {
4415 case SHF_WRITE: *p = 'W'; break;
4416 case SHF_ALLOC: *p = 'A'; break;
4417 case SHF_EXECINSTR: *p = 'X'; break;
4418 case SHF_MERGE: *p = 'M'; break;
4419 case SHF_STRINGS: *p = 'S'; break;
4420 case SHF_INFO_LINK: *p = 'I'; break;
4421 case SHF_LINK_ORDER: *p = 'L'; break;
4422 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4423 case SHF_GROUP: *p = 'G'; break;
4424 case SHF_TLS: *p = 'T'; break;
18ae9cc1 4425 case SHF_EXCLUDE: *p = 'E'; break;
5477e8a0
L		 4426
4427 default:
8a9036a4 4428 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 4429 || elf_header.e_machine == EM_L1OM
4430 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 4431 && flag == SHF_X86_64_LARGE)
4432 *p = 'l';
4433 else if (flag & SHF_MASKOS)
4434 {
4435 *p = 'o';
4436 sh_flags &= ~ SHF_MASKOS;
4437 }
4438 else if (flag & SHF_MASKPROC)
4439 {
4440 *p = 'p';
4441 sh_flags &= ~ SHF_MASKPROC;
4442 }
4443 else
4444 *p = 'x';
4445 break;
4446 }
4447 p++;
d1133906
NC		 4448 }
4449 }
76da6bbe 4450
8d5ff12c
L		 4451 if (do_section_details)
4452 {
4453 if (os_flags)
4454 {
4455 size -= 5 + field_size;
4456 if (p != buff + field_size + 4)
4457 {
4458 if (size < (2 + 1))
4459 abort ();
4460 size -= 2;
4461 *p++ = ',';
4462 *p++ = ' ';
4463 }
4464 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4465 (unsigned long) os_flags);
4466 p += 5 + field_size;
4467 }
4468 if (proc_flags)
4469 {
4470 size -= 7 + field_size;
4471 if (p != buff + field_size + 4)
4472 {
4473 if (size < (2 + 1))
4474 abort ();
4475 size -= 2;
4476 *p++ = ',';
4477 *p++ = ' ';
4478 }
4479 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4480 (unsigned long) proc_flags);
4481 p += 7 + field_size;
4482 }
4483 if (unknown_flags)
4484 {
4485 size -= 10 + field_size;
4486 if (p != buff + field_size + 4)
4487 {
4488 if (size < (2 + 1))
4489 abort ();
4490 size -= 2;
4491 *p++ = ',';
4492 *p++ = ' ';
4493 }
2b692964 4494 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 4495 (unsigned long) unknown_flags);
4496 p += 10 + field_size;
4497 }
4498 }
4499
e9e44622 4500 *p = '\0';
d1133906
NC		 4501 return buff;
4502}
4503
252b5132 4504static int
2cf0635d 4505process_section_headers (FILE * file)
252b5132 4506{
2cf0635d 4507 Elf_Internal_Shdr * section;
b34976b6 4508 unsigned int i;
252b5132
RH		 4509
4510 section_headers = NULL;
4511
4512 if (elf_header.e_shnum == 0)
4513 {
82f2dbf7
NC		 4514 /* PR binutils/12467. */
4515 if (elf_header.e_shoff != 0)
4516 warn (_("possibly corrupt ELF file header - it has a non-zero"
4517 " section header offset, but no section headers\n"));
4518 else if (do_sections)
252b5132
RH		 4519 printf (_("\nThere are no sections in this file.\n"));
4520
4521 return 1;
4522 }
4523
4524 if (do_sections && !do_header)
9ea033b2 4525 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 4526 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4527
9ea033b2
NC		 4528 if (is_32bit_elf)
4529 {
560f3c1c 4530 if (! get_32bit_section_headers (file, elf_header.e_shnum))
9ea033b2
NC		 4531 return 0;
4532 }
560f3c1c 4533 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
252b5132
RH		 4534 return 0;
4535
4536 /* Read in the string table, so that we have names to display. */
0b49d371 4537 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 4538 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 4539 {
4fbb74a6 4540 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 4541
c256ffe7
JJ		 4542 if (section->sh_size != 0)
4543 {
3f5e193b
NC		 4544 string_table = (char *) get_data (NULL, file, section->sh_offset,
4545 1, section->sh_size,
4546 _("string table"));
0de14b54 4547
c256ffe7
JJ		 4548 string_table_length = string_table != NULL ? section->sh_size : 0;
4549 }
252b5132
RH		 4550 }
4551
4552 /* Scan the sections for the dynamic symbol table
e3c8793a 4553 and dynamic string table and debug sections. */
252b5132
RH		 4554 dynamic_symbols = NULL;
4555 dynamic_strings = NULL;
4556 dynamic_syminfo = NULL;
f1ef08cb 4557 symtab_shndx_hdr = NULL;
103f02d3 4558
89fac5e3
RS		 4559 eh_addr_size = is_32bit_elf ? 4 : 8;
4560 switch (elf_header.e_machine)
4561 {
4562 case EM_MIPS:
4563 case EM_MIPS_RS3_LE:
4564 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4565 FDE addresses. However, the ABI also has a semi-official ILP32
4566 variant for which the normal FDE address size rules apply.
4567
4568 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4569 section, where XX is the size of longs in bits. Unfortunately,
4570 earlier compilers provided no way of distinguishing ILP32 objects
4571 from LP64 objects, so if there's any doubt, we should assume that
4572 the official LP64 form is being used. */
4573 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4574 && find_section (".gcc_compiled_long32") == NULL)
4575 eh_addr_size = 8;
4576 break;
0f56a26a
DD		 4577
4578 case EM_H8_300:
4579 case EM_H8_300H:
4580 switch (elf_header.e_flags & EF_H8_MACH)
4581 {
4582 case E_H8_MACH_H8300:
4583 case E_H8_MACH_H8300HN:
4584 case E_H8_MACH_H8300SN:
4585 case E_H8_MACH_H8300SXN:
4586 eh_addr_size = 2;
4587 break;
4588 case E_H8_MACH_H8300H:
4589 case E_H8_MACH_H8300S:
4590 case E_H8_MACH_H8300SX:
4591 eh_addr_size = 4;
4592 break;
4593 }
f4236fe4
DD		 4594 break;
4595
ff7eeb89 4596 case EM_M32C_OLD:
f4236fe4
DD		 4597 case EM_M32C:
4598 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4599 {
4600 case EF_M32C_CPU_M16C:
4601 eh_addr_size = 2;
4602 break;
4603 }
4604 break;
89fac5e3
RS		 4605 }
4606
08d8fa11
JJ		 4607#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4608 do \
4609 { \
4610 size_t expected_entsize \
4611 = is_32bit_elf ? size32 : size64; \
4612 if (section->sh_entsize != expected_entsize) \
4613 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4614 i, (unsigned long int) section->sh_entsize, \
4615 (unsigned long int) expected_entsize); \
4616 section->sh_entsize = expected_entsize; \
4617 } \
4618 while (0)
4619#define CHECK_ENTSIZE(section, i, type) \
4620 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4621 sizeof (Elf64_External_##type))
4622
252b5132
RH		 4623 for (i = 0, section = section_headers;
4624 i < elf_header.e_shnum;
b34976b6 4625 i++, section++)
252b5132 4626 {
2cf0635d 4627 char * name = SECTION_NAME (section);
252b5132
RH		 4628
4629 if (section->sh_type == SHT_DYNSYM)
4630 {
4631 if (dynamic_symbols != NULL)
4632 {
4633 error (_("File contains multiple dynamic symbol tables\n"));
4634 continue;
4635 }
4636
08d8fa11 4637 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 4638 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 4639 }
4640 else if (section->sh_type == SHT_STRTAB
18bd398b 4641 && streq (name, ".dynstr"))
252b5132
RH		 4642 {
4643 if (dynamic_strings != NULL)
4644 {
4645 error (_("File contains multiple dynamic string tables\n"));
4646 continue;
4647 }
4648
3f5e193b
NC		 4649 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4650 1, section->sh_size,
4651 _("dynamic strings"));
59245841 4652 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 4653 }
9ad5cbcf
AM		 4654 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4655 {
4656 if (symtab_shndx_hdr != NULL)
4657 {
4658 error (_("File contains multiple symtab shndx tables\n"));
4659 continue;
4660 }
4661 symtab_shndx_hdr = section;
4662 }
08d8fa11
JJ		 4663 else if (section->sh_type == SHT_SYMTAB)
4664 CHECK_ENTSIZE (section, i, Sym);
4665 else if (section->sh_type == SHT_GROUP)
4666 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4667 else if (section->sh_type == SHT_REL)
4668 CHECK_ENTSIZE (section, i, Rel);
4669 else if (section->sh_type == SHT_RELA)
4670 CHECK_ENTSIZE (section, i, Rela);
252b5132 4671 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 4672 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 4673 || do_debug_aranges || do_debug_frames || do_debug_macinfo
a262ae96 4674 || do_debug_str || do_debug_loc || do_debug_ranges)
1b315056
CS		 4675 && (const_strneq (name, ".debug_")
4676 || const_strneq (name, ".zdebug_")))
252b5132 4677 {
1b315056
CS		 4678 if (name[1] == 'z')
4679 name += sizeof (".zdebug_") - 1;
4680 else
4681 name += sizeof (".debug_") - 1;
252b5132
RH		 4682
4683 if (do_debugging
4723351a
CC		 4684 || (do_debug_info && const_strneq (name, "info"))
4685 || (do_debug_info && const_strneq (name, "types"))
4686 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
4687 || (do_debug_lines && const_strneq (name, "line"))
4688 || (do_debug_pubnames && const_strneq (name, "pubnames"))
4689 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
4690 || (do_debug_aranges && const_strneq (name, "aranges"))
4691 || (do_debug_ranges && const_strneq (name, "ranges"))
4692 || (do_debug_frames && const_strneq (name, "frame"))
4693 || (do_debug_macinfo && const_strneq (name, "macinfo"))
4694 || (do_debug_macinfo && const_strneq (name, "macro"))
4695 || (do_debug_str && const_strneq (name, "str"))
4696 || (do_debug_loc && const_strneq (name, "loc"))
252b5132 4697 )
09c11c86 4698 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 4699 }
a262ae96 4700 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 4701 else if ((do_debugging || do_debug_info)
0112cd26 4702 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 4703 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 4704 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 4705 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 4706 else if (do_gdb_index && streq (name, ".gdb_index"))
4707 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 4708 /* Trace sections for Itanium VMS. */
4709 else if ((do_debugging || do_trace_info || do_trace_abbrevs
4710 || do_trace_aranges)
4711 && const_strneq (name, ".trace_"))
4712 {
4713 name += sizeof (".trace_") - 1;
4714
4715 if (do_debugging
4716 || (do_trace_info && streq (name, "info"))
4717 || (do_trace_abbrevs && streq (name, "abbrev"))
4718 || (do_trace_aranges && streq (name, "aranges"))
4719 )
4720 request_dump_bynumber (i, DEBUG_DUMP);
4721 }
4722
252b5132
RH		 4723 }
4724
4725 if (! do_sections)
4726 return 1;
4727
3a1a2036
NC		 4728 if (elf_header.e_shnum > 1)
4729 printf (_("\nSection Headers:\n"));
4730 else
4731 printf (_("\nSection Header:\n"));
76da6bbe 4732
f7a99963 4733 if (is_32bit_elf)
595cf52e 4734 {
5477e8a0 4735 if (do_section_details)
595cf52e
L		 4736 {
4737 printf (_(" [Nr] Name\n"));
5477e8a0 4738 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 4739 }
4740 else
4741 printf
4742 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4743 }
d974e256 4744 else if (do_wide)
595cf52e 4745 {
5477e8a0 4746 if (do_section_details)
595cf52e
L		 4747 {
4748 printf (_(" [Nr] Name\n"));
5477e8a0 4749 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 4750 }
4751 else
4752 printf
4753 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4754 }
f7a99963
NC		 4755 else
4756 {
5477e8a0 4757 if (do_section_details)
595cf52e
L		 4758 {
4759 printf (_(" [Nr] Name\n"));
5477e8a0
L		 4760 printf (_(" Type Address Offset Link\n"));
4761 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 4762 }
4763 else
4764 {
4765 printf (_(" [Nr] Name Type Address Offset\n"));
4766 printf (_(" Size EntSize Flags Link Info Align\n"));
4767 }
f7a99963 4768 }
252b5132 4769
5477e8a0
L		 4770 if (do_section_details)
4771 printf (_(" Flags\n"));
4772
252b5132
RH		 4773 for (i = 0, section = section_headers;
4774 i < elf_header.e_shnum;
b34976b6 4775 i++, section++)
252b5132 4776 {
7bfd842d 4777 printf (" [%2u] ", i);
5477e8a0 4778 if (do_section_details)
595cf52e 4779 {
7bfd842d 4780 print_symbol (INT_MAX, SECTION_NAME (section));
ea52a088 4781 printf ("\n ");
595cf52e
L		 4782 }
4783 else
7bfd842d
NC		 4784 {
4785 print_symbol (-17, SECTION_NAME (section));
7bfd842d 4786 }
ea52a088
NC		 4787
4788 printf (do_wide ? " %-15s " : " %-15.15s ",
4789 get_section_type_name (section->sh_type));
4790
f7a99963
NC		 4791 if (is_32bit_elf)
4792 {
cfcac11d
NC		 4793 const char * link_too_big = NULL;
4794
f7a99963 4795 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 4796
f7a99963
NC		 4797 printf ( " %6.6lx %6.6lx %2.2lx",
4798 (unsigned long) section->sh_offset,
4799 (unsigned long) section->sh_size,
4800 (unsigned long) section->sh_entsize);
d1133906 4801
5477e8a0
L		 4802 if (do_section_details)
4803 fputs (" ", stdout);
4804 else
4805 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 4806
cfcac11d
NC		 4807 if (section->sh_link >= elf_header.e_shnum)
4808 {
4809 link_too_big = "";
4810 /* The sh_link value is out of range. Normally this indicates
caa83f8b 4811 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 4812 switch (elf_header.e_machine)
4813 {
caa83f8b
NC		 4814 case EM_386:
4815 case EM_486:
4816 case EM_X86_64:
7f502d6c 4817 case EM_L1OM:
7a9068fe 4818 case EM_K1OM:
cfcac11d
NC		 4819 case EM_OLD_SPARCV9:
4820 case EM_SPARC32PLUS:
4821 case EM_SPARCV9:
4822 case EM_SPARC:
4823 if (section->sh_link == (SHN_BEFORE & 0xffff))
4824 link_too_big = "BEFORE";
4825 else if (section->sh_link == (SHN_AFTER & 0xffff))
4826 link_too_big = "AFTER";
4827 break;
4828 default:
4829 break;
4830 }
4831 }
4832
4833 if (do_section_details)
4834 {
4835 if (link_too_big != NULL && * link_too_big)
4836 printf ("<%s> ", link_too_big);
4837 else
4838 printf ("%2u ", section->sh_link);
4839 printf ("%3u %2lu\n", section->sh_info,
4840 (unsigned long) section->sh_addralign);
4841 }
4842 else
4843 printf ("%2u %3u %2lu\n",
4844 section->sh_link,
4845 section->sh_info,
4846 (unsigned long) section->sh_addralign);
4847
4848 if (link_too_big && ! * link_too_big)
4849 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4850 i, section->sh_link);
f7a99963 4851 }
d974e256
JJ		 4852 else if (do_wide)
4853 {
4854 print_vma (section->sh_addr, LONG_HEX);
4855
4856 if ((long) section->sh_offset == section->sh_offset)
4857 printf (" %6.6lx", (unsigned long) section->sh_offset);
4858 else
4859 {
4860 putchar (' ');
4861 print_vma (section->sh_offset, LONG_HEX);
4862 }
4863
4864 if ((unsigned long) section->sh_size == section->sh_size)
4865 printf (" %6.6lx", (unsigned long) section->sh_size);
4866 else
4867 {
4868 putchar (' ');
4869 print_vma (section->sh_size, LONG_HEX);
4870 }
4871
4872 if ((unsigned long) section->sh_entsize == section->sh_entsize)
4873 printf (" %2.2lx", (unsigned long) section->sh_entsize);
4874 else
4875 {
4876 putchar (' ');
4877 print_vma (section->sh_entsize, LONG_HEX);
4878 }
4879
5477e8a0
L		 4880 if (do_section_details)
4881 fputs (" ", stdout);
4882 else
4883 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 4884
72de5009 4885 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 4886
4887 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 4888 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 4889 else
4890 {
4891 print_vma (section->sh_addralign, DEC);
4892 putchar ('\n');
4893 }
4894 }
5477e8a0 4895 else if (do_section_details)
595cf52e 4896 {
5477e8a0 4897 printf (" %-15.15s ",
595cf52e 4898 get_section_type_name (section->sh_type));
595cf52e
L		 4899 print_vma (section->sh_addr, LONG_HEX);
4900 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 4901 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 4902 else
4903 {
4904 printf (" ");
4905 print_vma (section->sh_offset, LONG_HEX);
4906 }
72de5009 4907 printf (" %u\n ", section->sh_link);
595cf52e 4908 print_vma (section->sh_size, LONG_HEX);
5477e8a0 4909 putchar (' ');
595cf52e
L		 4910 print_vma (section->sh_entsize, LONG_HEX);
4911
72de5009
AM		 4912 printf (" %-16u %lu\n",
4913 section->sh_info,
595cf52e
L		 4914 (unsigned long) section->sh_addralign);
4915 }
f7a99963
NC		 4916 else
4917 {
4918 putchar (' ');
4919 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 4920 if ((long) section->sh_offset == section->sh_offset)
4921 printf (" %8.8lx", (unsigned long) section->sh_offset);
4922 else
4923 {
4924 printf (" ");
4925 print_vma (section->sh_offset, LONG_HEX);
4926 }
f7a99963
NC		 4927 printf ("\n ");
4928 print_vma (section->sh_size, LONG_HEX);
4929 printf (" ");
4930 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 4931
d1133906 4932 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 4933
72de5009
AM		 4934 printf (" %2u %3u %lu\n",
4935 section->sh_link,
4936 section->sh_info,
f7a99963
NC		 4937 (unsigned long) section->sh_addralign);
4938 }
5477e8a0
L		 4939
4940 if (do_section_details)
4941 printf (" %s\n", get_elf_section_flags (section->sh_flags));
252b5132
RH		 4942 }
4943
5477e8a0 4944 if (!do_section_details)
3dbcc61d
NC		 4945 {
4946 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 4947 || elf_header.e_machine == EM_L1OM
4948 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 4949 printf (_("Key to Flags:\n\
4950 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
4951 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4952 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4953 else
4954 printf (_("Key to Flags:\n\
e3c8793a 4955 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 4956 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 4957 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3dbcc61d 4958 }
d1133906 4959
252b5132
RH		 4960 return 1;
4961}
4962
f5842774
L		 4963static const char *
4964get_group_flags (unsigned int flags)
4965{
4966 static char buff[32];
4967 switch (flags)
4968 {
220453ec
AM		 4969 case 0:
4970 return "";
4971
f5842774 4972 case GRP_COMDAT:
220453ec 4973 return "COMDAT ";
f5842774
L		 4974
4975 default:
220453ec 4976 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 4977 break;
4978 }
4979 return buff;
4980}
4981
4982static int
2cf0635d 4983process_section_groups (FILE * file)
f5842774 4984{
2cf0635d 4985 Elf_Internal_Shdr * section;
f5842774 4986 unsigned int i;
2cf0635d
NC		 4987 struct group * group;
4988 Elf_Internal_Shdr * symtab_sec;
4989 Elf_Internal_Shdr * strtab_sec;
4990 Elf_Internal_Sym * symtab;
ba5cdace 4991 unsigned long num_syms;
2cf0635d 4992 char * strtab;
c256ffe7 4993 size_t strtab_size;
d1f5c6e3
L		 4994
4995 /* Don't process section groups unless needed. */
4996 if (!do_unwind && !do_section_groups)
4997 return 1;
f5842774
L		 4998
4999 if (elf_header.e_shnum == 0)
5000 {
5001 if (do_section_groups)
82f2dbf7 5002 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 5003
5004 return 1;
5005 }
5006
5007 if (section_headers == NULL)
5008 {
5009 error (_("Section headers are not available!\n"));
fa1908fd
NC		 5010 /* PR 13622: This can happen with a corrupt ELF header. */
5011 return 0;
f5842774
L		 5012 }
5013
3f5e193b
NC		 5014 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5015 sizeof (struct group *));
e4b17d5c
L		 5016
5017 if (section_headers_groups == NULL)
5018 {
5019 error (_("Out of memory\n"));
5020 return 0;
5021 }
5022
f5842774 5023 /* Scan the sections for the group section. */
d1f5c6e3 5024 group_count = 0;
f5842774
L		 5025 for (i = 0, section = section_headers;
5026 i < elf_header.e_shnum;
5027 i++, section++)
e4b17d5c
L		 5028 if (section->sh_type == SHT_GROUP)
5029 group_count++;
5030
d1f5c6e3
L		 5031 if (group_count == 0)
5032 {
5033 if (do_section_groups)
5034 printf (_("\nThere are no section groups in this file.\n"));
5035
5036 return 1;
5037 }
5038
3f5e193b 5039 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 5040
5041 if (section_groups == NULL)
5042 {
5043 error (_("Out of memory\n"));
5044 return 0;
5045 }
5046
d1f5c6e3
L		 5047 symtab_sec = NULL;
5048 strtab_sec = NULL;
5049 symtab = NULL;
ba5cdace 5050 num_syms = 0;
d1f5c6e3 5051 strtab = NULL;
c256ffe7 5052 strtab_size = 0;
e4b17d5c
L		 5053 for (i = 0, section = section_headers, group = section_groups;
5054 i < elf_header.e_shnum;
5055 i++, section++)
f5842774
L		 5056 {
5057 if (section->sh_type == SHT_GROUP)
5058 {
2cf0635d
NC		 5059 char * name = SECTION_NAME (section);
5060 char * group_name;
5061 unsigned char * start;
5062 unsigned char * indices;
f5842774 5063 unsigned int entry, j, size;
2cf0635d
NC		 5064 Elf_Internal_Shdr * sec;
5065 Elf_Internal_Sym * sym;
f5842774
L		 5066
5067 /* Get the symbol table. */
4fbb74a6
AM		 5068 if (section->sh_link >= elf_header.e_shnum
5069 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 5070 != SHT_SYMTAB))
f5842774
L		 5071 {
5072 error (_("Bad sh_link in group section `%s'\n"), name);
5073 continue;
5074 }
d1f5c6e3
L		 5075
5076 if (symtab_sec != sec)
5077 {
5078 symtab_sec = sec;
5079 if (symtab)
5080 free (symtab);
ba5cdace 5081 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 5082 }
f5842774 5083
dd24e3da
NC		 5084 if (symtab == NULL)
5085 {
5086 error (_("Corrupt header in group section `%s'\n"), name);
5087 continue;
5088 }
5089
ba5cdace
NC		 5090 if (section->sh_info >= num_syms)
5091 {
5092 error (_("Bad sh_info in group section `%s'\n"), name);
5093 continue;
5094 }
5095
f5842774
L		 5096 sym = symtab + section->sh_info;
5097
5098 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5099 {
4fbb74a6
AM		 5100 if (sym->st_shndx == 0
5101 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 5102 {
5103 error (_("Bad sh_info in group section `%s'\n"), name);
5104 continue;
5105 }
ba2685cc 5106
4fbb74a6 5107 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 5108 strtab_sec = NULL;
5109 if (strtab)
5110 free (strtab);
f5842774 5111 strtab = NULL;
c256ffe7 5112 strtab_size = 0;
f5842774
L		 5113 }
5114 else
5115 {
5116 /* Get the string table. */
4fbb74a6 5117 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 5118 {
5119 strtab_sec = NULL;
5120 if (strtab)
5121 free (strtab);
5122 strtab = NULL;
5123 strtab_size = 0;
5124 }
5125 else if (strtab_sec
4fbb74a6 5126 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 5127 {
5128 strtab_sec = sec;
5129 if (strtab)
5130 free (strtab);
3f5e193b
NC		 5131 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5132 1, strtab_sec->sh_size,
5133 _("string table"));
c256ffe7 5134 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 5135 }
c256ffe7 5136 group_name = sym->st_name < strtab_size
2b692964 5137 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 5138 }
5139
3f5e193b
NC		 5140 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5141 1, section->sh_size,
5142 _("section data"));
59245841
NC		 5143 if (start == NULL)
5144 continue;
f5842774
L		 5145
5146 indices = start;
5147 size = (section->sh_size / section->sh_entsize) - 1;
5148 entry = byte_get (indices, 4);
5149 indices += 4;
e4b17d5c
L		 5150
5151 if (do_section_groups)
5152 {
2b692964 5153 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 5154 get_group_flags (entry), i, name, group_name, size);
ba2685cc 5155
e4b17d5c
L		 5156 printf (_(" [Index] Name\n"));
5157 }
5158
5159 group->group_index = i;
5160
f5842774
L		 5161 for (j = 0; j < size; j++)
5162 {
2cf0635d 5163 struct group_list * g;
e4b17d5c 5164
f5842774
L		 5165 entry = byte_get (indices, 4);
5166 indices += 4;
5167
4fbb74a6 5168 if (entry >= elf_header.e_shnum)
391cb864
L		 5169 {
5170 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5171 entry, i, elf_header.e_shnum - 1);
5172 continue;
5173 }
391cb864 5174
4fbb74a6 5175 if (section_headers_groups [entry] != NULL)
e4b17d5c 5176 {
d1f5c6e3
L		 5177 if (entry)
5178 {
391cb864
L		 5179 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5180 entry, i,
4fbb74a6 5181 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5182 continue;
5183 }
5184 else
5185 {
5186 /* Intel C/C++ compiler may put section 0 in a
5187 section group. We just warn it the first time
5188 and ignore it afterwards. */
5189 static int warned = 0;
5190 if (!warned)
5191 {
5192 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 5193 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5194 warned++;
5195 }
5196 }
e4b17d5c
L		 5197 }
5198
4fbb74a6 5199 section_headers_groups [entry] = group;
e4b17d5c
L		 5200
5201 if (do_section_groups)
5202 {
4fbb74a6 5203 sec = section_headers + entry;
c256ffe7 5204 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
ba2685cc
AM		 5205 }
5206
3f5e193b 5207 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 5208 g->section_index = entry;
5209 g->next = group->root;
5210 group->root = g;
f5842774
L		 5211 }
5212
f5842774
L		 5213 if (start)
5214 free (start);
e4b17d5c
L		 5215
5216 group++;
f5842774
L		 5217 }
5218 }
5219
d1f5c6e3
L		 5220 if (symtab)
5221 free (symtab);
5222 if (strtab)
5223 free (strtab);
f5842774
L		 5224 return 1;
5225}
5226
28f997cf
TG		 5227/* Data used to display dynamic fixups. */
5228
5229struct ia64_vms_dynfixup
5230{
5231 bfd_vma needed_ident; /* Library ident number. */
5232 bfd_vma needed; /* Index in the dstrtab of the library name. */
5233 bfd_vma fixup_needed; /* Index of the library. */
5234 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5235 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5236};
5237
5238/* Data used to display dynamic relocations. */
5239
5240struct ia64_vms_dynimgrela
5241{
5242 bfd_vma img_rela_cnt; /* Number of relocations. */
5243 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5244};
5245
5246/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5247 library). */
5248
5249static void
5250dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5251 const char *strtab, unsigned int strtab_sz)
5252{
5253 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5254 long i;
5255 const char *lib_name;
5256
5257 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5258 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5259 _("dynamic section image fixups"));
5260 if (!imfs)
5261 return;
5262
5263 if (fixup->needed < strtab_sz)
5264 lib_name = strtab + fixup->needed;
5265 else
5266 {
5267 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 5268 (unsigned long) fixup->needed);
28f997cf
TG		 5269 lib_name = "???";
5270 }
5271 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5272 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5273 printf
5274 (_("Seg Offset Type SymVec DataType\n"));
5275
5276 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5277 {
5278 unsigned int type;
5279 const char *rtype;
5280
5281 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5282 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5283 type = BYTE_GET (imfs [i].type);
5284 rtype = elf_ia64_reloc_type (type);
5285 if (rtype == NULL)
5286 printf (" 0x%08x ", type);
5287 else
5288 printf (" %-32s ", rtype);
5289 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5290 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5291 }
5292
5293 free (imfs);
5294}
5295
5296/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5297
5298static void
5299dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5300{
5301 Elf64_External_VMS_IMAGE_RELA *imrs;
5302 long i;
5303
5304 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5305 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 5306 _("dynamic section image relocations"));
28f997cf
TG		 5307 if (!imrs)
5308 return;
5309
5310 printf (_("\nImage relocs\n"));
5311 printf
5312 (_("Seg Offset Type Addend Seg Sym Off\n"));
5313
5314 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5315 {
5316 unsigned int type;
5317 const char *rtype;
5318
5319 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5320 printf ("%08" BFD_VMA_FMT "x ",
5321 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5322 type = BYTE_GET (imrs [i].type);
5323 rtype = elf_ia64_reloc_type (type);
5324 if (rtype == NULL)
5325 printf ("0x%08x ", type);
5326 else
5327 printf ("%-31s ", rtype);
5328 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5329 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5330 printf ("%08" BFD_VMA_FMT "x\n",
5331 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5332 }
5333
5334 free (imrs);
5335}
5336
5337/* Display IA-64 OpenVMS dynamic relocations and fixups. */
5338
5339static int
5340process_ia64_vms_dynamic_relocs (FILE *file)
5341{
5342 struct ia64_vms_dynfixup fixup;
5343 struct ia64_vms_dynimgrela imgrela;
5344 Elf_Internal_Dyn *entry;
5345 int res = 0;
5346 bfd_vma strtab_off = 0;
5347 bfd_vma strtab_sz = 0;
5348 char *strtab = NULL;
5349
5350 memset (&fixup, 0, sizeof (fixup));
5351 memset (&imgrela, 0, sizeof (imgrela));
5352
5353 /* Note: the order of the entries is specified by the OpenVMS specs. */
5354 for (entry = dynamic_section;
5355 entry < dynamic_section + dynamic_nent;
5356 entry++)
5357 {
5358 switch (entry->d_tag)
5359 {
5360 case DT_IA_64_VMS_STRTAB_OFFSET:
5361 strtab_off = entry->d_un.d_val;
5362 break;
5363 case DT_STRSZ:
5364 strtab_sz = entry->d_un.d_val;
5365 if (strtab == NULL)
5366 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5367 1, strtab_sz, _("dynamic string section"));
5368 break;
5369
5370 case DT_IA_64_VMS_NEEDED_IDENT:
5371 fixup.needed_ident = entry->d_un.d_val;
5372 break;
5373 case DT_NEEDED:
5374 fixup.needed = entry->d_un.d_val;
5375 break;
5376 case DT_IA_64_VMS_FIXUP_NEEDED:
5377 fixup.fixup_needed = entry->d_un.d_val;
5378 break;
5379 case DT_IA_64_VMS_FIXUP_RELA_CNT:
5380 fixup.fixup_rela_cnt = entry->d_un.d_val;
5381 break;
5382 case DT_IA_64_VMS_FIXUP_RELA_OFF:
5383 fixup.fixup_rela_off = entry->d_un.d_val;
5384 res++;
5385 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5386 break;
5387
5388 case DT_IA_64_VMS_IMG_RELA_CNT:
5389 imgrela.img_rela_cnt = entry->d_un.d_val;
5390 break;
5391 case DT_IA_64_VMS_IMG_RELA_OFF:
5392 imgrela.img_rela_off = entry->d_un.d_val;
5393 res++;
5394 dump_ia64_vms_dynamic_relocs (file, &imgrela);
5395 break;
5396
5397 default:
5398 break;
5399 }
5400 }
5401
5402 if (strtab != NULL)
5403 free (strtab);
5404
5405 return res;
5406}
5407
85b1c36d 5408static struct
566b0d53 5409{
2cf0635d 5410 const char * name;
566b0d53
L		 5411 int reloc;
5412 int size;
5413 int rela;
5414} dynamic_relocations [] =
5415{
5416 { "REL", DT_REL, DT_RELSZ, FALSE },
5417 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5418 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5419};
5420
252b5132 5421/* Process the reloc section. */
18bd398b 5422
252b5132 5423static int
2cf0635d 5424process_relocs (FILE * file)
252b5132 5425{
b34976b6
AM		 5426 unsigned long rel_size;
5427 unsigned long rel_offset;
252b5132
RH		 5428
5429
5430 if (!do_reloc)
5431 return 1;
5432
5433 if (do_using_dynamic)
5434 {
566b0d53 5435 int is_rela;
2cf0635d 5436 const char * name;
566b0d53
L		 5437 int has_dynamic_reloc;
5438 unsigned int i;
0de14b54 5439
566b0d53 5440 has_dynamic_reloc = 0;
252b5132 5441
566b0d53 5442 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 5443 {
566b0d53
L		 5444 is_rela = dynamic_relocations [i].rela;
5445 name = dynamic_relocations [i].name;
5446 rel_size = dynamic_info [dynamic_relocations [i].size];
5447 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 5448
566b0d53
L		 5449 has_dynamic_reloc |= rel_size;
5450
5451 if (is_rela == UNKNOWN)
aa903cfb 5452 {
566b0d53
L		 5453 if (dynamic_relocations [i].reloc == DT_JMPREL)
5454 switch (dynamic_info[DT_PLTREL])
5455 {
5456 case DT_REL:
5457 is_rela = FALSE;
5458 break;
5459 case DT_RELA:
5460 is_rela = TRUE;
5461 break;
5462 }
aa903cfb 5463 }
252b5132 5464
566b0d53
L		 5465 if (rel_size)
5466 {
5467 printf
5468 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5469 name, rel_offset, rel_size);
252b5132 5470
d93f0186
NC		 5471 dump_relocations (file,
5472 offset_from_vma (file, rel_offset, rel_size),
5473 rel_size,
566b0d53 5474 dynamic_symbols, num_dynamic_syms,
d79b3d50 5475 dynamic_strings, dynamic_strings_length, is_rela);
566b0d53 5476 }
252b5132 5477 }
566b0d53 5478
28f997cf
TG		 5479 if (is_ia64_vms ())
5480 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5481
566b0d53 5482 if (! has_dynamic_reloc)
252b5132
RH		 5483 printf (_("\nThere are no dynamic relocations in this file.\n"));
5484 }
5485 else
5486 {
2cf0635d 5487 Elf_Internal_Shdr * section;
b34976b6
AM		 5488 unsigned long i;
5489 int found = 0;
252b5132
RH		 5490
5491 for (i = 0, section = section_headers;
5492 i < elf_header.e_shnum;
b34976b6 5493 i++, section++)
252b5132
RH		 5494 {
5495 if ( section->sh_type != SHT_RELA
5496 && section->sh_type != SHT_REL)
5497 continue;
5498
5499 rel_offset = section->sh_offset;
5500 rel_size = section->sh_size;
5501
5502 if (rel_size)
5503 {
2cf0635d 5504 Elf_Internal_Shdr * strsec;
b34976b6 5505 int is_rela;
103f02d3 5506
252b5132
RH		 5507 printf (_("\nRelocation section "));
5508
5509 if (string_table == NULL)
19936277 5510 printf ("%d", section->sh_name);
252b5132 5511 else
9cf03b7e 5512 printf ("'%s'", SECTION_NAME (section));
252b5132
RH		 5513
5514 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5515 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5516
d79b3d50
NC		 5517 is_rela = section->sh_type == SHT_RELA;
5518
4fbb74a6
AM		 5519 if (section->sh_link != 0
5520 && section->sh_link < elf_header.e_shnum)
af3fc3bc 5521 {
2cf0635d
NC		 5522 Elf_Internal_Shdr * symsec;
5523 Elf_Internal_Sym * symtab;
d79b3d50 5524 unsigned long nsyms;
c256ffe7 5525 unsigned long strtablen = 0;
2cf0635d 5526 char * strtab = NULL;
57346661 5527
4fbb74a6 5528 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 5529 if (symsec->sh_type != SHT_SYMTAB
5530 && symsec->sh_type != SHT_DYNSYM)
5531 continue;
5532
ba5cdace 5533 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 5534
af3fc3bc
AM		 5535 if (symtab == NULL)
5536 continue;
252b5132 5537
4fbb74a6
AM		 5538 if (symsec->sh_link != 0
5539 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 5540 {
4fbb74a6 5541 strsec = section_headers + symsec->sh_link;
103f02d3 5542
3f5e193b
NC		 5543 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5544 1, strsec->sh_size,
5545 _("string table"));
c256ffe7
JJ		 5546 strtablen = strtab == NULL ? 0 : strsec->sh_size;
5547 }
252b5132 5548
d79b3d50
NC		 5549 dump_relocations (file, rel_offset, rel_size,
5550 symtab, nsyms, strtab, strtablen, is_rela);
5551 if (strtab)
5552 free (strtab);
5553 free (symtab);
5554 }
5555 else
5556 dump_relocations (file, rel_offset, rel_size,
5557 NULL, 0, NULL, 0, is_rela);
252b5132
RH		 5558
5559 found = 1;
5560 }
5561 }
5562
5563 if (! found)
5564 printf (_("\nThere are no relocations in this file.\n"));
5565 }
5566
5567 return 1;
5568}
5569
57346661
AM		 5570/* Process the unwind section. */
5571
4d6ed7c8
NC		 5572#include "unwind-ia64.h"
5573
5574/* An absolute address consists of a section and an offset. If the
5575 section is NULL, the offset itself is the address, otherwise, the
5576 address equals to LOAD_ADDRESS(section) + offset. */
5577
5578struct absaddr
5579 {
5580 unsigned short section;
5581 bfd_vma offset;
5582 };
5583
1949de15
L		 5584#define ABSADDR(a) \
5585 ((a).section \
5586 ? section_headers [(a).section].sh_addr + (a).offset \
5587 : (a).offset)
5588
3f5e193b
NC		 5589struct ia64_unw_table_entry
5590 {
5591 struct absaddr start;
5592 struct absaddr end;
5593 struct absaddr info;
5594 };
5595
57346661 5596struct ia64_unw_aux_info
4d6ed7c8 5597 {
3f5e193b
NC		 5598
5599 struct ia64_unw_table_entry *table; /* Unwind table. */
b34976b6 5600 unsigned long table_len; /* Length of unwind table. */
2cf0635d 5601 unsigned char * info; /* Unwind info. */
b34976b6
AM		 5602 unsigned long info_size; /* Size of unwind info. */
5603 bfd_vma info_addr; /* starting address of unwind info. */
5604 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 5605 Elf_Internal_Sym * symtab; /* The symbol table. */
b34976b6 5606 unsigned long nsyms; /* Number of symbols. */
2cf0635d 5607 char * strtab; /* The string table. */
b34976b6 5608 unsigned long strtab_size; /* Size of string table. */
4d6ed7c8
NC		 5609 };
5610
4d6ed7c8 5611static void
2cf0635d 5612find_symbol_for_address (Elf_Internal_Sym * symtab,
57346661 5613 unsigned long nsyms,
2cf0635d 5614 const char * strtab,
57346661 5615 unsigned long strtab_size,
d3ba0551 5616 struct absaddr addr,
2cf0635d
NC		 5617 const char ** symname,
5618 bfd_vma * offset)
4d6ed7c8 5619{
d3ba0551 5620 bfd_vma dist = 0x100000;
2cf0635d
NC		 5621 Elf_Internal_Sym * sym;
5622 Elf_Internal_Sym * best = NULL;
4d6ed7c8
NC		 5623 unsigned long i;
5624
0b6ae522
DJ		 5625 REMOVE_ARCH_BITS (addr.offset);
5626
57346661 5627 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4d6ed7c8 5628 {
0b6ae522
DJ		 5629 bfd_vma value = sym->st_value;
5630
5631 REMOVE_ARCH_BITS (value);
5632
4d6ed7c8
NC		 5633 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5634 && sym->st_name != 0
5635 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 5636 && addr.offset >= value
5637 && addr.offset - value < dist)
4d6ed7c8
NC		 5638 {
5639 best = sym;
0b6ae522 5640 dist = addr.offset - value;
4d6ed7c8
NC		 5641 if (!dist)
5642 break;
5643 }
5644 }
1b31d05e 5645
4d6ed7c8
NC		 5646 if (best)
5647 {
57346661 5648 *symname = (best->st_name >= strtab_size
2b692964 5649 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 5650 *offset = dist;
5651 return;
5652 }
1b31d05e 5653
4d6ed7c8
NC		 5654 *symname = NULL;
5655 *offset = addr.offset;
5656}
5657
5658static void
2cf0635d 5659dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 5660{
2cf0635d 5661 struct ia64_unw_table_entry * tp;
4d6ed7c8 5662 int in_body;
7036c0e1 5663
4d6ed7c8
NC		 5664 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5665 {
5666 bfd_vma stamp;
5667 bfd_vma offset;
2cf0635d
NC		 5668 const unsigned char * dp;
5669 const unsigned char * head;
5670 const char * procname;
4d6ed7c8 5671
57346661
AM		 5672 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5673 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 5674
5675 fputs ("\n<", stdout);
5676
5677 if (procname)
5678 {
5679 fputs (procname, stdout);
5680
5681 if (offset)
5682 printf ("+%lx", (unsigned long) offset);
5683 }
5684
5685 fputs (">: [", stdout);
5686 print_vma (tp->start.offset, PREFIX_HEX);
5687 fputc ('-', stdout);
5688 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 5689 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 5690 (unsigned long) (tp->info.offset - aux->seg_base));
5691
1949de15 5692 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 5693 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 5694
86f55779 5695 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 5696 (unsigned) UNW_VER (stamp),
5697 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5698 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5699 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 5700 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 5701
5702 if (UNW_VER (stamp) != 1)
5703 {
2b692964 5704 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 5705 continue;
5706 }
5707
5708 in_body = 0;
89fac5e3 5709 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
4d6ed7c8
NC		 5710 dp = unw_decode (dp, in_body, & in_body);
5711 }
5712}
5713
5714static int
2cf0635d
NC		 5715slurp_ia64_unwind_table (FILE * file,
5716 struct ia64_unw_aux_info * aux,
5717 Elf_Internal_Shdr * sec)
4d6ed7c8 5718{
89fac5e3 5719 unsigned long size, nrelas, i;
2cf0635d
NC		 5720 Elf_Internal_Phdr * seg;
5721 struct ia64_unw_table_entry * tep;
5722 Elf_Internal_Shdr * relsec;
5723 Elf_Internal_Rela * rela;
5724 Elf_Internal_Rela * rp;
5725 unsigned char * table;
5726 unsigned char * tp;
5727 Elf_Internal_Sym * sym;
5728 const char * relname;
4d6ed7c8 5729
4d6ed7c8
NC		 5730 /* First, find the starting address of the segment that includes
5731 this section: */
5732
5733 if (elf_header.e_phnum)
5734 {
d93f0186 5735 if (! get_program_headers (file))
4d6ed7c8 5736 return 0;
4d6ed7c8 5737
d93f0186
NC		 5738 for (seg = program_headers;
5739 seg < program_headers + elf_header.e_phnum;
5740 ++seg)
4d6ed7c8
NC		 5741 {
5742 if (seg->p_type != PT_LOAD)
5743 continue;
5744
5745 if (sec->sh_addr >= seg->p_vaddr
5746 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5747 {
5748 aux->seg_base = seg->p_vaddr;
5749 break;
5750 }
5751 }
4d6ed7c8
NC		 5752 }
5753
5754 /* Second, build the unwind table from the contents of the unwind section: */
5755 size = sec->sh_size;
3f5e193b
NC		 5756 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5757 _("unwind table"));
a6e9f9df
AM		 5758 if (!table)
5759 return 0;
4d6ed7c8 5760
3f5e193b
NC		 5761 aux->table = (struct ia64_unw_table_entry *)
5762 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
89fac5e3 5763 tep = aux->table;
c6a0c689 5764 for (tp = table; tp < table + size; ++tep)
4d6ed7c8
NC		 5765 {
5766 tep->start.section = SHN_UNDEF;
5767 tep->end.section = SHN_UNDEF;
5768 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 5769 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5770 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5771 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 5772 tep->start.offset += aux->seg_base;
5773 tep->end.offset += aux->seg_base;
5774 tep->info.offset += aux->seg_base;
5775 }
5776 free (table);
5777
41e92641 5778 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 5779 for (relsec = section_headers;
5780 relsec < section_headers + elf_header.e_shnum;
5781 ++relsec)
5782 {
5783 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 5784 || relsec->sh_info >= elf_header.e_shnum
5785 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 5786 continue;
5787
5788 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5789 & rela, & nrelas))
5790 return 0;
5791
5792 for (rp = rela; rp < rela + nrelas; ++rp)
5793 {
aca88567
NC		 5794 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5795 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 5796
0112cd26 5797 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 5798 {
e5fb9629 5799 warn (_("Skipping unexpected relocation type %s\n"), relname);
4d6ed7c8
NC		 5800 continue;
5801 }
5802
89fac5e3 5803 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 5804
89fac5e3 5805 switch (rp->r_offset/eh_addr_size % 3)
4d6ed7c8
NC		 5806 {
5807 case 0:
5808 aux->table[i].start.section = sym->st_shndx;
e466bc6e 5809 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5810 break;
5811 case 1:
5812 aux->table[i].end.section = sym->st_shndx;
e466bc6e 5813 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5814 break;
5815 case 2:
5816 aux->table[i].info.section = sym->st_shndx;
e466bc6e 5817 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5818 break;
5819 default:
5820 break;
5821 }
5822 }
5823
5824 free (rela);
5825 }
5826
89fac5e3 5827 aux->table_len = size / (3 * eh_addr_size);
4d6ed7c8
NC		 5828 return 1;
5829}
5830
1b31d05e 5831static void
2cf0635d 5832ia64_process_unwind (FILE * file)
4d6ed7c8 5833{
2cf0635d
NC		 5834 Elf_Internal_Shdr * sec;
5835 Elf_Internal_Shdr * unwsec = NULL;
5836 Elf_Internal_Shdr * strsec;
89fac5e3 5837 unsigned long i, unwcount = 0, unwstart = 0;
57346661 5838 struct ia64_unw_aux_info aux;
f1467e33 5839
4d6ed7c8
NC		 5840 memset (& aux, 0, sizeof (aux));
5841
4d6ed7c8
NC		 5842 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5843 {
c256ffe7 5844 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 5845 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 5846 {
ba5cdace 5847 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 5848
4fbb74a6 5849 strsec = section_headers + sec->sh_link;
59245841 5850 assert (aux.strtab == NULL);
3f5e193b
NC		 5851 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5852 1, strsec->sh_size,
5853 _("string table"));
c256ffe7 5854 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 5855 }
5856 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 5857 unwcount++;
5858 }
5859
5860 if (!unwcount)
5861 printf (_("\nThere are no unwind sections in this file.\n"));
5862
5863 while (unwcount-- > 0)
5864 {
2cf0635d 5865 char * suffix;
579f31ac
JJ		 5866 size_t len, len2;
5867
5868 for (i = unwstart, sec = section_headers + unwstart;
5869 i < elf_header.e_shnum; ++i, ++sec)
5870 if (sec->sh_type == SHT_IA_64_UNWIND)
5871 {
5872 unwsec = sec;
5873 break;
5874 }
5875
5876 unwstart = i + 1;
5877 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
5878
e4b17d5c
L		 5879 if ((unwsec->sh_flags & SHF_GROUP) != 0)
5880 {
5881 /* We need to find which section group it is in. */
2cf0635d 5882 struct group_list * g = section_headers_groups [i]->root;
e4b17d5c
L		 5883
5884 for (; g != NULL; g = g->next)
5885 {
4fbb74a6 5886 sec = section_headers + g->section_index;
18bd398b
NC		 5887
5888 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
57346661 5889 break;
e4b17d5c
L		 5890 }
5891
5892 if (g == NULL)
5893 i = elf_header.e_shnum;
5894 }
18bd398b 5895 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 5896 {
18bd398b 5897 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 5898 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
5899 suffix = SECTION_NAME (unwsec) + len;
5900 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5901 ++i, ++sec)
18bd398b
NC		 5902 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
5903 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 5904 break;
5905 }
5906 else
5907 {
5908 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 5909 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 5910 len = sizeof (ELF_STRING_ia64_unwind) - 1;
5911 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
5912 suffix = "";
18bd398b 5913 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 5914 suffix = SECTION_NAME (unwsec) + len;
5915 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5916 ++i, ++sec)
18bd398b
NC		 5917 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
5918 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 5919 break;
5920 }
5921
5922 if (i == elf_header.e_shnum)
5923 {
5924 printf (_("\nCould not find unwind info section for "));
5925
5926 if (string_table == NULL)
5927 printf ("%d", unwsec->sh_name);
5928 else
3a1a2036 5929 printf (_("'%s'"), SECTION_NAME (unwsec));
579f31ac
JJ		 5930 }
5931 else
4d6ed7c8 5932 {
4d6ed7c8 5933 aux.info_addr = sec->sh_addr;
3f5e193b 5934 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
59245841 5935 sec->sh_size,
3f5e193b 5936 _("unwind info"));
59245841 5937 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 5938
579f31ac 5939 printf (_("\nUnwind section "));
4d6ed7c8 5940
579f31ac
JJ		 5941 if (string_table == NULL)
5942 printf ("%d", unwsec->sh_name);
5943 else
3a1a2036 5944 printf (_("'%s'"), SECTION_NAME (unwsec));
4d6ed7c8 5945
579f31ac 5946 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 5947 (unsigned long) unwsec->sh_offset,
89fac5e3 5948 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 5949
579f31ac 5950 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4d6ed7c8 5951
579f31ac
JJ		 5952 if (aux.table_len > 0)
5953 dump_ia64_unwind (& aux);
5954
5955 if (aux.table)
5956 free ((char *) aux.table);
5957 if (aux.info)
5958 free ((char *) aux.info);
5959 aux.table = NULL;
5960 aux.info = NULL;
5961 }
4d6ed7c8 5962 }
4d6ed7c8 5963
4d6ed7c8
NC		 5964 if (aux.symtab)
5965 free (aux.symtab);
5966 if (aux.strtab)
5967 free ((char *) aux.strtab);
4d6ed7c8
NC		 5968}
5969
3f5e193b
NC		 5970struct hppa_unw_table_entry
5971 {
5972 struct absaddr start;
5973 struct absaddr end;
5974 unsigned int Cannot_unwind:1; /* 0 */
5975 unsigned int Millicode:1; /* 1 */
5976 unsigned int Millicode_save_sr0:1; /* 2 */
5977 unsigned int Region_description:2; /* 3..4 */
5978 unsigned int reserved1:1; /* 5 */
5979 unsigned int Entry_SR:1; /* 6 */
5980 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
5981 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
5982 unsigned int Args_stored:1; /* 16 */
5983 unsigned int Variable_Frame:1; /* 17 */
5984 unsigned int Separate_Package_Body:1; /* 18 */
5985 unsigned int Frame_Extension_Millicode:1; /* 19 */
5986 unsigned int Stack_Overflow_Check:1; /* 20 */
5987 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
5988 unsigned int Ada_Region:1; /* 22 */
5989 unsigned int cxx_info:1; /* 23 */
5990 unsigned int cxx_try_catch:1; /* 24 */
5991 unsigned int sched_entry_seq:1; /* 25 */
5992 unsigned int reserved2:1; /* 26 */
5993 unsigned int Save_SP:1; /* 27 */
5994 unsigned int Save_RP:1; /* 28 */
5995 unsigned int Save_MRP_in_frame:1; /* 29 */
5996 unsigned int extn_ptr_defined:1; /* 30 */
5997 unsigned int Cleanup_defined:1; /* 31 */
5998
5999 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
6000 unsigned int HP_UX_interrupt_marker:1; /* 1 */
6001 unsigned int Large_frame:1; /* 2 */
6002 unsigned int Pseudo_SP_Set:1; /* 3 */
6003 unsigned int reserved4:1; /* 4 */
6004 unsigned int Total_frame_size:27; /* 5..31 */
6005 };
6006
57346661
AM		 6007struct hppa_unw_aux_info
6008 {
3f5e193b 6009 struct hppa_unw_table_entry *table; /* Unwind table. */
57346661
AM		 6010 unsigned long table_len; /* Length of unwind table. */
6011 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 6012 Elf_Internal_Sym * symtab; /* The symbol table. */
57346661 6013 unsigned long nsyms; /* Number of symbols. */
2cf0635d 6014 char * strtab; /* The string table. */
57346661
AM		 6015 unsigned long strtab_size; /* Size of string table. */
6016 };
6017
6018static void
2cf0635d 6019dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 6020{
2cf0635d 6021 struct hppa_unw_table_entry * tp;
57346661 6022
57346661
AM		 6023 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6024 {
6025 bfd_vma offset;
2cf0635d 6026 const char * procname;
57346661
AM		 6027
6028 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6029 aux->strtab_size, tp->start, &procname,
6030 &offset);
6031
6032 fputs ("\n<", stdout);
6033
6034 if (procname)
6035 {
6036 fputs (procname, stdout);
6037
6038 if (offset)
6039 printf ("+%lx", (unsigned long) offset);
6040 }
6041
6042 fputs (">: [", stdout);
6043 print_vma (tp->start.offset, PREFIX_HEX);
6044 fputc ('-', stdout);
6045 print_vma (tp->end.offset, PREFIX_HEX);
6046 printf ("]\n\t");
6047
18bd398b
NC		 6048#define PF(_m) if (tp->_m) printf (#_m " ");
6049#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 6050 PF(Cannot_unwind);
6051 PF(Millicode);
6052 PF(Millicode_save_sr0);
18bd398b 6053 /* PV(Region_description); */
57346661
AM		 6054 PF(Entry_SR);
6055 PV(Entry_FR);
6056 PV(Entry_GR);
6057 PF(Args_stored);
6058 PF(Variable_Frame);
6059 PF(Separate_Package_Body);
6060 PF(Frame_Extension_Millicode);
6061 PF(Stack_Overflow_Check);
6062 PF(Two_Instruction_SP_Increment);
6063 PF(Ada_Region);
6064 PF(cxx_info);
6065 PF(cxx_try_catch);
6066 PF(sched_entry_seq);
6067 PF(Save_SP);
6068 PF(Save_RP);
6069 PF(Save_MRP_in_frame);
6070 PF(extn_ptr_defined);
6071 PF(Cleanup_defined);
6072 PF(MPE_XL_interrupt_marker);
6073 PF(HP_UX_interrupt_marker);
6074 PF(Large_frame);
6075 PF(Pseudo_SP_Set);
6076 PV(Total_frame_size);
6077#undef PF
6078#undef PV
6079 }
6080
18bd398b 6081 printf ("\n");
57346661
AM		 6082}
6083
6084static int
2cf0635d
NC		 6085slurp_hppa_unwind_table (FILE * file,
6086 struct hppa_unw_aux_info * aux,
6087 Elf_Internal_Shdr * sec)
57346661 6088{
1c0751b2 6089 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 6090 Elf_Internal_Phdr * seg;
6091 struct hppa_unw_table_entry * tep;
6092 Elf_Internal_Shdr * relsec;
6093 Elf_Internal_Rela * rela;
6094 Elf_Internal_Rela * rp;
6095 unsigned char * table;
6096 unsigned char * tp;
6097 Elf_Internal_Sym * sym;
6098 const char * relname;
57346661 6099
57346661
AM		 6100 /* First, find the starting address of the segment that includes
6101 this section. */
6102
6103 if (elf_header.e_phnum)
6104 {
6105 if (! get_program_headers (file))
6106 return 0;
6107
6108 for (seg = program_headers;
6109 seg < program_headers + elf_header.e_phnum;
6110 ++seg)
6111 {
6112 if (seg->p_type != PT_LOAD)
6113 continue;
6114
6115 if (sec->sh_addr >= seg->p_vaddr
6116 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6117 {
6118 aux->seg_base = seg->p_vaddr;
6119 break;
6120 }
6121 }
6122 }
6123
6124 /* Second, build the unwind table from the contents of the unwind
6125 section. */
6126 size = sec->sh_size;
3f5e193b
NC		 6127 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6128 _("unwind table"));
57346661
AM		 6129 if (!table)
6130 return 0;
6131
1c0751b2
DA		 6132 unw_ent_size = 16;
6133 nentries = size / unw_ent_size;
6134 size = unw_ent_size * nentries;
57346661 6135
3f5e193b
NC		 6136 tep = aux->table = (struct hppa_unw_table_entry *)
6137 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 6138
1c0751b2 6139 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 6140 {
6141 unsigned int tmp1, tmp2;
6142
6143 tep->start.section = SHN_UNDEF;
6144 tep->end.section = SHN_UNDEF;
6145
1c0751b2
DA		 6146 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6147 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6148 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6149 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6150
6151 tep->start.offset += aux->seg_base;
6152 tep->end.offset += aux->seg_base;
57346661
AM		 6153
6154 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6155 tep->Millicode = (tmp1 >> 30) & 0x1;
6156 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6157 tep->Region_description = (tmp1 >> 27) & 0x3;
6158 tep->reserved1 = (tmp1 >> 26) & 0x1;
6159 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6160 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6161 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6162 tep->Args_stored = (tmp1 >> 15) & 0x1;
6163 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6164 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6165 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6166 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6167 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6168 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6169 tep->cxx_info = (tmp1 >> 8) & 0x1;
6170 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6171 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6172 tep->reserved2 = (tmp1 >> 5) & 0x1;
6173 tep->Save_SP = (tmp1 >> 4) & 0x1;
6174 tep->Save_RP = (tmp1 >> 3) & 0x1;
6175 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6176 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6177 tep->Cleanup_defined = tmp1 & 0x1;
6178
6179 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6180 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6181 tep->Large_frame = (tmp2 >> 29) & 0x1;
6182 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6183 tep->reserved4 = (tmp2 >> 27) & 0x1;
6184 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 6185 }
6186 free (table);
6187
6188 /* Third, apply any relocations to the unwind table. */
57346661
AM		 6189 for (relsec = section_headers;
6190 relsec < section_headers + elf_header.e_shnum;
6191 ++relsec)
6192 {
6193 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6194 || relsec->sh_info >= elf_header.e_shnum
6195 || section_headers + relsec->sh_info != sec)
57346661
AM		 6196 continue;
6197
6198 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6199 & rela, & nrelas))
6200 return 0;
6201
6202 for (rp = rela; rp < rela + nrelas; ++rp)
6203 {
aca88567
NC		 6204 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6205 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 6206
6207 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 6208 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 6209 {
6210 warn (_("Skipping unexpected relocation type %s\n"), relname);
6211 continue;
6212 }
6213
6214 i = rp->r_offset / unw_ent_size;
6215
89fac5e3 6216 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 6217 {
6218 case 0:
6219 aux->table[i].start.section = sym->st_shndx;
1e456d54 6220 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 6221 break;
6222 case 1:
6223 aux->table[i].end.section = sym->st_shndx;
1e456d54 6224 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 6225 break;
6226 default:
6227 break;
6228 }
6229 }
6230
6231 free (rela);
6232 }
6233
1c0751b2 6234 aux->table_len = nentries;
57346661
AM		 6235
6236 return 1;
6237}
6238
1b31d05e 6239static void
2cf0635d 6240hppa_process_unwind (FILE * file)
57346661 6241{
57346661 6242 struct hppa_unw_aux_info aux;
2cf0635d
NC		 6243 Elf_Internal_Shdr * unwsec = NULL;
6244 Elf_Internal_Shdr * strsec;
6245 Elf_Internal_Shdr * sec;
18bd398b 6246 unsigned long i;
57346661 6247
c256ffe7 6248 if (string_table == NULL)
1b31d05e
NC		 6249 return;
6250
6251 memset (& aux, 0, sizeof (aux));
57346661
AM		 6252
6253 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6254 {
c256ffe7 6255 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6256 && sec->sh_link < elf_header.e_shnum)
57346661 6257 {
ba5cdace 6258 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 6259
4fbb74a6 6260 strsec = section_headers + sec->sh_link;
59245841 6261 assert (aux.strtab == NULL);
3f5e193b
NC		 6262 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6263 1, strsec->sh_size,
6264 _("string table"));
c256ffe7 6265 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 6266 }
18bd398b 6267 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 6268 unwsec = sec;
6269 }
6270
6271 if (!unwsec)
6272 printf (_("\nThere are no unwind sections in this file.\n"));
6273
6274 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6275 {
18bd398b 6276 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 6277 {
57346661
AM		 6278 printf (_("\nUnwind section "));
6279 printf (_("'%s'"), SECTION_NAME (sec));
6280
6281 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6282 (unsigned long) sec->sh_offset,
89fac5e3 6283 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 6284
6285 slurp_hppa_unwind_table (file, &aux, sec);
6286 if (aux.table_len > 0)
6287 dump_hppa_unwind (&aux);
6288
6289 if (aux.table)
6290 free ((char *) aux.table);
6291 aux.table = NULL;
6292 }
6293 }
6294
6295 if (aux.symtab)
6296 free (aux.symtab);
6297 if (aux.strtab)
6298 free ((char *) aux.strtab);
57346661
AM		 6299}
6300
0b6ae522
DJ		 6301struct arm_section
6302{
a734115a
NC		 6303 unsigned char * data; /* The unwind data. */
6304 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
6305 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
6306 unsigned long nrelas; /* The number of relocations. */
6307 unsigned int rel_type; /* REL or RELA ? */
6308 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 6309};
6310
6311struct arm_unw_aux_info
6312{
a734115a
NC		 6313 FILE * file; /* The file containing the unwind sections. */
6314 Elf_Internal_Sym * symtab; /* The file's symbol table. */
6315 unsigned long nsyms; /* Number of symbols. */
6316 char * strtab; /* The file's string table. */
6317 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 6318};
6319
6320static const char *
6321arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6322 bfd_vma fn, struct absaddr addr)
6323{
6324 const char *procname;
6325 bfd_vma sym_offset;
6326
6327 if (addr.section == SHN_UNDEF)
6328 addr.offset = fn;
6329
6330 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6331 aux->strtab_size, addr, &procname,
6332 &sym_offset);
6333
6334 print_vma (fn, PREFIX_HEX);
6335
6336 if (procname)
6337 {
6338 fputs (" <", stdout);
6339 fputs (procname, stdout);
6340
6341 if (sym_offset)
6342 printf ("+0x%lx", (unsigned long) sym_offset);
6343 fputc ('>', stdout);
6344 }
6345
6346 return procname;
6347}
6348
6349static void
6350arm_free_section (struct arm_section *arm_sec)
6351{
6352 if (arm_sec->data != NULL)
6353 free (arm_sec->data);
6354
6355 if (arm_sec->rela != NULL)
6356 free (arm_sec->rela);
6357}
6358
a734115a
NC		 6359/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6360 cached section and install SEC instead.
6361 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6362 and return its valued in * WORDP, relocating if necessary.
1b31d05e 6363 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 6364 relocation's offset in ADDR.
1b31d05e
NC		 6365 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6366 into the string table of the symbol associated with the reloc. If no
6367 reloc was applied store -1 there.
6368 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 6369
6370static bfd_boolean
1b31d05e
NC		 6371get_unwind_section_word (struct arm_unw_aux_info * aux,
6372 struct arm_section * arm_sec,
6373 Elf_Internal_Shdr * sec,
6374 bfd_vma word_offset,
6375 unsigned int * wordp,
6376 struct absaddr * addr,
6377 bfd_vma * sym_name)
0b6ae522
DJ		 6378{
6379 Elf_Internal_Rela *rp;
6380 Elf_Internal_Sym *sym;
6381 const char * relname;
6382 unsigned int word;
6383 bfd_boolean wrapped;
6384
6385 addr->section = SHN_UNDEF;
6386 addr->offset = 0;
6387
1b31d05e
NC		 6388 if (sym_name != NULL)
6389 *sym_name = (bfd_vma) -1;
6390
a734115a 6391 /* If necessary, update the section cache. */
0b6ae522
DJ		 6392 if (sec != arm_sec->sec)
6393 {
6394 Elf_Internal_Shdr *relsec;
6395
6396 arm_free_section (arm_sec);
6397
6398 arm_sec->sec = sec;
6399 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6400 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 6401 arm_sec->rela = NULL;
6402 arm_sec->nrelas = 0;
6403
6404 for (relsec = section_headers;
6405 relsec < section_headers + elf_header.e_shnum;
6406 ++relsec)
6407 {
6408 if (relsec->sh_info >= elf_header.e_shnum
6409 || section_headers + relsec->sh_info != sec)
6410 continue;
6411
a734115a 6412 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 6413 if (relsec->sh_type == SHT_REL)
6414 {
6415 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6416 relsec->sh_size,
6417 & arm_sec->rela, & arm_sec->nrelas))
a734115a 6418 return FALSE;
0b6ae522
DJ		 6419 break;
6420 }
6421 else if (relsec->sh_type == SHT_RELA)
6422 {
6423 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6424 relsec->sh_size,
6425 & arm_sec->rela, & arm_sec->nrelas))
a734115a 6426 return FALSE;
0b6ae522
DJ		 6427 break;
6428 }
a734115a
NC		 6429 else
6430 warn (_("unexpected relocation type (%d) for section %d"),
6431 relsec->sh_type, relsec->sh_info);
0b6ae522
DJ		 6432 }
6433
6434 arm_sec->next_rela = arm_sec->rela;
6435 }
6436
a734115a 6437 /* If there is no unwind data we can do nothing. */
0b6ae522 6438 if (arm_sec->data == NULL)
a734115a 6439 return FALSE;
0b6ae522 6440
a734115a 6441 /* Get the word at the required offset. */
0b6ae522
DJ		 6442 word = byte_get (arm_sec->data + word_offset, 4);
6443
a734115a 6444 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 6445 wrapped = FALSE;
6446 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6447 {
6448 bfd_vma prelval, offset;
6449
6450 if (rp->r_offset > word_offset && !wrapped)
6451 {
6452 rp = arm_sec->rela;
6453 wrapped = TRUE;
6454 }
6455 if (rp->r_offset > word_offset)
6456 break;
6457
6458 if (rp->r_offset & 3)
6459 {
6460 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6461 (unsigned long) rp->r_offset);
6462 continue;
6463 }
6464
6465 if (rp->r_offset < word_offset)
6466 continue;
6467
0b6ae522
DJ		 6468 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6469
6470 if (arm_sec->rel_type == SHT_REL)
6471 {
6472 offset = word & 0x7fffffff;
6473 if (offset & 0x40000000)
6474 offset |= ~ (bfd_vma) 0x7fffffff;
6475 }
a734115a 6476 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 6477 offset = rp->r_addend;
a734115a
NC		 6478 else
6479 abort ();
0b6ae522
DJ		 6480
6481 offset += sym->st_value;
6482 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6483
a734115a
NC		 6484 /* Check that we are processing the expected reloc type. */
6485 if (elf_header.e_machine == EM_ARM)
6486 {
6487 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6488
6489 if (streq (relname, "R_ARM_NONE"))
6490 continue;
6491
6492 if (! streq (relname, "R_ARM_PREL31"))
6493 {
6494 warn (_("Skipping unexpected relocation type %s\n"), relname);
6495 continue;
6496 }
6497 }
6498 else if (elf_header.e_machine == EM_TI_C6000)
6499 {
6500 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6501
6502 if (streq (relname, "R_C6000_NONE"))
6503 continue;
6504
6505 if (! streq (relname, "R_C6000_PREL31"))
6506 {
6507 warn (_("Skipping unexpected relocation type %s\n"), relname);
6508 continue;
6509 }
6510
6511 prelval >>= 1;
6512 }
6513 else
6514 /* This function currently only supports ARM and TI unwinders. */
6515 abort ();
fa197c1c 6516
0b6ae522
DJ		 6517 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6518 addr->section = sym->st_shndx;
6519 addr->offset = offset;
1b31d05e
NC		 6520 if (sym_name)
6521 * sym_name = sym->st_name;
0b6ae522
DJ		 6522 break;
6523 }
6524
6525 *wordp = word;
6526 arm_sec->next_rela = rp;
6527
a734115a 6528 return TRUE;
0b6ae522
DJ		 6529}
6530
a734115a
NC		 6531static const char *tic6x_unwind_regnames[16] =
6532{
6533 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6534 "A14", "A13", "A12", "A11", "A10",
6535 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6536};
fa197c1c 6537
0b6ae522 6538static void
fa197c1c 6539decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 6540{
fa197c1c
PB		 6541 int i;
6542
6543 for (i = 12; mask; mask >>= 1, i--)
6544 {
6545 if (mask & 1)
6546 {
6547 fputs (tic6x_unwind_regnames[i], stdout);
6548 if (mask > 1)
6549 fputs (", ", stdout);
6550 }
6551 }
6552}
0b6ae522
DJ		 6553
6554#define ADVANCE \
6555 if (remaining == 0 && more_words) \
6556 { \
6557 data_offset += 4; \
1b31d05e
NC		 6558 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
6559 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 6560 return; \
6561 remaining = 4; \
6562 more_words--; \
6563 } \
6564
6565#define GET_OP(OP) \
6566 ADVANCE; \
6567 if (remaining) \
6568 { \
6569 remaining--; \
6570 (OP) = word >> 24; \
6571 word <<= 8; \
6572 } \
6573 else \
6574 { \
2b692964 6575 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 6576 return; \
6577 } \
cc5914eb 6578 printf ("0x%02x ", OP)
0b6ae522 6579
fa197c1c
PB		 6580static void
6581decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
6582 unsigned int word, unsigned int remaining,
6583 unsigned int more_words,
6584 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6585 struct arm_section *data_arm_sec)
6586{
6587 struct absaddr addr;
0b6ae522
DJ		 6588
6589 /* Decode the unwinding instructions. */
6590 while (1)
6591 {
6592 unsigned int op, op2;
6593
6594 ADVANCE;
6595 if (remaining == 0)
6596 break;
6597 remaining--;
6598 op = word >> 24;
6599 word <<= 8;
6600
cc5914eb 6601 printf (" 0x%02x ", op);
0b6ae522
DJ		 6602
6603 if ((op & 0xc0) == 0x00)
6604 {
6605 int offset = ((op & 0x3f) << 2) + 4;
61865e30 6606
cc5914eb 6607 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 6608 }
6609 else if ((op & 0xc0) == 0x40)
6610 {
6611 int offset = ((op & 0x3f) << 2) + 4;
61865e30 6612
cc5914eb 6613 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 6614 }
6615 else if ((op & 0xf0) == 0x80)
6616 {
6617 GET_OP (op2);
6618 if (op == 0x80 && op2 == 0)
6619 printf (_("Refuse to unwind"));
6620 else
6621 {
6622 unsigned int mask = ((op & 0x0f) << 8) | op2;
6623 int first = 1;
6624 int i;
2b692964 6625
0b6ae522
DJ		 6626 printf ("pop {");
6627 for (i = 0; i < 12; i++)
6628 if (mask & (1 << i))
6629 {
6630 if (first)
6631 first = 0;
6632 else
6633 printf (", ");
6634 printf ("r%d", 4 + i);
6635 }
6636 printf ("}");
6637 }
6638 }
6639 else if ((op & 0xf0) == 0x90)
6640 {
6641 if (op == 0x9d || op == 0x9f)
6642 printf (_(" [Reserved]"));
6643 else
cc5914eb 6644 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 6645 }
6646 else if ((op & 0xf0) == 0xa0)
6647 {
6648 int end = 4 + (op & 0x07);
6649 int first = 1;
6650 int i;
61865e30 6651
0b6ae522
DJ		 6652 printf (" pop {");
6653 for (i = 4; i <= end; i++)
6654 {
6655 if (first)
6656 first = 0;
6657 else
6658 printf (", ");
6659 printf ("r%d", i);
6660 }
6661 if (op & 0x08)
6662 {
1b31d05e 6663 if (!first)
0b6ae522
DJ		 6664 printf (", ");
6665 printf ("r14");
6666 }
6667 printf ("}");
6668 }
6669 else if (op == 0xb0)
6670 printf (_(" finish"));
6671 else if (op == 0xb1)
6672 {
6673 GET_OP (op2);
6674 if (op2 == 0 || (op2 & 0xf0) != 0)
6675 printf (_("[Spare]"));
6676 else
6677 {
6678 unsigned int mask = op2 & 0x0f;
6679 int first = 1;
6680 int i;
61865e30 6681
0b6ae522
DJ		 6682 printf ("pop {");
6683 for (i = 0; i < 12; i++)
6684 if (mask & (1 << i))
6685 {
6686 if (first)
6687 first = 0;
6688 else
6689 printf (", ");
6690 printf ("r%d", i);
6691 }
6692 printf ("}");
6693 }
6694 }
6695 else if (op == 0xb2)
6696 {
b115cf96 6697 unsigned char buf[9];
0b6ae522
DJ		 6698 unsigned int i, len;
6699 unsigned long offset;
61865e30 6700
b115cf96 6701 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 6702 {
6703 GET_OP (buf[i]);
6704 if ((buf[i] & 0x80) == 0)
6705 break;
6706 }
6707 assert (i < sizeof (buf));
6708 offset = read_uleb128 (buf, &len);
6709 assert (len == i + 1);
6710 offset = offset * 4 + 0x204;
cc5914eb 6711 printf ("vsp = vsp + %ld", offset);
0b6ae522 6712 }
61865e30 6713 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 6714 {
61865e30
NC		 6715 unsigned int first, last;
6716
6717 GET_OP (op2);
6718 first = op2 >> 4;
6719 last = op2 & 0x0f;
6720 if (op == 0xc8)
6721 first = first + 16;
6722 printf ("pop {D%d", first);
6723 if (last)
6724 printf ("-D%d", first + last);
6725 printf ("}");
6726 }
6727 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
6728 {
6729 unsigned int count = op & 0x07;
6730
6731 printf ("pop {D8");
6732 if (count)
6733 printf ("-D%d", 8 + count);
6734 printf ("}");
6735 }
6736 else if (op >= 0xc0 && op <= 0xc5)
6737 {
6738 unsigned int count = op & 0x07;
6739
6740 printf (" pop {wR10");
6741 if (count)
6742 printf ("-wR%d", 10 + count);
6743 printf ("}");
6744 }
6745 else if (op == 0xc6)
6746 {
6747 unsigned int first, last;
6748
6749 GET_OP (op2);
6750 first = op2 >> 4;
6751 last = op2 & 0x0f;
6752 printf ("pop {wR%d", first);
6753 if (last)
6754 printf ("-wR%d", first + last);
6755 printf ("}");
6756 }
6757 else if (op == 0xc7)
6758 {
6759 GET_OP (op2);
6760 if (op2 == 0 || (op2 & 0xf0) != 0)
6761 printf (_("[Spare]"));
0b6ae522
DJ		 6762 else
6763 {
61865e30
NC		 6764 unsigned int mask = op2 & 0x0f;
6765 int first = 1;
6766 int i;
6767
6768 printf ("pop {");
6769 for (i = 0; i < 4; i++)
6770 if (mask & (1 << i))
6771 {
6772 if (first)
6773 first = 0;
6774 else
6775 printf (", ");
6776 printf ("wCGR%d", i);
6777 }
6778 printf ("}");
0b6ae522
DJ		 6779 }
6780 }
61865e30
NC		 6781 else
6782 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 6783 printf ("\n");
6784 }
fa197c1c
PB		 6785}
6786
6787static void
6788decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
6789 unsigned int word, unsigned int remaining,
6790 unsigned int more_words,
6791 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6792 struct arm_section *data_arm_sec)
6793{
6794 struct absaddr addr;
6795
6796 /* Decode the unwinding instructions. */
6797 while (1)
6798 {
6799 unsigned int op, op2;
6800
6801 ADVANCE;
6802 if (remaining == 0)
6803 break;
6804 remaining--;
6805 op = word >> 24;
6806 word <<= 8;
6807
9cf03b7e 6808 printf (" 0x%02x ", op);
fa197c1c
PB		 6809
6810 if ((op & 0xc0) == 0x00)
6811 {
6812 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 6813 printf (" sp = sp + %d", offset);
fa197c1c
PB		 6814 }
6815 else if ((op & 0xc0) == 0x80)
6816 {
6817 GET_OP (op2);
6818 if (op == 0x80 && op2 == 0)
6819 printf (_("Refuse to unwind"));
6820 else
6821 {
6822 unsigned int mask = ((op & 0x1f) << 8) | op2;
6823 if (op & 0x20)
6824 printf ("pop compact {");
6825 else
6826 printf ("pop {");
6827
6828 decode_tic6x_unwind_regmask (mask);
6829 printf("}");
6830 }
6831 }
6832 else if ((op & 0xf0) == 0xc0)
6833 {
6834 unsigned int reg;
6835 unsigned int nregs;
6836 unsigned int i;
6837 const char *name;
a734115a
NC		 6838 struct
6839 {
fa197c1c
PB		 6840 unsigned int offset;
6841 unsigned int reg;
6842 } regpos[16];
6843
6844 /* Scan entire instruction first so that GET_OP output is not
6845 interleaved with disassembly. */
6846 nregs = 0;
6847 for (i = 0; nregs < (op & 0xf); i++)
6848 {
6849 GET_OP (op2);
6850 reg = op2 >> 4;
6851 if (reg != 0xf)
6852 {
6853 regpos[nregs].offset = i * 2;
6854 regpos[nregs].reg = reg;
6855 nregs++;
6856 }
6857
6858 reg = op2 & 0xf;
6859 if (reg != 0xf)
6860 {
6861 regpos[nregs].offset = i * 2 + 1;
6862 regpos[nregs].reg = reg;
6863 nregs++;
6864 }
6865 }
6866
6867 printf (_("pop frame {"));
6868 reg = nregs - 1;
6869 for (i = i * 2; i > 0; i--)
6870 {
6871 if (regpos[reg].offset == i - 1)
6872 {
6873 name = tic6x_unwind_regnames[regpos[reg].reg];
6874 if (reg > 0)
6875 reg--;
6876 }
6877 else
6878 name = _("[pad]");
6879
6880 fputs (name, stdout);
6881 if (i > 1)
6882 printf (", ");
6883 }
6884
6885 printf ("}");
6886 }
6887 else if (op == 0xd0)
6888 printf (" MOV FP, SP");
6889 else if (op == 0xd1)
6890 printf (" __c6xabi_pop_rts");
6891 else if (op == 0xd2)
6892 {
6893 unsigned char buf[9];
6894 unsigned int i, len;
6895 unsigned long offset;
a734115a 6896
fa197c1c
PB		 6897 for (i = 0; i < sizeof (buf); i++)
6898 {
6899 GET_OP (buf[i]);
6900 if ((buf[i] & 0x80) == 0)
6901 break;
6902 }
6903 assert (i < sizeof (buf));
6904 offset = read_uleb128 (buf, &len);
6905 assert (len == i + 1);
6906 offset = offset * 8 + 0x408;
6907 printf (_("sp = sp + %ld"), offset);
6908 }
6909 else if ((op & 0xf0) == 0xe0)
6910 {
6911 if ((op & 0x0f) == 7)
6912 printf (" RETURN");
6913 else
6914 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
6915 }
6916 else
6917 {
6918 printf (_(" [unsupported opcode]"));
6919 }
6920 putchar ('\n');
6921 }
6922}
6923
6924static bfd_vma
a734115a 6925arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 6926{
6927 bfd_vma offset;
6928
6929 offset = word & 0x7fffffff;
6930 if (offset & 0x40000000)
6931 offset |= ~ (bfd_vma) 0x7fffffff;
6932
6933 if (elf_header.e_machine == EM_TI_C6000)
6934 offset <<= 1;
6935
6936 return offset + where;
6937}
6938
6939static void
1b31d05e
NC		 6940decode_arm_unwind (struct arm_unw_aux_info * aux,
6941 unsigned int word,
6942 unsigned int remaining,
6943 bfd_vma data_offset,
6944 Elf_Internal_Shdr * data_sec,
6945 struct arm_section * data_arm_sec)
fa197c1c
PB		 6946{
6947 int per_index;
6948 unsigned int more_words = 0;
6949 struct absaddr addr;
1b31d05e 6950 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 6951
6952 if (remaining == 0)
6953 {
1b31d05e
NC		 6954 /* Fetch the first word.
6955 Note - when decoding an object file the address extracted
6956 here will always be 0. So we also pass in the sym_name
6957 parameter so that we can find the symbol associated with
6958 the personality routine. */
6959 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
6960 & word, & addr, & sym_name))
fa197c1c 6961 return;
1b31d05e 6962
fa197c1c
PB		 6963 remaining = 4;
6964 }
6965
6966 if ((word & 0x80000000) == 0)
6967 {
6968 /* Expand prel31 for personality routine. */
6969 bfd_vma fn;
6970 const char *procname;
6971
a734115a 6972 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 6973 printf (_(" Personality routine: "));
1b31d05e
NC		 6974 if (fn == 0
6975 && addr.section == SHN_UNDEF && addr.offset == 0
6976 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
6977 {
6978 procname = aux->strtab + sym_name;
6979 print_vma (fn, PREFIX_HEX);
6980 if (procname)
6981 {
6982 fputs (" <", stdout);
6983 fputs (procname, stdout);
6984 fputc ('>', stdout);
6985 }
6986 }
6987 else
6988 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 6989 fputc ('\n', stdout);
6990
6991 /* The GCC personality routines use the standard compact
6992 encoding, starting with one byte giving the number of
6993 words. */
6994 if (procname != NULL
6995 && (const_strneq (procname, "__gcc_personality_v0")
6996 || const_strneq (procname, "__gxx_personality_v0")
6997 || const_strneq (procname, "__gcj_personality_v0")
6998 || const_strneq (procname, "__gnu_objc_personality_v0")))
6999 {
7000 remaining = 0;
7001 more_words = 1;
7002 ADVANCE;
7003 if (!remaining)
7004 {
7005 printf (_(" [Truncated data]\n"));
7006 return;
7007 }
7008 more_words = word >> 24;
7009 word <<= 8;
7010 remaining--;
7011 per_index = -1;
7012 }
7013 else
7014 return;
7015 }
7016 else
7017 {
1b31d05e
NC		 7018 /* ARM EHABI Section 6.3:
7019
7020 An exception-handling table entry for the compact model looks like:
7021
7022 31 30-28 27-24 23-0
7023 -- ----- ----- ----
7024 1 0 index Data for personalityRoutine[index] */
7025
7026 if (elf_header.e_machine == EM_ARM
7027 && (word & 0x70000000))
83c257ca 7028 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 7029
fa197c1c 7030 per_index = (word >> 24) & 0x7f;
1b31d05e 7031 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 7032 if (per_index == 0)
7033 {
7034 more_words = 0;
7035 word <<= 8;
7036 remaining--;
7037 }
7038 else if (per_index < 3)
7039 {
7040 more_words = (word >> 16) & 0xff;
7041 word <<= 16;
7042 remaining -= 2;
7043 }
7044 }
7045
7046 switch (elf_header.e_machine)
7047 {
7048 case EM_ARM:
7049 if (per_index < 3)
7050 {
7051 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7052 data_offset, data_sec, data_arm_sec);
7053 }
7054 else
1b31d05e
NC		 7055 {
7056 warn (_("Unknown ARM compact model index encountered\n"));
7057 printf (_(" [reserved]\n"));
7058 }
fa197c1c
PB		 7059 break;
7060
7061 case EM_TI_C6000:
7062 if (per_index < 3)
7063 {
7064 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 7065 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 7066 }
7067 else if (per_index < 5)
7068 {
7069 if (((word >> 17) & 0x7f) == 0x7f)
7070 printf (_(" Restore stack from frame pointer\n"));
7071 else
7072 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
7073 printf (_(" Registers restored: "));
7074 if (per_index == 4)
7075 printf (" (compact) ");
7076 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7077 putchar ('\n');
7078 printf (_(" Return register: %s\n"),
7079 tic6x_unwind_regnames[word & 0xf]);
7080 }
7081 else
1b31d05e 7082 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 7083 break;
7084
7085 default:
1b31d05e
NC		 7086 error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7087 elf_header.e_machine);
fa197c1c 7088 }
0b6ae522
DJ		 7089
7090 /* Decode the descriptors. Not implemented. */
7091}
7092
7093static void
7094dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7095{
7096 struct arm_section exidx_arm_sec, extab_arm_sec;
7097 unsigned int i, exidx_len;
7098
7099 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7100 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7101 exidx_len = exidx_sec->sh_size / 8;
7102
7103 for (i = 0; i < exidx_len; i++)
7104 {
7105 unsigned int exidx_fn, exidx_entry;
7106 struct absaddr fn_addr, entry_addr;
7107 bfd_vma fn;
7108
7109 fputc ('\n', stdout);
7110
1b31d05e
NC		 7111 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7112 8 * i, & exidx_fn, & fn_addr, NULL)
7113 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7114 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 7115 {
1b31d05e
NC		 7116 arm_free_section (& exidx_arm_sec);
7117 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 7118 return;
7119 }
7120
83c257ca
NC		 7121 /* ARM EHABI, Section 5:
7122 An index table entry consists of 2 words.
7123 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7124 if (exidx_fn & 0x80000000)
7125 warn (_("corrupt index table entry: %x\n"), exidx_fn);
7126
a734115a 7127 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 7128
a734115a 7129 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 7130 fputs (": ", stdout);
7131
7132 if (exidx_entry == 1)
7133 {
7134 print_vma (exidx_entry, PREFIX_HEX);
7135 fputs (" [cantunwind]\n", stdout);
7136 }
7137 else if (exidx_entry & 0x80000000)
7138 {
7139 print_vma (exidx_entry, PREFIX_HEX);
7140 fputc ('\n', stdout);
7141 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7142 }
7143 else
7144 {
8f73510c 7145 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 7146 Elf_Internal_Shdr *table_sec;
7147
7148 fputs ("@", stdout);
a734115a 7149 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 7150 print_vma (table, PREFIX_HEX);
7151 printf ("\n");
7152
7153 /* Locate the matching .ARM.extab. */
7154 if (entry_addr.section != SHN_UNDEF
7155 && entry_addr.section < elf_header.e_shnum)
7156 {
7157 table_sec = section_headers + entry_addr.section;
7158 table_offset = entry_addr.offset;
7159 }
7160 else
7161 {
7162 table_sec = find_section_by_address (table);
7163 if (table_sec != NULL)
7164 table_offset = table - table_sec->sh_addr;
7165 }
7166 if (table_sec == NULL)
7167 {
7168 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7169 (unsigned long) table);
7170 continue;
7171 }
7172 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7173 &extab_arm_sec);
7174 }
7175 }
7176
7177 printf ("\n");
7178
7179 arm_free_section (&exidx_arm_sec);
7180 arm_free_section (&extab_arm_sec);
7181}
7182
fa197c1c 7183/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 7184
7185static void
0b6ae522
DJ		 7186arm_process_unwind (FILE *file)
7187{
7188 struct arm_unw_aux_info aux;
7189 Elf_Internal_Shdr *unwsec = NULL;
7190 Elf_Internal_Shdr *strsec;
7191 Elf_Internal_Shdr *sec;
7192 unsigned long i;
fa197c1c 7193 unsigned int sec_type;
0b6ae522 7194
fa197c1c
PB		 7195 switch (elf_header.e_machine)
7196 {
7197 case EM_ARM:
7198 sec_type = SHT_ARM_EXIDX;
7199 break;
7200
7201 case EM_TI_C6000:
7202 sec_type = SHT_C6000_UNWIND;
7203 break;
7204
1b31d05e
NC		 7205 default:
7206 error (_("Unsupported architecture type %d encountered when processing unwind table"),
7207 elf_header.e_machine);
7208 return;
fa197c1c
PB		 7209 }
7210
0b6ae522 7211 if (string_table == NULL)
1b31d05e
NC		 7212 return;
7213
7214 memset (& aux, 0, sizeof (aux));
7215 aux.file = file;
0b6ae522
DJ		 7216
7217 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7218 {
7219 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7220 {
ba5cdace 7221 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 7222
7223 strsec = section_headers + sec->sh_link;
59245841 7224 assert (aux.strtab == NULL);
0b6ae522
DJ		 7225 aux.strtab = get_data (NULL, file, strsec->sh_offset,
7226 1, strsec->sh_size, _("string table"));
7227 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7228 }
fa197c1c 7229 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 7230 unwsec = sec;
7231 }
7232
1b31d05e 7233 if (unwsec == NULL)
0b6ae522 7234 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 7235 else
7236 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7237 {
7238 if (sec->sh_type == sec_type)
7239 {
7240 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7241 SECTION_NAME (sec),
7242 (unsigned long) sec->sh_offset,
7243 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 7244
1b31d05e
NC		 7245 dump_arm_unwind (&aux, sec);
7246 }
7247 }
0b6ae522
DJ		 7248
7249 if (aux.symtab)
7250 free (aux.symtab);
7251 if (aux.strtab)
7252 free ((char *) aux.strtab);
0b6ae522
DJ		 7253}
7254
1b31d05e 7255static void
2cf0635d 7256process_unwind (FILE * file)
57346661 7257{
2cf0635d
NC		 7258 struct unwind_handler
7259 {
57346661 7260 int machtype;
1b31d05e 7261 void (* handler)(FILE *);
2cf0635d
NC		 7262 } handlers[] =
7263 {
0b6ae522 7264 { EM_ARM, arm_process_unwind },
57346661
AM		 7265 { EM_IA_64, ia64_process_unwind },
7266 { EM_PARISC, hppa_process_unwind },
fa197c1c 7267 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 7268 { 0, 0 }
7269 };
7270 int i;
7271
7272 if (!do_unwind)
1b31d05e 7273 return;
57346661
AM		 7274
7275 for (i = 0; handlers[i].handler != NULL; i++)
7276 if (elf_header.e_machine == handlers[i].machtype)
18bd398b 7277 return handlers[i].handler (file);
57346661 7278
1b31d05e
NC		 7279 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7280 get_machine_name (elf_header.e_machine));
57346661
AM		 7281}
7282
252b5132 7283static void
2cf0635d 7284dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 7285{
7286 switch (entry->d_tag)
7287 {
7288 case DT_MIPS_FLAGS:
7289 if (entry->d_un.d_val == 0)
4b68bca3 7290 printf (_("NONE"));
252b5132
RH		 7291 else
7292 {
7293 static const char * opts[] =
7294 {
7295 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7296 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7297 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7298 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7299 "RLD_ORDER_SAFE"
7300 };
7301 unsigned int cnt;
7302 int first = 1;
2b692964 7303
60bca95a 7304 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 7305 if (entry->d_un.d_val & (1 << cnt))
7306 {
7307 printf ("%s%s", first ? "" : " ", opts[cnt]);
7308 first = 0;
7309 }
252b5132
RH		 7310 }
7311 break;
103f02d3 7312
252b5132 7313 case DT_MIPS_IVERSION:
d79b3d50 7314 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 7315 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 7316 else
4b68bca3 7317 printf (_("<corrupt: %" BFD_VMA_FMT "d>"), entry->d_un.d_ptr);
252b5132 7318 break;
103f02d3 7319
252b5132
RH		 7320 case DT_MIPS_TIME_STAMP:
7321 {
7322 char timebuf[20];
2cf0635d 7323 struct tm * tmp;
50da7a9c 7324
91d6fa6a
NC		 7325 time_t atime = entry->d_un.d_val;
7326 tmp = gmtime (&atime);
e9e44622
JJ		 7327 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7328 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7329 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 7330 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 7331 }
7332 break;
103f02d3 7333
252b5132
RH		 7334 case DT_MIPS_RLD_VERSION:
7335 case DT_MIPS_LOCAL_GOTNO:
7336 case DT_MIPS_CONFLICTNO:
7337 case DT_MIPS_LIBLISTNO:
7338 case DT_MIPS_SYMTABNO:
7339 case DT_MIPS_UNREFEXTNO:
7340 case DT_MIPS_HIPAGENO:
7341 case DT_MIPS_DELTA_CLASS_NO:
7342 case DT_MIPS_DELTA_INSTANCE_NO:
7343 case DT_MIPS_DELTA_RELOC_NO:
7344 case DT_MIPS_DELTA_SYM_NO:
7345 case DT_MIPS_DELTA_CLASSSYM_NO:
7346 case DT_MIPS_COMPACT_SIZE:
4b68bca3 7347 print_vma (entry->d_un.d_ptr, DEC);
252b5132 7348 break;
103f02d3
UD		 7349
7350 default:
4b68bca3 7351 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 7352 }
4b68bca3 7353 putchar ('\n');
103f02d3
UD		 7354}
7355
103f02d3 7356static void
2cf0635d 7357dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 7358{
7359 switch (entry->d_tag)
7360 {
7361 case DT_HP_DLD_FLAGS:
7362 {
7363 static struct
7364 {
7365 long int bit;
2cf0635d 7366 const char * str;
5e220199
NC		 7367 }
7368 flags[] =
7369 {
7370 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7371 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7372 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7373 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7374 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7375 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7376 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7377 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7378 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7379 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 7380 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7381 { DT_HP_GST, "HP_GST" },
7382 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7383 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7384 { DT_HP_NODELETE, "HP_NODELETE" },
7385 { DT_HP_GROUP, "HP_GROUP" },
7386 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 7387 };
103f02d3 7388 int first = 1;
5e220199 7389 size_t cnt;
f7a99963 7390 bfd_vma val = entry->d_un.d_val;
103f02d3 7391
60bca95a 7392 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 7393 if (val & flags[cnt].bit)
30800947
NC		 7394 {
7395 if (! first)
7396 putchar (' ');
7397 fputs (flags[cnt].str, stdout);
7398 first = 0;
7399 val ^= flags[cnt].bit;
7400 }
76da6bbe 7401
103f02d3 7402 if (val != 0 || first)
f7a99963
NC		 7403 {
7404 if (! first)
7405 putchar (' ');
7406 print_vma (val, HEX);
7407 }
103f02d3
UD		 7408 }
7409 break;
76da6bbe 7410
252b5132 7411 default:
f7a99963
NC		 7412 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7413 break;
252b5132 7414 }
35b1837e 7415 putchar ('\n');
252b5132
RH		 7416}
7417
28f997cf
TG		 7418#ifdef BFD64
7419
7420/* VMS vs Unix time offset and factor. */
7421
7422#define VMS_EPOCH_OFFSET 35067168000000000LL
7423#define VMS_GRANULARITY_FACTOR 10000000
7424
7425/* Display a VMS time in a human readable format. */
7426
7427static void
7428print_vms_time (bfd_int64_t vmstime)
7429{
7430 struct tm *tm;
7431 time_t unxtime;
7432
7433 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7434 tm = gmtime (&unxtime);
7435 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7436 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7437 tm->tm_hour, tm->tm_min, tm->tm_sec);
7438}
7439#endif /* BFD64 */
7440
ecc51f48 7441static void
2cf0635d 7442dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 7443{
7444 switch (entry->d_tag)
7445 {
0de14b54 7446 case DT_IA_64_PLT_RESERVE:
bdf4d63a 7447 /* First 3 slots reserved. */
ecc51f48
NC		 7448 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7449 printf (" -- ");
7450 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 7451 break;
7452
28f997cf
TG		 7453 case DT_IA_64_VMS_LINKTIME:
7454#ifdef BFD64
7455 print_vms_time (entry->d_un.d_val);
7456#endif
7457 break;
7458
7459 case DT_IA_64_VMS_LNKFLAGS:
7460 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7461 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7462 printf (" CALL_DEBUG");
7463 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7464 printf (" NOP0BUFS");
7465 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7466 printf (" P0IMAGE");
7467 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7468 printf (" MKTHREADS");
7469 if (entry->d_un.d_val & VMS_LF_UPCALLS)
7470 printf (" UPCALLS");
7471 if (entry->d_un.d_val & VMS_LF_IMGSTA)
7472 printf (" IMGSTA");
7473 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7474 printf (" INITIALIZE");
7475 if (entry->d_un.d_val & VMS_LF_MAIN)
7476 printf (" MAIN");
7477 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7478 printf (" EXE_INIT");
7479 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7480 printf (" TBK_IN_IMG");
7481 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7482 printf (" DBG_IN_IMG");
7483 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7484 printf (" TBK_IN_DSF");
7485 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7486 printf (" DBG_IN_DSF");
7487 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7488 printf (" SIGNATURES");
7489 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7490 printf (" REL_SEG_OFF");
7491 break;
7492
bdf4d63a
JJ		 7493 default:
7494 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7495 break;
ecc51f48 7496 }
bdf4d63a 7497 putchar ('\n');
ecc51f48
NC		 7498}
7499
252b5132 7500static int
2cf0635d 7501get_32bit_dynamic_section (FILE * file)
252b5132 7502{
2cf0635d
NC		 7503 Elf32_External_Dyn * edyn;
7504 Elf32_External_Dyn * ext;
7505 Elf_Internal_Dyn * entry;
103f02d3 7506
3f5e193b
NC		 7507 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7508 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 7509 if (!edyn)
7510 return 0;
103f02d3 7511
ba2685cc
AM		 7512/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7513 might not have the luxury of section headers. Look for the DT_NULL
7514 terminator to determine the number of entries. */
7515 for (ext = edyn, dynamic_nent = 0;
7516 (char *) ext < (char *) edyn + dynamic_size;
7517 ext++)
7518 {
7519 dynamic_nent++;
7520 if (BYTE_GET (ext->d_tag) == DT_NULL)
7521 break;
7522 }
252b5132 7523
3f5e193b
NC		 7524 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7525 sizeof (* entry));
b2d38a17 7526 if (dynamic_section == NULL)
252b5132 7527 {
9ea033b2
NC		 7528 error (_("Out of memory\n"));
7529 free (edyn);
7530 return 0;
7531 }
252b5132 7532
fb514b26 7533 for (ext = edyn, entry = dynamic_section;
ba2685cc 7534 entry < dynamic_section + dynamic_nent;
fb514b26 7535 ext++, entry++)
9ea033b2 7536 {
fb514b26
AM		 7537 entry->d_tag = BYTE_GET (ext->d_tag);
7538 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 7539 }
7540
9ea033b2
NC		 7541 free (edyn);
7542
7543 return 1;
7544}
7545
7546static int
2cf0635d 7547get_64bit_dynamic_section (FILE * file)
9ea033b2 7548{
2cf0635d
NC		 7549 Elf64_External_Dyn * edyn;
7550 Elf64_External_Dyn * ext;
7551 Elf_Internal_Dyn * entry;
103f02d3 7552
3f5e193b
NC		 7553 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7554 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 7555 if (!edyn)
7556 return 0;
103f02d3 7557
ba2685cc
AM		 7558/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7559 might not have the luxury of section headers. Look for the DT_NULL
7560 terminator to determine the number of entries. */
7561 for (ext = edyn, dynamic_nent = 0;
7562 (char *) ext < (char *) edyn + dynamic_size;
7563 ext++)
7564 {
7565 dynamic_nent++;
66543521 7566 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 7567 break;
7568 }
252b5132 7569
3f5e193b
NC		 7570 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7571 sizeof (* entry));
b2d38a17 7572 if (dynamic_section == NULL)
252b5132
RH		 7573 {
7574 error (_("Out of memory\n"));
7575 free (edyn);
7576 return 0;
7577 }
7578
fb514b26 7579 for (ext = edyn, entry = dynamic_section;
ba2685cc 7580 entry < dynamic_section + dynamic_nent;
fb514b26 7581 ext++, entry++)
252b5132 7582 {
66543521
AM		 7583 entry->d_tag = BYTE_GET (ext->d_tag);
7584 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 7585 }
7586
7587 free (edyn);
7588
9ea033b2
NC		 7589 return 1;
7590}
7591
e9e44622
JJ		 7592static void
7593print_dynamic_flags (bfd_vma flags)
d1133906 7594{
e9e44622 7595 int first = 1;
13ae64f3 7596
d1133906
NC		 7597 while (flags)
7598 {
7599 bfd_vma flag;
7600
7601 flag = flags & - flags;
7602 flags &= ~ flag;
7603
e9e44622
JJ		 7604 if (first)
7605 first = 0;
7606 else
7607 putc (' ', stdout);
13ae64f3 7608
d1133906
NC		 7609 switch (flag)
7610 {
e9e44622
JJ		 7611 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
7612 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
7613 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
7614 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
7615 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 7616 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 7617 }
7618 }
e9e44622 7619 puts ("");
d1133906
NC		 7620}
7621
b2d38a17
NC		 7622/* Parse and display the contents of the dynamic section. */
7623
9ea033b2 7624static int
2cf0635d 7625process_dynamic_section (FILE * file)
9ea033b2 7626{
2cf0635d 7627 Elf_Internal_Dyn * entry;
9ea033b2
NC		 7628
7629 if (dynamic_size == 0)
7630 {
7631 if (do_dynamic)
b2d38a17 7632 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 7633
7634 return 1;
7635 }
7636
7637 if (is_32bit_elf)
7638 {
b2d38a17 7639 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 7640 return 0;
7641 }
b2d38a17 7642 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 7643 return 0;
7644
252b5132
RH		 7645 /* Find the appropriate symbol table. */
7646 if (dynamic_symbols == NULL)
7647 {
86dba8ee
AM		 7648 for (entry = dynamic_section;
7649 entry < dynamic_section + dynamic_nent;
7650 ++entry)
252b5132 7651 {
c8286bd1 7652 Elf_Internal_Shdr section;
252b5132
RH		 7653
7654 if (entry->d_tag != DT_SYMTAB)
7655 continue;
7656
7657 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7658
7659 /* Since we do not know how big the symbol table is,
7660 we default to reading in the entire file (!) and
7661 processing that. This is overkill, I know, but it
e3c8793a 7662 should work. */
d93f0186 7663 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 7664
fb52b2f4
NC		 7665 if (archive_file_offset != 0)
7666 section.sh_size = archive_file_size - section.sh_offset;
7667 else
7668 {
7669 if (fseek (file, 0, SEEK_END))
591a748a 7670 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 7671
7672 section.sh_size = ftell (file) - section.sh_offset;
7673 }
252b5132 7674
9ea033b2 7675 if (is_32bit_elf)
9ad5cbcf 7676 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 7677 else
9ad5cbcf 7678 section.sh_entsize = sizeof (Elf64_External_Sym);
252b5132 7679
ba5cdace 7680 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 7681 if (num_dynamic_syms < 1)
252b5132
RH		 7682 {
7683 error (_("Unable to determine the number of symbols to load\n"));
7684 continue;
7685 }
252b5132
RH		 7686 }
7687 }
7688
7689 /* Similarly find a string table. */
7690 if (dynamic_strings == NULL)
7691 {
86dba8ee
AM		 7692 for (entry = dynamic_section;
7693 entry < dynamic_section + dynamic_nent;
7694 ++entry)
252b5132
RH		 7695 {
7696 unsigned long offset;
b34976b6 7697 long str_tab_len;
252b5132
RH		 7698
7699 if (entry->d_tag != DT_STRTAB)
7700 continue;
7701
7702 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7703
7704 /* Since we do not know how big the string table is,
7705 we default to reading in the entire file (!) and
7706 processing that. This is overkill, I know, but it
e3c8793a 7707 should work. */
252b5132 7708
d93f0186 7709 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 7710
7711 if (archive_file_offset != 0)
7712 str_tab_len = archive_file_size - offset;
7713 else
7714 {
7715 if (fseek (file, 0, SEEK_END))
7716 error (_("Unable to seek to end of file\n"));
7717 str_tab_len = ftell (file) - offset;
7718 }
252b5132
RH		 7719
7720 if (str_tab_len < 1)
7721 {
7722 error
7723 (_("Unable to determine the length of the dynamic string table\n"));
7724 continue;
7725 }
7726
3f5e193b
NC		 7727 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7728 str_tab_len,
7729 _("dynamic string table"));
59245841 7730 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 7731 break;
7732 }
7733 }
7734
7735 /* And find the syminfo section if available. */
7736 if (dynamic_syminfo == NULL)
7737 {
3e8bba36 7738 unsigned long syminsz = 0;
252b5132 7739
86dba8ee
AM		 7740 for (entry = dynamic_section;
7741 entry < dynamic_section + dynamic_nent;
7742 ++entry)
252b5132
RH		 7743 {
7744 if (entry->d_tag == DT_SYMINENT)
7745 {
7746 /* Note: these braces are necessary to avoid a syntax
7747 error from the SunOS4 C compiler. */
7748 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7749 }
7750 else if (entry->d_tag == DT_SYMINSZ)
7751 syminsz = entry->d_un.d_val;
7752 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 7753 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7754 syminsz);
252b5132
RH		 7755 }
7756
7757 if (dynamic_syminfo_offset != 0 && syminsz != 0)
7758 {
2cf0635d
NC		 7759 Elf_External_Syminfo * extsyminfo;
7760 Elf_External_Syminfo * extsym;
7761 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 7762
7763 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 7764 extsyminfo = (Elf_External_Syminfo *)
7765 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
7766 _("symbol information"));
a6e9f9df
AM		 7767 if (!extsyminfo)
7768 return 0;
252b5132 7769
3f5e193b 7770 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 7771 if (dynamic_syminfo == NULL)
7772 {
7773 error (_("Out of memory\n"));
7774 return 0;
7775 }
7776
7777 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 7778 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
7779 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
7780 ++syminfo, ++extsym)
252b5132 7781 {
86dba8ee
AM		 7782 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
7783 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 7784 }
7785
7786 free (extsyminfo);
7787 }
7788 }
7789
7790 if (do_dynamic && dynamic_addr)
86dba8ee
AM		 7791 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7792 dynamic_addr, dynamic_nent);
252b5132
RH		 7793 if (do_dynamic)
7794 printf (_(" Tag Type Name/Value\n"));
7795
86dba8ee
AM		 7796 for (entry = dynamic_section;
7797 entry < dynamic_section + dynamic_nent;
7798 entry++)
252b5132
RH		 7799 {
7800 if (do_dynamic)
f7a99963 7801 {
2cf0635d 7802 const char * dtype;
e699b9ff 7803
f7a99963
NC		 7804 putchar (' ');
7805 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 7806 dtype = get_dynamic_type (entry->d_tag);
7807 printf (" (%s)%*s", dtype,
7808 ((is_32bit_elf ? 27 : 19)
7809 - (int) strlen (dtype)),
f7a99963
NC		 7810 " ");
7811 }
252b5132
RH		 7812
7813 switch (entry->d_tag)
7814 {
d1133906
NC		 7815 case DT_FLAGS:
7816 if (do_dynamic)
e9e44622 7817 print_dynamic_flags (entry->d_un.d_val);
d1133906 7818 break;
76da6bbe 7819
252b5132
RH		 7820 case DT_AUXILIARY:
7821 case DT_FILTER:
019148e4
L		 7822 case DT_CONFIG:
7823 case DT_DEPAUDIT:
7824 case DT_AUDIT:
252b5132
RH		 7825 if (do_dynamic)
7826 {
019148e4 7827 switch (entry->d_tag)
b34976b6 7828 {
019148e4
L		 7829 case DT_AUXILIARY:
7830 printf (_("Auxiliary library"));
7831 break;
7832
7833 case DT_FILTER:
7834 printf (_("Filter library"));
7835 break;
7836
b34976b6 7837 case DT_CONFIG:
019148e4
L		 7838 printf (_("Configuration file"));
7839 break;
7840
7841 case DT_DEPAUDIT:
7842 printf (_("Dependency audit library"));
7843 break;
7844
7845 case DT_AUDIT:
7846 printf (_("Audit library"));
7847 break;
7848 }
252b5132 7849
d79b3d50
NC		 7850 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7851 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 7852 else
f7a99963
NC		 7853 {
7854 printf (": ");
7855 print_vma (entry->d_un.d_val, PREFIX_HEX);
7856 putchar ('\n');
7857 }
252b5132
RH		 7858 }
7859 break;
7860
dcefbbbd 7861 case DT_FEATURE:
252b5132
RH		 7862 if (do_dynamic)
7863 {
7864 printf (_("Flags:"));
86f55779 7865
252b5132
RH		 7866 if (entry->d_un.d_val == 0)
7867 printf (_(" None\n"));
7868 else
7869 {
7870 unsigned long int val = entry->d_un.d_val;
86f55779 7871
252b5132
RH		 7872 if (val & DTF_1_PARINIT)
7873 {
7874 printf (" PARINIT");
7875 val ^= DTF_1_PARINIT;
7876 }
dcefbbbd
L		 7877 if (val & DTF_1_CONFEXP)
7878 {
7879 printf (" CONFEXP");
7880 val ^= DTF_1_CONFEXP;
7881 }
252b5132
RH		 7882 if (val != 0)
7883 printf (" %lx", val);
7884 puts ("");
7885 }
7886 }
7887 break;
7888
7889 case DT_POSFLAG_1:
7890 if (do_dynamic)
7891 {
7892 printf (_("Flags:"));
86f55779 7893
252b5132
RH		 7894 if (entry->d_un.d_val == 0)
7895 printf (_(" None\n"));
7896 else
7897 {
7898 unsigned long int val = entry->d_un.d_val;
86f55779 7899
252b5132
RH		 7900 if (val & DF_P1_LAZYLOAD)
7901 {
7902 printf (" LAZYLOAD");
7903 val ^= DF_P1_LAZYLOAD;
7904 }
7905 if (val & DF_P1_GROUPPERM)
7906 {
7907 printf (" GROUPPERM");
7908 val ^= DF_P1_GROUPPERM;
7909 }
7910 if (val != 0)
7911 printf (" %lx", val);
7912 puts ("");
7913 }
7914 }
7915 break;
7916
7917 case DT_FLAGS_1:
7918 if (do_dynamic)
7919 {
7920 printf (_("Flags:"));
7921 if (entry->d_un.d_val == 0)
7922 printf (_(" None\n"));
7923 else
7924 {
7925 unsigned long int val = entry->d_un.d_val;
86f55779 7926
252b5132
RH		 7927 if (val & DF_1_NOW)
7928 {
7929 printf (" NOW");
7930 val ^= DF_1_NOW;
7931 }
7932 if (val & DF_1_GLOBAL)
7933 {
7934 printf (" GLOBAL");
7935 val ^= DF_1_GLOBAL;
7936 }
7937 if (val & DF_1_GROUP)
7938 {
7939 printf (" GROUP");
7940 val ^= DF_1_GROUP;
7941 }
7942 if (val & DF_1_NODELETE)
7943 {
7944 printf (" NODELETE");
7945 val ^= DF_1_NODELETE;
7946 }
7947 if (val & DF_1_LOADFLTR)
7948 {
7949 printf (" LOADFLTR");
7950 val ^= DF_1_LOADFLTR;
7951 }
7952 if (val & DF_1_INITFIRST)
7953 {
7954 printf (" INITFIRST");
7955 val ^= DF_1_INITFIRST;
7956 }
7957 if (val & DF_1_NOOPEN)
7958 {
7959 printf (" NOOPEN");
7960 val ^= DF_1_NOOPEN;
7961 }
7962 if (val & DF_1_ORIGIN)
7963 {
7964 printf (" ORIGIN");
7965 val ^= DF_1_ORIGIN;
7966 }
7967 if (val & DF_1_DIRECT)
7968 {
7969 printf (" DIRECT");
7970 val ^= DF_1_DIRECT;
7971 }
7972 if (val & DF_1_TRANS)
7973 {
7974 printf (" TRANS");
7975 val ^= DF_1_TRANS;
7976 }
7977 if (val & DF_1_INTERPOSE)
7978 {
7979 printf (" INTERPOSE");
7980 val ^= DF_1_INTERPOSE;
7981 }
f7db6139 7982 if (val & DF_1_NODEFLIB)
dcefbbbd 7983 {
f7db6139
L		 7984 printf (" NODEFLIB");
7985 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 7986 }
7987 if (val & DF_1_NODUMP)
7988 {
7989 printf (" NODUMP");
7990 val ^= DF_1_NODUMP;
7991 }
7992 if (val & DF_1_CONLFAT)
7993 {
7994 printf (" CONLFAT");
7995 val ^= DF_1_CONLFAT;
7996 }
252b5132
RH		 7997 if (val != 0)
7998 printf (" %lx", val);
7999 puts ("");
8000 }
8001 }
8002 break;
8003
8004 case DT_PLTREL:
566b0d53 8005 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 8006 if (do_dynamic)
8007 puts (get_dynamic_type (entry->d_un.d_val));
8008 break;
8009
8010 case DT_NULL :
8011 case DT_NEEDED :
8012 case DT_PLTGOT :
8013 case DT_HASH :
8014 case DT_STRTAB :
8015 case DT_SYMTAB :
8016 case DT_RELA :
8017 case DT_INIT :
8018 case DT_FINI :
8019 case DT_SONAME :
8020 case DT_RPATH :
8021 case DT_SYMBOLIC:
8022 case DT_REL :
8023 case DT_DEBUG :
8024 case DT_TEXTREL :
8025 case DT_JMPREL :
019148e4 8026 case DT_RUNPATH :
252b5132
RH		 8027 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8028
8029 if (do_dynamic)
8030 {
2cf0635d 8031 char * name;
252b5132 8032
d79b3d50
NC		 8033 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8034 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 8035 else
d79b3d50 8036 name = NULL;
252b5132
RH		 8037
8038 if (name)
8039 {
8040 switch (entry->d_tag)
8041 {
8042 case DT_NEEDED:
8043 printf (_("Shared library: [%s]"), name);
8044
18bd398b 8045 if (streq (name, program_interpreter))
f7a99963 8046 printf (_(" program interpreter"));
252b5132
RH		 8047 break;
8048
8049 case DT_SONAME:
f7a99963 8050 printf (_("Library soname: [%s]"), name);
252b5132
RH		 8051 break;
8052
8053 case DT_RPATH:
f7a99963 8054 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 8055 break;
8056
019148e4
L		 8057 case DT_RUNPATH:
8058 printf (_("Library runpath: [%s]"), name);
8059 break;
8060
252b5132 8061 default:
f7a99963
NC		 8062 print_vma (entry->d_un.d_val, PREFIX_HEX);
8063 break;
252b5132
RH		 8064 }
8065 }
8066 else
f7a99963
NC		 8067 print_vma (entry->d_un.d_val, PREFIX_HEX);
8068
8069 putchar ('\n');
252b5132
RH		 8070 }
8071 break;
8072
8073 case DT_PLTRELSZ:
8074 case DT_RELASZ :
8075 case DT_STRSZ :
8076 case DT_RELSZ :
8077 case DT_RELAENT :
8078 case DT_SYMENT :
8079 case DT_RELENT :
566b0d53 8080 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 8081 case DT_PLTPADSZ:
8082 case DT_MOVEENT :
8083 case DT_MOVESZ :
8084 case DT_INIT_ARRAYSZ:
8085 case DT_FINI_ARRAYSZ:
047b2264
JJ		 8086 case DT_GNU_CONFLICTSZ:
8087 case DT_GNU_LIBLISTSZ:
252b5132 8088 if (do_dynamic)
f7a99963
NC		 8089 {
8090 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 8091 printf (_(" (bytes)\n"));
f7a99963 8092 }
252b5132
RH		 8093 break;
8094
8095 case DT_VERDEFNUM:
8096 case DT_VERNEEDNUM:
8097 case DT_RELACOUNT:
8098 case DT_RELCOUNT:
8099 if (do_dynamic)
f7a99963
NC		 8100 {
8101 print_vma (entry->d_un.d_val, UNSIGNED);
8102 putchar ('\n');
8103 }
252b5132
RH		 8104 break;
8105
8106 case DT_SYMINSZ:
8107 case DT_SYMINENT:
8108 case DT_SYMINFO:
8109 case DT_USED:
8110 case DT_INIT_ARRAY:
8111 case DT_FINI_ARRAY:
8112 if (do_dynamic)
8113 {
d79b3d50
NC		 8114 if (entry->d_tag == DT_USED
8115 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 8116 {
2cf0635d 8117 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 8118
b34976b6 8119 if (*name)
252b5132
RH		 8120 {
8121 printf (_("Not needed object: [%s]\n"), name);
8122 break;
8123 }
8124 }
103f02d3 8125
f7a99963
NC		 8126 print_vma (entry->d_un.d_val, PREFIX_HEX);
8127 putchar ('\n');
252b5132
RH		 8128 }
8129 break;
8130
8131 case DT_BIND_NOW:
8132 /* The value of this entry is ignored. */
35b1837e
AM		 8133 if (do_dynamic)
8134 putchar ('\n');
252b5132 8135 break;
103f02d3 8136
047b2264
JJ		 8137 case DT_GNU_PRELINKED:
8138 if (do_dynamic)
8139 {
2cf0635d 8140 struct tm * tmp;
91d6fa6a 8141 time_t atime = entry->d_un.d_val;
047b2264 8142
91d6fa6a 8143 tmp = gmtime (&atime);
047b2264
JJ		 8144 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8145 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8146 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8147
8148 }
8149 break;
8150
fdc90cb4
JJ		 8151 case DT_GNU_HASH:
8152 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8153 if (do_dynamic)
8154 {
8155 print_vma (entry->d_un.d_val, PREFIX_HEX);
8156 putchar ('\n');
8157 }
8158 break;
8159
252b5132
RH		 8160 default:
8161 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 8162 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 8163 entry->d_un.d_val;
8164
8165 if (do_dynamic)
8166 {
8167 switch (elf_header.e_machine)
8168 {
8169 case EM_MIPS:
4fe85591 8170 case EM_MIPS_RS3_LE:
b2d38a17 8171 dynamic_section_mips_val (entry);
252b5132 8172 break;
103f02d3 8173 case EM_PARISC:
b2d38a17 8174 dynamic_section_parisc_val (entry);
103f02d3 8175 break;
ecc51f48 8176 case EM_IA_64:
b2d38a17 8177 dynamic_section_ia64_val (entry);
ecc51f48 8178 break;
252b5132 8179 default:
f7a99963
NC		 8180 print_vma (entry->d_un.d_val, PREFIX_HEX);
8181 putchar ('\n');
252b5132
RH		 8182 }
8183 }
8184 break;
8185 }
8186 }
8187
8188 return 1;
8189}
8190
8191static char *
d3ba0551 8192get_ver_flags (unsigned int flags)
252b5132 8193{
b34976b6 8194 static char buff[32];
252b5132
RH		 8195
8196 buff[0] = 0;
8197
8198 if (flags == 0)
8199 return _("none");
8200
8201 if (flags & VER_FLG_BASE)
8202 strcat (buff, "BASE ");
8203
8204 if (flags & VER_FLG_WEAK)
8205 {
8206 if (flags & VER_FLG_BASE)
8207 strcat (buff, "| ");
8208
8209 strcat (buff, "WEAK ");
8210 }
8211
44ec90b9
RO		 8212 if (flags & VER_FLG_INFO)
8213 {
8214 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8215 strcat (buff, "| ");
8216
8217 strcat (buff, "INFO ");
8218 }
8219
8220 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 8221 strcat (buff, _("| <unknown>"));
252b5132
RH		 8222
8223 return buff;
8224}
8225
8226/* Display the contents of the version sections. */
98fb390a 8227
252b5132 8228static int
2cf0635d 8229process_version_sections (FILE * file)
252b5132 8230{
2cf0635d 8231 Elf_Internal_Shdr * section;
b34976b6
AM		 8232 unsigned i;
8233 int found = 0;
252b5132
RH		 8234
8235 if (! do_version)
8236 return 1;
8237
8238 for (i = 0, section = section_headers;
8239 i < elf_header.e_shnum;
b34976b6 8240 i++, section++)
252b5132
RH		 8241 {
8242 switch (section->sh_type)
8243 {
8244 case SHT_GNU_verdef:
8245 {
2cf0635d 8246 Elf_External_Verdef * edefs;
b34976b6
AM		 8247 unsigned int idx;
8248 unsigned int cnt;
2cf0635d 8249 char * endbuf;
252b5132
RH		 8250
8251 found = 1;
8252
8253 printf
72de5009 8254 (_("\nVersion definition section '%s' contains %u entries:\n"),
252b5132
RH		 8255 SECTION_NAME (section), section->sh_info);
8256
8257 printf (_(" Addr: 0x"));
8258 printf_vma (section->sh_addr);
72de5009 8259 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8260 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8261 section->sh_link < elf_header.e_shnum
8262 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8263 : _("<corrupt>"));
252b5132 8264
3f5e193b
NC		 8265 edefs = (Elf_External_Verdef *)
8266 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8267 _("version definition section"));
a6e9f9df
AM		 8268 if (!edefs)
8269 break;
59245841 8270 endbuf = (char *) edefs + section->sh_size;
252b5132 8271
b34976b6 8272 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 8273 {
2cf0635d
NC		 8274 char * vstart;
8275 Elf_External_Verdef * edef;
b34976b6 8276 Elf_Internal_Verdef ent;
2cf0635d 8277 Elf_External_Verdaux * eaux;
b34976b6
AM		 8278 Elf_Internal_Verdaux aux;
8279 int j;
8280 int isum;
103f02d3 8281
dd24e3da
NC		 8282 /* Check for negative or very large indicies. */
8283 if ((unsigned char *) edefs + idx < (unsigned char *) edefs)
8284 break;
8285
252b5132 8286 vstart = ((char *) edefs) + idx;
54806181
AM		 8287 if (vstart + sizeof (*edef) > endbuf)
8288 break;
252b5132
RH		 8289
8290 edef = (Elf_External_Verdef *) vstart;
8291
8292 ent.vd_version = BYTE_GET (edef->vd_version);
8293 ent.vd_flags = BYTE_GET (edef->vd_flags);
8294 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
8295 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
8296 ent.vd_hash = BYTE_GET (edef->vd_hash);
8297 ent.vd_aux = BYTE_GET (edef->vd_aux);
8298 ent.vd_next = BYTE_GET (edef->vd_next);
8299
8300 printf (_(" %#06x: Rev: %d Flags: %s"),
8301 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8302
8303 printf (_(" Index: %d Cnt: %d "),
8304 ent.vd_ndx, ent.vd_cnt);
8305
dd24e3da
NC		 8306 /* Check for overflow. */
8307 if ((unsigned char *)(vstart + ent.vd_aux) < (unsigned char *) vstart
8308 || (unsigned char *)(vstart + ent.vd_aux) > (unsigned char *) endbuf)
8309 break;
8310
252b5132
RH		 8311 vstart += ent.vd_aux;
8312
8313 eaux = (Elf_External_Verdaux *) vstart;
8314
8315 aux.vda_name = BYTE_GET (eaux->vda_name);
8316 aux.vda_next = BYTE_GET (eaux->vda_next);
8317
d79b3d50
NC		 8318 if (VALID_DYNAMIC_NAME (aux.vda_name))
8319 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8320 else
8321 printf (_("Name index: %ld\n"), aux.vda_name);
8322
8323 isum = idx + ent.vd_aux;
8324
b34976b6 8325 for (j = 1; j < ent.vd_cnt; j++)
252b5132 8326 {
dd24e3da
NC		 8327 /* Check for overflow. */
8328 if ((unsigned char *)(vstart + aux.vda_next) < (unsigned char *) vstart
8329 || (unsigned char *)(vstart + aux.vda_next) > (unsigned char *) endbuf)
8330 break;
8331
252b5132
RH		 8332 isum += aux.vda_next;
8333 vstart += aux.vda_next;
8334
8335 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 8336 if (vstart + sizeof (*eaux) > endbuf)
8337 break;
252b5132
RH		 8338
8339 aux.vda_name = BYTE_GET (eaux->vda_name);
8340 aux.vda_next = BYTE_GET (eaux->vda_next);
8341
d79b3d50 8342 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 8343 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 8344 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8345 else
8346 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8347 isum, j, aux.vda_name);
8348 }
dd24e3da 8349
54806181
AM		 8350 if (j < ent.vd_cnt)
8351 printf (_(" Version def aux past end of section\n"));
252b5132
RH		 8352
8353 idx += ent.vd_next;
8354 }
dd24e3da 8355
54806181
AM		 8356 if (cnt < section->sh_info)
8357 printf (_(" Version definition past end of section\n"));
252b5132
RH		 8358
8359 free (edefs);
8360 }
8361 break;
103f02d3 8362
252b5132
RH		 8363 case SHT_GNU_verneed:
8364 {
2cf0635d 8365 Elf_External_Verneed * eneed;
b34976b6
AM		 8366 unsigned int idx;
8367 unsigned int cnt;
2cf0635d 8368 char * endbuf;
252b5132
RH		 8369
8370 found = 1;
8371
72de5009 8372 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
252b5132
RH		 8373 SECTION_NAME (section), section->sh_info);
8374
8375 printf (_(" Addr: 0x"));
8376 printf_vma (section->sh_addr);
72de5009 8377 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8378 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8379 section->sh_link < elf_header.e_shnum
8380 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8381 : _("<corrupt>"));
252b5132 8382
3f5e193b
NC		 8383 eneed = (Elf_External_Verneed *) get_data (NULL, file,
8384 section->sh_offset, 1,
8385 section->sh_size,
9cf03b7e 8386 _("Version Needs section"));
a6e9f9df
AM		 8387 if (!eneed)
8388 break;
59245841 8389 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 8390
8391 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8392 {
2cf0635d 8393 Elf_External_Verneed * entry;
b34976b6
AM		 8394 Elf_Internal_Verneed ent;
8395 int j;
8396 int isum;
2cf0635d 8397 char * vstart;
252b5132 8398
dd24e3da
NC		 8399 if ((unsigned char *) eneed + idx < (unsigned char *) eneed)
8400 break;
8401
252b5132 8402 vstart = ((char *) eneed) + idx;
54806181
AM		 8403 if (vstart + sizeof (*entry) > endbuf)
8404 break;
252b5132
RH		 8405
8406 entry = (Elf_External_Verneed *) vstart;
8407
8408 ent.vn_version = BYTE_GET (entry->vn_version);
8409 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
8410 ent.vn_file = BYTE_GET (entry->vn_file);
8411 ent.vn_aux = BYTE_GET (entry->vn_aux);
8412 ent.vn_next = BYTE_GET (entry->vn_next);
8413
8414 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
8415
d79b3d50
NC		 8416 if (VALID_DYNAMIC_NAME (ent.vn_file))
8417 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 8418 else
8419 printf (_(" File: %lx"), ent.vn_file);
8420
8421 printf (_(" Cnt: %d\n"), ent.vn_cnt);
8422
dd24e3da
NC		 8423 /* Check for overflow. */
8424 if ((unsigned char *)(vstart + ent.vn_aux) < (unsigned char *) vstart
8425 || (unsigned char *)(vstart + ent.vn_aux) > (unsigned char *) endbuf)
8426 break;
8427
252b5132
RH		 8428 vstart += ent.vn_aux;
8429
8430 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8431 {
2cf0635d 8432 Elf_External_Vernaux * eaux;
b34976b6 8433 Elf_Internal_Vernaux aux;
252b5132 8434
54806181
AM		 8435 if (vstart + sizeof (*eaux) > endbuf)
8436 break;
252b5132
RH		 8437 eaux = (Elf_External_Vernaux *) vstart;
8438
8439 aux.vna_hash = BYTE_GET (eaux->vna_hash);
8440 aux.vna_flags = BYTE_GET (eaux->vna_flags);
8441 aux.vna_other = BYTE_GET (eaux->vna_other);
8442 aux.vna_name = BYTE_GET (eaux->vna_name);
8443 aux.vna_next = BYTE_GET (eaux->vna_next);
8444
d79b3d50 8445 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 8446 printf (_(" %#06x: Name: %s"),
d79b3d50 8447 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 8448 else
ecc2063b 8449 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 8450 isum, aux.vna_name);
8451
8452 printf (_(" Flags: %s Version: %d\n"),
8453 get_ver_flags (aux.vna_flags), aux.vna_other);
8454
dd24e3da
NC		 8455 /* Check for overflow. */
8456 if ((unsigned char *)(vstart + aux.vna_next) < (unsigned char *) vstart
8457 || (unsigned char *)(vstart + aux.vna_next) > (unsigned char *) endbuf)
8458 break;
8459
252b5132
RH		 8460 isum += aux.vna_next;
8461 vstart += aux.vna_next;
8462 }
9cf03b7e 8463
54806181 8464 if (j < ent.vn_cnt)
9cf03b7e 8465 warn (_("Missing Version Needs auxillary information\n"));
252b5132
RH		 8466
8467 idx += ent.vn_next;
8468 }
9cf03b7e 8469
54806181 8470 if (cnt < section->sh_info)
9cf03b7e 8471 warn (_("Missing Version Needs information\n"));
103f02d3 8472
252b5132
RH		 8473 free (eneed);
8474 }
8475 break;
8476
8477 case SHT_GNU_versym:
8478 {
2cf0635d 8479 Elf_Internal_Shdr * link_section;
b34976b6
AM		 8480 int total;
8481 int cnt;
2cf0635d
NC		 8482 unsigned char * edata;
8483 unsigned short * data;
8484 char * strtab;
8485 Elf_Internal_Sym * symbols;
8486 Elf_Internal_Shdr * string_sec;
ba5cdace 8487 unsigned long num_syms;
d3ba0551 8488 long off;
252b5132 8489
4fbb74a6 8490 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 8491 break;
8492
4fbb74a6 8493 link_section = section_headers + section->sh_link;
08d8fa11 8494 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 8495
4fbb74a6 8496 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 8497 break;
8498
252b5132
RH		 8499 found = 1;
8500
ba5cdace 8501 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 8502 if (symbols == NULL)
8503 break;
252b5132 8504
4fbb74a6 8505 string_sec = section_headers + link_section->sh_link;
252b5132 8506
3f5e193b
NC		 8507 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8508 string_sec->sh_size,
8509 _("version string table"));
a6e9f9df 8510 if (!strtab)
0429c154
MS		 8511 {
8512 free (symbols);
8513 break;
8514 }
252b5132
RH		 8515
8516 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8517 SECTION_NAME (section), total);
8518
8519 printf (_(" Addr: "));
8520 printf_vma (section->sh_addr);
72de5009 8521 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8522 (unsigned long) section->sh_offset, section->sh_link,
252b5132
RH		 8523 SECTION_NAME (link_section));
8524
d3ba0551
AM		 8525 off = offset_from_vma (file,
8526 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8527 total * sizeof (short));
3f5e193b
NC		 8528 edata = (unsigned char *) get_data (NULL, file, off, total,
8529 sizeof (short),
8530 _("version symbol data"));
a6e9f9df
AM		 8531 if (!edata)
8532 {
8533 free (strtab);
0429c154 8534 free (symbols);
a6e9f9df
AM		 8535 break;
8536 }
252b5132 8537
3f5e193b 8538 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 8539
8540 for (cnt = total; cnt --;)
b34976b6
AM		 8541 data[cnt] = byte_get (edata + cnt * sizeof (short),
8542 sizeof (short));
252b5132
RH		 8543
8544 free (edata);
8545
8546 for (cnt = 0; cnt < total; cnt += 4)
8547 {
8548 int j, nn;
00d93f34 8549 int check_def, check_need;
2cf0635d 8550 char * name;
252b5132
RH		 8551
8552 printf (" %03x:", cnt);
8553
8554 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 8555 switch (data[cnt + j])
252b5132
RH		 8556 {
8557 case 0:
8558 fputs (_(" 0 (*local*) "), stdout);
8559 break;
8560
8561 case 1:
8562 fputs (_(" 1 (*global*) "), stdout);
8563 break;
8564
8565 default:
c244d050
NC		 8566 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8567 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 8568
dd24e3da 8569 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 8570 array, break to avoid an out-of-bounds read. */
8571 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 8572 {
8573 warn (_("invalid index into symbol array\n"));
8574 break;
8575 }
8576
00d93f34
JJ		 8577 check_def = 1;
8578 check_need = 1;
4fbb74a6
AM		 8579 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8580 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 8581 != SHT_NOBITS)
252b5132 8582 {
b34976b6 8583 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 8584 check_def = 0;
8585 else
8586 check_need = 0;
252b5132 8587 }
00d93f34
JJ		 8588
8589 if (check_need
b34976b6 8590 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 8591 {
b34976b6
AM		 8592 Elf_Internal_Verneed ivn;
8593 unsigned long offset;
252b5132 8594
d93f0186
NC		 8595 offset = offset_from_vma
8596 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8597 sizeof (Elf_External_Verneed));
252b5132 8598
b34976b6 8599 do
252b5132 8600 {
b34976b6
AM		 8601 Elf_Internal_Vernaux ivna;
8602 Elf_External_Verneed evn;
8603 Elf_External_Vernaux evna;
8604 unsigned long a_off;
252b5132 8605
59245841
NC		 8606 if (get_data (&evn, file, offset, sizeof (evn), 1,
8607 _("version need")) == NULL)
8608 break;
8609
252b5132
RH		 8610 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8611 ivn.vn_next = BYTE_GET (evn.vn_next);
8612
8613 a_off = offset + ivn.vn_aux;
8614
8615 do
8616 {
59245841
NC		 8617 if (get_data (&evna, file, a_off, sizeof (evna),
8618 1, _("version need aux (2)")) == NULL)
8619 {
8620 ivna.vna_next = 0;
8621 ivna.vna_other = 0;
8622 }
8623 else
8624 {
8625 ivna.vna_next = BYTE_GET (evna.vna_next);
8626 ivna.vna_other = BYTE_GET (evna.vna_other);
8627 }
252b5132
RH		 8628
8629 a_off += ivna.vna_next;
8630 }
b34976b6 8631 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 8632 && ivna.vna_next != 0);
8633
b34976b6 8634 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 8635 {
8636 ivna.vna_name = BYTE_GET (evna.vna_name);
8637
54806181
AM		 8638 if (ivna.vna_name >= string_sec->sh_size)
8639 name = _("*invalid*");
8640 else
8641 name = strtab + ivna.vna_name;
252b5132 8642 nn += printf ("(%s%-*s",
16062207
ILT		 8643 name,
8644 12 - (int) strlen (name),
252b5132 8645 ")");
00d93f34 8646 check_def = 0;
252b5132
RH		 8647 break;
8648 }
8649
8650 offset += ivn.vn_next;
8651 }
8652 while (ivn.vn_next);
8653 }
00d93f34 8654
b34976b6
AM		 8655 if (check_def && data[cnt + j] != 0x8001
8656 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 8657 {
b34976b6
AM		 8658 Elf_Internal_Verdef ivd;
8659 Elf_External_Verdef evd;
8660 unsigned long offset;
252b5132 8661
d93f0186
NC		 8662 offset = offset_from_vma
8663 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8664 sizeof evd);
252b5132
RH		 8665
8666 do
8667 {
59245841
NC		 8668 if (get_data (&evd, file, offset, sizeof (evd), 1,
8669 _("version def")) == NULL)
8670 {
8671 ivd.vd_next = 0;
8672 ivd.vd_ndx = 0;
8673 }
8674 else
8675 {
8676 ivd.vd_next = BYTE_GET (evd.vd_next);
8677 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8678 }
252b5132
RH		 8679
8680 offset += ivd.vd_next;
8681 }
c244d050 8682 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 8683 && ivd.vd_next != 0);
8684
c244d050 8685 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 8686 {
b34976b6
AM		 8687 Elf_External_Verdaux evda;
8688 Elf_Internal_Verdaux ivda;
252b5132
RH		 8689
8690 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8691
59245841
NC		 8692 if (get_data (&evda, file,
8693 offset - ivd.vd_next + ivd.vd_aux,
8694 sizeof (evda), 1,
8695 _("version def aux")) == NULL)
8696 break;
252b5132
RH		 8697
8698 ivda.vda_name = BYTE_GET (evda.vda_name);
8699
54806181
AM		 8700 if (ivda.vda_name >= string_sec->sh_size)
8701 name = _("*invalid*");
8702 else
8703 name = strtab + ivda.vda_name;
252b5132 8704 nn += printf ("(%s%-*s",
16062207
ILT		 8705 name,
8706 12 - (int) strlen (name),
252b5132
RH		 8707 ")");
8708 }
8709 }
8710
8711 if (nn < 18)
8712 printf ("%*c", 18 - nn, ' ');
8713 }
8714
8715 putchar ('\n');
8716 }
8717
8718 free (data);
8719 free (strtab);
8720 free (symbols);
8721 }
8722 break;
103f02d3 8723
252b5132
RH		 8724 default:
8725 break;
8726 }
8727 }
8728
8729 if (! found)
8730 printf (_("\nNo version information found in this file.\n"));
8731
8732 return 1;
8733}
8734
d1133906 8735static const char *
d3ba0551 8736get_symbol_binding (unsigned int binding)
252b5132 8737{
b34976b6 8738 static char buff[32];
252b5132
RH		 8739
8740 switch (binding)
8741 {
b34976b6
AM		 8742 case STB_LOCAL: return "LOCAL";
8743 case STB_GLOBAL: return "GLOBAL";
8744 case STB_WEAK: return "WEAK";
252b5132
RH		 8745 default:
8746 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 8747 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
8748 binding);
252b5132 8749 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 8750 {
8751 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 8752 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
8753 /* GNU is still using the default value 0. */
3e7a7d11
NC		 8754 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8755 return "UNIQUE";
8756 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
8757 }
252b5132 8758 else
e9e44622 8759 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 8760 return buff;
8761 }
8762}
8763
d1133906 8764static const char *
d3ba0551 8765get_symbol_type (unsigned int type)
252b5132 8766{
b34976b6 8767 static char buff[32];
252b5132
RH		 8768
8769 switch (type)
8770 {
b34976b6
AM		 8771 case STT_NOTYPE: return "NOTYPE";
8772 case STT_OBJECT: return "OBJECT";
8773 case STT_FUNC: return "FUNC";
8774 case STT_SECTION: return "SECTION";
8775 case STT_FILE: return "FILE";
8776 case STT_COMMON: return "COMMON";
8777 case STT_TLS: return "TLS";
15ab5209
DB		 8778 case STT_RELC: return "RELC";
8779 case STT_SRELC: return "SRELC";
252b5132
RH		 8780 default:
8781 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af
NC		 8782 {
8783 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
103f02d3
UD		 8784 return "THUMB_FUNC";
8785
351b4b40 8786 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 8787 return "REGISTER";
8788
8789 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
8790 return "PARISC_MILLI";
8791
e9e44622 8792 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 8793 }
252b5132 8794 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 8795 {
8796 if (elf_header.e_machine == EM_PARISC)
8797 {
8798 if (type == STT_HP_OPAQUE)
8799 return "HP_OPAQUE";
8800 if (type == STT_HP_STUB)
8801 return "HP_STUB";
8802 }
8803
d8045f23 8804 if (type == STT_GNU_IFUNC
9c55345c 8805 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 8806 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 8807 /* GNU is still using the default value 0. */
d8045f23
NC		 8808 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8809 return "IFUNC";
8810
e9e44622 8811 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 8812 }
252b5132 8813 else
e9e44622 8814 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 8815 return buff;
8816 }
8817}
8818
d1133906 8819static const char *
d3ba0551 8820get_symbol_visibility (unsigned int visibility)
d1133906
NC		 8821{
8822 switch (visibility)
8823 {
b34976b6
AM		 8824 case STV_DEFAULT: return "DEFAULT";
8825 case STV_INTERNAL: return "INTERNAL";
8826 case STV_HIDDEN: return "HIDDEN";
d1133906
NC		 8827 case STV_PROTECTED: return "PROTECTED";
8828 default: abort ();
8829 }
8830}
8831
5e2b0d47
NC		 8832static const char *
8833get_mips_symbol_other (unsigned int other)
8834{
8835 switch (other)
8836 {
df58fc94
RS		 8837 case STO_OPTIONAL:
8838 return "OPTIONAL";
8839 case STO_MIPS_PLT:
8840 return "MIPS PLT";
8841 case STO_MIPS_PIC:
8842 return "MIPS PIC";
8843 case STO_MICROMIPS:
8844 return "MICROMIPS";
8845 case STO_MICROMIPS | STO_MIPS_PIC:
8846 return "MICROMIPS, MIPS PIC";
8847 case STO_MIPS16:
8848 return "MIPS16";
8849 default:
8850 return NULL;
5e2b0d47
NC		 8851 }
8852}
8853
28f997cf
TG		 8854static const char *
8855get_ia64_symbol_other (unsigned int other)
8856{
8857 if (is_ia64_vms ())
8858 {
8859 static char res[32];
8860
8861 res[0] = 0;
8862
8863 /* Function types is for images and .STB files only. */
8864 switch (elf_header.e_type)
8865 {
8866 case ET_DYN:
8867 case ET_EXEC:
8868 switch (VMS_ST_FUNC_TYPE (other))
8869 {
8870 case VMS_SFT_CODE_ADDR:
8871 strcat (res, " CA");
8872 break;
8873 case VMS_SFT_SYMV_IDX:
8874 strcat (res, " VEC");
8875 break;
8876 case VMS_SFT_FD:
8877 strcat (res, " FD");
8878 break;
8879 case VMS_SFT_RESERVE:
8880 strcat (res, " RSV");
8881 break;
8882 default:
8883 abort ();
8884 }
8885 break;
8886 default:
8887 break;
8888 }
8889 switch (VMS_ST_LINKAGE (other))
8890 {
8891 case VMS_STL_IGNORE:
8892 strcat (res, " IGN");
8893 break;
8894 case VMS_STL_RESERVE:
8895 strcat (res, " RSV");
8896 break;
8897 case VMS_STL_STD:
8898 strcat (res, " STD");
8899 break;
8900 case VMS_STL_LNK:
8901 strcat (res, " LNK");
8902 break;
8903 default:
8904 abort ();
8905 }
8906
8907 if (res[0] != 0)
8908 return res + 1;
8909 else
8910 return res;
8911 }
8912 return NULL;
8913}
8914
5e2b0d47
NC		 8915static const char *
8916get_symbol_other (unsigned int other)
8917{
8918 const char * result = NULL;
8919 static char buff [32];
8920
8921 if (other == 0)
8922 return "";
8923
8924 switch (elf_header.e_machine)
8925 {
8926 case EM_MIPS:
8927 result = get_mips_symbol_other (other);
28f997cf
TG		 8928 break;
8929 case EM_IA_64:
8930 result = get_ia64_symbol_other (other);
8931 break;
5e2b0d47
NC		 8932 default:
8933 break;
8934 }
8935
8936 if (result)
8937 return result;
8938
8939 snprintf (buff, sizeof buff, _("<other>: %x"), other);
8940 return buff;
8941}
8942
d1133906 8943static const char *
d3ba0551 8944get_symbol_index_type (unsigned int type)
252b5132 8945{
b34976b6 8946 static char buff[32];
5cf1065c 8947
252b5132
RH		 8948 switch (type)
8949 {
b34976b6
AM		 8950 case SHN_UNDEF: return "UND";
8951 case SHN_ABS: return "ABS";
8952 case SHN_COMMON: return "COM";
252b5132 8953 default:
9ce701e2
L		 8954 if (type == SHN_IA_64_ANSI_COMMON
8955 && elf_header.e_machine == EM_IA_64
8956 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
8957 return "ANSI_COM";
8a9036a4 8958 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 8959 || elf_header.e_machine == EM_L1OM
8960 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 8961 && type == SHN_X86_64_LCOMMON)
8962 return "LARGE_COM";
ac145307
BS		 8963 else if ((type == SHN_MIPS_SCOMMON
8964 && elf_header.e_machine == EM_MIPS)
8965 || (type == SHN_TIC6X_SCOMMON
8966 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 8967 return "SCOM";
8968 else if (type == SHN_MIPS_SUNDEFINED
8969 && elf_header.e_machine == EM_MIPS)
8970 return "SUND";
9ce701e2 8971 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 8972 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 8973 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 8974 sprintf (buff, "OS [0x%04x]", type & 0xffff);
8975 else if (type >= SHN_LORESERVE)
8976 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
252b5132 8977 else
232e7cb8 8978 sprintf (buff, "%3d", type);
5cf1065c 8979 break;
252b5132 8980 }
5cf1065c
NC		 8981
8982 return buff;
252b5132
RH		 8983}
8984
66543521 8985static bfd_vma *
2cf0635d 8986get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
252b5132 8987{
2cf0635d
NC		 8988 unsigned char * e_data;
8989 bfd_vma * i_data;
252b5132 8990
3f5e193b 8991 e_data = (unsigned char *) cmalloc (number, ent_size);
252b5132
RH		 8992
8993 if (e_data == NULL)
8994 {
8995 error (_("Out of memory\n"));
8996 return NULL;
8997 }
8998
66543521 8999 if (fread (e_data, ent_size, number, file) != number)
252b5132
RH		 9000 {
9001 error (_("Unable to read in dynamic data\n"));
9002 return NULL;
9003 }
9004
3f5e193b 9005 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
252b5132
RH		 9006
9007 if (i_data == NULL)
9008 {
9009 error (_("Out of memory\n"));
9010 free (e_data);
9011 return NULL;
9012 }
9013
9014 while (number--)
66543521 9015 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 9016
9017 free (e_data);
9018
9019 return i_data;
9020}
9021
6bd1a22c
L		 9022static void
9023print_dynamic_symbol (bfd_vma si, unsigned long hn)
9024{
2cf0635d 9025 Elf_Internal_Sym * psym;
6bd1a22c
L		 9026 int n;
9027
9028 psym = dynamic_symbols + si;
9029
9030 n = print_vma (si, DEC_5);
9031 if (n < 5)
9032 fputs (" " + n, stdout);
9033 printf (" %3lu: ", hn);
9034 print_vma (psym->st_value, LONG_HEX);
9035 putchar (' ');
9036 print_vma (psym->st_size, DEC_5);
9037
f4be36b3
AM		 9038 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9039 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9040 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 9041 /* Check to see if any other bits in the st_other field are set.
9042 Note - displaying this information disrupts the layout of the
9043 table being generated, but for the moment this case is very
9044 rare. */
9045 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9046 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9047 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9048 if (VALID_DYNAMIC_NAME (psym->st_name))
9049 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9050 else
2b692964 9051 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 9052 putchar ('\n');
9053}
9054
e3c8793a 9055/* Dump the symbol table. */
252b5132 9056static int
2cf0635d 9057process_symbol_table (FILE * file)
252b5132 9058{
2cf0635d 9059 Elf_Internal_Shdr * section;
66543521
AM		 9060 bfd_vma nbuckets = 0;
9061 bfd_vma nchains = 0;
2cf0635d
NC		 9062 bfd_vma * buckets = NULL;
9063 bfd_vma * chains = NULL;
fdc90cb4 9064 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 9065 bfd_vma * gnubuckets = NULL;
9066 bfd_vma * gnuchains = NULL;
6bd1a22c 9067 bfd_vma gnusymidx = 0;
252b5132 9068
2c610e4b 9069 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 9070 return 1;
9071
6bd1a22c
L		 9072 if (dynamic_info[DT_HASH]
9073 && (do_histogram
2c610e4b
L		 9074 || (do_using_dynamic
9075 && !do_dyn_syms
9076 && dynamic_strings != NULL)))
252b5132 9077 {
66543521
AM		 9078 unsigned char nb[8];
9079 unsigned char nc[8];
9080 int hash_ent_size = 4;
9081
9082 if ((elf_header.e_machine == EM_ALPHA
9083 || elf_header.e_machine == EM_S390
9084 || elf_header.e_machine == EM_S390_OLD)
9085 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
9086 hash_ent_size = 8;
9087
fb52b2f4
NC		 9088 if (fseek (file,
9089 (archive_file_offset
9090 + offset_from_vma (file, dynamic_info[DT_HASH],
9091 sizeof nb + sizeof nc)),
d93f0186 9092 SEEK_SET))
252b5132 9093 {
591a748a 9094 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9095 goto no_hash;
252b5132
RH		 9096 }
9097
66543521 9098 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 9099 {
9100 error (_("Failed to read in number of buckets\n"));
d3a44ec6 9101 goto no_hash;
252b5132
RH		 9102 }
9103
66543521 9104 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 9105 {
9106 error (_("Failed to read in number of chains\n"));
d3a44ec6 9107 goto no_hash;
252b5132
RH		 9108 }
9109
66543521
AM		 9110 nbuckets = byte_get (nb, hash_ent_size);
9111 nchains = byte_get (nc, hash_ent_size);
252b5132 9112
66543521
AM		 9113 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
9114 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 9115
d3a44ec6 9116 no_hash:
252b5132 9117 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 9118 {
9119 if (do_using_dynamic)
9120 return 0;
9121 free (buckets);
9122 free (chains);
9123 buckets = NULL;
9124 chains = NULL;
9125 nbuckets = 0;
9126 nchains = 0;
9127 }
252b5132
RH		 9128 }
9129
6bd1a22c
L		 9130 if (dynamic_info_DT_GNU_HASH
9131 && (do_histogram
2c610e4b
L		 9132 || (do_using_dynamic
9133 && !do_dyn_syms
9134 && dynamic_strings != NULL)))
252b5132 9135 {
6bd1a22c
L		 9136 unsigned char nb[16];
9137 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
9138 bfd_vma buckets_vma;
9139
9140 if (fseek (file,
9141 (archive_file_offset
9142 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
9143 sizeof nb)),
9144 SEEK_SET))
9145 {
9146 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9147 goto no_gnu_hash;
6bd1a22c 9148 }
252b5132 9149
6bd1a22c
L		 9150 if (fread (nb, 16, 1, file) != 1)
9151 {
9152 error (_("Failed to read in number of buckets\n"));
d3a44ec6 9153 goto no_gnu_hash;
6bd1a22c
L		 9154 }
9155
9156 ngnubuckets = byte_get (nb, 4);
9157 gnusymidx = byte_get (nb + 4, 4);
9158 bitmaskwords = byte_get (nb + 8, 4);
9159 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 9160 if (is_32bit_elf)
6bd1a22c 9161 buckets_vma += bitmaskwords * 4;
f7a99963 9162 else
6bd1a22c 9163 buckets_vma += bitmaskwords * 8;
252b5132 9164
6bd1a22c
L		 9165 if (fseek (file,
9166 (archive_file_offset
9167 + offset_from_vma (file, buckets_vma, 4)),
9168 SEEK_SET))
252b5132 9169 {
6bd1a22c 9170 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9171 goto no_gnu_hash;
6bd1a22c
L		 9172 }
9173
9174 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 9175
6bd1a22c 9176 if (gnubuckets == NULL)
d3a44ec6 9177 goto no_gnu_hash;
6bd1a22c
L		 9178
9179 for (i = 0; i < ngnubuckets; i++)
9180 if (gnubuckets[i] != 0)
9181 {
9182 if (gnubuckets[i] < gnusymidx)
9183 return 0;
9184
9185 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9186 maxchain = gnubuckets[i];
9187 }
9188
9189 if (maxchain == 0xffffffff)
d3a44ec6 9190 goto no_gnu_hash;
6bd1a22c
L		 9191
9192 maxchain -= gnusymidx;
9193
9194 if (fseek (file,
9195 (archive_file_offset
9196 + offset_from_vma (file, buckets_vma
9197 + 4 * (ngnubuckets + maxchain), 4)),
9198 SEEK_SET))
9199 {
9200 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9201 goto no_gnu_hash;
6bd1a22c
L		 9202 }
9203
9204 do
9205 {
9206 if (fread (nb, 4, 1, file) != 1)
252b5132 9207 {
6bd1a22c 9208 error (_("Failed to determine last chain length\n"));
d3a44ec6 9209 goto no_gnu_hash;
6bd1a22c 9210 }
252b5132 9211
6bd1a22c 9212 if (maxchain + 1 == 0)
d3a44ec6 9213 goto no_gnu_hash;
252b5132 9214
6bd1a22c
L		 9215 ++maxchain;
9216 }
9217 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 9218
6bd1a22c
L		 9219 if (fseek (file,
9220 (archive_file_offset
9221 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9222 SEEK_SET))
9223 {
9224 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9225 goto no_gnu_hash;
6bd1a22c
L		 9226 }
9227
9228 gnuchains = get_dynamic_data (file, maxchain, 4);
9229
d3a44ec6 9230 no_gnu_hash:
6bd1a22c 9231 if (gnuchains == NULL)
d3a44ec6
JJ		 9232 {
9233 free (gnubuckets);
d3a44ec6
JJ		 9234 gnubuckets = NULL;
9235 ngnubuckets = 0;
f64fddf1
NC		 9236 if (do_using_dynamic)
9237 return 0;
d3a44ec6 9238 }
6bd1a22c
L		 9239 }
9240
9241 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9242 && do_syms
9243 && do_using_dynamic
9244 && dynamic_strings != NULL)
9245 {
9246 unsigned long hn;
9247
9248 if (dynamic_info[DT_HASH])
9249 {
9250 bfd_vma si;
9251
9252 printf (_("\nSymbol table for image:\n"));
9253 if (is_32bit_elf)
9254 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9255 else
9256 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9257
9258 for (hn = 0; hn < nbuckets; hn++)
9259 {
9260 if (! buckets[hn])
9261 continue;
9262
9263 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9264 print_dynamic_symbol (si, hn);
252b5132
RH		 9265 }
9266 }
6bd1a22c
L		 9267
9268 if (dynamic_info_DT_GNU_HASH)
9269 {
9270 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9271 if (is_32bit_elf)
9272 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9273 else
9274 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9275
9276 for (hn = 0; hn < ngnubuckets; ++hn)
9277 if (gnubuckets[hn] != 0)
9278 {
9279 bfd_vma si = gnubuckets[hn];
9280 bfd_vma off = si - gnusymidx;
9281
9282 do
9283 {
9284 print_dynamic_symbol (si, hn);
9285 si++;
9286 }
9287 while ((gnuchains[off++] & 1) == 0);
9288 }
9289 }
252b5132 9290 }
2c610e4b 9291 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
252b5132 9292 {
b34976b6 9293 unsigned int i;
252b5132
RH		 9294
9295 for (i = 0, section = section_headers;
9296 i < elf_header.e_shnum;
9297 i++, section++)
9298 {
b34976b6 9299 unsigned int si;
2cf0635d 9300 char * strtab = NULL;
c256ffe7 9301 unsigned long int strtab_size = 0;
2cf0635d
NC		 9302 Elf_Internal_Sym * symtab;
9303 Elf_Internal_Sym * psym;
ba5cdace 9304 unsigned long num_syms;
252b5132 9305
2c610e4b
L		 9306 if ((section->sh_type != SHT_SYMTAB
9307 && section->sh_type != SHT_DYNSYM)
9308 || (!do_syms
9309 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 9310 continue;
9311
dd24e3da
NC		 9312 if (section->sh_entsize == 0)
9313 {
9314 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9315 SECTION_NAME (section));
9316 continue;
9317 }
9318
252b5132
RH		 9319 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9320 SECTION_NAME (section),
9321 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 9322
f7a99963 9323 if (is_32bit_elf)
ca47b30c 9324 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 9325 else
ca47b30c 9326 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 9327
ba5cdace 9328 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 9329 if (symtab == NULL)
9330 continue;
9331
9332 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 9333 {
9334 strtab = string_table;
9335 strtab_size = string_table_length;
9336 }
4fbb74a6 9337 else if (section->sh_link < elf_header.e_shnum)
252b5132 9338 {
2cf0635d 9339 Elf_Internal_Shdr * string_sec;
252b5132 9340
4fbb74a6 9341 string_sec = section_headers + section->sh_link;
252b5132 9342
3f5e193b
NC		 9343 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9344 1, string_sec->sh_size,
9345 _("string table"));
c256ffe7 9346 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 9347 }
9348
ba5cdace 9349 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 9350 {
5e220199 9351 printf ("%6d: ", si);
f7a99963
NC		 9352 print_vma (psym->st_value, LONG_HEX);
9353 putchar (' ');
9354 print_vma (psym->st_size, DEC_5);
d1133906
NC		 9355 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9356 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 9357 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 9358 /* Check to see if any other bits in the st_other field are set.
9359 Note - displaying this information disrupts the layout of the
9360 table being generated, but for the moment this case is very rare. */
9361 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9362 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 9363 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 9364 print_symbol (25, psym->st_name < strtab_size
2b692964 9365 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 9366
59245841
NC		 9367 if (section->sh_type == SHT_DYNSYM
9368 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
252b5132 9369 {
b34976b6
AM		 9370 unsigned char data[2];
9371 unsigned short vers_data;
9372 unsigned long offset;
9373 int is_nobits;
9374 int check_def;
252b5132 9375
d93f0186
NC		 9376 offset = offset_from_vma
9377 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9378 sizeof data + si * sizeof (vers_data));
252b5132 9379
59245841
NC		 9380 if (get_data (&data, file, offset + si * sizeof (vers_data),
9381 sizeof (data), 1, _("version data")) == NULL)
9382 break;
252b5132
RH		 9383
9384 vers_data = byte_get (data, 2);
9385
4fbb74a6
AM		 9386 is_nobits = (psym->st_shndx < elf_header.e_shnum
9387 && section_headers[psym->st_shndx].sh_type
c256ffe7 9388 == SHT_NOBITS);
252b5132
RH		 9389
9390 check_def = (psym->st_shndx != SHN_UNDEF);
9391
c244d050 9392 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
252b5132 9393 {
b34976b6 9394 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
00d93f34 9395 && (is_nobits || ! check_def))
252b5132 9396 {
b34976b6
AM		 9397 Elf_External_Verneed evn;
9398 Elf_Internal_Verneed ivn;
9399 Elf_Internal_Vernaux ivna;
252b5132
RH		 9400
9401 /* We must test both. */
d93f0186
NC		 9402 offset = offset_from_vma
9403 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9404 sizeof evn);
252b5132 9405
252b5132
RH		 9406 do
9407 {
b34976b6 9408 unsigned long vna_off;
252b5132 9409
59245841
NC		 9410 if (get_data (&evn, file, offset, sizeof (evn), 1,
9411 _("version need")) == NULL)
9412 {
9413 ivna.vna_next = 0;
9414 ivna.vna_other = 0;
9415 ivna.vna_name = 0;
9416 break;
9417 }
dd27201e
L		 9418
9419 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9420 ivn.vn_next = BYTE_GET (evn.vn_next);
9421
252b5132
RH		 9422 vna_off = offset + ivn.vn_aux;
9423
9424 do
9425 {
b34976b6 9426 Elf_External_Vernaux evna;
252b5132 9427
59245841
NC		 9428 if (get_data (&evna, file, vna_off,
9429 sizeof (evna), 1,
9430 _("version need aux (3)")) == NULL)
9431 {
9432 ivna.vna_next = 0;
9433 ivna.vna_other = 0;
9434 ivna.vna_name = 0;
9435 }
9436 else
9437 {
9438 ivna.vna_other = BYTE_GET (evna.vna_other);
9439 ivna.vna_next = BYTE_GET (evna.vna_next);
9440 ivna.vna_name = BYTE_GET (evna.vna_name);
9441 }
252b5132
RH		 9442
9443 vna_off += ivna.vna_next;
9444 }
9445 while (ivna.vna_other != vers_data
9446 && ivna.vna_next != 0);
9447
9448 if (ivna.vna_other == vers_data)
9449 break;
9450
9451 offset += ivn.vn_next;
9452 }
9453 while (ivn.vn_next != 0);
9454
9455 if (ivna.vna_other == vers_data)
9456 {
9457 printf ("@%s (%d)",
c256ffe7 9458 ivna.vna_name < strtab_size
2b692964 9459 ? strtab + ivna.vna_name : _("<corrupt>"),
c256ffe7 9460 ivna.vna_other);
252b5132
RH		 9461 check_def = 0;
9462 }
9463 else if (! is_nobits)
591a748a 9464 error (_("bad dynamic symbol\n"));
252b5132
RH		 9465 else
9466 check_def = 1;
9467 }
9468
9469 if (check_def)
9470 {
00d93f34 9471 if (vers_data != 0x8001
b34976b6 9472 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9473 {
b34976b6
AM		 9474 Elf_Internal_Verdef ivd;
9475 Elf_Internal_Verdaux ivda;
9476 Elf_External_Verdaux evda;
91d6fa6a 9477 unsigned long off;
252b5132 9478
91d6fa6a 9479 off = offset_from_vma
d93f0186
NC		 9480 (file,
9481 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9482 sizeof (Elf_External_Verdef));
252b5132
RH		 9483
9484 do
9485 {
b34976b6 9486 Elf_External_Verdef evd;
252b5132 9487
59245841
NC		 9488 if (get_data (&evd, file, off, sizeof (evd),
9489 1, _("version def")) == NULL)
9490 {
9491 ivd.vd_ndx = 0;
9492 ivd.vd_aux = 0;
9493 ivd.vd_next = 0;
9494 }
9495 else
9496 {
9497 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9498 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9499 ivd.vd_next = BYTE_GET (evd.vd_next);
9500 }
252b5132 9501
91d6fa6a 9502 off += ivd.vd_next;
252b5132 9503 }
c244d050 9504 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
252b5132
RH		 9505 && ivd.vd_next != 0);
9506
91d6fa6a
NC		 9507 off -= ivd.vd_next;
9508 off += ivd.vd_aux;
252b5132 9509
59245841
NC		 9510 if (get_data (&evda, file, off, sizeof (evda),
9511 1, _("version def aux")) == NULL)
9512 break;
252b5132
RH		 9513
9514 ivda.vda_name = BYTE_GET (evda.vda_name);
9515
9516 if (psym->st_name != ivda.vda_name)
c244d050 9517 printf ((vers_data & VERSYM_HIDDEN)
252b5132 9518 ? "@%s" : "@@%s",
c256ffe7 9519 ivda.vda_name < strtab_size
2b692964 9520 ? strtab + ivda.vda_name : _("<corrupt>"));
252b5132
RH		 9521 }
9522 }
9523 }
9524 }
9525
9526 putchar ('\n');
9527 }
9528
9529 free (symtab);
9530 if (strtab != string_table)
9531 free (strtab);
9532 }
9533 }
9534 else if (do_syms)
9535 printf
9536 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9537
9538 if (do_histogram && buckets != NULL)
9539 {
2cf0635d
NC		 9540 unsigned long * lengths;
9541 unsigned long * counts;
66543521
AM		 9542 unsigned long hn;
9543 bfd_vma si;
9544 unsigned long maxlength = 0;
9545 unsigned long nzero_counts = 0;
9546 unsigned long nsyms = 0;
252b5132 9547
66543521
AM		 9548 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9549 (unsigned long) nbuckets);
252b5132
RH		 9550 printf (_(" Length Number %% of total Coverage\n"));
9551
3f5e193b 9552 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 9553 if (lengths == NULL)
9554 {
591a748a 9555 error (_("Out of memory\n"));
252b5132
RH		 9556 return 0;
9557 }
9558 for (hn = 0; hn < nbuckets; ++hn)
9559 {
f7a99963 9560 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
252b5132 9561 {
b34976b6 9562 ++nsyms;
252b5132 9563 if (maxlength < ++lengths[hn])
b34976b6 9564 ++maxlength;
252b5132
RH		 9565 }
9566 }
9567
3f5e193b 9568 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 9569 if (counts == NULL)
9570 {
591a748a 9571 error (_("Out of memory\n"));
252b5132
RH		 9572 return 0;
9573 }
9574
9575 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 9576 ++counts[lengths[hn]];
252b5132 9577
103f02d3 9578 if (nbuckets > 0)
252b5132 9579 {
66543521
AM		 9580 unsigned long i;
9581 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 9582 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 9583 for (i = 1; i <= maxlength; ++i)
103f02d3 9584 {
66543521
AM		 9585 nzero_counts += counts[i] * i;
9586 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9587 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 9588 (nzero_counts * 100.0) / nsyms);
9589 }
252b5132
RH		 9590 }
9591
9592 free (counts);
9593 free (lengths);
9594 }
9595
9596 if (buckets != NULL)
9597 {
9598 free (buckets);
9599 free (chains);
9600 }
9601
d3a44ec6 9602 if (do_histogram && gnubuckets != NULL)
fdc90cb4 9603 {
2cf0635d
NC		 9604 unsigned long * lengths;
9605 unsigned long * counts;
fdc90cb4
JJ		 9606 unsigned long hn;
9607 unsigned long maxlength = 0;
9608 unsigned long nzero_counts = 0;
9609 unsigned long nsyms = 0;
fdc90cb4 9610
3f5e193b 9611 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 9612 if (lengths == NULL)
9613 {
591a748a 9614 error (_("Out of memory\n"));
fdc90cb4
JJ		 9615 return 0;
9616 }
9617
9618 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9619 (unsigned long) ngnubuckets);
9620 printf (_(" Length Number %% of total Coverage\n"));
9621
9622 for (hn = 0; hn < ngnubuckets; ++hn)
9623 if (gnubuckets[hn] != 0)
9624 {
9625 bfd_vma off, length = 1;
9626
6bd1a22c 9627 for (off = gnubuckets[hn] - gnusymidx;
fdc90cb4
JJ		 9628 (gnuchains[off] & 1) == 0; ++off)
9629 ++length;
9630 lengths[hn] = length;
9631 if (length > maxlength)
9632 maxlength = length;
9633 nsyms += length;
9634 }
9635
3f5e193b 9636 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 9637 if (counts == NULL)
9638 {
591a748a 9639 error (_("Out of memory\n"));
fdc90cb4
JJ		 9640 return 0;
9641 }
9642
9643 for (hn = 0; hn < ngnubuckets; ++hn)
9644 ++counts[lengths[hn]];
9645
9646 if (ngnubuckets > 0)
9647 {
9648 unsigned long j;
9649 printf (" 0 %-10lu (%5.1f%%)\n",
9650 counts[0], (counts[0] * 100.0) / ngnubuckets);
9651 for (j = 1; j <= maxlength; ++j)
9652 {
9653 nzero_counts += counts[j] * j;
9654 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9655 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9656 (nzero_counts * 100.0) / nsyms);
9657 }
9658 }
9659
9660 free (counts);
9661 free (lengths);
9662 free (gnubuckets);
9663 free (gnuchains);
9664 }
9665
252b5132
RH		 9666 return 1;
9667}
9668
9669static int
2cf0635d 9670process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 9671{
b4c96d0d 9672 unsigned int i;
252b5132
RH		 9673
9674 if (dynamic_syminfo == NULL
9675 || !do_dynamic)
9676 /* No syminfo, this is ok. */
9677 return 1;
9678
9679 /* There better should be a dynamic symbol section. */
9680 if (dynamic_symbols == NULL || dynamic_strings == NULL)
9681 return 0;
9682
9683 if (dynamic_addr)
9684 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9685 dynamic_syminfo_offset, dynamic_syminfo_nent);
9686
9687 printf (_(" Num: Name BoundTo Flags\n"));
9688 for (i = 0; i < dynamic_syminfo_nent; ++i)
9689 {
9690 unsigned short int flags = dynamic_syminfo[i].si_flags;
9691
31104126 9692 printf ("%4d: ", i);
d79b3d50
NC		 9693 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9694 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9695 else
2b692964 9696 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 9697 putchar (' ');
252b5132
RH		 9698
9699 switch (dynamic_syminfo[i].si_boundto)
9700 {
9701 case SYMINFO_BT_SELF:
9702 fputs ("SELF ", stdout);
9703 break;
9704 case SYMINFO_BT_PARENT:
9705 fputs ("PARENT ", stdout);
9706 break;
9707 default:
9708 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 9709 && dynamic_syminfo[i].si_boundto < dynamic_nent
9710 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 9711 {
d79b3d50 9712 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 9713 putchar (' ' );
9714 }
252b5132
RH		 9715 else
9716 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
9717 break;
9718 }
9719
9720 if (flags & SYMINFO_FLG_DIRECT)
9721 printf (" DIRECT");
9722 if (flags & SYMINFO_FLG_PASSTHRU)
9723 printf (" PASSTHRU");
9724 if (flags & SYMINFO_FLG_COPY)
9725 printf (" COPY");
9726 if (flags & SYMINFO_FLG_LAZYLOAD)
9727 printf (" LAZYLOAD");
9728
9729 puts ("");
9730 }
9731
9732 return 1;
9733}
9734
cf13d699
NC		 9735/* Check to see if the given reloc needs to be handled in a target specific
9736 manner. If so then process the reloc and return TRUE otherwise return
9737 FALSE. */
09c11c86 9738
cf13d699
NC		 9739static bfd_boolean
9740target_specific_reloc_handling (Elf_Internal_Rela * reloc,
9741 unsigned char * start,
9742 Elf_Internal_Sym * symtab)
252b5132 9743{
cf13d699 9744 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 9745
cf13d699 9746 switch (elf_header.e_machine)
252b5132 9747 {
cf13d699
NC		 9748 case EM_MN10300:
9749 case EM_CYGNUS_MN10300:
9750 {
9751 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 9752
cf13d699
NC		 9753 switch (reloc_type)
9754 {
9755 case 34: /* R_MN10300_ALIGN */
9756 return TRUE;
9757 case 33: /* R_MN10300_SYM_DIFF */
9758 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
9759 return TRUE;
9760 case 1: /* R_MN10300_32 */
9761 case 2: /* R_MN10300_16 */
9762 if (saved_sym != NULL)
9763 {
9764 bfd_vma value;
252b5132 9765
cf13d699
NC		 9766 value = reloc->r_addend
9767 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
9768 - saved_sym->st_value);
252b5132 9769
cf13d699 9770 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 9771
cf13d699
NC		 9772 saved_sym = NULL;
9773 return TRUE;
9774 }
9775 break;
9776 default:
9777 if (saved_sym != NULL)
9778 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9779 break;
9780 }
9781 break;
9782 }
252b5132
RH		 9783 }
9784
cf13d699 9785 return FALSE;
252b5132
RH		 9786}
9787
aca88567
NC		 9788/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9789 DWARF debug sections. This is a target specific test. Note - we do not
9790 go through the whole including-target-headers-multiple-times route, (as
9791 we have already done with <elf/h8.h>) because this would become very
9792 messy and even then this function would have to contain target specific
9793 information (the names of the relocs instead of their numeric values).
9794 FIXME: This is not the correct way to solve this problem. The proper way
9795 is to have target specific reloc sizing and typing functions created by
9796 the reloc-macros.h header, in the same way that it already creates the
9797 reloc naming functions. */
9798
9799static bfd_boolean
9800is_32bit_abs_reloc (unsigned int reloc_type)
9801{
9802 switch (elf_header.e_machine)
9803 {
41e92641
NC		 9804 case EM_386:
9805 case EM_486:
9806 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 9807 case EM_68K:
9808 return reloc_type == 1; /* R_68K_32. */
9809 case EM_860:
9810 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 9811 case EM_960:
9812 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 9813 case EM_AARCH64:
9814 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 9815 case EM_ALPHA:
137b6b5f 9816 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 9817 case EM_ARC:
9818 return reloc_type == 1; /* R_ARC_32. */
9819 case EM_ARM:
9820 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 9821 case EM_AVR_OLD:
aca88567
NC		 9822 case EM_AVR:
9823 return reloc_type == 1;
cfb8c092
NC		 9824 case EM_ADAPTEVA_EPIPHANY:
9825 return reloc_type == 3;
aca88567
NC		 9826 case EM_BLACKFIN:
9827 return reloc_type == 0x12; /* R_byte4_data. */
9828 case EM_CRIS:
9829 return reloc_type == 3; /* R_CRIS_32. */
9830 case EM_CR16:
9831 return reloc_type == 3; /* R_CR16_NUM32. */
9832 case EM_CRX:
9833 return reloc_type == 15; /* R_CRX_NUM32. */
9834 case EM_CYGNUS_FRV:
9835 return reloc_type == 1;
41e92641
NC		 9836 case EM_CYGNUS_D10V:
9837 case EM_D10V:
9838 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 9839 case EM_CYGNUS_D30V:
9840 case EM_D30V:
9841 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 9842 case EM_DLX:
9843 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 9844 case EM_CYGNUS_FR30:
9845 case EM_FR30:
9846 return reloc_type == 3; /* R_FR30_32. */
9847 case EM_H8S:
9848 case EM_H8_300:
9849 case EM_H8_300H:
9850 return reloc_type == 1; /* R_H8_DIR32. */
3730236a
NC		 9851 case EM_IA_64:
9852 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
aca88567
NC		 9853 case EM_IP2K_OLD:
9854 case EM_IP2K:
9855 return reloc_type == 2; /* R_IP2K_32. */
9856 case EM_IQ2000:
9857 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 9858 case EM_LATTICEMICO32:
9859 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 9860 case EM_M32C_OLD:
aca88567
NC		 9861 case EM_M32C:
9862 return reloc_type == 3; /* R_M32C_32. */
9863 case EM_M32R:
9864 return reloc_type == 34; /* R_M32R_32_RELA. */
9865 case EM_MCORE:
9866 return reloc_type == 1; /* R_MCORE_ADDR32. */
9867 case EM_CYGNUS_MEP:
9868 return reloc_type == 4; /* R_MEP_32. */
137b6b5f
AM		 9869 case EM_MICROBLAZE:
9870 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 9871 case EM_MIPS:
9872 return reloc_type == 2; /* R_MIPS_32. */
9873 case EM_MMIX:
9874 return reloc_type == 4; /* R_MMIX_32. */
9875 case EM_CYGNUS_MN10200:
9876 case EM_MN10200:
9877 return reloc_type == 1; /* R_MN10200_32. */
9878 case EM_CYGNUS_MN10300:
9879 case EM_MN10300:
9880 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 9881 case EM_MOXIE:
9882 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 9883 case EM_MSP430_OLD:
9884 case EM_MSP430:
9885 return reloc_type == 1; /* R_MSP43_32. */
9886 case EM_MT:
9887 return reloc_type == 2; /* R_MT_32. */
3e0873ac
NC		 9888 case EM_ALTERA_NIOS2:
9889 case EM_NIOS32:
9890 return reloc_type == 1; /* R_NIOS_32. */
41e92641
NC		 9891 case EM_OPENRISC:
9892 case EM_OR32:
9893 return reloc_type == 1; /* R_OR32_32. */
aca88567 9894 case EM_PARISC:
5fda8eca
NC		 9895 return (reloc_type == 1 /* R_PARISC_DIR32. */
9896 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 9897 case EM_PJ:
9898 case EM_PJ_OLD:
9899 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
9900 case EM_PPC64:
9901 return reloc_type == 1; /* R_PPC64_ADDR32. */
9902 case EM_PPC:
9903 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 9904 case EM_RL78:
9905 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 9906 case EM_RX:
9907 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 9908 case EM_S370:
9909 return reloc_type == 1; /* R_I370_ADDR31. */
9910 case EM_S390_OLD:
9911 case EM_S390:
9912 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 9913 case EM_SCORE:
9914 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 9915 case EM_SH:
9916 return reloc_type == 1; /* R_SH_DIR32. */
9917 case EM_SPARC32PLUS:
9918 case EM_SPARCV9:
9919 case EM_SPARC:
9920 return reloc_type == 3 /* R_SPARC_32. */
9921 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 9922 case EM_SPU:
9923 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 9924 case EM_TI_C6000:
9925 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 9926 case EM_TILEGX:
9927 return reloc_type == 2; /* R_TILEGX_32. */
9928 case EM_TILEPRO:
9929 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 9930 case EM_CYGNUS_V850:
9931 case EM_V850:
9932 return reloc_type == 6; /* R_V850_ABS32. */
9933 case EM_VAX:
9934 return reloc_type == 1; /* R_VAX_32. */
9935 case EM_X86_64:
8a9036a4 9936 case EM_L1OM:
7a9068fe 9937 case EM_K1OM:
aca88567 9938 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 9939 case EM_XC16X:
9940 case EM_C166:
9941 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 9942 case EM_XGATE:
9943 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 9944 case EM_XSTORMY16:
9945 return reloc_type == 1; /* R_XSTROMY16_32. */
9946 case EM_XTENSA_OLD:
9947 case EM_XTENSA:
9948 return reloc_type == 1; /* R_XTENSA_32. */
aca88567
NC		 9949 default:
9950 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
9951 elf_header.e_machine);
9952 abort ();
9953 }
9954}
9955
9956/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9957 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
9958
9959static bfd_boolean
9960is_32bit_pcrel_reloc (unsigned int reloc_type)
9961{
9962 switch (elf_header.e_machine)
9963 {
41e92641
NC		 9964 case EM_386:
9965 case EM_486:
3e0873ac 9966 return reloc_type == 2; /* R_386_PC32. */
aca88567 9967 case EM_68K:
3e0873ac 9968 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 9969 case EM_AARCH64:
9970 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 9971 case EM_ADAPTEVA_EPIPHANY:
9972 return reloc_type == 6;
aca88567
NC		 9973 case EM_ALPHA:
9974 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 9975 case EM_ARM:
3e0873ac 9976 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 9977 case EM_MICROBLAZE:
9978 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
aca88567 9979 case EM_PARISC:
85acf597 9980 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 9981 case EM_PPC:
9982 return reloc_type == 26; /* R_PPC_REL32. */
9983 case EM_PPC64:
3e0873ac 9984 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 9985 case EM_S390_OLD:
9986 case EM_S390:
3e0873ac 9987 return reloc_type == 5; /* R_390_PC32. */
aca88567 9988 case EM_SH:
3e0873ac 9989 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 9990 case EM_SPARC32PLUS:
9991 case EM_SPARCV9:
9992 case EM_SPARC:
3e0873ac 9993 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 9994 case EM_SPU:
9995 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 9996 case EM_TILEGX:
9997 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
9998 case EM_TILEPRO:
9999 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
aca88567 10000 case EM_X86_64:
8a9036a4 10001 case EM_L1OM:
7a9068fe 10002 case EM_K1OM:
3e0873ac 10003 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 10004 case EM_XTENSA_OLD:
10005 case EM_XTENSA:
10006 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 10007 default:
10008 /* Do not abort or issue an error message here. Not all targets use
10009 pc-relative 32-bit relocs in their DWARF debug information and we
10010 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 10011 more helpful warning message will be generated by apply_relocations
10012 anyway, so just return. */
aca88567
NC		 10013 return FALSE;
10014 }
10015}
10016
10017/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10018 a 64-bit absolute RELA relocation used in DWARF debug sections. */
10019
10020static bfd_boolean
10021is_64bit_abs_reloc (unsigned int reloc_type)
10022{
10023 switch (elf_header.e_machine)
10024 {
a06ea964
NC		 10025 case EM_AARCH64:
10026 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 10027 case EM_ALPHA:
10028 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 10029 case EM_IA_64:
10030 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 10031 case EM_PARISC:
10032 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 10033 case EM_PPC64:
10034 return reloc_type == 38; /* R_PPC64_ADDR64. */
10035 case EM_SPARC32PLUS:
10036 case EM_SPARCV9:
10037 case EM_SPARC:
10038 return reloc_type == 54; /* R_SPARC_UA64. */
10039 case EM_X86_64:
8a9036a4 10040 case EM_L1OM:
7a9068fe 10041 case EM_K1OM:
aca88567 10042 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 10043 case EM_S390_OLD:
10044 case EM_S390:
aa137e4d
NC		 10045 return reloc_type == 22; /* R_S390_64. */
10046 case EM_TILEGX:
10047 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 10048 case EM_MIPS:
aa137e4d 10049 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 10050 default:
10051 return FALSE;
10052 }
10053}
10054
85acf597
RH		 10055/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10056 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10057
10058static bfd_boolean
10059is_64bit_pcrel_reloc (unsigned int reloc_type)
10060{
10061 switch (elf_header.e_machine)
10062 {
a06ea964
NC		 10063 case EM_AARCH64:
10064 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 10065 case EM_ALPHA:
aa137e4d 10066 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 10067 case EM_IA_64:
aa137e4d 10068 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 10069 case EM_PARISC:
aa137e4d 10070 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 10071 case EM_PPC64:
aa137e4d 10072 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 10073 case EM_SPARC32PLUS:
10074 case EM_SPARCV9:
10075 case EM_SPARC:
aa137e4d 10076 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 10077 case EM_X86_64:
8a9036a4 10078 case EM_L1OM:
7a9068fe 10079 case EM_K1OM:
aa137e4d 10080 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 10081 case EM_S390_OLD:
10082 case EM_S390:
aa137e4d
NC		 10083 return reloc_type == 23; /* R_S390_PC64. */
10084 case EM_TILEGX:
10085 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 10086 default:
10087 return FALSE;
10088 }
10089}
10090
4dc3c23d
AM		 10091/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10092 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10093
10094static bfd_boolean
10095is_24bit_abs_reloc (unsigned int reloc_type)
10096{
10097 switch (elf_header.e_machine)
10098 {
10099 case EM_CYGNUS_MN10200:
10100 case EM_MN10200:
10101 return reloc_type == 4; /* R_MN10200_24. */
10102 default:
10103 return FALSE;
10104 }
10105}
10106
aca88567
NC		 10107/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10108 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10109
10110static bfd_boolean
10111is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 10112{
10113 switch (elf_header.e_machine)
10114 {
aca88567
NC		 10115 case EM_AVR_OLD:
10116 case EM_AVR:
10117 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 10118 case EM_ADAPTEVA_EPIPHANY:
10119 return reloc_type == 5;
41e92641
NC		 10120 case EM_CYGNUS_D10V:
10121 case EM_D10V:
10122 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 10123 case EM_H8S:
10124 case EM_H8_300:
10125 case EM_H8_300H:
aca88567
NC		 10126 return reloc_type == R_H8_DIR16;
10127 case EM_IP2K_OLD:
10128 case EM_IP2K:
10129 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 10130 case EM_M32C_OLD:
f4236fe4
DD		 10131 case EM_M32C:
10132 return reloc_type == 1; /* R_M32C_16 */
aca88567
NC		 10133 case EM_MSP430_OLD:
10134 case EM_MSP430:
10135 return reloc_type == 5; /* R_MSP430_16_BYTE. */
3e0873ac
NC		 10136 case EM_ALTERA_NIOS2:
10137 case EM_NIOS32:
10138 return reloc_type == 9; /* R_NIOS_16. */
40b36596
JM		 10139 case EM_TI_C6000:
10140 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 10141 case EM_XC16X:
10142 case EM_C166:
10143 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 10144 case EM_CYGNUS_MN10200:
10145 case EM_MN10200:
10146 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 10147 case EM_CYGNUS_MN10300:
10148 case EM_MN10300:
10149 return reloc_type == 2; /* R_MN10300_16. */
f6c1a2d5
NC		 10150 case EM_XGATE:
10151 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 10152 default:
aca88567 10153 return FALSE;
4b78141a
NC		 10154 }
10155}
10156
2a7b2e88
JK		 10157/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10158 relocation entries (possibly formerly used for SHT_GROUP sections). */
10159
10160static bfd_boolean
10161is_none_reloc (unsigned int reloc_type)
10162{
10163 switch (elf_header.e_machine)
10164 {
cb8f3167
NC		 10165 case EM_68K: /* R_68K_NONE. */
10166 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 10167 case EM_SPARC32PLUS:
10168 case EM_SPARCV9:
cb8f3167
NC		 10169 case EM_SPARC: /* R_SPARC_NONE. */
10170 case EM_MIPS: /* R_MIPS_NONE. */
10171 case EM_PARISC: /* R_PARISC_NONE. */
10172 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 10173 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 10174 case EM_PPC: /* R_PPC_NONE. */
10175 case EM_PPC64: /* R_PPC64_NONE. */
10176 case EM_ARM: /* R_ARM_NONE. */
10177 case EM_IA_64: /* R_IA64_NONE. */
10178 case EM_SH: /* R_SH_NONE. */
2a7b2e88 10179 case EM_S390_OLD:
cb8f3167
NC		 10180 case EM_S390: /* R_390_NONE. */
10181 case EM_CRIS: /* R_CRIS_NONE. */
10182 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 10183 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 10184 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 10185 case EM_MN10300: /* R_MN10300_NONE. */
5506d11a 10186 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 10187 case EM_M32R: /* R_M32R_NONE. */
40b36596 10188 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 10189 case EM_TILEGX: /* R_TILEGX_NONE. */
10190 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 10191 case EM_XC16X:
10192 case EM_C166: /* R_XC16X_NONE. */
cb8f3167 10193 return reloc_type == 0;
a06ea964
NC		 10194 case EM_AARCH64:
10195 return reloc_type == 0 || reloc_type == 256;
58332dda
JK		 10196 case EM_XTENSA_OLD:
10197 case EM_XTENSA:
4dc3c23d
AM		 10198 return (reloc_type == 0 /* R_XTENSA_NONE. */
10199 || reloc_type == 17 /* R_XTENSA_DIFF8. */
10200 || reloc_type == 18 /* R_XTENSA_DIFF16. */
10201 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
2a7b2e88
JK		 10202 }
10203 return FALSE;
10204}
10205
cf13d699
NC		 10206/* Apply relocations to a section.
10207 Note: So far support has been added only for those relocations
10208 which can be found in debug sections.
10209 FIXME: Add support for more relocations ? */
1b315056 10210
cf13d699
NC		 10211static void
10212apply_relocations (void * file,
10213 Elf_Internal_Shdr * section,
10214 unsigned char * start)
1b315056 10215{
cf13d699
NC		 10216 Elf_Internal_Shdr * relsec;
10217 unsigned char * end = start + section->sh_size;
cb8f3167 10218
cf13d699
NC		 10219 if (elf_header.e_type != ET_REL)
10220 return;
1b315056 10221
cf13d699 10222 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 10223 for (relsec = section_headers;
10224 relsec < section_headers + elf_header.e_shnum;
10225 ++relsec)
252b5132 10226 {
41e92641
NC		 10227 bfd_boolean is_rela;
10228 unsigned long num_relocs;
2cf0635d
NC		 10229 Elf_Internal_Rela * relocs;
10230 Elf_Internal_Rela * rp;
10231 Elf_Internal_Shdr * symsec;
10232 Elf_Internal_Sym * symtab;
ba5cdace 10233 unsigned long num_syms;
2cf0635d 10234 Elf_Internal_Sym * sym;
252b5132 10235
41e92641 10236 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 10237 || relsec->sh_info >= elf_header.e_shnum
10238 || section_headers + relsec->sh_info != section
c256ffe7 10239 || relsec->sh_size == 0
4fbb74a6 10240 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 10241 continue;
428409d5 10242
41e92641
NC		 10243 is_rela = relsec->sh_type == SHT_RELA;
10244
10245 if (is_rela)
10246 {
3f5e193b
NC		 10247 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10248 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10249 return;
10250 }
10251 else
10252 {
3f5e193b
NC		 10253 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10254 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10255 return;
10256 }
10257
10258 /* SH uses RELA but uses in place value instead of the addend field. */
10259 if (elf_header.e_machine == EM_SH)
10260 is_rela = FALSE;
428409d5 10261
4fbb74a6 10262 symsec = section_headers + relsec->sh_link;
ba5cdace 10263 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 10264
41e92641 10265 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 10266 {
41e92641
NC		 10267 bfd_vma addend;
10268 unsigned int reloc_type;
10269 unsigned int reloc_size;
91d6fa6a 10270 unsigned char * rloc;
ba5cdace 10271 unsigned long sym_index;
4b78141a 10272
aca88567 10273 reloc_type = get_reloc_type (rp->r_info);
41e92641 10274
98fb390a 10275 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 10276 continue;
98fb390a
NC		 10277 else if (is_none_reloc (reloc_type))
10278 continue;
10279 else if (is_32bit_abs_reloc (reloc_type)
10280 || is_32bit_pcrel_reloc (reloc_type))
aca88567 10281 reloc_size = 4;
85acf597
RH		 10282 else if (is_64bit_abs_reloc (reloc_type)
10283 || is_64bit_pcrel_reloc (reloc_type))
aca88567 10284 reloc_size = 8;
4dc3c23d
AM		 10285 else if (is_24bit_abs_reloc (reloc_type))
10286 reloc_size = 3;
aca88567
NC		 10287 else if (is_16bit_abs_reloc (reloc_type))
10288 reloc_size = 2;
10289 else
4b78141a 10290 {
41e92641 10291 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
aca88567 10292 reloc_type, SECTION_NAME (section));
4b78141a
NC		 10293 continue;
10294 }
103f02d3 10295
91d6fa6a
NC		 10296 rloc = start + rp->r_offset;
10297 if ((rloc + reloc_size) > end)
700dd8b7
L		 10298 {
10299 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10300 (unsigned long) rp->r_offset,
10301 SECTION_NAME (section));
10302 continue;
10303 }
103f02d3 10304
ba5cdace
NC		 10305 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
10306 if (sym_index >= num_syms)
10307 {
10308 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10309 sym_index, SECTION_NAME (section));
10310 continue;
10311 }
10312 sym = symtab + sym_index;
41e92641
NC		 10313
10314 /* If the reloc has a symbol associated with it,
55f25fc3
L		 10315 make sure that it is of an appropriate type.
10316
10317 Relocations against symbols without type can happen.
10318 Gcc -feliminate-dwarf2-dups may generate symbols
10319 without type for debug info.
10320
10321 Icc generates relocations against function symbols
10322 instead of local labels.
10323
10324 Relocations against object symbols can happen, eg when
10325 referencing a global array. For an example of this see
10326 the _clz.o binary in libgcc.a. */
aca88567 10327 if (sym != symtab
55f25fc3 10328 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 10329 {
41e92641 10330 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 10331 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 10332 (long int)(rp - relocs),
41e92641 10333 SECTION_NAME (relsec));
aca88567 10334 continue;
5b18a4bc 10335 }
252b5132 10336
4dc3c23d
AM		 10337 addend = 0;
10338 if (is_rela)
10339 addend += rp->r_addend;
c47320c3
AM		 10340 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10341 partial_inplace. */
4dc3c23d
AM		 10342 if (!is_rela
10343 || (elf_header.e_machine == EM_XTENSA
10344 && reloc_type == 1)
10345 || ((elf_header.e_machine == EM_PJ
10346 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 10347 && reloc_type == 1)
10348 || ((elf_header.e_machine == EM_D30V
10349 || elf_header.e_machine == EM_CYGNUS_D30V)
10350 && reloc_type == 12))
91d6fa6a 10351 addend += byte_get (rloc, reloc_size);
cb8f3167 10352
85acf597
RH		 10353 if (is_32bit_pcrel_reloc (reloc_type)
10354 || is_64bit_pcrel_reloc (reloc_type))
10355 {
10356 /* On HPPA, all pc-relative relocations are biased by 8. */
10357 if (elf_header.e_machine == EM_PARISC)
10358 addend -= 8;
91d6fa6a 10359 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 10360 reloc_size);
10361 }
41e92641 10362 else
91d6fa6a 10363 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 10364 }
252b5132 10365
5b18a4bc 10366 free (symtab);
41e92641 10367 free (relocs);
5b18a4bc
NC		 10368 break;
10369 }
5b18a4bc 10370}
103f02d3 10371
cf13d699
NC		 10372#ifdef SUPPORT_DISASSEMBLY
10373static int
10374disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10375{
10376 printf (_("\nAssembly dump of section %s\n"),
10377 SECTION_NAME (section));
10378
10379 /* XXX -- to be done --- XXX */
10380
10381 return 1;
10382}
10383#endif
10384
10385/* Reads in the contents of SECTION from FILE, returning a pointer
10386 to a malloc'ed buffer or NULL if something went wrong. */
10387
10388static char *
10389get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10390{
10391 bfd_size_type num_bytes;
10392
10393 num_bytes = section->sh_size;
10394
10395 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
10396 {
10397 printf (_("\nSection '%s' has no data to dump.\n"),
10398 SECTION_NAME (section));
10399 return NULL;
10400 }
10401
3f5e193b
NC		 10402 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
10403 _("section contents"));
cf13d699
NC		 10404}
10405
dd24e3da 10406
cf13d699
NC		 10407static void
10408dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
10409{
10410 Elf_Internal_Shdr * relsec;
10411 bfd_size_type num_bytes;
cf13d699
NC		 10412 char * data;
10413 char * end;
10414 char * start;
10415 char * name = SECTION_NAME (section);
10416 bfd_boolean some_strings_shown;
10417
10418 start = get_section_contents (section, file);
10419 if (start == NULL)
10420 return;
10421
10422 printf (_("\nString dump of section '%s':\n"), name);
10423
10424 /* If the section being dumped has relocations against it the user might
10425 be expecting these relocations to have been applied. Check for this
10426 case and issue a warning message in order to avoid confusion.
10427 FIXME: Maybe we ought to have an option that dumps a section with
10428 relocs applied ? */
10429 for (relsec = section_headers;
10430 relsec < section_headers + elf_header.e_shnum;
10431 ++relsec)
10432 {
10433 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10434 || relsec->sh_info >= elf_header.e_shnum
10435 || section_headers + relsec->sh_info != section
10436 || relsec->sh_size == 0
10437 || relsec->sh_link >= elf_header.e_shnum)
10438 continue;
10439
10440 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10441 break;
10442 }
10443
10444 num_bytes = section->sh_size;
cf13d699
NC		 10445 data = start;
10446 end = start + num_bytes;
10447 some_strings_shown = FALSE;
10448
10449 while (data < end)
10450 {
10451 while (!ISPRINT (* data))
10452 if (++ data >= end)
10453 break;
10454
10455 if (data < end)
10456 {
10457#ifndef __MSVCRT__
c975cc98
NC		 10458 /* PR 11128: Use two separate invocations in order to work
10459 around bugs in the Solaris 8 implementation of printf. */
10460 printf (" [%6tx] ", data - start);
10461 printf ("%s\n", data);
cf13d699
NC		 10462#else
10463 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
10464#endif
10465 data += strlen (data);
10466 some_strings_shown = TRUE;
10467 }
10468 }
10469
10470 if (! some_strings_shown)
10471 printf (_(" No strings found in this section."));
10472
10473 free (start);
10474
10475 putchar ('\n');
10476}
10477
10478static void
10479dump_section_as_bytes (Elf_Internal_Shdr * section,
10480 FILE * file,
10481 bfd_boolean relocate)
10482{
10483 Elf_Internal_Shdr * relsec;
10484 bfd_size_type bytes;
10485 bfd_vma addr;
10486 unsigned char * data;
10487 unsigned char * start;
10488
10489 start = (unsigned char *) get_section_contents (section, file);
10490 if (start == NULL)
10491 return;
10492
10493 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
10494
10495 if (relocate)
10496 {
10497 apply_relocations (file, section, start);
10498 }
10499 else
10500 {
10501 /* If the section being dumped has relocations against it the user might
10502 be expecting these relocations to have been applied. Check for this
10503 case and issue a warning message in order to avoid confusion.
10504 FIXME: Maybe we ought to have an option that dumps a section with
10505 relocs applied ? */
10506 for (relsec = section_headers;
10507 relsec < section_headers + elf_header.e_shnum;
10508 ++relsec)
10509 {
10510 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10511 || relsec->sh_info >= elf_header.e_shnum
10512 || section_headers + relsec->sh_info != section
10513 || relsec->sh_size == 0
10514 || relsec->sh_link >= elf_header.e_shnum)
10515 continue;
10516
10517 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10518 break;
10519 }
10520 }
10521
10522 addr = section->sh_addr;
10523 bytes = section->sh_size;
10524 data = start;
10525
10526 while (bytes)
10527 {
10528 int j;
10529 int k;
10530 int lbytes;
10531
10532 lbytes = (bytes > 16 ? 16 : bytes);
10533
10534 printf (" 0x%8.8lx ", (unsigned long) addr);
10535
10536 for (j = 0; j < 16; j++)
10537 {
10538 if (j < lbytes)
10539 printf ("%2.2x", data[j]);
10540 else
10541 printf (" ");
10542
10543 if ((j & 3) == 3)
10544 printf (" ");
10545 }
10546
10547 for (j = 0; j < lbytes; j++)
10548 {
10549 k = data[j];
10550 if (k >= ' ' && k < 0x7f)
10551 printf ("%c", k);
10552 else
10553 printf (".");
10554 }
10555
10556 putchar ('\n');
10557
10558 data += lbytes;
10559 addr += lbytes;
10560 bytes -= lbytes;
10561 }
10562
10563 free (start);
10564
10565 putchar ('\n');
10566}
10567
4a114e3e 10568/* Uncompresses a section that was compressed using zlib, in place. */
cf13d699
NC		 10569
10570static int
d3dbc530
AM		 10571uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10572 dwarf_size_type *size ATTRIBUTE_UNUSED)
cf13d699
NC		 10573{
10574#ifndef HAVE_ZLIB_H
cf13d699
NC		 10575 return FALSE;
10576#else
10577 dwarf_size_type compressed_size = *size;
10578 unsigned char * compressed_buffer = *buffer;
10579 dwarf_size_type uncompressed_size;
10580 unsigned char * uncompressed_buffer;
10581 z_stream strm;
10582 int rc;
10583 dwarf_size_type header_size = 12;
10584
10585 /* Read the zlib header. In this case, it should be "ZLIB" followed
10586 by the uncompressed section size, 8 bytes in big-endian order. */
10587 if (compressed_size < header_size
10588 || ! streq ((char *) compressed_buffer, "ZLIB"))
10589 return 0;
10590
10591 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10592 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10593 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10594 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10595 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10596 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10597 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10598 uncompressed_size += compressed_buffer[11];
10599
10600 /* It is possible the section consists of several compressed
10601 buffers concatenated together, so we uncompress in a loop. */
10602 strm.zalloc = NULL;
10603 strm.zfree = NULL;
10604 strm.opaque = NULL;
10605 strm.avail_in = compressed_size - header_size;
10606 strm.next_in = (Bytef *) compressed_buffer + header_size;
10607 strm.avail_out = uncompressed_size;
3f5e193b 10608 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
cf13d699
NC		 10609
10610 rc = inflateInit (& strm);
10611 while (strm.avail_in > 0)
10612 {
10613 if (rc != Z_OK)
10614 goto fail;
10615 strm.next_out = ((Bytef *) uncompressed_buffer
10616 + (uncompressed_size - strm.avail_out));
10617 rc = inflate (&strm, Z_FINISH);
10618 if (rc != Z_STREAM_END)
10619 goto fail;
10620 rc = inflateReset (& strm);
10621 }
10622 rc = inflateEnd (& strm);
10623 if (rc != Z_OK
10624 || strm.avail_out != 0)
10625 goto fail;
10626
10627 free (compressed_buffer);
10628 *buffer = uncompressed_buffer;
10629 *size = uncompressed_size;
10630 return 1;
10631
10632 fail:
10633 free (uncompressed_buffer);
4a114e3e
L		 10634 /* Indicate decompression failure. */
10635 *buffer = NULL;
cf13d699
NC		 10636 return 0;
10637#endif /* HAVE_ZLIB_H */
10638}
10639
d966045b
DJ		 10640static int
10641load_specific_debug_section (enum dwarf_section_display_enum debug,
2cf0635d 10642 Elf_Internal_Shdr * sec, void * file)
1007acb3 10643{
2cf0635d 10644 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 10645 char buf [64];
1007acb3 10646
19e6b90e
L		 10647 /* If it is already loaded, do nothing. */
10648 if (section->start != NULL)
10649 return 1;
1007acb3 10650
19e6b90e
L		 10651 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
10652 section->address = sec->sh_addr;
3f5e193b
NC		 10653 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
10654 sec->sh_offset, 1,
10655 sec->sh_size, buf);
59245841
NC		 10656 if (section->start == NULL)
10657 section->size = 0;
10658 else
10659 {
10660 section->size = sec->sh_size;
10661 if (uncompress_section_contents (&section->start, &section->size))
10662 sec->sh_size = section->size;
10663 }
4a114e3e 10664
1b315056
CS		 10665 if (section->start == NULL)
10666 return 0;
10667
19e6b90e 10668 if (debug_displays [debug].relocate)
3f5e193b 10669 apply_relocations ((FILE *) file, sec, section->start);
1007acb3 10670
1b315056 10671 return 1;
1007acb3
L		 10672}
10673
d966045b 10674int
2cf0635d 10675load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 10676{
2cf0635d
NC		 10677 struct dwarf_section * section = &debug_displays [debug].section;
10678 Elf_Internal_Shdr * sec;
d966045b
DJ		 10679
10680 /* Locate the debug section. */
10681 sec = find_section (section->uncompressed_name);
10682 if (sec != NULL)
10683 section->name = section->uncompressed_name;
10684 else
10685 {
10686 sec = find_section (section->compressed_name);
10687 if (sec != NULL)
10688 section->name = section->compressed_name;
10689 }
10690 if (sec == NULL)
10691 return 0;
10692
3f5e193b 10693 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 10694}
10695
19e6b90e
L		 10696void
10697free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 10698{
2cf0635d 10699 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 10700
19e6b90e
L		 10701 if (section->start == NULL)
10702 return;
1007acb3 10703
19e6b90e
L		 10704 free ((char *) section->start);
10705 section->start = NULL;
10706 section->address = 0;
10707 section->size = 0;
1007acb3
L		 10708}
10709
1007acb3 10710static int
2cf0635d 10711display_debug_section (Elf_Internal_Shdr * section, FILE * file)
1007acb3 10712{
2cf0635d 10713 char * name = SECTION_NAME (section);
19e6b90e
L		 10714 bfd_size_type length;
10715 int result = 1;
3f5e193b 10716 int i;
1007acb3 10717
19e6b90e
L		 10718 length = section->sh_size;
10719 if (length == 0)
1007acb3 10720 {
19e6b90e
L		 10721 printf (_("\nSection '%s' has no debugging data.\n"), name);
10722 return 0;
1007acb3 10723 }
5dff79d8
NC		 10724 if (section->sh_type == SHT_NOBITS)
10725 {
10726 /* There is no point in dumping the contents of a debugging section
10727 which has the NOBITS type - the bits in the file will be random.
10728 This can happen when a file containing a .eh_frame section is
10729 stripped with the --only-keep-debug command line option. */
10730 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
10731 return 0;
10732 }
1007acb3 10733
0112cd26 10734 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 10735 name = ".debug_info";
1007acb3 10736
19e6b90e
L		 10737 /* See if we know how to display the contents of this section. */
10738 for (i = 0; i < max; i++)
1b315056
CS		 10739 if (streq (debug_displays[i].section.uncompressed_name, name)
10740 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 10741 {
2cf0635d 10742 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 10743 int secondary = (section != find_section (name));
10744
10745 if (secondary)
3f5e193b 10746 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 10747
2b6f5997 10748 if (streq (sec->uncompressed_name, name))
d966045b
DJ		 10749 sec->name = sec->uncompressed_name;
10750 else
10751 sec->name = sec->compressed_name;
3f5e193b
NC		 10752 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
10753 section, file))
19e6b90e
L		 10754 {
10755 result &= debug_displays[i].display (sec, file);
1007acb3 10756
d966045b 10757 if (secondary || (i != info && i != abbrev))
3f5e193b 10758 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 10759 }
1007acb3 10760
19e6b90e
L		 10761 break;
10762 }
1007acb3 10763
19e6b90e 10764 if (i == max)
1007acb3 10765 {
19e6b90e
L		 10766 printf (_("Unrecognized debug section: %s\n"), name);
10767 result = 0;
1007acb3
L		 10768 }
10769
19e6b90e 10770 return result;
5b18a4bc 10771}
103f02d3 10772
aef1f6d0
DJ		 10773/* Set DUMP_SECTS for all sections where dumps were requested
10774 based on section name. */
10775
10776static void
10777initialise_dumps_byname (void)
10778{
2cf0635d 10779 struct dump_list_entry * cur;
aef1f6d0
DJ		 10780
10781 for (cur = dump_sects_byname; cur; cur = cur->next)
10782 {
10783 unsigned int i;
10784 int any;
10785
10786 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
10787 if (streq (SECTION_NAME (section_headers + i), cur->name))
10788 {
09c11c86 10789 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 10790 any = 1;
10791 }
10792
10793 if (!any)
10794 warn (_("Section '%s' was not dumped because it does not exist!\n"),
10795 cur->name);
10796 }
10797}
10798
5b18a4bc 10799static void
2cf0635d 10800process_section_contents (FILE * file)
5b18a4bc 10801{
2cf0635d 10802 Elf_Internal_Shdr * section;
19e6b90e 10803 unsigned int i;
103f02d3 10804
19e6b90e
L		 10805 if (! do_dump)
10806 return;
103f02d3 10807
aef1f6d0
DJ		 10808 initialise_dumps_byname ();
10809
19e6b90e
L		 10810 for (i = 0, section = section_headers;
10811 i < elf_header.e_shnum && i < num_dump_sects;
10812 i++, section++)
10813 {
10814#ifdef SUPPORT_DISASSEMBLY
10815 if (dump_sects[i] & DISASS_DUMP)
10816 disassemble_section (section, file);
10817#endif
10818 if (dump_sects[i] & HEX_DUMP)
cf13d699 10819 dump_section_as_bytes (section, file, FALSE);
103f02d3 10820
cf13d699
NC		 10821 if (dump_sects[i] & RELOC_DUMP)
10822 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 10823
10824 if (dump_sects[i] & STRING_DUMP)
10825 dump_section_as_strings (section, file);
cf13d699
NC		 10826
10827 if (dump_sects[i] & DEBUG_DUMP)
10828 display_debug_section (section, file);
5b18a4bc 10829 }
103f02d3 10830
19e6b90e
L		 10831 /* Check to see if the user requested a
10832 dump of a section that does not exist. */
10833 while (i++ < num_dump_sects)
10834 if (dump_sects[i])
10835 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 10836}
103f02d3 10837
5b18a4bc 10838static void
19e6b90e 10839process_mips_fpe_exception (int mask)
5b18a4bc 10840{
19e6b90e
L		 10841 if (mask)
10842 {
10843 int first = 1;
10844 if (mask & OEX_FPU_INEX)
10845 fputs ("INEX", stdout), first = 0;
10846 if (mask & OEX_FPU_UFLO)
10847 printf ("%sUFLO", first ? "" : "|"), first = 0;
10848 if (mask & OEX_FPU_OFLO)
10849 printf ("%sOFLO", first ? "" : "|"), first = 0;
10850 if (mask & OEX_FPU_DIV0)
10851 printf ("%sDIV0", first ? "" : "|"), first = 0;
10852 if (mask & OEX_FPU_INVAL)
10853 printf ("%sINVAL", first ? "" : "|");
10854 }
5b18a4bc 10855 else
19e6b90e 10856 fputs ("0", stdout);
5b18a4bc 10857}
103f02d3 10858
11c1ff18
PB		 10859/* ARM EABI attributes section. */
10860typedef struct
10861{
10862 int tag;
2cf0635d 10863 const char * name;
11c1ff18
PB		 10864 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
10865 int type;
2cf0635d 10866 const char ** table;
11c1ff18
PB		 10867} arm_attr_public_tag;
10868
2cf0635d 10869static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 10870 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 10871 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 10872static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
10873static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 10874 {"No", "Thumb-1", "Thumb-2"};
75375b3e 10875static const char * arm_attr_tag_FP_arch[] =
bca38921
MGD		 10876 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
10877 "FP for ARMv8"};
2cf0635d 10878static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 10879static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 10880 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 10881static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 10882 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
10883 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 10884static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 10885 {"V6", "SB", "TLS", "Unused"};
2cf0635d 10886static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 10887 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 10888static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 10889 {"Absolute", "PC-relative", "None"};
2cf0635d 10890static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 10891 {"None", "direct", "GOT-indirect"};
2cf0635d 10892static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 10893 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 10894static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
10895static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 10896 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 10897static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
10898static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
10899static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 10900 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 10901static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 10902 {"Unused", "small", "int", "forced to int"};
2cf0635d 10903static const char * arm_attr_tag_ABI_HardFP_use[] =
75375b3e 10904 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
2cf0635d 10905static const char * arm_attr_tag_ABI_VFP_args[] =
11c1ff18 10906 {"AAPCS", "VFP registers", "custom"};
2cf0635d 10907static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 10908 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 10909static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 10910 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10911 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 10912static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 10913 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10914 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 10915static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 10916static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 10917 {"Not Allowed", "Allowed"};
2cf0635d 10918static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 10919 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 10920static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 10921 {"Not Allowed", "Allowed"};
10922static const char * arm_attr_tag_DIV_use[] =
dd24e3da 10923 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 10924 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 10925static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
10926static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 10927 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 10928 "TrustZone and Virtualization Extensions"};
dd24e3da 10929static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 10930 {"Not Allowed", "Allowed"};
11c1ff18
PB		 10931
10932#define LOOKUP(id, name) \
10933 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 10934static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 10935{
10936 {4, "CPU_raw_name", 1, NULL},
10937 {5, "CPU_name", 1, NULL},
10938 LOOKUP(6, CPU_arch),
10939 {7, "CPU_arch_profile", 0, NULL},
10940 LOOKUP(8, ARM_ISA_use),
10941 LOOKUP(9, THUMB_ISA_use),
75375b3e 10942 LOOKUP(10, FP_arch),
11c1ff18 10943 LOOKUP(11, WMMX_arch),
f5f53991
AS		 10944 LOOKUP(12, Advanced_SIMD_arch),
10945 LOOKUP(13, PCS_config),
11c1ff18
PB		 10946 LOOKUP(14, ABI_PCS_R9_use),
10947 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 10948 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 10949 LOOKUP(17, ABI_PCS_GOT_use),
10950 LOOKUP(18, ABI_PCS_wchar_t),
10951 LOOKUP(19, ABI_FP_rounding),
10952 LOOKUP(20, ABI_FP_denormal),
10953 LOOKUP(21, ABI_FP_exceptions),
10954 LOOKUP(22, ABI_FP_user_exceptions),
10955 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 10956 {24, "ABI_align_needed", 0, NULL},
10957 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 10958 LOOKUP(26, ABI_enum_size),
10959 LOOKUP(27, ABI_HardFP_use),
10960 LOOKUP(28, ABI_VFP_args),
10961 LOOKUP(29, ABI_WMMX_args),
10962 LOOKUP(30, ABI_optimization_goals),
10963 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 10964 {32, "compatibility", 0, NULL},
f5f53991 10965 LOOKUP(34, CPU_unaligned_access),
75375b3e 10966 LOOKUP(36, FP_HP_extension),
8e79c3df 10967 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 10968 LOOKUP(42, MPextension_use),
10969 LOOKUP(44, DIV_use),
f5f53991
AS		 10970 {64, "nodefaults", 0, NULL},
10971 {65, "also_compatible_with", 0, NULL},
10972 LOOKUP(66, T2EE_use),
10973 {67, "conformance", 1, NULL},
10974 LOOKUP(68, Virtualization_use),
cd21e546 10975 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 10976};
10977#undef LOOKUP
10978
11c1ff18 10979static unsigned char *
2cf0635d 10980display_arm_attribute (unsigned char * p)
11c1ff18
PB		 10981{
10982 int tag;
10983 unsigned int len;
10984 int val;
2cf0635d 10985 arm_attr_public_tag * attr;
11c1ff18
PB		 10986 unsigned i;
10987 int type;
10988
10989 tag = read_uleb128 (p, &len);
10990 p += len;
10991 attr = NULL;
2cf0635d 10992 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 10993 {
10994 if (arm_attr_public_tags[i].tag == tag)
10995 {
10996 attr = &arm_attr_public_tags[i];
10997 break;
10998 }
10999 }
11000
11001 if (attr)
11002 {
11003 printf (" Tag_%s: ", attr->name);
11004 switch (attr->type)
11005 {
11006 case 0:
11007 switch (tag)
11008 {
11009 case 7: /* Tag_CPU_arch_profile. */
11010 val = read_uleb128 (p, &len);
11011 p += len;
11012 switch (val)
11013 {
2b692964
NC		 11014 case 0: printf (_("None\n")); break;
11015 case 'A': printf (_("Application\n")); break;
11016 case 'R': printf (_("Realtime\n")); break;
11017 case 'M': printf (_("Microcontroller\n")); break;
11018 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 11019 default: printf ("??? (%d)\n", val); break;
11020 }
11021 break;
11022
75375b3e
MGD		 11023 case 24: /* Tag_align_needed. */
11024 val = read_uleb128 (p, &len);
11025 p += len;
11026 switch (val)
11027 {
2b692964
NC		 11028 case 0: printf (_("None\n")); break;
11029 case 1: printf (_("8-byte\n")); break;
11030 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 11031 case 3: printf ("??? 3\n"); break;
11032 default:
11033 if (val <= 12)
dd24e3da 11034 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 11035 1 << val);
11036 else
11037 printf ("??? (%d)\n", val);
11038 break;
11039 }
11040 break;
11041
11042 case 25: /* Tag_align_preserved. */
11043 val = read_uleb128 (p, &len);
11044 p += len;
11045 switch (val)
11046 {
2b692964
NC		 11047 case 0: printf (_("None\n")); break;
11048 case 1: printf (_("8-byte, except leaf SP\n")); break;
11049 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 11050 case 3: printf ("??? 3\n"); break;
11051 default:
11052 if (val <= 12)
dd24e3da 11053 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 11054 1 << val);
11055 else
11056 printf ("??? (%d)\n", val);
11057 break;
11058 }
11059 break;
11060
11c1ff18
PB		 11061 case 32: /* Tag_compatibility. */
11062 val = read_uleb128 (p, &len);
11063 p += len;
2b692964 11064 printf (_("flag = %d, vendor = %s\n"), val, p);
2cf0635d 11065 p += strlen ((char *) p) + 1;
11c1ff18
PB		 11066 break;
11067
f5f53991
AS		 11068 case 64: /* Tag_nodefaults. */
11069 p++;
2b692964 11070 printf (_("True\n"));
f5f53991
AS		 11071 break;
11072
11073 case 65: /* Tag_also_compatible_with. */
11074 val = read_uleb128 (p, &len);
11075 p += len;
11076 if (val == 6 /* Tag_CPU_arch. */)
11077 {
11078 val = read_uleb128 (p, &len);
11079 p += len;
2cf0635d 11080 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 11081 printf ("??? (%d)\n", val);
11082 else
11083 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
11084 }
11085 else
11086 printf ("???\n");
11087 while (*(p++) != '\0' /* NUL terminator. */);
11088 break;
11089
11c1ff18 11090 default:
2cf0635d 11091 abort ();
11c1ff18
PB		 11092 }
11093 return p;
11094
11095 case 1:
11096 case 2:
11097 type = attr->type;
11098 break;
11099
11100 default:
11101 assert (attr->type & 0x80);
11102 val = read_uleb128 (p, &len);
11103 p += len;
11104 type = attr->type & 0x7f;
11105 if (val >= type)
11106 printf ("??? (%d)\n", val);
11107 else
11108 printf ("%s\n", attr->table[val]);
11109 return p;
11110 }
11111 }
11112 else
11113 {
11114 if (tag & 1)
11115 type = 1; /* String. */
11116 else
11117 type = 2; /* uleb128. */
11118 printf (" Tag_unknown_%d: ", tag);
11119 }
11120
11121 if (type == 1)
11122 {
11123 printf ("\"%s\"\n", p);
2cf0635d 11124 p += strlen ((char *) p) + 1;
11c1ff18
PB		 11125 }
11126 else
11127 {
11128 val = read_uleb128 (p, &len);
11129 p += len;
11130 printf ("%d (0x%x)\n", val, val);
11131 }
11132
11133 return p;
11134}
11135
104d59d1 11136static unsigned char *
60bca95a
NC		 11137display_gnu_attribute (unsigned char * p,
11138 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
104d59d1
JM		 11139{
11140 int tag;
11141 unsigned int len;
11142 int val;
11143 int type;
11144
11145 tag = read_uleb128 (p, &len);
11146 p += len;
11147
11148 /* Tag_compatibility is the only generic GNU attribute defined at
11149 present. */
11150 if (tag == 32)
11151 {
11152 val = read_uleb128 (p, &len);
11153 p += len;
2b692964 11154 printf (_("flag = %d, vendor = %s\n"), val, p);
60bca95a 11155 p += strlen ((char *) p) + 1;
104d59d1
JM		 11156 return p;
11157 }
11158
11159 if ((tag & 2) == 0 && display_proc_gnu_attribute)
11160 return display_proc_gnu_attribute (p, tag);
11161
11162 if (tag & 1)
11163 type = 1; /* String. */
11164 else
11165 type = 2; /* uleb128. */
11166 printf (" Tag_unknown_%d: ", tag);
11167
11168 if (type == 1)
11169 {
11170 printf ("\"%s\"\n", p);
60bca95a 11171 p += strlen ((char *) p) + 1;
104d59d1
JM		 11172 }
11173 else
11174 {
11175 val = read_uleb128 (p, &len);
11176 p += len;
11177 printf ("%d (0x%x)\n", val, val);
11178 }
11179
11180 return p;
11181}
11182
34c8bcba 11183static unsigned char *
2cf0635d 11184display_power_gnu_attribute (unsigned char * p, int tag)
34c8bcba
JM		 11185{
11186 int type;
11187 unsigned int len;
11188 int val;
11189
11190 if (tag == Tag_GNU_Power_ABI_FP)
11191 {
11192 val = read_uleb128 (p, &len);
11193 p += len;
11194 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 11195
34c8bcba
JM		 11196 switch (val)
11197 {
11198 case 0:
2b692964 11199 printf (_("Hard or soft float\n"));
34c8bcba
JM		 11200 break;
11201 case 1:
2b692964 11202 printf (_("Hard float\n"));
34c8bcba
JM		 11203 break;
11204 case 2:
2b692964 11205 printf (_("Soft float\n"));
34c8bcba 11206 break;
3c7b9897 11207 case 3:
2b692964 11208 printf (_("Single-precision hard float\n"));
3c7b9897 11209 break;
34c8bcba
JM		 11210 default:
11211 printf ("??? (%d)\n", val);
11212 break;
11213 }
11214 return p;
11215 }
11216
c6e65352
DJ		 11217 if (tag == Tag_GNU_Power_ABI_Vector)
11218 {
11219 val = read_uleb128 (p, &len);
11220 p += len;
11221 printf (" Tag_GNU_Power_ABI_Vector: ");
11222 switch (val)
11223 {
11224 case 0:
2b692964 11225 printf (_("Any\n"));
c6e65352
DJ		 11226 break;
11227 case 1:
2b692964 11228 printf (_("Generic\n"));
c6e65352
DJ		 11229 break;
11230 case 2:
11231 printf ("AltiVec\n");
11232 break;
11233 case 3:
11234 printf ("SPE\n");
11235 break;
11236 default:
11237 printf ("??? (%d)\n", val);
11238 break;
11239 }
11240 return p;
11241 }
11242
f82e0623
NF		 11243 if (tag == Tag_GNU_Power_ABI_Struct_Return)
11244 {
11245 val = read_uleb128 (p, &len);
11246 p += len;
11247 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11248 switch (val)
11249 {
11250 case 0:
2b692964 11251 printf (_("Any\n"));
f82e0623
NF		 11252 break;
11253 case 1:
11254 printf ("r3/r4\n");
11255 break;
11256 case 2:
2b692964 11257 printf (_("Memory\n"));
f82e0623
NF		 11258 break;
11259 default:
11260 printf ("??? (%d)\n", val);
11261 break;
11262 }
11263 return p;
11264 }
11265
34c8bcba
JM		 11266 if (tag & 1)
11267 type = 1; /* String. */
11268 else
11269 type = 2; /* uleb128. */
11270 printf (" Tag_unknown_%d: ", tag);
11271
11272 if (type == 1)
11273 {
11274 printf ("\"%s\"\n", p);
60bca95a 11275 p += strlen ((char *) p) + 1;
34c8bcba
JM		 11276 }
11277 else
11278 {
11279 val = read_uleb128 (p, &len);
11280 p += len;
11281 printf ("%d (0x%x)\n", val, val);
11282 }
11283
11284 return p;
11285}
11286
9e8c70f9
DM		 11287static void
11288display_sparc_hwcaps (int mask)
11289{
11290 if (mask)
11291 {
11292 int first = 1;
11293 if (mask & ELF_SPARC_HWCAP_MUL32)
11294 fputs ("mul32", stdout), first = 0;
11295 if (mask & ELF_SPARC_HWCAP_DIV32)
11296 printf ("%sdiv32", first ? "" : "|"), first = 0;
11297 if (mask & ELF_SPARC_HWCAP_FSMULD)
11298 printf ("%sfsmuld", first ? "" : "|"), first = 0;
11299 if (mask & ELF_SPARC_HWCAP_V8PLUS)
11300 printf ("%sv8plus", first ? "" : "|"), first = 0;
11301 if (mask & ELF_SPARC_HWCAP_POPC)
11302 printf ("%spopc", first ? "" : "|"), first = 0;
11303 if (mask & ELF_SPARC_HWCAP_VIS)
11304 printf ("%svis", first ? "" : "|"), first = 0;
11305 if (mask & ELF_SPARC_HWCAP_VIS2)
11306 printf ("%svis2", first ? "" : "|"), first = 0;
11307 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
11308 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
11309 if (mask & ELF_SPARC_HWCAP_FMAF)
11310 printf ("%sfmaf", first ? "" : "|"), first = 0;
11311 if (mask & ELF_SPARC_HWCAP_VIS3)
11312 printf ("%svis3", first ? "" : "|"), first = 0;
11313 if (mask & ELF_SPARC_HWCAP_HPC)
11314 printf ("%shpc", first ? "" : "|"), first = 0;
11315 if (mask & ELF_SPARC_HWCAP_RANDOM)
11316 printf ("%srandom", first ? "" : "|"), first = 0;
11317 if (mask & ELF_SPARC_HWCAP_TRANS)
11318 printf ("%strans", first ? "" : "|"), first = 0;
11319 if (mask & ELF_SPARC_HWCAP_FJFMAU)
11320 printf ("%sfjfmau", first ? "" : "|"), first = 0;
11321 if (mask & ELF_SPARC_HWCAP_IMA)
11322 printf ("%sima", first ? "" : "|"), first = 0;
11323 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
11324 printf ("%scspare", first ? "" : "|"), first = 0;
11325 }
11326 else
11327 fputc('0', stdout);
11328 fputc('\n', stdout);
11329}
11330
11331static unsigned char *
11332display_sparc_gnu_attribute (unsigned char * p, int tag)
11333{
11334 int type;
11335 unsigned int len;
11336 int val;
11337
11338 if (tag == Tag_GNU_Sparc_HWCAPS)
11339 {
11340 val = read_uleb128 (p, &len);
11341 p += len;
11342 printf (" Tag_GNU_Sparc_HWCAPS: ");
11343
11344 display_sparc_hwcaps (val);
11345 return p;
11346 }
11347
11348 if (tag & 1)
11349 type = 1; /* String. */
11350 else
11351 type = 2; /* uleb128. */
11352 printf (" Tag_unknown_%d: ", tag);
11353
11354 if (type == 1)
11355 {
11356 printf ("\"%s\"\n", p);
11357 p += strlen ((char *) p) + 1;
11358 }
11359 else
11360 {
11361 val = read_uleb128 (p, &len);
11362 p += len;
11363 printf ("%d (0x%x)\n", val, val);
11364 }
11365
11366 return p;
11367}
11368
2cf19d5c 11369static unsigned char *
2cf0635d 11370display_mips_gnu_attribute (unsigned char * p, int tag)
2cf19d5c
JM		 11371{
11372 int type;
11373 unsigned int len;
11374 int val;
11375
11376 if (tag == Tag_GNU_MIPS_ABI_FP)
11377 {
11378 val = read_uleb128 (p, &len);
11379 p += len;
11380 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 11381
2cf19d5c
JM		 11382 switch (val)
11383 {
11384 case 0:
2b692964 11385 printf (_("Hard or soft float\n"));
2cf19d5c
JM		 11386 break;
11387 case 1:
2b692964 11388 printf (_("Hard float (double precision)\n"));
2cf19d5c
JM		 11389 break;
11390 case 2:
2b692964 11391 printf (_("Hard float (single precision)\n"));
2cf19d5c
JM		 11392 break;
11393 case 3:
2b692964 11394 printf (_("Soft float\n"));
2cf19d5c 11395 break;
42554f6a 11396 case 4:
9eeefea8 11397 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
42554f6a 11398 break;
2cf19d5c
JM		 11399 default:
11400 printf ("??? (%d)\n", val);
11401 break;
11402 }
11403 return p;
11404 }
11405
11406 if (tag & 1)
11407 type = 1; /* String. */
11408 else
11409 type = 2; /* uleb128. */
11410 printf (" Tag_unknown_%d: ", tag);
11411
11412 if (type == 1)
11413 {
11414 printf ("\"%s\"\n", p);
60bca95a 11415 p += strlen ((char *) p) + 1;
2cf19d5c
JM		 11416 }
11417 else
11418 {
11419 val = read_uleb128 (p, &len);
11420 p += len;
11421 printf ("%d (0x%x)\n", val, val);
11422 }
11423
11424 return p;
11425}
11426
59e6276b
JM		 11427static unsigned char *
11428display_tic6x_attribute (unsigned char * p)
11429{
11430 int tag;
11431 unsigned int len;
11432 int val;
11433
11434 tag = read_uleb128 (p, &len);
11435 p += len;
11436
11437 switch (tag)
11438 {
75fa6dc1 11439 case Tag_ISA:
59e6276b
JM		 11440 val = read_uleb128 (p, &len);
11441 p += len;
75fa6dc1 11442 printf (" Tag_ISA: ");
59e6276b
JM		 11443
11444 switch (val)
11445 {
75fa6dc1 11446 case C6XABI_Tag_ISA_none:
59e6276b
JM		 11447 printf (_("None\n"));
11448 break;
75fa6dc1 11449 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 11450 printf ("C62x\n");
11451 break;
75fa6dc1 11452 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 11453 printf ("C67x\n");
11454 break;
75fa6dc1 11455 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 11456 printf ("C67x+\n");
11457 break;
75fa6dc1 11458 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 11459 printf ("C64x\n");
11460 break;
75fa6dc1 11461 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 11462 printf ("C64x+\n");
11463 break;
75fa6dc1 11464 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 11465 printf ("C674x\n");
11466 break;
11467 default:
11468 printf ("??? (%d)\n", val);
11469 break;
11470 }
11471 return p;
11472
87779176
JM		 11473 case Tag_ABI_wchar_t:
11474 val = read_uleb128 (p, &len);
11475 p += len;
11476 printf (" Tag_ABI_wchar_t: ");
11477 switch (val)
11478 {
11479 case 0:
11480 printf (_("Not used\n"));
11481 break;
11482 case 1:
11483 printf (_("2 bytes\n"));
11484 break;
11485 case 2:
11486 printf (_("4 bytes\n"));
11487 break;
11488 default:
11489 printf ("??? (%d)\n", val);
11490 break;
11491 }
11492 return p;
11493
11494 case Tag_ABI_stack_align_needed:
11495 val = read_uleb128 (p, &len);
11496 p += len;
11497 printf (" Tag_ABI_stack_align_needed: ");
11498 switch (val)
11499 {
11500 case 0:
11501 printf (_("8-byte\n"));
11502 break;
11503 case 1:
11504 printf (_("16-byte\n"));
11505 break;
11506 default:
11507 printf ("??? (%d)\n", val);
11508 break;
11509 }
11510 return p;
11511
11512 case Tag_ABI_stack_align_preserved:
11513 val = read_uleb128 (p, &len);
11514 p += len;
11515 printf (" Tag_ABI_stack_align_preserved: ");
11516 switch (val)
11517 {
11518 case 0:
11519 printf (_("8-byte\n"));
11520 break;
11521 case 1:
11522 printf (_("16-byte\n"));
11523 break;
11524 default:
11525 printf ("??? (%d)\n", val);
11526 break;
11527 }
11528 return p;
11529
b5593623
JM		 11530 case Tag_ABI_DSBT:
11531 val = read_uleb128 (p, &len);
11532 p += len;
11533 printf (" Tag_ABI_DSBT: ");
11534 switch (val)
11535 {
11536 case 0:
11537 printf (_("DSBT addressing not used\n"));
11538 break;
11539 case 1:
11540 printf (_("DSBT addressing used\n"));
11541 break;
11542 default:
11543 printf ("??? (%d)\n", val);
11544 break;
11545 }
11546 return p;
11547
87779176
JM		 11548 case Tag_ABI_PID:
11549 val = read_uleb128 (p, &len);
11550 p += len;
11551 printf (" Tag_ABI_PID: ");
11552 switch (val)
11553 {
11554 case 0:
11555 printf (_("Data addressing position-dependent\n"));
11556 break;
11557 case 1:
11558 printf (_("Data addressing position-independent, GOT near DP\n"));
11559 break;
11560 case 2:
11561 printf (_("Data addressing position-independent, GOT far from DP\n"));
11562 break;
11563 default:
11564 printf ("??? (%d)\n", val);
11565 break;
11566 }
11567 return p;
11568
11569 case Tag_ABI_PIC:
11570 val = read_uleb128 (p, &len);
11571 p += len;
11572 printf (" Tag_ABI_PIC: ");
11573 switch (val)
11574 {
11575 case 0:
11576 printf (_("Code addressing position-dependent\n"));
11577 break;
11578 case 1:
11579 printf (_("Code addressing position-independent\n"));
11580 break;
11581 default:
11582 printf ("??? (%d)\n", val);
11583 break;
11584 }
11585 return p;
11586
11587 case Tag_ABI_array_object_alignment:
11588 val = read_uleb128 (p, &len);
11589 p += len;
11590 printf (" Tag_ABI_array_object_alignment: ");
11591 switch (val)
11592 {
11593 case 0:
11594 printf (_("8-byte\n"));
11595 break;
11596 case 1:
11597 printf (_("4-byte\n"));
11598 break;
11599 case 2:
11600 printf (_("16-byte\n"));
11601 break;
11602 default:
11603 printf ("??? (%d)\n", val);
11604 break;
11605 }
11606 return p;
11607
11608 case Tag_ABI_array_object_align_expected:
11609 val = read_uleb128 (p, &len);
11610 p += len;
11611 printf (" Tag_ABI_array_object_align_expected: ");
11612 switch (val)
11613 {
11614 case 0:
11615 printf (_("8-byte\n"));
11616 break;
11617 case 1:
11618 printf (_("4-byte\n"));
11619 break;
11620 case 2:
11621 printf (_("16-byte\n"));
11622 break;
11623 default:
11624 printf ("??? (%d)\n", val);
11625 break;
11626 }
11627 return p;
11628
3cbd1c06 11629 case Tag_ABI_compatibility:
59e6276b
JM		 11630 val = read_uleb128 (p, &len);
11631 p += len;
3cbd1c06 11632 printf (" Tag_ABI_compatibility: ");
59e6276b
JM		 11633 printf (_("flag = %d, vendor = %s\n"), val, p);
11634 p += strlen ((char *) p) + 1;
11635 return p;
87779176
JM		 11636
11637 case Tag_ABI_conformance:
11638 printf (" Tag_ABI_conformance: ");
11639 printf ("\"%s\"\n", p);
11640 p += strlen ((char *) p) + 1;
11641 return p;
59e6276b
JM		 11642 }
11643
11644 printf (" Tag_unknown_%d: ", tag);
11645
87779176
JM		 11646 if (tag & 1)
11647 {
11648 printf ("\"%s\"\n", p);
11649 p += strlen ((char *) p) + 1;
11650 }
11651 else
11652 {
11653 val = read_uleb128 (p, &len);
11654 p += len;
11655 printf ("%d (0x%x)\n", val, val);
11656 }
59e6276b
JM		 11657
11658 return p;
11659}
11660
11c1ff18 11661static int
60bca95a
NC		 11662process_attributes (FILE * file,
11663 const char * public_name,
104d59d1 11664 unsigned int proc_type,
60bca95a
NC		 11665 unsigned char * (* display_pub_attribute) (unsigned char *),
11666 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11c1ff18 11667{
2cf0635d
NC		 11668 Elf_Internal_Shdr * sect;
11669 unsigned char * contents;
11670 unsigned char * p;
11671 unsigned char * end;
11c1ff18
PB		 11672 bfd_vma section_len;
11673 bfd_vma len;
11674 unsigned i;
11675
11676 /* Find the section header so that we get the size. */
11677 for (i = 0, sect = section_headers;
11678 i < elf_header.e_shnum;
11679 i++, sect++)
11680 {
104d59d1 11681 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 11682 continue;
11683
3f5e193b
NC		 11684 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
11685 sect->sh_size, _("attributes"));
60bca95a 11686 if (contents == NULL)
11c1ff18 11687 continue;
60bca95a 11688
11c1ff18
PB		 11689 p = contents;
11690 if (*p == 'A')
11691 {
11692 len = sect->sh_size - 1;
11693 p++;
60bca95a 11694
11c1ff18
PB		 11695 while (len > 0)
11696 {
11697 int namelen;
11698 bfd_boolean public_section;
104d59d1 11699 bfd_boolean gnu_section;
11c1ff18
PB		 11700
11701 section_len = byte_get (p, 4);
11702 p += 4;
60bca95a 11703
11c1ff18
PB		 11704 if (section_len > len)
11705 {
11706 printf (_("ERROR: Bad section length (%d > %d)\n"),
60bca95a 11707 (int) section_len, (int) len);
11c1ff18
PB		 11708 section_len = len;
11709 }
60bca95a 11710
11c1ff18 11711 len -= section_len;
2b692964 11712 printf (_("Attribute Section: %s\n"), p);
60bca95a
NC		 11713
11714 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 11715 public_section = TRUE;
11716 else
11717 public_section = FALSE;
60bca95a
NC		 11718
11719 if (streq ((char *) p, "gnu"))
104d59d1
JM		 11720 gnu_section = TRUE;
11721 else
11722 gnu_section = FALSE;
60bca95a
NC		 11723
11724 namelen = strlen ((char *) p) + 1;
11c1ff18
PB		 11725 p += namelen;
11726 section_len -= namelen + 4;
60bca95a 11727
11c1ff18
PB		 11728 while (section_len > 0)
11729 {
11730 int tag = *(p++);
11731 int val;
11732 bfd_vma size;
60bca95a 11733
11c1ff18
PB		 11734 size = byte_get (p, 4);
11735 if (size > section_len)
11736 {
11737 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
60bca95a 11738 (int) size, (int) section_len);
11c1ff18
PB		 11739 size = section_len;
11740 }
60bca95a 11741
11c1ff18
PB		 11742 section_len -= size;
11743 end = p + size - 1;
11744 p += 4;
60bca95a 11745
11c1ff18
PB		 11746 switch (tag)
11747 {
11748 case 1:
2b692964 11749 printf (_("File Attributes\n"));
11c1ff18
PB		 11750 break;
11751 case 2:
2b692964 11752 printf (_("Section Attributes:"));
11c1ff18
PB		 11753 goto do_numlist;
11754 case 3:
2b692964 11755 printf (_("Symbol Attributes:"));
11c1ff18
PB		 11756 do_numlist:
11757 for (;;)
11758 {
91d6fa6a 11759 unsigned int j;
60bca95a 11760
91d6fa6a
NC		 11761 val = read_uleb128 (p, &j);
11762 p += j;
11c1ff18
PB		 11763 if (val == 0)
11764 break;
11765 printf (" %d", val);
11766 }
11767 printf ("\n");
11768 break;
11769 default:
2b692964 11770 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 11771 public_section = FALSE;
11772 break;
11773 }
60bca95a 11774
11c1ff18
PB		 11775 if (public_section)
11776 {
11777 while (p < end)
104d59d1
JM		 11778 p = display_pub_attribute (p);
11779 }
11780 else if (gnu_section)
11781 {
11782 while (p < end)
11783 p = display_gnu_attribute (p,
11784 display_proc_gnu_attribute);
11c1ff18
PB		 11785 }
11786 else
11787 {
11788 /* ??? Do something sensible, like dump hex. */
2b692964 11789 printf (_(" Unknown section contexts\n"));
11c1ff18
PB		 11790 p = end;
11791 }
11792 }
11793 }
11794 }
11795 else
60bca95a 11796 printf (_("Unknown format '%c'\n"), *p);
d70c5fc7 11797
60bca95a 11798 free (contents);
11c1ff18
PB		 11799 }
11800 return 1;
11801}
11802
104d59d1 11803static int
2cf0635d 11804process_arm_specific (FILE * file)
104d59d1
JM		 11805{
11806 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
11807 display_arm_attribute, NULL);
11808}
11809
34c8bcba 11810static int
2cf0635d 11811process_power_specific (FILE * file)
34c8bcba
JM		 11812{
11813 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11814 display_power_gnu_attribute);
11815}
11816
9e8c70f9
DM		 11817static int
11818process_sparc_specific (FILE * file)
11819{
11820 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11821 display_sparc_gnu_attribute);
11822}
11823
59e6276b
JM		 11824static int
11825process_tic6x_specific (FILE * file)
11826{
11827 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
11828 display_tic6x_attribute, NULL);
11829}
11830
ccb4c951
RS		 11831/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
11832 Print the Address, Access and Initial fields of an entry at VMA ADDR
11833 and return the VMA of the next entry. */
11834
11835static bfd_vma
2cf0635d 11836print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
ccb4c951
RS		 11837{
11838 printf (" ");
11839 print_vma (addr, LONG_HEX);
11840 printf (" ");
11841 if (addr < pltgot + 0xfff0)
11842 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
11843 else
11844 printf ("%10s", "");
11845 printf (" ");
11846 if (data == NULL)
2b692964 11847 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 11848 else
11849 {
11850 bfd_vma entry;
11851
11852 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11853 print_vma (entry, LONG_HEX);
11854 }
11855 return addr + (is_32bit_elf ? 4 : 8);
11856}
11857
861fb55a
DJ		 11858/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
11859 PLTGOT. Print the Address and Initial fields of an entry at VMA
11860 ADDR and return the VMA of the next entry. */
11861
11862static bfd_vma
2cf0635d 11863print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 11864{
11865 printf (" ");
11866 print_vma (addr, LONG_HEX);
11867 printf (" ");
11868 if (data == NULL)
2b692964 11869 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 11870 else
11871 {
11872 bfd_vma entry;
11873
11874 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11875 print_vma (entry, LONG_HEX);
11876 }
11877 return addr + (is_32bit_elf ? 4 : 8);
11878}
11879
19e6b90e 11880static int
2cf0635d 11881process_mips_specific (FILE * file)
5b18a4bc 11882{
2cf0635d 11883 Elf_Internal_Dyn * entry;
19e6b90e
L		 11884 size_t liblist_offset = 0;
11885 size_t liblistno = 0;
11886 size_t conflictsno = 0;
11887 size_t options_offset = 0;
11888 size_t conflicts_offset = 0;
861fb55a
DJ		 11889 size_t pltrelsz = 0;
11890 size_t pltrel = 0;
ccb4c951 11891 bfd_vma pltgot = 0;
861fb55a
DJ		 11892 bfd_vma mips_pltgot = 0;
11893 bfd_vma jmprel = 0;
ccb4c951
RS		 11894 bfd_vma local_gotno = 0;
11895 bfd_vma gotsym = 0;
11896 bfd_vma symtabno = 0;
103f02d3 11897
2cf19d5c
JM		 11898 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11899 display_mips_gnu_attribute);
11900
19e6b90e
L		 11901 /* We have a lot of special sections. Thanks SGI! */
11902 if (dynamic_section == NULL)
11903 /* No information available. */
11904 return 0;
252b5132 11905
b2d38a17 11906 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
252b5132
RH		 11907 switch (entry->d_tag)
11908 {
11909 case DT_MIPS_LIBLIST:
d93f0186
NC		 11910 liblist_offset
11911 = offset_from_vma (file, entry->d_un.d_val,
11912 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 11913 break;
11914 case DT_MIPS_LIBLISTNO:
11915 liblistno = entry->d_un.d_val;
11916 break;
11917 case DT_MIPS_OPTIONS:
d93f0186 11918 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 11919 break;
11920 case DT_MIPS_CONFLICT:
d93f0186
NC		 11921 conflicts_offset
11922 = offset_from_vma (file, entry->d_un.d_val,
11923 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 11924 break;
11925 case DT_MIPS_CONFLICTNO:
11926 conflictsno = entry->d_un.d_val;
11927 break;
ccb4c951 11928 case DT_PLTGOT:
861fb55a
DJ		 11929 pltgot = entry->d_un.d_ptr;
11930 break;
ccb4c951
RS		 11931 case DT_MIPS_LOCAL_GOTNO:
11932 local_gotno = entry->d_un.d_val;
11933 break;
11934 case DT_MIPS_GOTSYM:
11935 gotsym = entry->d_un.d_val;
11936 break;
11937 case DT_MIPS_SYMTABNO:
11938 symtabno = entry->d_un.d_val;
11939 break;
861fb55a
DJ		 11940 case DT_MIPS_PLTGOT:
11941 mips_pltgot = entry->d_un.d_ptr;
11942 break;
11943 case DT_PLTREL:
11944 pltrel = entry->d_un.d_val;
11945 break;
11946 case DT_PLTRELSZ:
11947 pltrelsz = entry->d_un.d_val;
11948 break;
11949 case DT_JMPREL:
11950 jmprel = entry->d_un.d_ptr;
11951 break;
252b5132
RH		 11952 default:
11953 break;
11954 }
11955
11956 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
11957 {
2cf0635d 11958 Elf32_External_Lib * elib;
252b5132
RH		 11959 size_t cnt;
11960
3f5e193b
NC		 11961 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
11962 liblistno,
11963 sizeof (Elf32_External_Lib),
9cf03b7e 11964 _("liblist section data"));
a6e9f9df 11965 if (elib)
252b5132 11966 {
2b692964 11967 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 11968 (unsigned long) liblistno);
2b692964 11969 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 11970 stdout);
11971
11972 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 11973 {
a6e9f9df 11974 Elf32_Lib liblist;
91d6fa6a 11975 time_t atime;
a6e9f9df 11976 char timebuf[20];
2cf0635d 11977 struct tm * tmp;
a6e9f9df
AM		 11978
11979 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 11980 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 11981 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
11982 liblist.l_version = BYTE_GET (elib[cnt].l_version);
11983 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
11984
91d6fa6a 11985 tmp = gmtime (&atime);
e9e44622
JJ		 11986 snprintf (timebuf, sizeof (timebuf),
11987 "%04u-%02u-%02uT%02u:%02u:%02u",
11988 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
11989 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 11990
31104126 11991 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 11992 if (VALID_DYNAMIC_NAME (liblist.l_name))
11993 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
11994 else
2b692964 11995 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 11996 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
11997 liblist.l_version);
a6e9f9df
AM		 11998
11999 if (liblist.l_flags == 0)
2b692964 12000 puts (_(" NONE"));
a6e9f9df
AM		 12001 else
12002 {
12003 static const struct
252b5132 12004 {
2cf0635d 12005 const char * name;
a6e9f9df 12006 int bit;
252b5132 12007 }
a6e9f9df
AM		 12008 l_flags_vals[] =
12009 {
12010 { " EXACT_MATCH", LL_EXACT_MATCH },
12011 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
12012 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
12013 { " EXPORTS", LL_EXPORTS },
12014 { " DELAY_LOAD", LL_DELAY_LOAD },
12015 { " DELTA", LL_DELTA }
12016 };
12017 int flags = liblist.l_flags;
12018 size_t fcnt;
12019
60bca95a 12020 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 12021 if ((flags & l_flags_vals[fcnt].bit) != 0)
12022 {
12023 fputs (l_flags_vals[fcnt].name, stdout);
12024 flags ^= l_flags_vals[fcnt].bit;
12025 }
12026 if (flags != 0)
12027 printf (" %#x", (unsigned int) flags);
252b5132 12028
a6e9f9df
AM		 12029 puts ("");
12030 }
252b5132 12031 }
252b5132 12032
a6e9f9df
AM		 12033 free (elib);
12034 }
252b5132
RH		 12035 }
12036
12037 if (options_offset != 0)
12038 {
2cf0635d
NC		 12039 Elf_External_Options * eopt;
12040 Elf_Internal_Shdr * sect = section_headers;
12041 Elf_Internal_Options * iopt;
12042 Elf_Internal_Options * option;
252b5132
RH		 12043 size_t offset;
12044 int cnt;
12045
12046 /* Find the section header so that we get the size. */
12047 while (sect->sh_type != SHT_MIPS_OPTIONS)
b34976b6 12048 ++sect;
252b5132 12049
3f5e193b
NC		 12050 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
12051 sect->sh_size, _("options"));
a6e9f9df 12052 if (eopt)
252b5132 12053 {
3f5e193b
NC		 12054 iopt = (Elf_Internal_Options *)
12055 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 12056 if (iopt == NULL)
12057 {
591a748a 12058 error (_("Out of memory\n"));
a6e9f9df
AM		 12059 return 0;
12060 }
76da6bbe 12061
a6e9f9df
AM		 12062 offset = cnt = 0;
12063 option = iopt;
252b5132 12064
a6e9f9df
AM		 12065 while (offset < sect->sh_size)
12066 {
2cf0635d 12067 Elf_External_Options * eoption;
252b5132 12068
a6e9f9df 12069 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 12070
a6e9f9df
AM		 12071 option->kind = BYTE_GET (eoption->kind);
12072 option->size = BYTE_GET (eoption->size);
12073 option->section = BYTE_GET (eoption->section);
12074 option->info = BYTE_GET (eoption->info);
76da6bbe 12075
a6e9f9df 12076 offset += option->size;
252b5132 12077
a6e9f9df
AM		 12078 ++option;
12079 ++cnt;
12080 }
252b5132 12081
a6e9f9df
AM		 12082 printf (_("\nSection '%s' contains %d entries:\n"),
12083 SECTION_NAME (sect), cnt);
76da6bbe 12084
a6e9f9df 12085 option = iopt;
252b5132 12086
a6e9f9df 12087 while (cnt-- > 0)
252b5132 12088 {
a6e9f9df
AM		 12089 size_t len;
12090
12091 switch (option->kind)
252b5132 12092 {
a6e9f9df
AM		 12093 case ODK_NULL:
12094 /* This shouldn't happen. */
12095 printf (" NULL %d %lx", option->section, option->info);
12096 break;
12097 case ODK_REGINFO:
12098 printf (" REGINFO ");
12099 if (elf_header.e_machine == EM_MIPS)
12100 {
12101 /* 32bit form. */
2cf0635d 12102 Elf32_External_RegInfo * ereg;
b34976b6 12103 Elf32_RegInfo reginfo;
a6e9f9df
AM		 12104
12105 ereg = (Elf32_External_RegInfo *) (option + 1);
12106 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12107 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12108 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12109 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12110 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12111 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
12112
12113 printf ("GPR %08lx GP 0x%lx\n",
12114 reginfo.ri_gprmask,
12115 (unsigned long) reginfo.ri_gp_value);
12116 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12117 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12118 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12119 }
12120 else
12121 {
12122 /* 64 bit form. */
2cf0635d 12123 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 12124 Elf64_Internal_RegInfo reginfo;
12125
12126 ereg = (Elf64_External_RegInfo *) (option + 1);
12127 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12128 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12129 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12130 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12131 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 12132 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 12133
12134 printf ("GPR %08lx GP 0x",
12135 reginfo.ri_gprmask);
12136 printf_vma (reginfo.ri_gp_value);
12137 printf ("\n");
12138
12139 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12140 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12141 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12142 }
12143 ++option;
12144 continue;
12145 case ODK_EXCEPTIONS:
12146 fputs (" EXCEPTIONS fpe_min(", stdout);
12147 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
12148 fputs (") fpe_max(", stdout);
12149 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
12150 fputs (")", stdout);
12151
12152 if (option->info & OEX_PAGE0)
12153 fputs (" PAGE0", stdout);
12154 if (option->info & OEX_SMM)
12155 fputs (" SMM", stdout);
12156 if (option->info & OEX_FPDBUG)
12157 fputs (" FPDBUG", stdout);
12158 if (option->info & OEX_DISMISS)
12159 fputs (" DISMISS", stdout);
12160 break;
12161 case ODK_PAD:
12162 fputs (" PAD ", stdout);
12163 if (option->info & OPAD_PREFIX)
12164 fputs (" PREFIX", stdout);
12165 if (option->info & OPAD_POSTFIX)
12166 fputs (" POSTFIX", stdout);
12167 if (option->info & OPAD_SYMBOL)
12168 fputs (" SYMBOL", stdout);
12169 break;
12170 case ODK_HWPATCH:
12171 fputs (" HWPATCH ", stdout);
12172 if (option->info & OHW_R4KEOP)
12173 fputs (" R4KEOP", stdout);
12174 if (option->info & OHW_R8KPFETCH)
12175 fputs (" R8KPFETCH", stdout);
12176 if (option->info & OHW_R5KEOP)
12177 fputs (" R5KEOP", stdout);
12178 if (option->info & OHW_R5KCVTL)
12179 fputs (" R5KCVTL", stdout);
12180 break;
12181 case ODK_FILL:
12182 fputs (" FILL ", stdout);
12183 /* XXX Print content of info word? */
12184 break;
12185 case ODK_TAGS:
12186 fputs (" TAGS ", stdout);
12187 /* XXX Print content of info word? */
12188 break;
12189 case ODK_HWAND:
12190 fputs (" HWAND ", stdout);
12191 if (option->info & OHWA0_R4KEOP_CHECKED)
12192 fputs (" R4KEOP_CHECKED", stdout);
12193 if (option->info & OHWA0_R4KEOP_CLEAN)
12194 fputs (" R4KEOP_CLEAN", stdout);
12195 break;
12196 case ODK_HWOR:
12197 fputs (" HWOR ", stdout);
12198 if (option->info & OHWA0_R4KEOP_CHECKED)
12199 fputs (" R4KEOP_CHECKED", stdout);
12200 if (option->info & OHWA0_R4KEOP_CLEAN)
12201 fputs (" R4KEOP_CLEAN", stdout);
12202 break;
12203 case ODK_GP_GROUP:
12204 printf (" GP_GROUP %#06lx self-contained %#06lx",
12205 option->info & OGP_GROUP,
12206 (option->info & OGP_SELF) >> 16);
12207 break;
12208 case ODK_IDENT:
12209 printf (" IDENT %#06lx self-contained %#06lx",
12210 option->info & OGP_GROUP,
12211 (option->info & OGP_SELF) >> 16);
12212 break;
12213 default:
12214 /* This shouldn't happen. */
12215 printf (" %3d ??? %d %lx",
12216 option->kind, option->section, option->info);
12217 break;
252b5132 12218 }
a6e9f9df 12219
2cf0635d 12220 len = sizeof (* eopt);
a6e9f9df
AM		 12221 while (len < option->size)
12222 if (((char *) option)[len] >= ' '
12223 && ((char *) option)[len] < 0x7f)
12224 printf ("%c", ((char *) option)[len++]);
12225 else
12226 printf ("\\%03o", ((char *) option)[len++]);
12227
12228 fputs ("\n", stdout);
252b5132 12229 ++option;
252b5132
RH		 12230 }
12231
a6e9f9df 12232 free (eopt);
252b5132 12233 }
252b5132
RH		 12234 }
12235
12236 if (conflicts_offset != 0 && conflictsno != 0)
12237 {
2cf0635d 12238 Elf32_Conflict * iconf;
252b5132
RH		 12239 size_t cnt;
12240
12241 if (dynamic_symbols == NULL)
12242 {
591a748a 12243 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 12244 return 0;
12245 }
12246
3f5e193b 12247 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 12248 if (iconf == NULL)
12249 {
591a748a 12250 error (_("Out of memory\n"));
252b5132
RH		 12251 return 0;
12252 }
12253
9ea033b2 12254 if (is_32bit_elf)
252b5132 12255 {
2cf0635d 12256 Elf32_External_Conflict * econf32;
a6e9f9df 12257
3f5e193b
NC		 12258 econf32 = (Elf32_External_Conflict *)
12259 get_data (NULL, file, conflicts_offset, conflictsno,
12260 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 12261 if (!econf32)
12262 return 0;
252b5132
RH		 12263
12264 for (cnt = 0; cnt < conflictsno; ++cnt)
12265 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 12266
12267 free (econf32);
252b5132
RH		 12268 }
12269 else
12270 {
2cf0635d 12271 Elf64_External_Conflict * econf64;
a6e9f9df 12272
3f5e193b
NC		 12273 econf64 = (Elf64_External_Conflict *)
12274 get_data (NULL, file, conflicts_offset, conflictsno,
12275 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 12276 if (!econf64)
12277 return 0;
252b5132
RH		 12278
12279 for (cnt = 0; cnt < conflictsno; ++cnt)
12280 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 12281
12282 free (econf64);
252b5132
RH		 12283 }
12284
c7e7ca54
NC		 12285 printf (_("\nSection '.conflict' contains %lu entries:\n"),
12286 (unsigned long) conflictsno);
252b5132
RH		 12287 puts (_(" Num: Index Value Name"));
12288
12289 for (cnt = 0; cnt < conflictsno; ++cnt)
12290 {
2cf0635d 12291 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
252b5132 12292
b34976b6 12293 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
f7a99963 12294 print_vma (psym->st_value, FULL_HEX);
31104126 12295 putchar (' ');
d79b3d50
NC		 12296 if (VALID_DYNAMIC_NAME (psym->st_name))
12297 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
12298 else
2b692964 12299 printf (_("<corrupt: %14ld>"), psym->st_name);
31104126 12300 putchar ('\n');
252b5132
RH		 12301 }
12302
252b5132
RH		 12303 free (iconf);
12304 }
12305
ccb4c951
RS		 12306 if (pltgot != 0 && local_gotno != 0)
12307 {
91d6fa6a 12308 bfd_vma ent, local_end, global_end;
bbeee7ea 12309 size_t i, offset;
2cf0635d 12310 unsigned char * data;
bbeee7ea 12311 int addr_size;
ccb4c951 12312
91d6fa6a 12313 ent = pltgot;
ccb4c951
RS		 12314 addr_size = (is_32bit_elf ? 4 : 8);
12315 local_end = pltgot + local_gotno * addr_size;
12316 global_end = local_end + (symtabno - gotsym) * addr_size;
12317
12318 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 12319 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 12320 global_end - pltgot, 1,
12321 _("Global Offset Table data"));
59245841
NC		 12322 if (data == NULL)
12323 return 0;
12324
ccb4c951
RS		 12325 printf (_("\nPrimary GOT:\n"));
12326 printf (_(" Canonical gp value: "));
12327 print_vma (pltgot + 0x7ff0, LONG_HEX);
12328 printf ("\n\n");
12329
12330 printf (_(" Reserved entries:\n"));
12331 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 12332 addr_size * 2, _("Address"), _("Access"),
12333 addr_size * 2, _("Initial"));
91d6fa6a 12334 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 12335 printf (_(" Lazy resolver\n"));
ccb4c951 12336 if (data
91d6fa6a 12337 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 12338 >> (addr_size * 8 - 1)) != 0)
12339 {
91d6fa6a 12340 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 12341 printf (_(" Module pointer (GNU extension)\n"));
ccb4c951
RS		 12342 }
12343 printf ("\n");
12344
91d6fa6a 12345 if (ent < local_end)
ccb4c951
RS		 12346 {
12347 printf (_(" Local entries:\n"));
cc5914eb 12348 printf (" %*s %10s %*s\n",
2b692964
NC		 12349 addr_size * 2, _("Address"), _("Access"),
12350 addr_size * 2, _("Initial"));
91d6fa6a 12351 while (ent < local_end)
ccb4c951 12352 {
91d6fa6a 12353 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 12354 printf ("\n");
12355 }
12356 printf ("\n");
12357 }
12358
12359 if (gotsym < symtabno)
12360 {
12361 int sym_width;
12362
12363 printf (_(" Global entries:\n"));
cc5914eb 12364 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 12365 addr_size * 2, _("Address"),
12366 _("Access"),
2b692964 12367 addr_size * 2, _("Initial"),
9cf03b7e
NC		 12368 addr_size * 2, _("Sym.Val."),
12369 _("Type"),
12370 /* Note for translators: "Ndx" = abbreviated form of "Index". */
12371 _("Ndx"), _("Name"));
12372
ccb4c951
RS		 12373 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
12374 for (i = gotsym; i < symtabno; i++)
12375 {
2cf0635d 12376 Elf_Internal_Sym * psym;
ccb4c951
RS		 12377
12378 psym = dynamic_symbols + i;
91d6fa6a 12379 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 12380 printf (" ");
12381 print_vma (psym->st_value, LONG_HEX);
12382 printf (" %-7s %3s ",
12383 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12384 get_symbol_index_type (psym->st_shndx));
12385 if (VALID_DYNAMIC_NAME (psym->st_name))
12386 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12387 else
2b692964 12388 printf (_("<corrupt: %14ld>"), psym->st_name);
ccb4c951
RS		 12389 printf ("\n");
12390 }
12391 printf ("\n");
12392 }
12393
12394 if (data)
12395 free (data);
12396 }
12397
861fb55a
DJ		 12398 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
12399 {
91d6fa6a 12400 bfd_vma ent, end;
861fb55a
DJ		 12401 size_t offset, rel_offset;
12402 unsigned long count, i;
2cf0635d 12403 unsigned char * data;
861fb55a 12404 int addr_size, sym_width;
2cf0635d 12405 Elf_Internal_Rela * rels;
861fb55a
DJ		 12406
12407 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
12408 if (pltrel == DT_RELA)
12409 {
12410 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
12411 return 0;
12412 }
12413 else
12414 {
12415 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
12416 return 0;
12417 }
12418
91d6fa6a 12419 ent = mips_pltgot;
861fb55a
DJ		 12420 addr_size = (is_32bit_elf ? 4 : 8);
12421 end = mips_pltgot + (2 + count) * addr_size;
12422
12423 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 12424 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 12425 1, _("Procedure Linkage Table data"));
59245841
NC		 12426 if (data == NULL)
12427 return 0;
12428
9cf03b7e 12429 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 12430 printf (_(" Reserved entries:\n"));
12431 printf (_(" %*s %*s Purpose\n"),
2b692964 12432 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 12433 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 12434 printf (_(" PLT lazy resolver\n"));
91d6fa6a 12435 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 12436 printf (_(" Module pointer\n"));
861fb55a
DJ		 12437 printf ("\n");
12438
12439 printf (_(" Entries:\n"));
cc5914eb 12440 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 12441 addr_size * 2, _("Address"),
12442 addr_size * 2, _("Initial"),
12443 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 12444 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
12445 for (i = 0; i < count; i++)
12446 {
2cf0635d 12447 Elf_Internal_Sym * psym;
861fb55a
DJ		 12448
12449 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
91d6fa6a 12450 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a
DJ		 12451 printf (" ");
12452 print_vma (psym->st_value, LONG_HEX);
12453 printf (" %-7s %3s ",
12454 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12455 get_symbol_index_type (psym->st_shndx));
12456 if (VALID_DYNAMIC_NAME (psym->st_name))
12457 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12458 else
2b692964 12459 printf (_("<corrupt: %14ld>"), psym->st_name);
861fb55a
DJ		 12460 printf ("\n");
12461 }
12462 printf ("\n");
12463
12464 if (data)
12465 free (data);
12466 free (rels);
12467 }
12468
252b5132
RH		 12469 return 1;
12470}
12471
047b2264 12472static int
2cf0635d 12473process_gnu_liblist (FILE * file)
047b2264 12474{
2cf0635d
NC		 12475 Elf_Internal_Shdr * section;
12476 Elf_Internal_Shdr * string_sec;
12477 Elf32_External_Lib * elib;
12478 char * strtab;
c256ffe7 12479 size_t strtab_size;
047b2264
JJ		 12480 size_t cnt;
12481 unsigned i;
12482
12483 if (! do_arch)
12484 return 0;
12485
12486 for (i = 0, section = section_headers;
12487 i < elf_header.e_shnum;
b34976b6 12488 i++, section++)
047b2264
JJ		 12489 {
12490 switch (section->sh_type)
12491 {
12492 case SHT_GNU_LIBLIST:
4fbb74a6 12493 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 12494 break;
12495
3f5e193b
NC		 12496 elib = (Elf32_External_Lib *)
12497 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 12498 _("liblist section data"));
047b2264
JJ		 12499
12500 if (elib == NULL)
12501 break;
4fbb74a6 12502 string_sec = section_headers + section->sh_link;
047b2264 12503
3f5e193b
NC		 12504 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
12505 string_sec->sh_size,
12506 _("liblist string table"));
047b2264
JJ		 12507 if (strtab == NULL
12508 || section->sh_entsize != sizeof (Elf32_External_Lib))
12509 {
12510 free (elib);
2842702f 12511 free (strtab);
047b2264
JJ		 12512 break;
12513 }
59245841 12514 strtab_size = string_sec->sh_size;
047b2264
JJ		 12515
12516 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12517 SECTION_NAME (section),
0af1713e 12518 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 12519
2b692964 12520 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 12521
12522 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
12523 ++cnt)
12524 {
12525 Elf32_Lib liblist;
91d6fa6a 12526 time_t atime;
047b2264 12527 char timebuf[20];
2cf0635d 12528 struct tm * tmp;
047b2264
JJ		 12529
12530 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 12531 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 12532 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12533 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12534 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12535
91d6fa6a 12536 tmp = gmtime (&atime);
e9e44622
JJ		 12537 snprintf (timebuf, sizeof (timebuf),
12538 "%04u-%02u-%02uT%02u:%02u:%02u",
12539 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12540 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 12541
12542 printf ("%3lu: ", (unsigned long) cnt);
12543 if (do_wide)
c256ffe7 12544 printf ("%-20s", liblist.l_name < strtab_size
2b692964 12545 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 12546 else
c256ffe7 12547 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 12548 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 12549 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
12550 liblist.l_version, liblist.l_flags);
12551 }
12552
12553 free (elib);
2842702f 12554 free (strtab);
047b2264
JJ		 12555 }
12556 }
12557
12558 return 1;
12559}
12560
9437c45b 12561static const char *
d3ba0551 12562get_note_type (unsigned e_type)
779fe533
NC		 12563{
12564 static char buff[64];
103f02d3 12565
1ec5cd37
NC		 12566 if (elf_header.e_type == ET_CORE)
12567 switch (e_type)
12568 {
57346661 12569 case NT_AUXV:
1ec5cd37 12570 return _("NT_AUXV (auxiliary vector)");
57346661 12571 case NT_PRSTATUS:
1ec5cd37 12572 return _("NT_PRSTATUS (prstatus structure)");
57346661 12573 case NT_FPREGSET:
1ec5cd37 12574 return _("NT_FPREGSET (floating point registers)");
57346661 12575 case NT_PRPSINFO:
1ec5cd37 12576 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 12577 case NT_TASKSTRUCT:
1ec5cd37 12578 return _("NT_TASKSTRUCT (task structure)");
57346661 12579 case NT_PRXFPREG:
1ec5cd37 12580 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 12581 case NT_PPC_VMX:
12582 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 12583 case NT_PPC_VSX:
12584 return _("NT_PPC_VSX (ppc VSX registers)");
4339cae0
L		 12585 case NT_X86_XSTATE:
12586 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 12587 case NT_S390_HIGH_GPRS:
12588 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 12589 case NT_S390_TIMER:
12590 return _("NT_S390_TIMER (s390 timer register)");
12591 case NT_S390_TODCMP:
12592 return _("NT_S390_TODCMP (s390 TOD comparator register)");
12593 case NT_S390_TODPREG:
12594 return _("NT_S390_TODPREG (s390 TOD programmable register)");
12595 case NT_S390_CTRS:
12596 return _("NT_S390_CTRS (s390 control registers)");
12597 case NT_S390_PREFIX:
12598 return _("NT_S390_PREFIX (s390 prefix register)");
faa9a424
UW		 12599 case NT_ARM_VFP:
12600 return _("NT_ARM_VFP (arm VFP registers)");
57346661 12601 case NT_PSTATUS:
1ec5cd37 12602 return _("NT_PSTATUS (pstatus structure)");
57346661 12603 case NT_FPREGS:
1ec5cd37 12604 return _("NT_FPREGS (floating point registers)");
57346661 12605 case NT_PSINFO:
1ec5cd37 12606 return _("NT_PSINFO (psinfo structure)");
57346661 12607 case NT_LWPSTATUS:
1ec5cd37 12608 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 12609 case NT_LWPSINFO:
1ec5cd37 12610 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 12611 case NT_WIN32PSTATUS:
1ec5cd37
NC		 12612 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
12613 default:
12614 break;
12615 }
12616 else
12617 switch (e_type)
12618 {
12619 case NT_VERSION:
12620 return _("NT_VERSION (version)");
12621 case NT_ARCH:
12622 return _("NT_ARCH (architecture)");
12623 default:
12624 break;
12625 }
12626
e9e44622 12627 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 12628 return buff;
779fe533
NC		 12629}
12630
1118d252
RM		 12631static const char *
12632get_gnu_elf_note_type (unsigned e_type)
12633{
12634 static char buff[64];
12635
12636 switch (e_type)
12637 {
12638 case NT_GNU_ABI_TAG:
12639 return _("NT_GNU_ABI_TAG (ABI version tag)");
12640 case NT_GNU_HWCAP:
12641 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
12642 case NT_GNU_BUILD_ID:
12643 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 12644 case NT_GNU_GOLD_VERSION:
12645 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 12646 default:
12647 break;
12648 }
12649
12650 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12651 return buff;
12652}
12653
664f90a3
TT		 12654static int
12655print_gnu_note (Elf_Internal_Note *pnote)
12656{
12657 switch (pnote->type)
12658 {
12659 case NT_GNU_BUILD_ID:
12660 {
12661 unsigned long i;
12662
12663 printf (_(" Build ID: "));
12664 for (i = 0; i < pnote->descsz; ++i)
12665 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 12666 printf ("\n");
664f90a3
TT		 12667 }
12668 break;
12669
12670 case NT_GNU_ABI_TAG:
12671 {
12672 unsigned long os, major, minor, subminor;
12673 const char *osname;
12674
12675 os = byte_get ((unsigned char *) pnote->descdata, 4);
12676 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
12677 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
12678 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
12679
12680 switch (os)
12681 {
12682 case GNU_ABI_TAG_LINUX:
12683 osname = "Linux";
12684 break;
12685 case GNU_ABI_TAG_HURD:
12686 osname = "Hurd";
12687 break;
12688 case GNU_ABI_TAG_SOLARIS:
12689 osname = "Solaris";
12690 break;
12691 case GNU_ABI_TAG_FREEBSD:
12692 osname = "FreeBSD";
12693 break;
12694 case GNU_ABI_TAG_NETBSD:
12695 osname = "NetBSD";
12696 break;
12697 default:
12698 osname = "Unknown";
12699 break;
12700 }
12701
12702 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
12703 major, minor, subminor);
12704 }
12705 break;
12706 }
12707
12708 return 1;
12709}
12710
9437c45b 12711static const char *
d3ba0551 12712get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 12713{
12714 static char buff[64];
12715
b4db1224 12716 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 12717 {
12718 /* NetBSD core "procinfo" structure. */
12719 return _("NetBSD procinfo structure");
12720 }
12721
12722 /* As of Jan 2002 there are no other machine-independent notes
12723 defined for NetBSD core files. If the note type is less
12724 than the start of the machine-dependent note types, we don't
12725 understand it. */
12726
b4db1224 12727 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 12728 {
e9e44622 12729 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 12730 return buff;
12731 }
12732
12733 switch (elf_header.e_machine)
12734 {
12735 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
12736 and PT_GETFPREGS == mach+2. */
12737
12738 case EM_OLD_ALPHA:
12739 case EM_ALPHA:
12740 case EM_SPARC:
12741 case EM_SPARC32PLUS:
12742 case EM_SPARCV9:
12743 switch (e_type)
12744 {
2b692964 12745 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 12746 return _("PT_GETREGS (reg structure)");
2b692964 12747 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 12748 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 12749 default:
12750 break;
12751 }
12752 break;
12753
12754 /* On all other arch's, PT_GETREGS == mach+1 and
12755 PT_GETFPREGS == mach+3. */
12756 default:
12757 switch (e_type)
12758 {
2b692964 12759 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 12760 return _("PT_GETREGS (reg structure)");
2b692964 12761 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 12762 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 12763 default:
12764 break;
12765 }
12766 }
12767
9cf03b7e 12768 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 12769 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 12770 return buff;
12771}
12772
70616151
TT		 12773static const char *
12774get_stapsdt_note_type (unsigned e_type)
12775{
12776 static char buff[64];
12777
12778 switch (e_type)
12779 {
12780 case NT_STAPSDT:
12781 return _("NT_STAPSDT (SystemTap probe descriptors)");
12782
12783 default:
12784 break;
12785 }
12786
12787 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12788 return buff;
12789}
12790
c6a9fc58
TT		 12791static int
12792print_stapsdt_note (Elf_Internal_Note *pnote)
12793{
12794 int addr_size = is_32bit_elf ? 4 : 8;
12795 char *data = pnote->descdata;
12796 char *data_end = pnote->descdata + pnote->descsz;
12797 bfd_vma pc, base_addr, semaphore;
12798 char *provider, *probe, *arg_fmt;
12799
12800 pc = byte_get ((unsigned char *) data, addr_size);
12801 data += addr_size;
12802 base_addr = byte_get ((unsigned char *) data, addr_size);
12803 data += addr_size;
12804 semaphore = byte_get ((unsigned char *) data, addr_size);
12805 data += addr_size;
12806
12807 provider = data;
12808 data += strlen (data) + 1;
12809 probe = data;
12810 data += strlen (data) + 1;
12811 arg_fmt = data;
12812 data += strlen (data) + 1;
12813
12814 printf (_(" Provider: %s\n"), provider);
12815 printf (_(" Name: %s\n"), probe);
12816 printf (_(" Location: "));
12817 print_vma (pc, FULL_HEX);
12818 printf (_(", Base: "));
12819 print_vma (base_addr, FULL_HEX);
12820 printf (_(", Semaphore: "));
12821 print_vma (semaphore, FULL_HEX);
9cf03b7e 12822 printf ("\n");
c6a9fc58
TT		 12823 printf (_(" Arguments: %s\n"), arg_fmt);
12824
12825 return data == data_end;
12826}
12827
00e98fc7
TG		 12828static const char *
12829get_ia64_vms_note_type (unsigned e_type)
12830{
12831 static char buff[64];
12832
12833 switch (e_type)
12834 {
12835 case NT_VMS_MHD:
12836 return _("NT_VMS_MHD (module header)");
12837 case NT_VMS_LNM:
12838 return _("NT_VMS_LNM (language name)");
12839 case NT_VMS_SRC:
12840 return _("NT_VMS_SRC (source files)");
12841 case NT_VMS_TITLE:
9cf03b7e 12842 return "NT_VMS_TITLE";
00e98fc7
TG		 12843 case NT_VMS_EIDC:
12844 return _("NT_VMS_EIDC (consistency check)");
12845 case NT_VMS_FPMODE:
12846 return _("NT_VMS_FPMODE (FP mode)");
12847 case NT_VMS_LINKTIME:
9cf03b7e 12848 return "NT_VMS_LINKTIME";
00e98fc7
TG		 12849 case NT_VMS_IMGNAM:
12850 return _("NT_VMS_IMGNAM (image name)");
12851 case NT_VMS_IMGID:
12852 return _("NT_VMS_IMGID (image id)");
12853 case NT_VMS_LINKID:
12854 return _("NT_VMS_LINKID (link id)");
12855 case NT_VMS_IMGBID:
12856 return _("NT_VMS_IMGBID (build id)");
12857 case NT_VMS_GSTNAM:
12858 return _("NT_VMS_GSTNAM (sym table name)");
12859 case NT_VMS_ORIG_DYN:
9cf03b7e 12860 return "NT_VMS_ORIG_DYN";
00e98fc7 12861 case NT_VMS_PATCHTIME:
9cf03b7e 12862 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 12863 default:
12864 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12865 return buff;
12866 }
12867}
12868
12869static int
12870print_ia64_vms_note (Elf_Internal_Note * pnote)
12871{
12872 switch (pnote->type)
12873 {
12874 case NT_VMS_MHD:
12875 if (pnote->descsz > 36)
12876 {
12877 size_t l = strlen (pnote->descdata + 34);
12878 printf (_(" Creation date : %.17s\n"), pnote->descdata);
12879 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
12880 printf (_(" Module name : %s\n"), pnote->descdata + 34);
12881 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
12882 }
12883 else
12884 printf (_(" Invalid size\n"));
12885 break;
12886 case NT_VMS_LNM:
12887 printf (_(" Language: %s\n"), pnote->descdata);
12888 break;
12889#ifdef BFD64
12890 case NT_VMS_FPMODE:
9cf03b7e 12891 printf (_(" Floating Point mode: "));
4a5cb34f 12892 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 12893 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
12894 break;
12895 case NT_VMS_LINKTIME:
12896 printf (_(" Link time: "));
12897 print_vms_time
12898 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
12899 printf ("\n");
12900 break;
12901 case NT_VMS_PATCHTIME:
12902 printf (_(" Patch time: "));
12903 print_vms_time
12904 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
12905 printf ("\n");
12906 break;
12907 case NT_VMS_ORIG_DYN:
12908 printf (_(" Major id: %u, minor id: %u\n"),
12909 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
12910 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 12911 printf (_(" Last modified : "));
00e98fc7
TG		 12912 print_vms_time
12913 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 12914 printf (_("\n Link flags : "));
4a5cb34f 12915 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 12916 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
12917 printf (_(" Header flags: 0x%08x\n"),
12918 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
12919 printf (_(" Image id : %s\n"), pnote->descdata + 32);
12920 break;
12921#endif
12922 case NT_VMS_IMGNAM:
12923 printf (_(" Image name: %s\n"), pnote->descdata);
12924 break;
12925 case NT_VMS_GSTNAM:
12926 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
12927 break;
12928 case NT_VMS_IMGID:
12929 printf (_(" Image id: %s\n"), pnote->descdata);
12930 break;
12931 case NT_VMS_LINKID:
12932 printf (_(" Linker id: %s\n"), pnote->descdata);
12933 break;
12934 default:
12935 break;
12936 }
12937 return 1;
12938}
12939
6d118b09
NC		 12940/* Note that by the ELF standard, the name field is already null byte
12941 terminated, and namesz includes the terminating null byte.
12942 I.E. the value of namesz for the name "FSF" is 4.
12943
e3c8793a 12944 If the value of namesz is zero, there is no name present. */
779fe533 12945static int
2cf0635d 12946process_note (Elf_Internal_Note * pnote)
779fe533 12947{
2cf0635d
NC		 12948 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
12949 const char * nt;
9437c45b
JT		 12950
12951 if (pnote->namesz == 0)
1ec5cd37
NC		 12952 /* If there is no note name, then use the default set of
12953 note type strings. */
12954 nt = get_note_type (pnote->type);
12955
1118d252
RM		 12956 else if (const_strneq (pnote->namedata, "GNU"))
12957 /* GNU-specific object file notes. */
12958 nt = get_gnu_elf_note_type (pnote->type);
12959
0112cd26 12960 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 12961 /* NetBSD-specific core file notes. */
12962 nt = get_netbsd_elfcore_note_type (pnote->type);
12963
b15fa79e
AM		 12964 else if (strneq (pnote->namedata, "SPU/", 4))
12965 {
12966 /* SPU-specific core file notes. */
12967 nt = pnote->namedata + 4;
12968 name = "SPU";
12969 }
12970
00e98fc7
TG		 12971 else if (const_strneq (pnote->namedata, "IPF/VMS"))
12972 /* VMS/ia64-specific file notes. */
12973 nt = get_ia64_vms_note_type (pnote->type);
12974
70616151
TT		 12975 else if (const_strneq (pnote->namedata, "stapsdt"))
12976 nt = get_stapsdt_note_type (pnote->type);
12977
9437c45b 12978 else
1ec5cd37
NC		 12979 /* Don't recognize this note name; just use the default set of
12980 note type strings. */
00e98fc7 12981 nt = get_note_type (pnote->type);
9437c45b 12982
2aee03ae 12983 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 12984
12985 if (const_strneq (pnote->namedata, "IPF/VMS"))
12986 return print_ia64_vms_note (pnote);
664f90a3
TT		 12987 else if (const_strneq (pnote->namedata, "GNU"))
12988 return print_gnu_note (pnote);
c6a9fc58
TT		 12989 else if (const_strneq (pnote->namedata, "stapsdt"))
12990 return print_stapsdt_note (pnote);
00e98fc7
TG		 12991 else
12992 return 1;
779fe533
NC		 12993}
12994
6d118b09 12995
779fe533 12996static int
2cf0635d 12997process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 12998{
2cf0635d
NC		 12999 Elf_External_Note * pnotes;
13000 Elf_External_Note * external;
b34976b6 13001 int res = 1;
103f02d3 13002
779fe533
NC		 13003 if (length <= 0)
13004 return 0;
103f02d3 13005
3f5e193b
NC		 13006 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
13007 _("notes"));
dd24e3da 13008 if (pnotes == NULL)
a6e9f9df 13009 return 0;
779fe533 13010
103f02d3 13011 external = pnotes;
103f02d3 13012
305c7206 13013 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 13014 (unsigned long) offset, (unsigned long) length);
2aee03ae 13015 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 13016
2cf0635d 13017 while (external < (Elf_External_Note *) ((char *) pnotes + length))
779fe533 13018 {
2cf0635d 13019 Elf_External_Note * next;
b34976b6 13020 Elf_Internal_Note inote;
2cf0635d 13021 char * temp = NULL;
6d118b09 13022
00e98fc7
TG		 13023 if (!is_ia64_vms ())
13024 {
13025 inote.type = BYTE_GET (external->type);
13026 inote.namesz = BYTE_GET (external->namesz);
13027 inote.namedata = external->name;
13028 inote.descsz = BYTE_GET (external->descsz);
13029 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
13030 inote.descpos = offset + (inote.descdata - (char *) pnotes);
13031
13032 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
13033 }
13034 else
13035 {
13036 Elf64_External_VMS_Note *vms_external;
13037
13038 vms_external = (Elf64_External_VMS_Note *)external;
13039 inote.type = BYTE_GET (vms_external->type);
13040 inote.namesz = BYTE_GET (vms_external->namesz);
13041 inote.namedata = vms_external->name;
13042 inote.descsz = BYTE_GET (vms_external->descsz);
13043 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
13044 inote.descpos = offset + (inote.descdata - (char *) pnotes);
13045
13046 next = (Elf_External_Note *)
13047 (inote.descdata + align_power (inote.descsz, 3));
13048 }
3e55a963 13049
dd24e3da
NC		 13050 if ( ((char *) next > ((char *) pnotes) + length)
13051 || ((char *) next < (char *) pnotes))
3e55a963 13052 {
0fd3a477 13053 warn (_("corrupt note found at offset %lx into core notes\n"),
0af1713e 13054 (unsigned long) ((char *) external - (char *) pnotes));
0fd3a477 13055 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
3e55a963
NC		 13056 inote.type, inote.namesz, inote.descsz);
13057 break;
13058 }
13059
13060 external = next;
6d118b09 13061
dd24e3da 13062 /* Prevent out-of-bounds indexing. */
8b971f9f 13063 if (inote.namedata + inote.namesz > (char *) pnotes + length
dd24e3da
NC		 13064 || inote.namedata + inote.namesz < inote.namedata)
13065 {
13066 warn (_("corrupt note found at offset %lx into core notes\n"),
13067 (unsigned long) ((char *) external - (char *) pnotes));
13068 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
13069 inote.type, inote.namesz, inote.descsz);
13070 break;
13071 }
13072
6d118b09
NC		 13073 /* Verify that name is null terminated. It appears that at least
13074 one version of Linux (RedHat 6.0) generates corefiles that don't
13075 comply with the ELF spec by failing to include the null byte in
13076 namesz. */
8b971f9f 13077 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 13078 {
3f5e193b 13079 temp = (char *) malloc (inote.namesz + 1);
76da6bbe 13080
6d118b09
NC		 13081 if (temp == NULL)
13082 {
13083 error (_("Out of memory\n"));
13084 res = 0;
13085 break;
13086 }
76da6bbe 13087
6d118b09
NC		 13088 strncpy (temp, inote.namedata, inote.namesz);
13089 temp[inote.namesz] = 0;
76da6bbe 13090
6d118b09
NC		 13091 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
13092 inote.namedata = temp;
13093 }
13094
13095 res &= process_note (& inote);
103f02d3 13096
6d118b09
NC		 13097 if (temp != NULL)
13098 {
13099 free (temp);
13100 temp = NULL;
13101 }
779fe533
NC		 13102 }
13103
13104 free (pnotes);
103f02d3 13105
779fe533
NC		 13106 return res;
13107}
13108
13109static int
2cf0635d 13110process_corefile_note_segments (FILE * file)
779fe533 13111{
2cf0635d 13112 Elf_Internal_Phdr * segment;
b34976b6
AM		 13113 unsigned int i;
13114 int res = 1;
103f02d3 13115
d93f0186 13116 if (! get_program_headers (file))
779fe533 13117 return 0;
103f02d3 13118
779fe533
NC		 13119 for (i = 0, segment = program_headers;
13120 i < elf_header.e_phnum;
b34976b6 13121 i++, segment++)
779fe533
NC		 13122 {
13123 if (segment->p_type == PT_NOTE)
103f02d3 13124 res &= process_corefile_note_segment (file,
30800947
NC		 13125 (bfd_vma) segment->p_offset,
13126 (bfd_vma) segment->p_filesz);
779fe533 13127 }
103f02d3 13128
779fe533
NC		 13129 return res;
13130}
13131
13132static int
2cf0635d 13133process_note_sections (FILE * file)
1ec5cd37 13134{
2cf0635d 13135 Elf_Internal_Shdr * section;
1ec5cd37
NC		 13136 unsigned long i;
13137 int res = 1;
13138
13139 for (i = 0, section = section_headers;
fa1908fd 13140 i < elf_header.e_shnum && section != NULL;
1ec5cd37
NC		 13141 i++, section++)
13142 if (section->sh_type == SHT_NOTE)
13143 res &= process_corefile_note_segment (file,
13144 (bfd_vma) section->sh_offset,
13145 (bfd_vma) section->sh_size);
13146
13147 return res;
13148}
13149
13150static int
2cf0635d 13151process_notes (FILE * file)
779fe533
NC		 13152{
13153 /* If we have not been asked to display the notes then do nothing. */
13154 if (! do_notes)
13155 return 1;
103f02d3 13156
779fe533 13157 if (elf_header.e_type != ET_CORE)
1ec5cd37 13158 return process_note_sections (file);
103f02d3 13159
779fe533 13160 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 13161 if (elf_header.e_phnum > 0)
13162 return process_corefile_note_segments (file);
779fe533 13163
1ec5cd37
NC		 13164 printf (_("No note segments present in the core file.\n"));
13165 return 1;
779fe533
NC		 13166}
13167
252b5132 13168static int
2cf0635d 13169process_arch_specific (FILE * file)
252b5132 13170{
a952a375
NC		 13171 if (! do_arch)
13172 return 1;
13173
252b5132
RH		 13174 switch (elf_header.e_machine)
13175 {
11c1ff18
PB		 13176 case EM_ARM:
13177 return process_arm_specific (file);
252b5132 13178 case EM_MIPS:
4fe85591 13179 case EM_MIPS_RS3_LE:
252b5132
RH		 13180 return process_mips_specific (file);
13181 break;
34c8bcba
JM		 13182 case EM_PPC:
13183 return process_power_specific (file);
13184 break;
9e8c70f9
DM		 13185 case EM_SPARC:
13186 case EM_SPARC32PLUS:
13187 case EM_SPARCV9:
13188 return process_sparc_specific (file);
13189 break;
59e6276b
JM		 13190 case EM_TI_C6000:
13191 return process_tic6x_specific (file);
13192 break;
252b5132
RH		 13193 default:
13194 break;
13195 }
13196 return 1;
13197}
13198
13199static int
2cf0635d 13200get_file_header (FILE * file)
252b5132 13201{
9ea033b2
NC		 13202 /* Read in the identity array. */
13203 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 13204 return 0;
13205
9ea033b2 13206 /* Determine how to read the rest of the header. */
b34976b6 13207 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 13208 {
13209 default: /* fall through */
13210 case ELFDATANONE: /* fall through */
adab8cdc
AO		 13211 case ELFDATA2LSB:
13212 byte_get = byte_get_little_endian;
13213 byte_put = byte_put_little_endian;
13214 break;
13215 case ELFDATA2MSB:
13216 byte_get = byte_get_big_endian;
13217 byte_put = byte_put_big_endian;
13218 break;
9ea033b2
NC		 13219 }
13220
13221 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 13222 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 13223
13224 /* Read in the rest of the header. */
13225 if (is_32bit_elf)
13226 {
13227 Elf32_External_Ehdr ehdr32;
252b5132 13228
9ea033b2
NC		 13229 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
13230 return 0;
103f02d3 13231
9ea033b2
NC		 13232 elf_header.e_type = BYTE_GET (ehdr32.e_type);
13233 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
13234 elf_header.e_version = BYTE_GET (ehdr32.e_version);
13235 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
13236 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
13237 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
13238 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
13239 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
13240 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
13241 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
13242 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
13243 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
13244 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
13245 }
252b5132 13246 else
9ea033b2
NC		 13247 {
13248 Elf64_External_Ehdr ehdr64;
a952a375
NC		 13249
13250 /* If we have been compiled with sizeof (bfd_vma) == 4, then
13251 we will not be able to cope with the 64bit data found in
13252 64 ELF files. Detect this now and abort before we start
50c2245b 13253 overwriting things. */
a952a375
NC		 13254 if (sizeof (bfd_vma) < 8)
13255 {
e3c8793a
NC		 13256 error (_("This instance of readelf has been built without support for a\n\
1325764 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 13258 return 0;
13259 }
103f02d3 13260
9ea033b2
NC		 13261 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
13262 return 0;
103f02d3 13263
9ea033b2
NC		 13264 elf_header.e_type = BYTE_GET (ehdr64.e_type);
13265 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
13266 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 13267 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
13268 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
13269 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 13270 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
13271 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
13272 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
13273 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
13274 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
13275 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
13276 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
13277 }
252b5132 13278
7ece0d85
JJ		 13279 if (elf_header.e_shoff)
13280 {
13281 /* There may be some extensions in the first section header. Don't
13282 bomb if we can't read it. */
13283 if (is_32bit_elf)
13284 get_32bit_section_headers (file, 1);
13285 else
13286 get_64bit_section_headers (file, 1);
13287 }
560f3c1c 13288
252b5132
RH		 13289 return 1;
13290}
13291
fb52b2f4
NC		 13292/* Process one ELF object file according to the command line options.
13293 This file may actually be stored in an archive. The file is
13294 positioned at the start of the ELF object. */
13295
ff78d6d6 13296static int
2cf0635d 13297process_object (char * file_name, FILE * file)
252b5132 13298{
252b5132
RH		 13299 unsigned int i;
13300
252b5132
RH		 13301 if (! get_file_header (file))
13302 {
13303 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 13304 return 1;
252b5132
RH		 13305 }
13306
13307 /* Initialise per file variables. */
60bca95a 13308 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 13309 version_info[i] = 0;
13310
60bca95a 13311 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 13312 dynamic_info[i] = 0;
5115b233 13313 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 13314
13315 /* Process the file. */
13316 if (show_name)
13317 printf (_("\nFile: %s\n"), file_name);
13318
18bd398b
NC		 13319 /* Initialise the dump_sects array from the cmdline_dump_sects array.
13320 Note we do this even if cmdline_dump_sects is empty because we
13321 must make sure that the dump_sets array is zeroed out before each
13322 object file is processed. */
13323 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 13324 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 13325
13326 if (num_cmdline_dump_sects > 0)
13327 {
13328 if (num_dump_sects == 0)
13329 /* A sneaky way of allocating the dump_sects array. */
09c11c86 13330 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 13331
13332 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 13333 memcpy (dump_sects, cmdline_dump_sects,
13334 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 13335 }
d70c5fc7 13336
252b5132 13337 if (! process_file_header ())
fb52b2f4 13338 return 1;
252b5132 13339
d1f5c6e3 13340 if (! process_section_headers (file))
2f62977e 13341 {
d1f5c6e3
L		 13342 /* Without loaded section headers we cannot process lots of
13343 things. */
2f62977e 13344 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 13345
2f62977e 13346 if (! do_using_dynamic)
2c610e4b 13347 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 13348 }
252b5132 13349
d1f5c6e3
L		 13350 if (! process_section_groups (file))
13351 {
13352 /* Without loaded section groups we cannot process unwind. */
13353 do_unwind = 0;
13354 }
13355
2f62977e 13356 if (process_program_headers (file))
b2d38a17 13357 process_dynamic_section (file);
252b5132
RH		 13358
13359 process_relocs (file);
13360
4d6ed7c8
NC		 13361 process_unwind (file);
13362
252b5132
RH		 13363 process_symbol_table (file);
13364
13365 process_syminfo (file);
13366
13367 process_version_sections (file);
13368
13369 process_section_contents (file);
f5842774 13370
1ec5cd37 13371 process_notes (file);
103f02d3 13372
047b2264
JJ		 13373 process_gnu_liblist (file);
13374
252b5132
RH		 13375 process_arch_specific (file);
13376
d93f0186
NC		 13377 if (program_headers)
13378 {
13379 free (program_headers);
13380 program_headers = NULL;
13381 }
13382
252b5132
RH		 13383 if (section_headers)
13384 {
13385 free (section_headers);
13386 section_headers = NULL;
13387 }
13388
13389 if (string_table)
13390 {
13391 free (string_table);
13392 string_table = NULL;
d40ac9bd 13393 string_table_length = 0;
252b5132
RH		 13394 }
13395
13396 if (dynamic_strings)
13397 {
13398 free (dynamic_strings);
13399 dynamic_strings = NULL;
d79b3d50 13400 dynamic_strings_length = 0;
252b5132
RH		 13401 }
13402
13403 if (dynamic_symbols)
13404 {
13405 free (dynamic_symbols);
13406 dynamic_symbols = NULL;
19936277 13407 num_dynamic_syms = 0;
252b5132
RH		 13408 }
13409
13410 if (dynamic_syminfo)
13411 {
13412 free (dynamic_syminfo);
13413 dynamic_syminfo = NULL;
13414 }
ff78d6d6 13415
293c573e
MR		 13416 if (dynamic_section)
13417 {
13418 free (dynamic_section);
13419 dynamic_section = NULL;
13420 }
13421
e4b17d5c
L		 13422 if (section_headers_groups)
13423 {
13424 free (section_headers_groups);
13425 section_headers_groups = NULL;
13426 }
13427
13428 if (section_groups)
13429 {
2cf0635d
NC		 13430 struct group_list * g;
13431 struct group_list * next;
e4b17d5c
L		 13432
13433 for (i = 0; i < group_count; i++)
13434 {
13435 for (g = section_groups [i].root; g != NULL; g = next)
13436 {
13437 next = g->next;
13438 free (g);
13439 }
13440 }
13441
13442 free (section_groups);
13443 section_groups = NULL;
13444 }
13445
19e6b90e 13446 free_debug_memory ();
18bd398b 13447
ff78d6d6 13448 return 0;
252b5132
RH		 13449}
13450
2cf0635d
NC		 13451/* Process an ELF archive.
13452 On entry the file is positioned just after the ARMAG string. */
13453
13454static int
13455process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
13456{
13457 struct archive_info arch;
13458 struct archive_info nested_arch;
13459 size_t got;
2cf0635d
NC		 13460 int ret;
13461
13462 show_name = 1;
13463
13464 /* The ARCH structure is used to hold information about this archive. */
13465 arch.file_name = NULL;
13466 arch.file = NULL;
13467 arch.index_array = NULL;
13468 arch.sym_table = NULL;
13469 arch.longnames = NULL;
13470
13471 /* The NESTED_ARCH structure is used as a single-item cache of information
13472 about a nested archive (when members of a thin archive reside within
13473 another regular archive file). */
13474 nested_arch.file_name = NULL;
13475 nested_arch.file = NULL;
13476 nested_arch.index_array = NULL;
13477 nested_arch.sym_table = NULL;
13478 nested_arch.longnames = NULL;
13479
13480 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
13481 {
13482 ret = 1;
13483 goto out;
4145f1d5 13484 }
fb52b2f4 13485
4145f1d5
NC		 13486 if (do_archive_index)
13487 {
2cf0635d 13488 if (arch.sym_table == NULL)
4145f1d5
NC		 13489 error (_("%s: unable to dump the index as none was found\n"), file_name);
13490 else
13491 {
2cf0635d 13492 unsigned int i, l;
4145f1d5
NC		 13493 unsigned long current_pos;
13494
13495 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
c2a7d3f5 13496 file_name, (long) arch.index_num, arch.sym_size);
4145f1d5
NC		 13497 current_pos = ftell (file);
13498
2cf0635d 13499 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 13500 {
2cf0635d
NC		 13501 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
13502 {
13503 char * member_name;
4145f1d5 13504
2cf0635d
NC		 13505 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
13506
13507 if (member_name != NULL)
13508 {
13509 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
13510
13511 if (qualified_name != NULL)
13512 {
c2a7d3f5
NC		 13513 printf (_("Contents of binary %s at offset "), qualified_name);
13514 (void) print_vma (arch.index_array[i], PREFIX_HEX);
13515 putchar ('\n');
2cf0635d
NC		 13516 free (qualified_name);
13517 }
4145f1d5
NC		 13518 }
13519 }
2cf0635d
NC		 13520
13521 if (l >= arch.sym_size)
4145f1d5
NC		 13522 {
13523 error (_("%s: end of the symbol table reached before the end of the index\n"),
13524 file_name);
cb8f3167 13525 break;
4145f1d5 13526 }
2cf0635d
NC		 13527 printf ("\t%s\n", arch.sym_table + l);
13528 l += strlen (arch.sym_table + l) + 1;
4145f1d5
NC		 13529 }
13530
c2a7d3f5
NC		 13531 if (arch.uses_64bit_indicies)
13532 l = (l + 7) & ~ 7;
13533 else
13534 l += l & 1;
13535
2cf0635d 13536 if (l < arch.sym_size)
c2a7d3f5
NC		 13537 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
13538 file_name, arch.sym_size - l);
4145f1d5 13539
4145f1d5
NC		 13540 if (fseek (file, current_pos, SEEK_SET) != 0)
13541 {
13542 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 13543 ret = 1;
13544 goto out;
4145f1d5 13545 }
fb52b2f4 13546 }
4145f1d5
NC		 13547
13548 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
13549 && !do_segments && !do_header && !do_dump && !do_version
13550 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 13551 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 13552 {
13553 ret = 0; /* Archive index only. */
13554 goto out;
13555 }
fb52b2f4
NC		 13556 }
13557
d989285c 13558 ret = 0;
fb52b2f4
NC		 13559
13560 while (1)
13561 {
2cf0635d
NC		 13562 char * name;
13563 size_t namelen;
13564 char * qualified_name;
13565
13566 /* Read the next archive header. */
13567 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
13568 {
13569 error (_("%s: failed to seek to next archive header\n"), file_name);
13570 return 1;
13571 }
13572 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
13573 if (got != sizeof arch.arhdr)
13574 {
13575 if (got == 0)
13576 break;
13577 error (_("%s: failed to read archive header\n"), file_name);
13578 ret = 1;
13579 break;
13580 }
13581 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
13582 {
13583 error (_("%s: did not find a valid archive header\n"), arch.file_name);
13584 ret = 1;
13585 break;
13586 }
13587
13588 arch.next_arhdr_offset += sizeof arch.arhdr;
13589
13590 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
13591 if (archive_file_size & 01)
13592 ++archive_file_size;
13593
13594 name = get_archive_member_name (&arch, &nested_arch);
13595 if (name == NULL)
fb52b2f4 13596 {
0fd3a477 13597 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 13598 ret = 1;
13599 break;
fb52b2f4 13600 }
2cf0635d 13601 namelen = strlen (name);
fb52b2f4 13602
2cf0635d
NC		 13603 qualified_name = make_qualified_name (&arch, &nested_arch, name);
13604 if (qualified_name == NULL)
fb52b2f4 13605 {
2cf0635d 13606 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 13607 ret = 1;
13608 break;
fb52b2f4
NC		 13609 }
13610
2cf0635d
NC		 13611 if (is_thin_archive && arch.nested_member_origin == 0)
13612 {
13613 /* This is a proxy for an external member of a thin archive. */
13614 FILE * member_file;
13615 char * member_file_name = adjust_relative_path (file_name, name, namelen);
13616 if (member_file_name == NULL)
13617 {
13618 ret = 1;
13619 break;
13620 }
13621
13622 member_file = fopen (member_file_name, "rb");
13623 if (member_file == NULL)
13624 {
13625 error (_("Input file '%s' is not readable.\n"), member_file_name);
13626 free (member_file_name);
13627 ret = 1;
13628 break;
13629 }
13630
13631 archive_file_offset = arch.nested_member_origin;
13632
13633 ret |= process_object (qualified_name, member_file);
13634
13635 fclose (member_file);
13636 free (member_file_name);
13637 }
13638 else if (is_thin_archive)
13639 {
13640 /* This is a proxy for a member of a nested archive. */
13641 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
13642
13643 /* The nested archive file will have been opened and setup by
13644 get_archive_member_name. */
13645 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
13646 {
13647 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
13648 ret = 1;
13649 break;
13650 }
13651
13652 ret |= process_object (qualified_name, nested_arch.file);
13653 }
13654 else
13655 {
13656 archive_file_offset = arch.next_arhdr_offset;
13657 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 13658
2cf0635d
NC		 13659 ret |= process_object (qualified_name, file);
13660 }
fb52b2f4 13661
2b52916e
L		 13662 if (dump_sects != NULL)
13663 {
13664 free (dump_sects);
13665 dump_sects = NULL;
13666 num_dump_sects = 0;
13667 }
13668
2cf0635d 13669 free (qualified_name);
fb52b2f4
NC		 13670 }
13671
4145f1d5 13672 out:
2cf0635d
NC		 13673 if (nested_arch.file != NULL)
13674 fclose (nested_arch.file);
13675 release_archive (&nested_arch);
13676 release_archive (&arch);
fb52b2f4 13677
d989285c 13678 return ret;
fb52b2f4
NC		 13679}
13680
13681static int
2cf0635d 13682process_file (char * file_name)
fb52b2f4 13683{
2cf0635d 13684 FILE * file;
fb52b2f4
NC		 13685 struct stat statbuf;
13686 char armag[SARMAG];
13687 int ret;
13688
13689 if (stat (file_name, &statbuf) < 0)
13690 {
f24ddbdd
NC		 13691 if (errno == ENOENT)
13692 error (_("'%s': No such file\n"), file_name);
13693 else
13694 error (_("Could not locate '%s'. System error message: %s\n"),
13695 file_name, strerror (errno));
13696 return 1;
13697 }
13698
13699 if (! S_ISREG (statbuf.st_mode))
13700 {
13701 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 13702 return 1;
13703 }
13704
13705 file = fopen (file_name, "rb");
13706 if (file == NULL)
13707 {
f24ddbdd 13708 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 13709 return 1;
13710 }
13711
13712 if (fread (armag, SARMAG, 1, file) != 1)
13713 {
4145f1d5 13714 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 13715 fclose (file);
13716 return 1;
13717 }
13718
13719 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 13720 ret = process_archive (file_name, file, FALSE);
13721 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
13722 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 13723 else
13724 {
4145f1d5
NC		 13725 if (do_archive_index)
13726 error (_("File %s is not an archive so its index cannot be displayed.\n"),
13727 file_name);
13728
fb52b2f4
NC		 13729 rewind (file);
13730 archive_file_size = archive_file_offset = 0;
13731 ret = process_object (file_name, file);
13732 }
13733
13734 fclose (file);
13735
13736 return ret;
13737}
13738
252b5132
RH		 13739#ifdef SUPPORT_DISASSEMBLY
13740/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 13741 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 13742 symbols. */
252b5132
RH		 13743
13744void
2cf0635d 13745print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 13746{
13747 fprintf (outfile,"0x%8.8x", addr);
13748}
13749
e3c8793a 13750/* Needed by the i386 disassembler. */
252b5132
RH		 13751void
13752db_task_printsym (unsigned int addr)
13753{
13754 print_address (addr, stderr);
13755}
13756#endif
13757
13758int
2cf0635d 13759main (int argc, char ** argv)
252b5132 13760{
ff78d6d6
L		 13761 int err;
13762
252b5132
RH		 13763#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
13764 setlocale (LC_MESSAGES, "");
3882b010
L		 13765#endif
13766#if defined (HAVE_SETLOCALE)
13767 setlocale (LC_CTYPE, "");
252b5132
RH		 13768#endif
13769 bindtextdomain (PACKAGE, LOCALEDIR);
13770 textdomain (PACKAGE);
13771
869b9d07
MM		 13772 expandargv (&argc, &argv);
13773
252b5132
RH		 13774 parse_args (argc, argv);
13775
18bd398b 13776 if (num_dump_sects > 0)
59f14fc0 13777 {
18bd398b 13778 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 13779 cmdline_dump_sects = (dump_type *)
13780 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 13781 if (cmdline_dump_sects == NULL)
591a748a 13782 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 13783 else
13784 {
09c11c86
NC		 13785 memcpy (cmdline_dump_sects, dump_sects,
13786 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 13787 num_cmdline_dump_sects = num_dump_sects;
13788 }
13789 }
13790
18bd398b
NC		 13791 if (optind < (argc - 1))
13792 show_name = 1;
13793
ff78d6d6 13794 err = 0;
252b5132 13795 while (optind < argc)
18bd398b 13796 err |= process_file (argv[optind++]);
252b5132
RH		 13797
13798 if (dump_sects != NULL)
13799 free (dump_sects);
59f14fc0
AS		 13800 if (cmdline_dump_sects != NULL)
13801 free (cmdline_dump_sects);
252b5132 13802
ff78d6d6 13803 return err;
252b5132 13804}
GDB Binutils - Deliverables
This page took 1.795843 seconds and 4 git commands to generate.