]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - binutils/readelf.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
PR binutils/14028
[thirdparty/binutils-gdb.git] / binutils / readelf.c
CommitLineData
252b5132 1/* readelf.c -- display contents of an ELF format file
6e3d6dc1 2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
8b971f9f 3 2008, 2009, 2010, 2011, 2012
a0f19280 4 Free Software Foundation, Inc.
252b5132
RH		 5
6 Originally developed by Eric Youngdale <eric@andante.jic.com>
12ab83a9 7 Modifications by Nick Clifton <nickc@redhat.com>
252b5132
RH		 8
9 This file is part of GNU Binutils.
10
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
32866df7 13 the Free Software Foundation; either version 3 of the License, or
252b5132
RH		 14 (at your option) any later version.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
b43b5d5f
NC		 23 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 02110-1301, USA. */
252b5132 25\f
9eb20dd8 26/* The difference between readelf and objdump:
252b5132 27
74013231 28 Both programs are capable of displaying the contents of ELF format files,
9eb20dd8 29 so why does the binutils project have two file dumpers ?
0de14b54 30
9eb20dd8
NC		 31 The reason is that objdump sees an ELF file through a BFD filter of the
32 world; if BFD has a bug where, say, it disagrees about a machine constant
33 in e_flags, then the odds are good that it will remain internally
34 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
35 GAS sees it the BFD way. There was need for a tool to go find out what
36 the file actually says.
37
38 This is why the readelf program does not link against the BFD library - it
39 exists as an independent program to help verify the correct working of BFD.
40
41 There is also the case that readelf can provide more information about an
42 ELF file than is provided by objdump. In particular it can display DWARF
43 debugging information which (at the moment) objdump cannot. */
44\f
3db64b00 45#include "sysdep.h"
252b5132 46#include <assert.h>
252b5132 47#include <time.h>
1b315056
CS		 48#ifdef HAVE_ZLIB_H
49#include <zlib.h>
50#endif
252b5132 51
a952a375 52#if __GNUC__ >= 2
19936277 53/* Define BFD64 here, even if our default architecture is 32 bit ELF
a952a375 54 as this will allow us to read in and parse 64bit and 32bit ELF files.
b34976b6 55 Only do this if we believe that the compiler can support a 64 bit
a952a375 56 data type. For now we only rely on GCC being able to do this. */
19936277 57#define BFD64
a952a375
NC		 58#endif
59
3db64b00
AM		 60#include "bfd.h"
61#include "bucomm.h"
3284fe0c 62#include "elfcomm.h"
19e6b90e 63#include "dwarf.h"
252b5132
RH		 64
65#include "elf/common.h"
66#include "elf/external.h"
67#include "elf/internal.h"
252b5132 68
4b78141a
NC		 69
70/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
71 we can obtain the H8 reloc numbers. We need these for the
72 get_reloc_size() function. We include h8.h again after defining
73 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
74
75#include "elf/h8.h"
76#undef _ELF_H8_H
77
78/* Undo the effects of #including reloc-macros.h. */
79
80#undef START_RELOC_NUMBERS
81#undef RELOC_NUMBER
82#undef FAKE_RELOC
83#undef EMPTY_RELOC
84#undef END_RELOC_NUMBERS
85#undef _RELOC_MACROS_H
86
252b5132
RH		 87/* The following headers use the elf/reloc-macros.h file to
88 automatically generate relocation recognition functions
89 such as elf_mips_reloc_type() */
90
91#define RELOC_MACROS_GEN_FUNC
92
252b5132 93#include "elf/alpha.h"
3b16e843 94#include "elf/arc.h"
252b5132 95#include "elf/arm.h"
3b16e843 96#include "elf/avr.h"
1d65ded4 97#include "elf/bfin.h"
60bca95a 98#include "elf/cr16.h"
3b16e843 99#include "elf/cris.h"
1c0d3aa6 100#include "elf/crx.h"
252b5132
RH		 101#include "elf/d10v.h"
102#include "elf/d30v.h"
d172d4ba 103#include "elf/dlx.h"
cfb8c092 104#include "elf/epiphany.h"
252b5132 105#include "elf/fr30.h"
5c70f934 106#include "elf/frv.h"
3b16e843
NC		 107#include "elf/h8.h"
108#include "elf/hppa.h"
109#include "elf/i386.h"
35b1837e 110#include "elf/i370.h"
3b16e843
NC		 111#include "elf/i860.h"
112#include "elf/i960.h"
113#include "elf/ia64.h"
1e4cf259 114#include "elf/ip2k.h"
84e94c90 115#include "elf/lm32.h"
1c0d3aa6 116#include "elf/iq2000.h"
49f58d10 117#include "elf/m32c.h"
3b16e843
NC		 118#include "elf/m32r.h"
119#include "elf/m68k.h"
75751cd9 120#include "elf/m68hc11.h"
252b5132 121#include "elf/mcore.h"
15ab5209 122#include "elf/mep.h"
7ba29e2a 123#include "elf/microblaze.h"
3b16e843 124#include "elf/mips.h"
3c3bdf30 125#include "elf/mmix.h"
3b16e843
NC		 126#include "elf/mn10200.h"
127#include "elf/mn10300.h"
5506d11a 128#include "elf/moxie.h"
4970f871 129#include "elf/mt.h"
2469cfa2 130#include "elf/msp430.h"
3b16e843 131#include "elf/or32.h"
7d466069 132#include "elf/pj.h"
3b16e843 133#include "elf/ppc.h"
c833c019 134#include "elf/ppc64.h"
99c513f6 135#include "elf/rl78.h"
c7927a3c 136#include "elf/rx.h"
a85d7ed0 137#include "elf/s390.h"
1c0d3aa6 138#include "elf/score.h"
3b16e843
NC		 139#include "elf/sh.h"
140#include "elf/sparc.h"
e9f53129 141#include "elf/spu.h"
40b36596 142#include "elf/tic6x.h"
aa137e4d
NC		 143#include "elf/tilegx.h"
144#include "elf/tilepro.h"
3b16e843 145#include "elf/v850.h"
179d3252 146#include "elf/vax.h"
3b16e843 147#include "elf/x86-64.h"
c29aca4a 148#include "elf/xc16x.h"
f6c1a2d5 149#include "elf/xgate.h"
93fbbb04 150#include "elf/xstormy16.h"
88da6820 151#include "elf/xtensa.h"
252b5132 152
252b5132 153#include "getopt.h"
566b0d53 154#include "libiberty.h"
09c11c86 155#include "safe-ctype.h"
2cf0635d 156#include "filenames.h"
252b5132 157
2cf0635d 158char * program_name = "readelf";
85b1c36d
BE		 159static long archive_file_offset;
160static unsigned long archive_file_size;
161static unsigned long dynamic_addr;
162static bfd_size_type dynamic_size;
163static unsigned int dynamic_nent;
2cf0635d 164static char * dynamic_strings;
85b1c36d 165static unsigned long dynamic_strings_length;
2cf0635d 166static char * string_table;
85b1c36d
BE		 167static unsigned long string_table_length;
168static unsigned long num_dynamic_syms;
2cf0635d
NC		 169static Elf_Internal_Sym * dynamic_symbols;
170static Elf_Internal_Syminfo * dynamic_syminfo;
85b1c36d
BE		 171static unsigned long dynamic_syminfo_offset;
172static unsigned int dynamic_syminfo_nent;
f8eae8b2 173static char program_interpreter[PATH_MAX];
bb8a0291 174static bfd_vma dynamic_info[DT_ENCODING];
fdc90cb4 175static bfd_vma dynamic_info_DT_GNU_HASH;
85b1c36d
BE		 176static bfd_vma version_info[16];
177static Elf_Internal_Ehdr elf_header;
2cf0635d
NC		 178static Elf_Internal_Shdr * section_headers;
179static Elf_Internal_Phdr * program_headers;
180static Elf_Internal_Dyn * dynamic_section;
181static Elf_Internal_Shdr * symtab_shndx_hdr;
85b1c36d
BE		 182static int show_name;
183static int do_dynamic;
184static int do_syms;
2c610e4b 185static int do_dyn_syms;
85b1c36d
BE		 186static int do_reloc;
187static int do_sections;
188static int do_section_groups;
5477e8a0 189static int do_section_details;
85b1c36d
BE		 190static int do_segments;
191static int do_unwind;
192static int do_using_dynamic;
193static int do_header;
194static int do_dump;
195static int do_version;
85b1c36d
BE		 196static int do_histogram;
197static int do_debugging;
85b1c36d
BE		 198static int do_arch;
199static int do_notes;
4145f1d5 200static int do_archive_index;
85b1c36d 201static int is_32bit_elf;
252b5132 202
e4b17d5c
L		 203struct group_list
204{
2cf0635d 205 struct group_list * next;
e4b17d5c
L		 206 unsigned int section_index;
207};
208
209struct group
210{
2cf0635d 211 struct group_list * root;
e4b17d5c
L		 212 unsigned int group_index;
213};
214
85b1c36d 215static size_t group_count;
2cf0635d
NC		 216static struct group * section_groups;
217static struct group ** section_headers_groups;
e4b17d5c 218
09c11c86
NC		 219
220/* Flag bits indicating particular types of dump. */
221#define HEX_DUMP (1 << 0) /* The -x command line switch. */
222#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
223#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
224#define STRING_DUMP (1 << 3) /* The -p command line switch. */
cf13d699 225#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
09c11c86
NC		 226
227typedef unsigned char dump_type;
228
229/* A linked list of the section names for which dumps were requested. */
aef1f6d0
DJ		 230struct dump_list_entry
231{
2cf0635d 232 char * name;
09c11c86 233 dump_type type;
2cf0635d 234 struct dump_list_entry * next;
aef1f6d0 235};
2cf0635d 236static struct dump_list_entry * dump_sects_byname;
aef1f6d0 237
09c11c86
NC		 238/* A dynamic array of flags indicating for which sections a dump
239 has been requested via command line switches. */
240static dump_type * cmdline_dump_sects = NULL;
241static unsigned int num_cmdline_dump_sects = 0;
18bd398b
NC		 242
243/* A dynamic array of flags indicating for which sections a dump of
244 some kind has been requested. It is reset on a per-object file
aef1f6d0
DJ		 245 basis and then initialised from the cmdline_dump_sects array,
246 the results of interpreting the -w switch, and the
247 dump_sects_byname list. */
09c11c86
NC		 248static dump_type * dump_sects = NULL;
249static unsigned int num_dump_sects = 0;
252b5132 250
252b5132 251
c256ffe7 252/* How to print a vma value. */
843dd992
NC		 253typedef enum print_mode
254{
255 HEX,
256 DEC,
257 DEC_5,
258 UNSIGNED,
259 PREFIX_HEX,
260 FULL_HEX,
261 LONG_HEX
262}
263print_mode;
264
9c19a809
NC		 265#define UNKNOWN -1
266
2b692964
NC		 267#define SECTION_NAME(X) \
268 ((X) == NULL ? _("<none>") \
269 : string_table == NULL ? _("<no-name>") \
270 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
0b49d371 271 : string_table + (X)->sh_name))
252b5132 272
ee42cf8c 273#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
252b5132 274
ba5cdace
NC		 275#define GET_ELF_SYMBOLS(file, section, sym_count) \
276 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
277 : get_64bit_elf_symbols (file, section, sym_count))
9ea033b2 278
d79b3d50
NC		 279#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
280/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
281 already been called and verified that the string exists. */
282#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
18bd398b 283
61865e30
NC		 284#define REMOVE_ARCH_BITS(ADDR) \
285 do \
286 { \
287 if (elf_header.e_machine == EM_ARM) \
288 (ADDR) &= ~1; \
289 } \
290 while (0)
d79b3d50 291\f
59245841
NC		 292/* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
293 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
294 using malloc and fill that. In either case return the pointer to the start of
295 the retrieved data or NULL if something went wrong. If something does go wrong
296 emit an error message using REASON as part of the context. */
297
c256ffe7 298static void *
2cf0635d
NC		 299get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
300 const char * reason)
a6e9f9df 301{
2cf0635d 302 void * mvar;
a6e9f9df 303
c256ffe7 304 if (size == 0 || nmemb == 0)
a6e9f9df
AM		 305 return NULL;
306
fb52b2f4 307 if (fseek (file, archive_file_offset + offset, SEEK_SET))
a6e9f9df 308 {
0fd3a477 309 error (_("Unable to seek to 0x%lx for %s\n"),
0af1713e 310 (unsigned long) archive_file_offset + offset, reason);
a6e9f9df
AM		 311 return NULL;
312 }
313
314 mvar = var;
315 if (mvar == NULL)
316 {
c256ffe7
JJ		 317 /* Check for overflow. */
318 if (nmemb < (~(size_t) 0 - 1) / size)
319 /* + 1 so that we can '\0' terminate invalid string table sections. */
320 mvar = malloc (size * nmemb + 1);
a6e9f9df
AM		 321
322 if (mvar == NULL)
323 {
0fd3a477
JW		 324 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
325 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM		 326 return NULL;
327 }
c256ffe7
JJ		 328
329 ((char *) mvar)[size * nmemb] = '\0';
a6e9f9df
AM		 330 }
331
c256ffe7 332 if (fread (mvar, size, nmemb, file) != nmemb)
a6e9f9df 333 {
0fd3a477
JW		 334 error (_("Unable to read in 0x%lx bytes of %s\n"),
335 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM		 336 if (mvar != var)
337 free (mvar);
338 return NULL;
339 }
340
341 return mvar;
342}
343
14a91970 344/* Print a VMA value. */
cb8f3167 345
66543521 346static int
14a91970 347print_vma (bfd_vma vma, print_mode mode)
66543521 348{
66543521
AM		 349 int nc = 0;
350
14a91970 351 switch (mode)
66543521 352 {
14a91970
AM		 353 case FULL_HEX:
354 nc = printf ("0x");
355 /* Drop through. */
66543521 356
14a91970 357 case LONG_HEX:
f7a99963 358#ifdef BFD64
14a91970 359 if (is_32bit_elf)
437c2fb7 360 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
f7a99963 361#endif
14a91970
AM		 362 printf_vma (vma);
363 return nc + 16;
b19aac67 364
14a91970
AM		 365 case DEC_5:
366 if (vma <= 99999)
367 return printf ("%5" BFD_VMA_FMT "d", vma);
368 /* Drop through. */
66543521 369
14a91970
AM		 370 case PREFIX_HEX:
371 nc = printf ("0x");
372 /* Drop through. */
66543521 373
14a91970
AM		 374 case HEX:
375 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 376
14a91970
AM		 377 case DEC:
378 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 379
14a91970
AM		 380 case UNSIGNED:
381 return printf ("%" BFD_VMA_FMT "u", vma);
f7a99963 382 }
66543521 383 return 0;
f7a99963
NC		 384}
385
171191ba 386/* Display a symbol on stdout. Handles the display of non-printing characters.
31104126 387
171191ba
NC		 388 If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
389 truncating as necessary. If WIDTH is negative then format the string to be
390 exactly - WIDTH characters, truncating or padding as necessary.
391
392 Returns the number of emitted characters. */
393
394static unsigned int
7a88bc9c 395print_symbol (int width, const char *symbol)
31104126 396{
7a88bc9c 397 const char *c;
171191ba
NC		 398 bfd_boolean extra_padding = FALSE;
399 unsigned int num_printed = 0;
961c521f 400
31104126 401 if (do_wide)
961c521f 402 {
7a88bc9c
AS		 403 /* Set the width to a very large value. This simplifies the
404 code below. */
961c521f
NC		 405 width = INT_MAX;
406 }
31104126 407 else if (width < 0)
961c521f 408 {
961c521f
NC		 409 /* Keep the width positive. This also helps. */
410 width = - width;
171191ba 411 extra_padding = TRUE;
961c521f
NC		 412 }
413
414 while (width)
415 {
416 int len;
417
418 c = symbol;
419
420 /* Look for non-printing symbols inside the symbol's name.
421 This test is triggered in particular by the names generated
422 by the assembler for local labels. */
7a88bc9c 423 while (ISPRINT (*c))
961c521f
NC		 424 c++;
425
426 len = c - symbol;
427
428 if (len)
429 {
430 if (len > width)
431 len = width;
cb8f3167 432
171191ba 433 printf ("%.*s", len, symbol);
961c521f
NC		 434
435 width -= len;
171191ba 436 num_printed += len;
961c521f
NC		 437 }
438
7a88bc9c 439 if (*c == 0 || width == 0)
961c521f
NC		 440 break;
441
442 /* Now display the non-printing character, if
443 there is room left in which to dipslay it. */
7a88bc9c 444 if ((unsigned char) *c < 32)
961c521f
NC		 445 {
446 if (width < 2)
447 break;
448
449 printf ("^%c", *c + 0x40);
450
451 width -= 2;
171191ba 452 num_printed += 2;
961c521f
NC		 453 }
454 else
455 {
456 if (width < 6)
457 break;
cb8f3167 458
7a88bc9c 459 printf ("<0x%.2x>", (unsigned char) *c);
961c521f
NC		 460
461 width -= 6;
171191ba 462 num_printed += 6;
961c521f
NC		 463 }
464
465 symbol = c + 1;
466 }
171191ba
NC		 467
468 if (extra_padding && width > 0)
469 {
470 /* Fill in the remaining spaces. */
471 printf ("%-*s", width, " ");
472 num_printed += 2;
473 }
474
475 return num_printed;
31104126
NC		 476}
477
89fac5e3
RS		 478/* Return a pointer to section NAME, or NULL if no such section exists. */
479
480static Elf_Internal_Shdr *
2cf0635d 481find_section (const char * name)
89fac5e3
RS		 482{
483 unsigned int i;
484
485 for (i = 0; i < elf_header.e_shnum; i++)
486 if (streq (SECTION_NAME (section_headers + i), name))
487 return section_headers + i;
488
489 return NULL;
490}
491
0b6ae522
DJ		 492/* Return a pointer to a section containing ADDR, or NULL if no such
493 section exists. */
494
495static Elf_Internal_Shdr *
496find_section_by_address (bfd_vma addr)
497{
498 unsigned int i;
499
500 for (i = 0; i < elf_header.e_shnum; i++)
501 {
502 Elf_Internal_Shdr *sec = section_headers + i;
503 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
504 return sec;
505 }
506
507 return NULL;
508}
509
510/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
511 bytes read. */
512
513static unsigned long
514read_uleb128 (unsigned char *data, unsigned int *length_return)
515{
516 return read_leb128 (data, length_return, 0);
517}
518
28f997cf
TG		 519/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
520 This OS has so many departures from the ELF standard that we test it at
521 many places. */
522
523static inline int
524is_ia64_vms (void)
525{
526 return elf_header.e_machine == EM_IA_64
527 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
528}
529
bcedfee6 530/* Guess the relocation size commonly used by the specific machines. */
252b5132 531
252b5132 532static int
2dc4cec1 533guess_is_rela (unsigned int e_machine)
252b5132 534{
9c19a809 535 switch (e_machine)
252b5132
RH		 536 {
537 /* Targets that use REL relocations. */
252b5132
RH		 538 case EM_386:
539 case EM_486:
63fcb9e9 540 case EM_960:
e9f53129 541 case EM_ARM:
2b0337b0 542 case EM_D10V:
252b5132 543 case EM_CYGNUS_D10V:
e9f53129 544 case EM_DLX:
252b5132 545 case EM_MIPS:
4fe85591 546 case EM_MIPS_RS3_LE:
e9f53129
AM		 547 case EM_CYGNUS_M32R:
548 case EM_OPENRISC:
549 case EM_OR32:
1c0d3aa6 550 case EM_SCORE:
f6c1a2d5 551 case EM_XGATE:
9c19a809 552 return FALSE;
103f02d3 553
252b5132
RH		 554 /* Targets that use RELA relocations. */
555 case EM_68K:
e9f53129 556 case EM_860:
cfb8c092 557 case EM_ADAPTEVA_EPIPHANY:
e9f53129
AM		 558 case EM_ALPHA:
559 case EM_ALTERA_NIOS2:
560 case EM_AVR:
561 case EM_AVR_OLD:
562 case EM_BLACKFIN:
60bca95a 563 case EM_CR16:
e9f53129
AM		 564 case EM_CRIS:
565 case EM_CRX:
2b0337b0 566 case EM_D30V:
252b5132 567 case EM_CYGNUS_D30V:
2b0337b0 568 case EM_FR30:
252b5132 569 case EM_CYGNUS_FR30:
5c70f934 570 case EM_CYGNUS_FRV:
e9f53129
AM		 571 case EM_H8S:
572 case EM_H8_300:
573 case EM_H8_300H:
800eeca4 574 case EM_IA_64:
1e4cf259
NC		 575 case EM_IP2K:
576 case EM_IP2K_OLD:
3b36097d 577 case EM_IQ2000:
84e94c90 578 case EM_LATTICEMICO32:
ff7eeb89 579 case EM_M32C_OLD:
49f58d10 580 case EM_M32C:
e9f53129
AM		 581 case EM_M32R:
582 case EM_MCORE:
15ab5209 583 case EM_CYGNUS_MEP:
e9f53129
AM		 584 case EM_MMIX:
585 case EM_MN10200:
586 case EM_CYGNUS_MN10200:
587 case EM_MN10300:
588 case EM_CYGNUS_MN10300:
5506d11a 589 case EM_MOXIE:
e9f53129
AM		 590 case EM_MSP430:
591 case EM_MSP430_OLD:
d031aafb 592 case EM_MT:
64fd6348 593 case EM_NIOS32:
e9f53129
AM		 594 case EM_PPC64:
595 case EM_PPC:
99c513f6 596 case EM_RL78:
c7927a3c 597 case EM_RX:
e9f53129
AM		 598 case EM_S390:
599 case EM_S390_OLD:
600 case EM_SH:
601 case EM_SPARC:
602 case EM_SPARC32PLUS:
603 case EM_SPARCV9:
604 case EM_SPU:
40b36596 605 case EM_TI_C6000:
aa137e4d
NC		 606 case EM_TILEGX:
607 case EM_TILEPRO:
e9f53129
AM		 608 case EM_V850:
609 case EM_CYGNUS_V850:
610 case EM_VAX:
611 case EM_X86_64:
8a9036a4 612 case EM_L1OM:
7a9068fe 613 case EM_K1OM:
e9f53129
AM		 614 case EM_XSTORMY16:
615 case EM_XTENSA:
616 case EM_XTENSA_OLD:
7ba29e2a
NC		 617 case EM_MICROBLAZE:
618 case EM_MICROBLAZE_OLD:
9c19a809 619 return TRUE;
103f02d3 620
e9f53129
AM		 621 case EM_68HC05:
622 case EM_68HC08:
623 case EM_68HC11:
624 case EM_68HC16:
625 case EM_FX66:
626 case EM_ME16:
d1133906 627 case EM_MMA:
d1133906
NC		 628 case EM_NCPU:
629 case EM_NDR1:
e9f53129 630 case EM_PCP:
d1133906 631 case EM_ST100:
e9f53129 632 case EM_ST19:
d1133906 633 case EM_ST7:
e9f53129
AM		 634 case EM_ST9PLUS:
635 case EM_STARCORE:
d1133906 636 case EM_SVX:
e9f53129 637 case EM_TINYJ:
9c19a809
NC		 638 default:
639 warn (_("Don't know about relocations on this machine architecture\n"));
640 return FALSE;
641 }
642}
252b5132 643
9c19a809 644static int
2cf0635d 645slurp_rela_relocs (FILE * file,
d3ba0551
AM		 646 unsigned long rel_offset,
647 unsigned long rel_size,
2cf0635d
NC		 648 Elf_Internal_Rela ** relasp,
649 unsigned long * nrelasp)
9c19a809 650{
2cf0635d 651 Elf_Internal_Rela * relas;
4d6ed7c8
NC		 652 unsigned long nrelas;
653 unsigned int i;
252b5132 654
4d6ed7c8
NC		 655 if (is_32bit_elf)
656 {
2cf0635d 657 Elf32_External_Rela * erelas;
103f02d3 658
3f5e193b 659 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 660 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 661 if (!erelas)
662 return 0;
252b5132 663
4d6ed7c8 664 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 665
3f5e193b
NC		 666 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
667 sizeof (Elf_Internal_Rela));
103f02d3 668
4d6ed7c8
NC		 669 if (relas == NULL)
670 {
c256ffe7 671 free (erelas);
591a748a 672 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 673 return 0;
674 }
103f02d3 675
4d6ed7c8
NC		 676 for (i = 0; i < nrelas; i++)
677 {
678 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
679 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 680 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 681 }
103f02d3 682
4d6ed7c8
NC		 683 free (erelas);
684 }
685 else
686 {
2cf0635d 687 Elf64_External_Rela * erelas;
103f02d3 688
3f5e193b 689 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 690 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 691 if (!erelas)
692 return 0;
4d6ed7c8
NC		 693
694 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 695
3f5e193b
NC		 696 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
697 sizeof (Elf_Internal_Rela));
103f02d3 698
4d6ed7c8
NC		 699 if (relas == NULL)
700 {
c256ffe7 701 free (erelas);
591a748a 702 error (_("out of memory parsing relocs\n"));
4d6ed7c8 703 return 0;
9c19a809 704 }
4d6ed7c8
NC		 705
706 for (i = 0; i < nrelas; i++)
9c19a809 707 {
66543521
AM		 708 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
709 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 710 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 711
712 /* The #ifdef BFD64 below is to prevent a compile time
713 warning. We know that if we do not have a 64 bit data
714 type that we will never execute this code anyway. */
715#ifdef BFD64
716 if (elf_header.e_machine == EM_MIPS
717 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
718 {
719 /* In little-endian objects, r_info isn't really a
720 64-bit little-endian value: it has a 32-bit
721 little-endian symbol index followed by four
722 individual byte fields. Reorder INFO
723 accordingly. */
91d6fa6a
NC		 724 bfd_vma inf = relas[i].r_info;
725 inf = (((inf & 0xffffffff) << 32)
726 | ((inf >> 56) & 0xff)
727 | ((inf >> 40) & 0xff00)
728 | ((inf >> 24) & 0xff0000)
729 | ((inf >> 8) & 0xff000000));
730 relas[i].r_info = inf;
861fb55a
DJ		 731 }
732#endif /* BFD64 */
4d6ed7c8 733 }
103f02d3 734
4d6ed7c8
NC		 735 free (erelas);
736 }
737 *relasp = relas;
738 *nrelasp = nrelas;
739 return 1;
740}
103f02d3 741
4d6ed7c8 742static int
2cf0635d 743slurp_rel_relocs (FILE * file,
d3ba0551
AM		 744 unsigned long rel_offset,
745 unsigned long rel_size,
2cf0635d
NC		 746 Elf_Internal_Rela ** relsp,
747 unsigned long * nrelsp)
4d6ed7c8 748{
2cf0635d 749 Elf_Internal_Rela * rels;
4d6ed7c8
NC		 750 unsigned long nrels;
751 unsigned int i;
103f02d3 752
4d6ed7c8
NC		 753 if (is_32bit_elf)
754 {
2cf0635d 755 Elf32_External_Rel * erels;
103f02d3 756
3f5e193b 757 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 758 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 759 if (!erels)
760 return 0;
103f02d3 761
4d6ed7c8 762 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 763
3f5e193b 764 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 765
4d6ed7c8
NC		 766 if (rels == NULL)
767 {
c256ffe7 768 free (erels);
591a748a 769 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 770 return 0;
771 }
772
773 for (i = 0; i < nrels; i++)
774 {
775 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
776 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 777 rels[i].r_addend = 0;
9ea033b2 778 }
4d6ed7c8
NC		 779
780 free (erels);
9c19a809
NC		 781 }
782 else
783 {
2cf0635d 784 Elf64_External_Rel * erels;
9ea033b2 785
3f5e193b 786 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 787 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 788 if (!erels)
789 return 0;
103f02d3 790
4d6ed7c8 791 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 792
3f5e193b 793 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 794
4d6ed7c8 795 if (rels == NULL)
9c19a809 796 {
c256ffe7 797 free (erels);
591a748a 798 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 799 return 0;
800 }
103f02d3 801
4d6ed7c8
NC		 802 for (i = 0; i < nrels; i++)
803 {
66543521
AM		 804 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
805 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 806 rels[i].r_addend = 0;
861fb55a
DJ		 807
808 /* The #ifdef BFD64 below is to prevent a compile time
809 warning. We know that if we do not have a 64 bit data
810 type that we will never execute this code anyway. */
811#ifdef BFD64
812 if (elf_header.e_machine == EM_MIPS
813 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
814 {
815 /* In little-endian objects, r_info isn't really a
816 64-bit little-endian value: it has a 32-bit
817 little-endian symbol index followed by four
818 individual byte fields. Reorder INFO
819 accordingly. */
91d6fa6a
NC		 820 bfd_vma inf = rels[i].r_info;
821 inf = (((inf & 0xffffffff) << 32)
822 | ((inf >> 56) & 0xff)
823 | ((inf >> 40) & 0xff00)
824 | ((inf >> 24) & 0xff0000)
825 | ((inf >> 8) & 0xff000000));
826 rels[i].r_info = inf;
861fb55a
DJ		 827 }
828#endif /* BFD64 */
4d6ed7c8 829 }
103f02d3 830
4d6ed7c8
NC		 831 free (erels);
832 }
833 *relsp = rels;
834 *nrelsp = nrels;
835 return 1;
836}
103f02d3 837
aca88567
NC		 838/* Returns the reloc type extracted from the reloc info field. */
839
840static unsigned int
841get_reloc_type (bfd_vma reloc_info)
842{
843 if (is_32bit_elf)
844 return ELF32_R_TYPE (reloc_info);
845
846 switch (elf_header.e_machine)
847 {
848 case EM_MIPS:
849 /* Note: We assume that reloc_info has already been adjusted for us. */
850 return ELF64_MIPS_R_TYPE (reloc_info);
851
852 case EM_SPARCV9:
853 return ELF64_R_TYPE_ID (reloc_info);
854
855 default:
856 return ELF64_R_TYPE (reloc_info);
857 }
858}
859
860/* Return the symbol index extracted from the reloc info field. */
861
862static bfd_vma
863get_reloc_symindex (bfd_vma reloc_info)
864{
865 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
866}
867
d3ba0551
AM		 868/* Display the contents of the relocation data found at the specified
869 offset. */
ee42cf8c 870
41e92641 871static void
2cf0635d 872dump_relocations (FILE * file,
d3ba0551
AM		 873 unsigned long rel_offset,
874 unsigned long rel_size,
2cf0635d 875 Elf_Internal_Sym * symtab,
d3ba0551 876 unsigned long nsyms,
2cf0635d 877 char * strtab,
d79b3d50 878 unsigned long strtablen,
d3ba0551 879 int is_rela)
4d6ed7c8 880{
b34976b6 881 unsigned int i;
2cf0635d 882 Elf_Internal_Rela * rels;
103f02d3 883
4d6ed7c8
NC		 884 if (is_rela == UNKNOWN)
885 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 886
4d6ed7c8
NC		 887 if (is_rela)
888 {
c8286bd1 889 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 890 return;
4d6ed7c8
NC		 891 }
892 else
893 {
894 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 895 return;
252b5132
RH		 896 }
897
410f7a12
L		 898 if (is_32bit_elf)
899 {
900 if (is_rela)
2c71103e
NC		 901 {
902 if (do_wide)
903 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
904 else
905 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
906 }
410f7a12 907 else
2c71103e
NC		 908 {
909 if (do_wide)
910 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
911 else
912 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
913 }
410f7a12 914 }
252b5132 915 else
410f7a12
L		 916 {
917 if (is_rela)
2c71103e
NC		 918 {
919 if (do_wide)
8beeaeb7 920 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 921 else
922 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
923 }
410f7a12 924 else
2c71103e
NC		 925 {
926 if (do_wide)
8beeaeb7 927 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 928 else
929 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
930 }
410f7a12 931 }
252b5132
RH		 932
933 for (i = 0; i < rel_size; i++)
934 {
2cf0635d 935 const char * rtype;
b34976b6 936 bfd_vma offset;
91d6fa6a 937 bfd_vma inf;
b34976b6
AM		 938 bfd_vma symtab_index;
939 bfd_vma type;
103f02d3 940
b34976b6 941 offset = rels[i].r_offset;
91d6fa6a 942 inf = rels[i].r_info;
103f02d3 943
91d6fa6a
NC		 944 type = get_reloc_type (inf);
945 symtab_index = get_reloc_symindex (inf);
252b5132 946
410f7a12
L		 947 if (is_32bit_elf)
948 {
39dbeff8
AM		 949 printf ("%8.8lx %8.8lx ",
950 (unsigned long) offset & 0xffffffff,
91d6fa6a 951 (unsigned long) inf & 0xffffffff);
410f7a12
L		 952 }
953 else
954 {
39dbeff8
AM		 955#if BFD_HOST_64BIT_LONG
956 printf (do_wide
957 ? "%16.16lx %16.16lx "
958 : "%12.12lx %12.12lx ",
91d6fa6a 959 offset, inf);
39dbeff8 960#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 961#ifndef __MSVCRT__
39dbeff8
AM		 962 printf (do_wide
963 ? "%16.16llx %16.16llx "
964 : "%12.12llx %12.12llx ",
91d6fa6a 965 offset, inf);
6e3d6dc1
NC		 966#else
967 printf (do_wide
968 ? "%16.16I64x %16.16I64x "
969 : "%12.12I64x %12.12I64x ",
91d6fa6a 970 offset, inf);
6e3d6dc1 971#endif
39dbeff8 972#else
2c71103e
NC		 973 printf (do_wide
974 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
975 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 976 _bfd_int64_high (offset),
977 _bfd_int64_low (offset),
91d6fa6a
NC		 978 _bfd_int64_high (inf),
979 _bfd_int64_low (inf));
9ea033b2 980#endif
410f7a12 981 }
103f02d3 982
252b5132
RH		 983 switch (elf_header.e_machine)
984 {
985 default:
986 rtype = NULL;
987 break;
988
2b0337b0 989 case EM_M32R:
252b5132 990 case EM_CYGNUS_M32R:
9ea033b2 991 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 992 break;
993
994 case EM_386:
995 case EM_486:
9ea033b2 996 rtype = elf_i386_reloc_type (type);
252b5132
RH		 997 break;
998
ba2685cc
AM		 999 case EM_68HC11:
1000 case EM_68HC12:
1001 rtype = elf_m68hc11_reloc_type (type);
1002 break;
75751cd9 1003
252b5132 1004 case EM_68K:
9ea033b2 1005 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1006 break;
1007
63fcb9e9 1008 case EM_960:
9ea033b2 1009 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1010 break;
1011
adde6300 1012 case EM_AVR:
2b0337b0 1013 case EM_AVR_OLD:
adde6300
AM		 1014 rtype = elf_avr_reloc_type (type);
1015 break;
1016
9ea033b2
NC		 1017 case EM_OLD_SPARCV9:
1018 case EM_SPARC32PLUS:
1019 case EM_SPARCV9:
252b5132 1020 case EM_SPARC:
9ea033b2 1021 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1022 break;
1023
e9f53129
AM		 1024 case EM_SPU:
1025 rtype = elf_spu_reloc_type (type);
1026 break;
1027
2b0337b0 1028 case EM_V850:
252b5132 1029 case EM_CYGNUS_V850:
9ea033b2 1030 rtype = v850_reloc_type (type);
252b5132
RH		 1031 break;
1032
2b0337b0 1033 case EM_D10V:
252b5132 1034 case EM_CYGNUS_D10V:
9ea033b2 1035 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1036 break;
1037
2b0337b0 1038 case EM_D30V:
252b5132 1039 case EM_CYGNUS_D30V:
9ea033b2 1040 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1041 break;
1042
d172d4ba
NC		 1043 case EM_DLX:
1044 rtype = elf_dlx_reloc_type (type);
1045 break;
1046
252b5132 1047 case EM_SH:
9ea033b2 1048 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1049 break;
1050
2b0337b0 1051 case EM_MN10300:
252b5132 1052 case EM_CYGNUS_MN10300:
9ea033b2 1053 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1054 break;
1055
2b0337b0 1056 case EM_MN10200:
252b5132 1057 case EM_CYGNUS_MN10200:
9ea033b2 1058 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1059 break;
1060
2b0337b0 1061 case EM_FR30:
252b5132 1062 case EM_CYGNUS_FR30:
9ea033b2 1063 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1064 break;
1065
ba2685cc
AM		 1066 case EM_CYGNUS_FRV:
1067 rtype = elf_frv_reloc_type (type);
1068 break;
5c70f934 1069
252b5132 1070 case EM_MCORE:
9ea033b2 1071 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1072 break;
1073
3c3bdf30
NC		 1074 case EM_MMIX:
1075 rtype = elf_mmix_reloc_type (type);
1076 break;
1077
5506d11a
AM		 1078 case EM_MOXIE:
1079 rtype = elf_moxie_reloc_type (type);
1080 break;
1081
2469cfa2
NC		 1082 case EM_MSP430:
1083 case EM_MSP430_OLD:
1084 rtype = elf_msp430_reloc_type (type);
1085 break;
1086
252b5132 1087 case EM_PPC:
9ea033b2 1088 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1089 break;
1090
c833c019
AM		 1091 case EM_PPC64:
1092 rtype = elf_ppc64_reloc_type (type);
1093 break;
1094
252b5132 1095 case EM_MIPS:
4fe85591 1096 case EM_MIPS_RS3_LE:
9ea033b2 1097 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1098 break;
1099
1100 case EM_ALPHA:
9ea033b2 1101 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1102 break;
1103
1104 case EM_ARM:
9ea033b2 1105 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1106 break;
1107
584da044 1108 case EM_ARC:
9ea033b2 1109 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1110 break;
1111
1112 case EM_PARISC:
69e617ca 1113 rtype = elf_hppa_reloc_type (type);
252b5132 1114 break;
7d466069 1115
b8720f9d
JL		 1116 case EM_H8_300:
1117 case EM_H8_300H:
1118 case EM_H8S:
1119 rtype = elf_h8_reloc_type (type);
1120 break;
1121
3b16e843
NC		 1122 case EM_OPENRISC:
1123 case EM_OR32:
1124 rtype = elf_or32_reloc_type (type);
1125 break;
1126
7d466069 1127 case EM_PJ:
2b0337b0 1128 case EM_PJ_OLD:
7d466069
ILT		 1129 rtype = elf_pj_reloc_type (type);
1130 break;
800eeca4
JW		 1131 case EM_IA_64:
1132 rtype = elf_ia64_reloc_type (type);
1133 break;
1b61cf92
HPN		 1134
1135 case EM_CRIS:
1136 rtype = elf_cris_reloc_type (type);
1137 break;
535c37ff
JE		 1138
1139 case EM_860:
1140 rtype = elf_i860_reloc_type (type);
1141 break;
bcedfee6
NC		 1142
1143 case EM_X86_64:
8a9036a4 1144 case EM_L1OM:
7a9068fe 1145 case EM_K1OM:
bcedfee6
NC		 1146 rtype = elf_x86_64_reloc_type (type);
1147 break;
a85d7ed0 1148
35b1837e
AM		 1149 case EM_S370:
1150 rtype = i370_reloc_type (type);
1151 break;
1152
53c7db4b
KH		 1153 case EM_S390_OLD:
1154 case EM_S390:
1155 rtype = elf_s390_reloc_type (type);
1156 break;
93fbbb04 1157
1c0d3aa6
NC		 1158 case EM_SCORE:
1159 rtype = elf_score_reloc_type (type);
1160 break;
1161
93fbbb04
GK		 1162 case EM_XSTORMY16:
1163 rtype = elf_xstormy16_reloc_type (type);
1164 break;
179d3252 1165
1fe1f39c
NC		 1166 case EM_CRX:
1167 rtype = elf_crx_reloc_type (type);
1168 break;
1169
179d3252
JT		 1170 case EM_VAX:
1171 rtype = elf_vax_reloc_type (type);
1172 break;
1e4cf259 1173
cfb8c092
NC		 1174 case EM_ADAPTEVA_EPIPHANY:
1175 rtype = elf_epiphany_reloc_type (type);
1176 break;
1177
1e4cf259
NC		 1178 case EM_IP2K:
1179 case EM_IP2K_OLD:
1180 rtype = elf_ip2k_reloc_type (type);
1181 break;
3b36097d
SC		 1182
1183 case EM_IQ2000:
1184 rtype = elf_iq2000_reloc_type (type);
1185 break;
88da6820
NC		 1186
1187 case EM_XTENSA_OLD:
1188 case EM_XTENSA:
1189 rtype = elf_xtensa_reloc_type (type);
1190 break;
a34e3ecb 1191
84e94c90
NC		 1192 case EM_LATTICEMICO32:
1193 rtype = elf_lm32_reloc_type (type);
1194 break;
1195
ff7eeb89 1196 case EM_M32C_OLD:
49f58d10
JB		 1197 case EM_M32C:
1198 rtype = elf_m32c_reloc_type (type);
1199 break;
1200
d031aafb
NS		 1201 case EM_MT:
1202 rtype = elf_mt_reloc_type (type);
a34e3ecb 1203 break;
1d65ded4
CM		 1204
1205 case EM_BLACKFIN:
1206 rtype = elf_bfin_reloc_type (type);
1207 break;
15ab5209
DB		 1208
1209 case EM_CYGNUS_MEP:
1210 rtype = elf_mep_reloc_type (type);
1211 break;
60bca95a
NC		 1212
1213 case EM_CR16:
1214 rtype = elf_cr16_reloc_type (type);
1215 break;
dd24e3da 1216
7ba29e2a
NC		 1217 case EM_MICROBLAZE:
1218 case EM_MICROBLAZE_OLD:
1219 rtype = elf_microblaze_reloc_type (type);
1220 break;
c7927a3c 1221
99c513f6
DD		 1222 case EM_RL78:
1223 rtype = elf_rl78_reloc_type (type);
1224 break;
1225
c7927a3c
NC		 1226 case EM_RX:
1227 rtype = elf_rx_reloc_type (type);
1228 break;
c29aca4a
NC		 1229
1230 case EM_XC16X:
1231 case EM_C166:
1232 rtype = elf_xc16x_reloc_type (type);
1233 break;
40b36596
JM		 1234
1235 case EM_TI_C6000:
1236 rtype = elf_tic6x_reloc_type (type);
1237 break;
aa137e4d
NC		 1238
1239 case EM_TILEGX:
1240 rtype = elf_tilegx_reloc_type (type);
1241 break;
1242
1243 case EM_TILEPRO:
1244 rtype = elf_tilepro_reloc_type (type);
1245 break;
f6c1a2d5
NC		 1246
1247 case EM_XGATE:
1248 rtype = elf_xgate_reloc_type (type);
1249 break;
252b5132
RH		 1250 }
1251
1252 if (rtype == NULL)
39dbeff8 1253 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1254 else
8beeaeb7 1255 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1256
7ace3541 1257 if (elf_header.e_machine == EM_ALPHA
157c2599 1258 && rtype != NULL
7ace3541
RH		 1259 && streq (rtype, "R_ALPHA_LITUSE")
1260 && is_rela)
1261 {
1262 switch (rels[i].r_addend)
1263 {
1264 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1265 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1266 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1267 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1268 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1269 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1270 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1271 default: rtype = NULL;
1272 }
1273 if (rtype)
1274 printf (" (%s)", rtype);
1275 else
1276 {
1277 putchar (' ');
1278 printf (_("<unknown addend: %lx>"),
1279 (unsigned long) rels[i].r_addend);
1280 }
1281 }
1282 else if (symtab_index)
252b5132 1283 {
af3fc3bc 1284 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1285 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1286 else
19936277 1287 {
2cf0635d 1288 Elf_Internal_Sym * psym;
19936277 1289
af3fc3bc 1290 psym = symtab + symtab_index;
103f02d3 1291
af3fc3bc 1292 printf (" ");
171191ba 1293
d8045f23
NC		 1294 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1295 {
1296 const char * name;
1297 unsigned int len;
1298 unsigned int width = is_32bit_elf ? 8 : 14;
1299
1300 /* Relocations against GNU_IFUNC symbols do not use the value
1301 of the symbol as the address to relocate against. Instead
1302 they invoke the function named by the symbol and use its
1303 result as the address for relocation.
1304
1305 To indicate this to the user, do not display the value of
1306 the symbol in the "Symbols's Value" field. Instead show
1307 its name followed by () as a hint that the symbol is
1308 invoked. */
1309
1310 if (strtab == NULL
1311 || psym->st_name == 0
1312 || psym->st_name >= strtablen)
1313 name = "??";
1314 else
1315 name = strtab + psym->st_name;
1316
1317 len = print_symbol (width, name);
1318 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1319 }
1320 else
1321 {
1322 print_vma (psym->st_value, LONG_HEX);
171191ba 1323
d8045f23
NC		 1324 printf (is_32bit_elf ? " " : " ");
1325 }
103f02d3 1326
af3fc3bc 1327 if (psym->st_name == 0)
f1ef08cb 1328 {
2cf0635d 1329 const char * sec_name = "<null>";
f1ef08cb
AM		 1330 char name_buf[40];
1331
1332 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1333 {
4fbb74a6
AM		 1334 if (psym->st_shndx < elf_header.e_shnum)
1335 sec_name
1336 = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1337 else if (psym->st_shndx == SHN_ABS)
1338 sec_name = "ABS";
1339 else if (psym->st_shndx == SHN_COMMON)
1340 sec_name = "COMMON";
ac145307
BS		 1341 else if ((elf_header.e_machine == EM_MIPS
1342 && psym->st_shndx == SHN_MIPS_SCOMMON)
1343 || (elf_header.e_machine == EM_TI_C6000
1344 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1345 sec_name = "SCOMMON";
1346 else if (elf_header.e_machine == EM_MIPS
1347 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1348 sec_name = "SUNDEF";
8a9036a4 1349 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1350 || elf_header.e_machine == EM_L1OM
1351 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1352 && psym->st_shndx == SHN_X86_64_LCOMMON)
1353 sec_name = "LARGE_COMMON";
9ce701e2
L		 1354 else if (elf_header.e_machine == EM_IA_64
1355 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1356 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1357 sec_name = "ANSI_COM";
28f997cf 1358 else if (is_ia64_vms ()
148b93f2
NC		 1359 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1360 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1361 else
1362 {
1363 sprintf (name_buf, "<section 0x%x>",
1364 (unsigned int) psym->st_shndx);
1365 sec_name = name_buf;
1366 }
1367 }
1368 print_symbol (22, sec_name);
1369 }
af3fc3bc 1370 else if (strtab == NULL)
d79b3d50 1371 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1372 else if (psym->st_name >= strtablen)
d79b3d50 1373 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1374 else
2c71103e 1375 print_symbol (22, strtab + psym->st_name);
103f02d3 1376
af3fc3bc 1377 if (is_rela)
171191ba 1378 {
598aaa76 1379 bfd_signed_vma off = rels[i].r_addend;
171191ba 1380
91d6fa6a 1381 if (off < 0)
598aaa76 1382 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1383 else
598aaa76 1384 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1385 }
19936277 1386 }
252b5132 1387 }
1b228002 1388 else if (is_rela)
f7a99963 1389 {
18bd398b
NC		 1390 printf ("%*c", is_32bit_elf ?
1391 (do_wide ? 34 : 28) : (do_wide ? 26 : 20), ' ');
c8286bd1 1392 print_vma (rels[i].r_addend, LONG_HEX);
f7a99963 1393 }
252b5132 1394
157c2599
NC		 1395 if (elf_header.e_machine == EM_SPARCV9
1396 && rtype != NULL
1397 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1398 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1399
252b5132 1400 putchar ('\n');
2c71103e 1401
aca88567 1402#ifdef BFD64
53c7db4b 1403 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1404 {
91d6fa6a
NC		 1405 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1406 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1407 const char * rtype2 = elf_mips_reloc_type (type2);
1408 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1409
2c71103e
NC		 1410 printf (" Type2: ");
1411
1412 if (rtype2 == NULL)
39dbeff8
AM		 1413 printf (_("unrecognized: %-7lx"),
1414 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1415 else
1416 printf ("%-17.17s", rtype2);
1417
18bd398b 1418 printf ("\n Type3: ");
2c71103e
NC		 1419
1420 if (rtype3 == NULL)
39dbeff8
AM		 1421 printf (_("unrecognized: %-7lx"),
1422 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1423 else
1424 printf ("%-17.17s", rtype3);
1425
53c7db4b 1426 putchar ('\n');
2c71103e 1427 }
aca88567 1428#endif /* BFD64 */
252b5132
RH		 1429 }
1430
c8286bd1 1431 free (rels);
252b5132
RH		 1432}
1433
1434static const char *
d3ba0551 1435get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1436{
1437 switch (type)
1438 {
1439 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1440 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1441 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1442 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1443 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1444 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1445 case DT_MIPS_MSYM: return "MIPS_MSYM";
1446 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1447 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1448 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1449 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1450 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1451 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1452 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1453 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1454 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1455 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1456 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1457 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1458 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1459 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1460 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1461 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1462 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1463 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1464 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1465 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1466 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1467 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1468 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1469 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1470 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1471 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1472 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1473 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1474 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1475 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1476 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1477 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1478 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1479 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1480 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1481 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1482 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1483 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1484 default:
1485 return NULL;
1486 }
1487}
1488
9a097730 1489static const char *
d3ba0551 1490get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1491{
1492 switch (type)
1493 {
1494 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1495 default:
1496 return NULL;
1497 }
103f02d3
UD		 1498}
1499
7490d522
AM		 1500static const char *
1501get_ppc_dynamic_type (unsigned long type)
1502{
1503 switch (type)
1504 {
a7f2871e
AM		 1505 case DT_PPC_GOT: return "PPC_GOT";
1506 case DT_PPC_TLSOPT: return "PPC_TLSOPT";
7490d522
AM		 1507 default:
1508 return NULL;
1509 }
1510}
1511
f1cb7e17 1512static const char *
d3ba0551 1513get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1514{
1515 switch (type)
1516 {
a7f2871e
AM		 1517 case DT_PPC64_GLINK: return "PPC64_GLINK";
1518 case DT_PPC64_OPD: return "PPC64_OPD";
1519 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1520 case DT_PPC64_TLSOPT: return "PPC64_TLSOPT";
f1cb7e17
AM		 1521 default:
1522 return NULL;
1523 }
1524}
1525
103f02d3 1526static const char *
d3ba0551 1527get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1528{
1529 switch (type)
1530 {
1531 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1532 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1533 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1534 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1535 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1536 case DT_HP_PREINIT: return "HP_PREINIT";
1537 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1538 case DT_HP_NEEDED: return "HP_NEEDED";
1539 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1540 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1541 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1542 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1543 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1544 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1545 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1546 case DT_HP_FILTERED: return "HP_FILTERED";
1547 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1548 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1549 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1550 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1551 case DT_PLT: return "PLT";
1552 case DT_PLT_SIZE: return "PLT_SIZE";
1553 case DT_DLT: return "DLT";
1554 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1555 default:
1556 return NULL;
1557 }
1558}
9a097730 1559
ecc51f48 1560static const char *
d3ba0551 1561get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1562{
1563 switch (type)
1564 {
148b93f2
NC		 1565 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1566 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1567 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1568 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1569 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1570 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1571 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1572 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1573 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1574 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1575 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1576 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1577 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1578 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1579 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1580 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1581 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1582 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1583 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1584 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1585 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1586 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1587 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1588 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1589 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1590 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1591 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1592 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1593 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1594 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1595 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1596 default:
1597 return NULL;
1598 }
1599}
1600
fabcb361
RH		 1601static const char *
1602get_alpha_dynamic_type (unsigned long type)
1603{
1604 switch (type)
1605 {
1606 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1607 default:
1608 return NULL;
1609 }
1610}
1611
1c0d3aa6
NC		 1612static const char *
1613get_score_dynamic_type (unsigned long type)
1614{
1615 switch (type)
1616 {
1617 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1618 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1619 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1620 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1621 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1622 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1623 default:
1624 return NULL;
1625 }
1626}
1627
40b36596
JM		 1628static const char *
1629get_tic6x_dynamic_type (unsigned long type)
1630{
1631 switch (type)
1632 {
1633 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1634 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1635 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1636 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1637 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1638 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1639 default:
1640 return NULL;
1641 }
1642}
1c0d3aa6 1643
252b5132 1644static const char *
d3ba0551 1645get_dynamic_type (unsigned long type)
252b5132 1646{
e9e44622 1647 static char buff[64];
252b5132
RH		 1648
1649 switch (type)
1650 {
1651 case DT_NULL: return "NULL";
1652 case DT_NEEDED: return "NEEDED";
1653 case DT_PLTRELSZ: return "PLTRELSZ";
1654 case DT_PLTGOT: return "PLTGOT";
1655 case DT_HASH: return "HASH";
1656 case DT_STRTAB: return "STRTAB";
1657 case DT_SYMTAB: return "SYMTAB";
1658 case DT_RELA: return "RELA";
1659 case DT_RELASZ: return "RELASZ";
1660 case DT_RELAENT: return "RELAENT";
1661 case DT_STRSZ: return "STRSZ";
1662 case DT_SYMENT: return "SYMENT";
1663 case DT_INIT: return "INIT";
1664 case DT_FINI: return "FINI";
1665 case DT_SONAME: return "SONAME";
1666 case DT_RPATH: return "RPATH";
1667 case DT_SYMBOLIC: return "SYMBOLIC";
1668 case DT_REL: return "REL";
1669 case DT_RELSZ: return "RELSZ";
1670 case DT_RELENT: return "RELENT";
1671 case DT_PLTREL: return "PLTREL";
1672 case DT_DEBUG: return "DEBUG";
1673 case DT_TEXTREL: return "TEXTREL";
1674 case DT_JMPREL: return "JMPREL";
1675 case DT_BIND_NOW: return "BIND_NOW";
1676 case DT_INIT_ARRAY: return "INIT_ARRAY";
1677 case DT_FINI_ARRAY: return "FINI_ARRAY";
1678 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1679 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1680 case DT_RUNPATH: return "RUNPATH";
1681 case DT_FLAGS: return "FLAGS";
2d0e6f43 1682
d1133906
NC		 1683 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1684 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1685
05107a46 1686 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1687 case DT_PLTPADSZ: return "PLTPADSZ";
1688 case DT_MOVEENT: return "MOVEENT";
1689 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1690 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1691 case DT_POSFLAG_1: return "POSFLAG_1";
1692 case DT_SYMINSZ: return "SYMINSZ";
1693 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1694
252b5132 1695 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1696 case DT_CONFIG: return "CONFIG";
1697 case DT_DEPAUDIT: return "DEPAUDIT";
1698 case DT_AUDIT: return "AUDIT";
1699 case DT_PLTPAD: return "PLTPAD";
1700 case DT_MOVETAB: return "MOVETAB";
252b5132 1701 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1702
252b5132 1703 case DT_VERSYM: return "VERSYM";
103f02d3 1704
67a4f2b7
AO		 1705 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1706 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1707 case DT_RELACOUNT: return "RELACOUNT";
1708 case DT_RELCOUNT: return "RELCOUNT";
1709 case DT_FLAGS_1: return "FLAGS_1";
1710 case DT_VERDEF: return "VERDEF";
1711 case DT_VERDEFNUM: return "VERDEFNUM";
1712 case DT_VERNEED: return "VERNEED";
1713 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1714
019148e4 1715 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1716 case DT_USED: return "USED";
1717 case DT_FILTER: return "FILTER";
103f02d3 1718
047b2264
JJ		 1719 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1720 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1721 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1722 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1723 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1724 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1725
252b5132
RH		 1726 default:
1727 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1728 {
2cf0635d 1729 const char * result;
103f02d3 1730
252b5132
RH		 1731 switch (elf_header.e_machine)
1732 {
1733 case EM_MIPS:
4fe85591 1734 case EM_MIPS_RS3_LE:
252b5132
RH		 1735 result = get_mips_dynamic_type (type);
1736 break;
9a097730
RH		 1737 case EM_SPARCV9:
1738 result = get_sparc64_dynamic_type (type);
1739 break;
7490d522
AM		 1740 case EM_PPC:
1741 result = get_ppc_dynamic_type (type);
1742 break;
f1cb7e17
AM		 1743 case EM_PPC64:
1744 result = get_ppc64_dynamic_type (type);
1745 break;
ecc51f48
NC		 1746 case EM_IA_64:
1747 result = get_ia64_dynamic_type (type);
1748 break;
fabcb361
RH		 1749 case EM_ALPHA:
1750 result = get_alpha_dynamic_type (type);
1751 break;
1c0d3aa6
NC		 1752 case EM_SCORE:
1753 result = get_score_dynamic_type (type);
1754 break;
40b36596
JM		 1755 case EM_TI_C6000:
1756 result = get_tic6x_dynamic_type (type);
1757 break;
252b5132
RH		 1758 default:
1759 result = NULL;
1760 break;
1761 }
1762
1763 if (result != NULL)
1764 return result;
1765
e9e44622 1766 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 1767 }
eec8f817
DA		 1768 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1769 || (elf_header.e_machine == EM_PARISC
1770 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 1771 {
2cf0635d 1772 const char * result;
103f02d3
UD		 1773
1774 switch (elf_header.e_machine)
1775 {
1776 case EM_PARISC:
1777 result = get_parisc_dynamic_type (type);
1778 break;
148b93f2
NC		 1779 case EM_IA_64:
1780 result = get_ia64_dynamic_type (type);
1781 break;
103f02d3
UD		 1782 default:
1783 result = NULL;
1784 break;
1785 }
1786
1787 if (result != NULL)
1788 return result;
1789
e9e44622
JJ		 1790 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1791 type);
103f02d3 1792 }
252b5132 1793 else
e9e44622 1794 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 1795
252b5132
RH		 1796 return buff;
1797 }
1798}
1799
1800static char *
d3ba0551 1801get_file_type (unsigned e_type)
252b5132 1802{
b34976b6 1803 static char buff[32];
252b5132
RH		 1804
1805 switch (e_type)
1806 {
1807 case ET_NONE: return _("NONE (None)");
1808 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 1809 case ET_EXEC: return _("EXEC (Executable file)");
1810 case ET_DYN: return _("DYN (Shared object file)");
1811 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 1812
1813 default:
1814 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 1815 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 1816 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 1817 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 1818 else
e9e44622 1819 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 1820 return buff;
1821 }
1822}
1823
1824static char *
d3ba0551 1825get_machine_name (unsigned e_machine)
252b5132 1826{
b34976b6 1827 static char buff[64]; /* XXX */
252b5132
RH		 1828
1829 switch (e_machine)
1830 {
c45021f2
NC		 1831 case EM_NONE: return _("None");
1832 case EM_M32: return "WE32100";
1833 case EM_SPARC: return "Sparc";
e9f53129 1834 case EM_SPU: return "SPU";
c45021f2
NC		 1835 case EM_386: return "Intel 80386";
1836 case EM_68K: return "MC68000";
1837 case EM_88K: return "MC88000";
1838 case EM_486: return "Intel 80486";
1839 case EM_860: return "Intel 80860";
1840 case EM_MIPS: return "MIPS R3000";
1841 case EM_S370: return "IBM System/370";
7036c0e1 1842 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 1843 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 1844 case EM_PARISC: return "HPPA";
252b5132 1845 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 1846 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 1847 case EM_960: return "Intel 90860";
1848 case EM_PPC: return "PowerPC";
285d1771 1849 case EM_PPC64: return "PowerPC64";
c45021f2
NC		 1850 case EM_V800: return "NEC V800";
1851 case EM_FR20: return "Fujitsu FR20";
1852 case EM_RH32: return "TRW RH32";
b34976b6 1853 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 1854 case EM_ARM: return "ARM";
1855 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 1856 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 1857 case EM_SPARCV9: return "Sparc v9";
1858 case EM_TRICORE: return "Siemens Tricore";
584da044 1859 case EM_ARC: return "ARC";
c2dcd04e
NC		 1860 case EM_H8_300: return "Renesas H8/300";
1861 case EM_H8_300H: return "Renesas H8/300H";
1862 case EM_H8S: return "Renesas H8S";
1863 case EM_H8_500: return "Renesas H8/500";
30800947 1864 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 1865 case EM_MIPS_X: return "Stanford MIPS-X";
1866 case EM_COLDFIRE: return "Motorola Coldfire";
1867 case EM_68HC12: return "Motorola M68HC12";
c45021f2 1868 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 1869 case EM_CYGNUS_D10V:
1870 case EM_D10V: return "d10v";
1871 case EM_CYGNUS_D30V:
b34976b6 1872 case EM_D30V: return "d30v";
2b0337b0 1873 case EM_CYGNUS_M32R:
26597c86 1874 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 1875 case EM_CYGNUS_V850:
f6c1a2d5 1876 case EM_V850: return "Renesas V850";
2b0337b0
AO		 1877 case EM_CYGNUS_MN10300:
1878 case EM_MN10300: return "mn10300";
1879 case EM_CYGNUS_MN10200:
1880 case EM_MN10200: return "mn10200";
5506d11a 1881 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 1882 case EM_CYGNUS_FR30:
1883 case EM_FR30: return "Fujitsu FR30";
b34976b6 1884 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 1885 case EM_PJ_OLD:
b34976b6 1886 case EM_PJ: return "picoJava";
7036c0e1
AJ		 1887 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1888 case EM_PCP: return "Siemens PCP";
1889 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1890 case EM_NDR1: return "Denso NDR1 microprocesspr";
1891 case EM_STARCORE: return "Motorola Star*Core processor";
1892 case EM_ME16: return "Toyota ME16 processor";
1893 case EM_ST100: return "STMicroelectronics ST100 processor";
1894 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 1895 case EM_PDSP: return "Sony DSP processor";
1896 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
1897 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 1898 case EM_FX66: return "Siemens FX66 microcontroller";
1899 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1900 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1901 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1902 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1903 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1904 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1905 case EM_SVX: return "Silicon Graphics SVx";
1906 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1907 case EM_VAX: return "Digital VAX";
2b0337b0 1908 case EM_AVR_OLD:
b34976b6 1909 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 1910 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 1911 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1912 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1913 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 1914 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 1915 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 1916 case EM_PRISM: return "Vitesse Prism";
bcedfee6 1917 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 1918 case EM_L1OM: return "Intel L1OM";
7a9068fe 1919 case EM_K1OM: return "Intel K1OM";
b7498e0e 1920 case EM_S390_OLD:
b34976b6 1921 case EM_S390: return "IBM S/390";
1c0d3aa6 1922 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 1923 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
3b16e843
NC		 1924 case EM_OPENRISC:
1925 case EM_OR32: return "OpenRISC";
11636f9e 1926 case EM_ARC_A5: return "ARC International ARCompact processor";
1fe1f39c 1927 case EM_CRX: return "National Semiconductor CRX microprocessor";
cfb8c092 1928 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
d172d4ba 1929 case EM_DLX: return "OpenDLX";
1e4cf259 1930 case EM_IP2K_OLD:
b34976b6 1931 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 1932 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 1933 case EM_XTENSA_OLD:
1934 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 1935 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
1936 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
1937 case EM_NS32K: return "National Semiconductor 32000 series";
1938 case EM_TPC: return "Tenor Network TPC processor";
1939 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
1940 case EM_MAX: return "MAX Processor";
1941 case EM_CR: return "National Semiconductor CompactRISC";
1942 case EM_F2MC16: return "Fujitsu F2MC16";
1943 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 1944 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 1945 case EM_M32C_OLD:
49f58d10 1946 case EM_M32C: return "Renesas M32c";
d031aafb 1947 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 1948 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 1949 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
1950 case EM_SEP: return "Sharp embedded microprocessor";
1951 case EM_ARCA: return "Arca RISC microprocessor";
1952 case EM_UNICORE: return "Unicore";
1953 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
1954 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 1955 case EM_NIOS32: return "Altera Nios";
1956 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 1957 case EM_C166:
d70c5fc7 1958 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 1959 case EM_M16C: return "Renesas M16C series microprocessors";
1960 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
1961 case EM_CE: return "Freescale Communication Engine RISC core";
1962 case EM_TSK3000: return "Altium TSK3000 core";
1963 case EM_RS08: return "Freescale RS08 embedded processor";
1964 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
1965 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
1966 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
1967 case EM_SE_C17: return "Seiko Epson C17 family";
1968 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
1969 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
1970 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
1971 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
1972 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
1973 case EM_R32C: return "Renesas R32C series microprocessors";
1974 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
1975 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
1976 case EM_8051: return "Intel 8051 and variants";
1977 case EM_STXP7X: return "STMicroelectronics STxP7x family";
1978 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
1979 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
1980 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
1981 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
1982 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
1983 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 1984 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 1985 case EM_CR16:
f6c1a2d5 1986 case EM_MICROBLAZE:
7ba29e2a 1987 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
99c513f6 1988 case EM_RL78: return "Renesas RL78";
c7927a3c 1989 case EM_RX: return "Renesas RX";
11636f9e
JM		 1990 case EM_METAG: return "Imagination Technologies META processor architecture";
1991 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
1992 case EM_ECOG16: return "Cyan Technology eCOG16 family";
1993 case EM_ETPU: return "Freescale Extended Time Processing Unit";
1994 case EM_SLE9X: return "Infineon Technologies SLE9X core";
1995 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
1996 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
1997 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
1998 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 1999 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 2000 case EM_CUDA: return "NVIDIA CUDA architecture";
f6c1a2d5 2001 case EM_XGATE: return "Motorola XGATE embedded processor";
252b5132 2002 default:
35d9dd2f 2003 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2004 return buff;
2005 }
2006}
2007
f3485b74 2008static void
d3ba0551 2009decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2010{
2011 unsigned eabi;
2012 int unknown = 0;
2013
2014 eabi = EF_ARM_EABI_VERSION (e_flags);
2015 e_flags &= ~ EF_ARM_EABIMASK;
2016
2017 /* Handle "generic" ARM flags. */
2018 if (e_flags & EF_ARM_RELEXEC)
2019 {
2020 strcat (buf, ", relocatable executable");
2021 e_flags &= ~ EF_ARM_RELEXEC;
2022 }
76da6bbe 2023
f3485b74
NC		 2024 if (e_flags & EF_ARM_HASENTRY)
2025 {
2026 strcat (buf, ", has entry point");
2027 e_flags &= ~ EF_ARM_HASENTRY;
2028 }
76da6bbe 2029
f3485b74
NC		 2030 /* Now handle EABI specific flags. */
2031 switch (eabi)
2032 {
2033 default:
2c71103e 2034 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2035 if (e_flags)
2036 unknown = 1;
2037 break;
2038
2039 case EF_ARM_EABI_VER1:
a5bcd848 2040 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2041 while (e_flags)
2042 {
2043 unsigned flag;
76da6bbe 2044
f3485b74
NC		 2045 /* Process flags one bit at a time. */
2046 flag = e_flags & - e_flags;
2047 e_flags &= ~ flag;
76da6bbe 2048
f3485b74
NC		 2049 switch (flag)
2050 {
a5bcd848 2051 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2052 strcat (buf, ", sorted symbol tables");
2053 break;
76da6bbe 2054
f3485b74
NC		 2055 default:
2056 unknown = 1;
2057 break;
2058 }
2059 }
2060 break;
76da6bbe 2061
a5bcd848
PB		 2062 case EF_ARM_EABI_VER2:
2063 strcat (buf, ", Version2 EABI");
2064 while (e_flags)
2065 {
2066 unsigned flag;
2067
2068 /* Process flags one bit at a time. */
2069 flag = e_flags & - e_flags;
2070 e_flags &= ~ flag;
2071
2072 switch (flag)
2073 {
2074 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2075 strcat (buf, ", sorted symbol tables");
2076 break;
2077
2078 case EF_ARM_DYNSYMSUSESEGIDX:
2079 strcat (buf, ", dynamic symbols use segment index");
2080 break;
2081
2082 case EF_ARM_MAPSYMSFIRST:
2083 strcat (buf, ", mapping symbols precede others");
2084 break;
2085
2086 default:
2087 unknown = 1;
2088 break;
2089 }
2090 }
2091 break;
2092
d507cf36
PB		 2093 case EF_ARM_EABI_VER3:
2094 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2095 break;
2096
2097 case EF_ARM_EABI_VER4:
2098 strcat (buf, ", Version4 EABI");
3a4a14e9
PB		 2099 goto eabi;
2100
2101 case EF_ARM_EABI_VER5:
2102 strcat (buf, ", Version5 EABI");
2103 eabi:
d507cf36
PB		 2104 while (e_flags)
2105 {
2106 unsigned flag;
2107
2108 /* Process flags one bit at a time. */
2109 flag = e_flags & - e_flags;
2110 e_flags &= ~ flag;
2111
2112 switch (flag)
2113 {
2114 case EF_ARM_BE8:
2115 strcat (buf, ", BE8");
2116 break;
2117
2118 case EF_ARM_LE8:
2119 strcat (buf, ", LE8");
2120 break;
2121
2122 default:
2123 unknown = 1;
2124 break;
2125 }
2126 }
2127 break;
2128
f3485b74 2129 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2130 strcat (buf, ", GNU EABI");
f3485b74
NC		 2131 while (e_flags)
2132 {
2133 unsigned flag;
76da6bbe 2134
f3485b74
NC		 2135 /* Process flags one bit at a time. */
2136 flag = e_flags & - e_flags;
2137 e_flags &= ~ flag;
76da6bbe 2138
f3485b74
NC		 2139 switch (flag)
2140 {
a5bcd848 2141 case EF_ARM_INTERWORK:
f3485b74
NC		 2142 strcat (buf, ", interworking enabled");
2143 break;
76da6bbe 2144
a5bcd848 2145 case EF_ARM_APCS_26:
f3485b74
NC		 2146 strcat (buf, ", uses APCS/26");
2147 break;
76da6bbe 2148
a5bcd848 2149 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2150 strcat (buf, ", uses APCS/float");
2151 break;
76da6bbe 2152
a5bcd848 2153 case EF_ARM_PIC:
f3485b74
NC		 2154 strcat (buf, ", position independent");
2155 break;
76da6bbe 2156
a5bcd848 2157 case EF_ARM_ALIGN8:
f3485b74
NC		 2158 strcat (buf, ", 8 bit structure alignment");
2159 break;
76da6bbe 2160
a5bcd848 2161 case EF_ARM_NEW_ABI:
f3485b74
NC		 2162 strcat (buf, ", uses new ABI");
2163 break;
76da6bbe 2164
a5bcd848 2165 case EF_ARM_OLD_ABI:
f3485b74
NC		 2166 strcat (buf, ", uses old ABI");
2167 break;
76da6bbe 2168
a5bcd848 2169 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2170 strcat (buf, ", software FP");
2171 break;
76da6bbe 2172
90e01f86
ILT		 2173 case EF_ARM_VFP_FLOAT:
2174 strcat (buf, ", VFP");
2175 break;
2176
fde78edd
NC		 2177 case EF_ARM_MAVERICK_FLOAT:
2178 strcat (buf, ", Maverick FP");
2179 break;
2180
f3485b74
NC		 2181 default:
2182 unknown = 1;
2183 break;
2184 }
2185 }
2186 }
f3485b74
NC		 2187
2188 if (unknown)
2b692964 2189 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2190}
2191
252b5132 2192static char *
d3ba0551 2193get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2194{
b34976b6 2195 static char buf[1024];
252b5132
RH		 2196
2197 buf[0] = '\0';
76da6bbe 2198
252b5132
RH		 2199 if (e_flags)
2200 {
2201 switch (e_machine)
2202 {
2203 default:
2204 break;
2205
f3485b74
NC		 2206 case EM_ARM:
2207 decode_ARM_machine_flags (e_flags, buf);
2208 break;
76da6bbe 2209
781303ce
MF		 2210 case EM_BLACKFIN:
2211 if (e_flags & EF_BFIN_PIC)
2212 strcat (buf, ", PIC");
2213
2214 if (e_flags & EF_BFIN_FDPIC)
2215 strcat (buf, ", FDPIC");
2216
2217 if (e_flags & EF_BFIN_CODE_IN_L1)
2218 strcat (buf, ", code in L1");
2219
2220 if (e_flags & EF_BFIN_DATA_IN_L1)
2221 strcat (buf, ", data in L1");
2222
2223 break;
2224
ec2dfb42
AO		 2225 case EM_CYGNUS_FRV:
2226 switch (e_flags & EF_FRV_CPU_MASK)
2227 {
2228 case EF_FRV_CPU_GENERIC:
2229 break;
2230
2231 default:
2232 strcat (buf, ", fr???");
2233 break;
57346661 2234
ec2dfb42
AO		 2235 case EF_FRV_CPU_FR300:
2236 strcat (buf, ", fr300");
2237 break;
2238
2239 case EF_FRV_CPU_FR400:
2240 strcat (buf, ", fr400");
2241 break;
2242 case EF_FRV_CPU_FR405:
2243 strcat (buf, ", fr405");
2244 break;
2245
2246 case EF_FRV_CPU_FR450:
2247 strcat (buf, ", fr450");
2248 break;
2249
2250 case EF_FRV_CPU_FR500:
2251 strcat (buf, ", fr500");
2252 break;
2253 case EF_FRV_CPU_FR550:
2254 strcat (buf, ", fr550");
2255 break;
2256
2257 case EF_FRV_CPU_SIMPLE:
2258 strcat (buf, ", simple");
2259 break;
2260 case EF_FRV_CPU_TOMCAT:
2261 strcat (buf, ", tomcat");
2262 break;
2263 }
1c877e87 2264 break;
ec2dfb42 2265
53c7db4b 2266 case EM_68K:
425c6cb0 2267 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2268 strcat (buf, ", m68000");
425c6cb0 2269 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2270 strcat (buf, ", cpu32");
2271 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2272 strcat (buf, ", fido_a");
425c6cb0 2273 else
266abb8f 2274 {
2cf0635d
NC		 2275 char const * isa = _("unknown");
2276 char const * mac = _("unknown mac");
2277 char const * additional = NULL;
0112cd26 2278
c694fd50 2279 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2280 {
c694fd50 2281 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2282 isa = "A";
2283 additional = ", nodiv";
2284 break;
c694fd50 2285 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2286 isa = "A";
2287 break;
c694fd50 2288 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2289 isa = "A+";
2290 break;
c694fd50 2291 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2292 isa = "B";
2293 additional = ", nousp";
2294 break;
c694fd50 2295 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2296 isa = "B";
2297 break;
f608cd77
NS		 2298 case EF_M68K_CF_ISA_C:
2299 isa = "C";
2300 break;
2301 case EF_M68K_CF_ISA_C_NODIV:
2302 isa = "C";
2303 additional = ", nodiv";
2304 break;
266abb8f
NS		 2305 }
2306 strcat (buf, ", cf, isa ");
2307 strcat (buf, isa);
0b2e31dc
NS		 2308 if (additional)
2309 strcat (buf, additional);
c694fd50 2310 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2311 strcat (buf, ", float");
c694fd50 2312 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2313 {
2314 case 0:
2315 mac = NULL;
2316 break;
c694fd50 2317 case EF_M68K_CF_MAC:
266abb8f
NS		 2318 mac = "mac";
2319 break;
c694fd50 2320 case EF_M68K_CF_EMAC:
266abb8f
NS		 2321 mac = "emac";
2322 break;
f608cd77
NS		 2323 case EF_M68K_CF_EMAC_B:
2324 mac = "emac_b";
2325 break;
266abb8f
NS		 2326 }
2327 if (mac)
2328 {
2329 strcat (buf, ", ");
2330 strcat (buf, mac);
2331 }
266abb8f 2332 }
53c7db4b 2333 break;
33c63f9d 2334
252b5132
RH		 2335 case EM_PPC:
2336 if (e_flags & EF_PPC_EMB)
2337 strcat (buf, ", emb");
2338
2339 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2340 strcat (buf, _(", relocatable"));
252b5132
RH		 2341
2342 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 2343 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 2344 break;
2345
2b0337b0 2346 case EM_V850:
252b5132
RH		 2347 case EM_CYGNUS_V850:
2348 switch (e_flags & EF_V850_ARCH)
2349 {
1cd986c5
NC		 2350 case E_V850E2V3_ARCH:
2351 strcat (buf, ", v850e2v3");
2352 break;
2353 case E_V850E2_ARCH:
2354 strcat (buf, ", v850e2");
2355 break;
2356 case E_V850E1_ARCH:
2357 strcat (buf, ", v850e1");
8ad30312 2358 break;
252b5132
RH		 2359 case E_V850E_ARCH:
2360 strcat (buf, ", v850e");
2361 break;
252b5132
RH		 2362 case E_V850_ARCH:
2363 strcat (buf, ", v850");
2364 break;
2365 default:
2b692964 2366 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 2367 break;
2368 }
2369 break;
2370
2b0337b0 2371 case EM_M32R:
252b5132
RH		 2372 case EM_CYGNUS_M32R:
2373 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2374 strcat (buf, ", m32r");
252b5132
RH		 2375 break;
2376
2377 case EM_MIPS:
4fe85591 2378 case EM_MIPS_RS3_LE:
252b5132
RH		 2379 if (e_flags & EF_MIPS_NOREORDER)
2380 strcat (buf, ", noreorder");
2381
2382 if (e_flags & EF_MIPS_PIC)
2383 strcat (buf, ", pic");
2384
2385 if (e_flags & EF_MIPS_CPIC)
2386 strcat (buf, ", cpic");
2387
d1bdd336
TS		 2388 if (e_flags & EF_MIPS_UCODE)
2389 strcat (buf, ", ugen_reserved");
2390
252b5132
RH		 2391 if (e_flags & EF_MIPS_ABI2)
2392 strcat (buf, ", abi2");
2393
43521d43
TS		 2394 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2395 strcat (buf, ", odk first");
2396
a5d22d2a
TS		 2397 if (e_flags & EF_MIPS_32BITMODE)
2398 strcat (buf, ", 32bitmode");
2399
156c2f8b
NC		 2400 switch ((e_flags & EF_MIPS_MACH))
2401 {
2402 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2403 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2404 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 2405 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 2406 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2407 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2408 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2409 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 2410 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 2411 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 2412 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2413 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 2414 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 2415 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 2416 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
52b6b6b9 2417 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 2418 case 0:
2419 /* We simply ignore the field in this case to avoid confusion:
2420 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2421 extension. */
2422 break;
2b692964 2423 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 2424 }
43521d43
TS		 2425
2426 switch ((e_flags & EF_MIPS_ABI))
2427 {
2428 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2429 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2430 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2431 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2432 case 0:
2433 /* We simply ignore the field in this case to avoid confusion:
2434 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2435 This means it is likely to be an o32 file, but not for
2436 sure. */
2437 break;
2b692964 2438 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 2439 }
2440
2441 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2442 strcat (buf, ", mdmx");
2443
2444 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2445 strcat (buf, ", mips16");
2446
df58fc94
RS		 2447 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2448 strcat (buf, ", micromips");
2449
43521d43
TS		 2450 switch ((e_flags & EF_MIPS_ARCH))
2451 {
2452 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2453 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2454 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2455 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2456 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2457 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 2458 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
43521d43 2459 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 2460 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2b692964 2461 default: strcat (buf, _(", unknown ISA")); break;
43521d43
TS		 2462 }
2463
8e45593f
NC		 2464 if (e_flags & EF_SH_PIC)
2465 strcat (buf, ", pic");
2466
2467 if (e_flags & EF_SH_FDPIC)
2468 strcat (buf, ", fdpic");
252b5132 2469 break;
351b4b40 2470
ccde1100
AO		 2471 case EM_SH:
2472 switch ((e_flags & EF_SH_MACH_MASK))
2473 {
2474 case EF_SH1: strcat (buf, ", sh1"); break;
2475 case EF_SH2: strcat (buf, ", sh2"); break;
2476 case EF_SH3: strcat (buf, ", sh3"); break;
2477 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2478 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2479 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2480 case EF_SH3E: strcat (buf, ", sh3e"); break;
2481 case EF_SH4: strcat (buf, ", sh4"); break;
2482 case EF_SH5: strcat (buf, ", sh5"); break;
2483 case EF_SH2E: strcat (buf, ", sh2e"); break;
2484 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 2485 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 2486 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2487 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 2488 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 2489 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2490 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2491 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2492 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2493 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2494 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 2495 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 2496 }
2497
2498 break;
57346661 2499
351b4b40
RH		 2500 case EM_SPARCV9:
2501 if (e_flags & EF_SPARC_32PLUS)
2502 strcat (buf, ", v8+");
2503
2504 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 2505 strcat (buf, ", ultrasparcI");
2506
2507 if (e_flags & EF_SPARC_SUN_US3)
2508 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 2509
2510 if (e_flags & EF_SPARC_HAL_R1)
2511 strcat (buf, ", halr1");
2512
2513 if (e_flags & EF_SPARC_LEDATA)
2514 strcat (buf, ", ledata");
2515
2516 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2517 strcat (buf, ", tso");
2518
2519 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2520 strcat (buf, ", pso");
2521
2522 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2523 strcat (buf, ", rmo");
2524 break;
7d466069 2525
103f02d3
UD		 2526 case EM_PARISC:
2527 switch (e_flags & EF_PARISC_ARCH)
2528 {
2529 case EFA_PARISC_1_0:
2530 strcpy (buf, ", PA-RISC 1.0");
2531 break;
2532 case EFA_PARISC_1_1:
2533 strcpy (buf, ", PA-RISC 1.1");
2534 break;
2535 case EFA_PARISC_2_0:
2536 strcpy (buf, ", PA-RISC 2.0");
2537 break;
2538 default:
2539 break;
2540 }
2541 if (e_flags & EF_PARISC_TRAPNIL)
2542 strcat (buf, ", trapnil");
2543 if (e_flags & EF_PARISC_EXT)
2544 strcat (buf, ", ext");
2545 if (e_flags & EF_PARISC_LSB)
2546 strcat (buf, ", lsb");
2547 if (e_flags & EF_PARISC_WIDE)
2548 strcat (buf, ", wide");
2549 if (e_flags & EF_PARISC_NO_KABP)
2550 strcat (buf, ", no kabp");
2551 if (e_flags & EF_PARISC_LAZYSWAP)
2552 strcat (buf, ", lazyswap");
30800947 2553 break;
76da6bbe 2554
7d466069 2555 case EM_PJ:
2b0337b0 2556 case EM_PJ_OLD:
7d466069
ILT		 2557 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2558 strcat (buf, ", new calling convention");
2559
2560 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2561 strcat (buf, ", gnu calling convention");
2562 break;
4d6ed7c8
NC		 2563
2564 case EM_IA_64:
2565 if ((e_flags & EF_IA_64_ABI64))
2566 strcat (buf, ", 64-bit");
2567 else
2568 strcat (buf, ", 32-bit");
2569 if ((e_flags & EF_IA_64_REDUCEDFP))
2570 strcat (buf, ", reduced fp model");
2571 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2572 strcat (buf, ", no function descriptors, constant gp");
2573 else if ((e_flags & EF_IA_64_CONS_GP))
2574 strcat (buf, ", constant gp");
2575 if ((e_flags & EF_IA_64_ABSOLUTE))
2576 strcat (buf, ", absolute");
28f997cf
TG		 2577 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2578 {
2579 if ((e_flags & EF_IA_64_VMS_LINKAGES))
2580 strcat (buf, ", vms_linkages");
2581 switch ((e_flags & EF_IA_64_VMS_COMCOD))
2582 {
2583 case EF_IA_64_VMS_COMCOD_SUCCESS:
2584 break;
2585 case EF_IA_64_VMS_COMCOD_WARNING:
2586 strcat (buf, ", warning");
2587 break;
2588 case EF_IA_64_VMS_COMCOD_ERROR:
2589 strcat (buf, ", error");
2590 break;
2591 case EF_IA_64_VMS_COMCOD_ABORT:
2592 strcat (buf, ", abort");
2593 break;
2594 default:
2595 abort ();
2596 }
2597 }
4d6ed7c8 2598 break;
179d3252
JT		 2599
2600 case EM_VAX:
2601 if ((e_flags & EF_VAX_NONPIC))
2602 strcat (buf, ", non-PIC");
2603 if ((e_flags & EF_VAX_DFLOAT))
2604 strcat (buf, ", D-Float");
2605 if ((e_flags & EF_VAX_GFLOAT))
2606 strcat (buf, ", G-Float");
2607 break;
c7927a3c
NC		 2608
2609 case EM_RX:
2610 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2611 strcat (buf, ", 64-bit doubles");
2612 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 2613 strcat (buf, ", dsp");
d4cb0ea0
NC		 2614 if (e_flags & E_FLAG_RX_PID)
2615 strcat (buf, ", pid");
2616 break;
55786da2
AK		 2617
2618 case EM_S390:
2619 if (e_flags & EF_S390_HIGH_GPRS)
2620 strcat (buf, ", highgprs");
d4cb0ea0 2621 break;
40b36596
JM		 2622
2623 case EM_TI_C6000:
2624 if ((e_flags & EF_C6000_REL))
2625 strcat (buf, ", relocatable module");
d4cb0ea0 2626 break;
252b5132
RH		 2627 }
2628 }
2629
2630 return buf;
2631}
2632
252b5132 2633static const char *
d3ba0551
AM		 2634get_osabi_name (unsigned int osabi)
2635{
2636 static char buff[32];
2637
2638 switch (osabi)
2639 {
2640 case ELFOSABI_NONE: return "UNIX - System V";
2641 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2642 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 2643 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 2644 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2645 case ELFOSABI_AIX: return "UNIX - AIX";
2646 case ELFOSABI_IRIX: return "UNIX - IRIX";
2647 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2648 case ELFOSABI_TRU64: return "UNIX - TRU64";
2649 case ELFOSABI_MODESTO: return "Novell - Modesto";
2650 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2651 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2652 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 2653 case ELFOSABI_AROS: return "AROS";
11636f9e 2654 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 2655 default:
40b36596
JM		 2656 if (osabi >= 64)
2657 switch (elf_header.e_machine)
2658 {
2659 case EM_ARM:
2660 switch (osabi)
2661 {
2662 case ELFOSABI_ARM: return "ARM";
2663 default:
2664 break;
2665 }
2666 break;
2667
2668 case EM_MSP430:
2669 case EM_MSP430_OLD:
2670 switch (osabi)
2671 {
2672 case ELFOSABI_STANDALONE: return _("Standalone App");
2673 default:
2674 break;
2675 }
2676 break;
2677
2678 case EM_TI_C6000:
2679 switch (osabi)
2680 {
2681 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
2682 case ELFOSABI_C6000_LINUX: return "Linux C6000";
2683 default:
2684 break;
2685 }
2686 break;
2687
2688 default:
2689 break;
2690 }
e9e44622 2691 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 2692 return buff;
2693 }
2694}
2695
b294bdf8
MM		 2696static const char *
2697get_arm_segment_type (unsigned long type)
2698{
2699 switch (type)
2700 {
2701 case PT_ARM_EXIDX:
2702 return "EXIDX";
2703 default:
2704 break;
2705 }
2706
2707 return NULL;
2708}
2709
d3ba0551
AM		 2710static const char *
2711get_mips_segment_type (unsigned long type)
252b5132
RH		 2712{
2713 switch (type)
2714 {
2715 case PT_MIPS_REGINFO:
2716 return "REGINFO";
2717 case PT_MIPS_RTPROC:
2718 return "RTPROC";
2719 case PT_MIPS_OPTIONS:
2720 return "OPTIONS";
2721 default:
2722 break;
2723 }
2724
2725 return NULL;
2726}
2727
103f02d3 2728static const char *
d3ba0551 2729get_parisc_segment_type (unsigned long type)
103f02d3
UD		 2730{
2731 switch (type)
2732 {
2733 case PT_HP_TLS: return "HP_TLS";
2734 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2735 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2736 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2737 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2738 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2739 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2740 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2741 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2742 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2743 case PT_HP_PARALLEL: return "HP_PARALLEL";
2744 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 2745 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
2746 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
2747 case PT_HP_STACK: return "HP_STACK";
2748 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 2749 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2750 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 2751 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 2752 default:
2753 break;
2754 }
2755
2756 return NULL;
2757}
2758
4d6ed7c8 2759static const char *
d3ba0551 2760get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 2761{
2762 switch (type)
2763 {
2764 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2765 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 2766 case PT_HP_TLS: return "HP_TLS";
2767 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2768 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2769 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 2770 default:
2771 break;
2772 }
2773
2774 return NULL;
2775}
2776
40b36596
JM		 2777static const char *
2778get_tic6x_segment_type (unsigned long type)
2779{
2780 switch (type)
2781 {
2782 case PT_C6000_PHATTR: return "C6000_PHATTR";
2783 default:
2784 break;
2785 }
2786
2787 return NULL;
2788}
2789
252b5132 2790static const char *
d3ba0551 2791get_segment_type (unsigned long p_type)
252b5132 2792{
b34976b6 2793 static char buff[32];
252b5132
RH		 2794
2795 switch (p_type)
2796 {
b34976b6
AM		 2797 case PT_NULL: return "NULL";
2798 case PT_LOAD: return "LOAD";
252b5132 2799 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 2800 case PT_INTERP: return "INTERP";
2801 case PT_NOTE: return "NOTE";
2802 case PT_SHLIB: return "SHLIB";
2803 case PT_PHDR: return "PHDR";
13ae64f3 2804 case PT_TLS: return "TLS";
252b5132 2805
65765700
JJ		 2806 case PT_GNU_EH_FRAME:
2807 return "GNU_EH_FRAME";
2b05f1b7 2808 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 2809 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 2810
252b5132
RH		 2811 default:
2812 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2813 {
2cf0635d 2814 const char * result;
103f02d3 2815
252b5132
RH		 2816 switch (elf_header.e_machine)
2817 {
b294bdf8
MM		 2818 case EM_ARM:
2819 result = get_arm_segment_type (p_type);
2820 break;
252b5132 2821 case EM_MIPS:
4fe85591 2822 case EM_MIPS_RS3_LE:
252b5132
RH		 2823 result = get_mips_segment_type (p_type);
2824 break;
103f02d3
UD		 2825 case EM_PARISC:
2826 result = get_parisc_segment_type (p_type);
2827 break;
4d6ed7c8
NC		 2828 case EM_IA_64:
2829 result = get_ia64_segment_type (p_type);
2830 break;
40b36596
JM		 2831 case EM_TI_C6000:
2832 result = get_tic6x_segment_type (p_type);
2833 break;
252b5132
RH		 2834 default:
2835 result = NULL;
2836 break;
2837 }
103f02d3 2838
252b5132
RH		 2839 if (result != NULL)
2840 return result;
103f02d3 2841
252b5132
RH		 2842 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2843 }
2844 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 2845 {
2cf0635d 2846 const char * result;
103f02d3
UD		 2847
2848 switch (elf_header.e_machine)
2849 {
2850 case EM_PARISC:
2851 result = get_parisc_segment_type (p_type);
2852 break;
00428cca
AM		 2853 case EM_IA_64:
2854 result = get_ia64_segment_type (p_type);
2855 break;
103f02d3
UD		 2856 default:
2857 result = NULL;
2858 break;
2859 }
2860
2861 if (result != NULL)
2862 return result;
2863
2864 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2865 }
252b5132 2866 else
e9e44622 2867 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 2868
2869 return buff;
2870 }
2871}
2872
2873static const char *
d3ba0551 2874get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 2875{
2876 switch (sh_type)
2877 {
b34976b6
AM		 2878 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
2879 case SHT_MIPS_MSYM: return "MIPS_MSYM";
2880 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
2881 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
2882 case SHT_MIPS_UCODE: return "MIPS_UCODE";
2883 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
2884 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
2885 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
2886 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
2887 case SHT_MIPS_RELD: return "MIPS_RELD";
2888 case SHT_MIPS_IFACE: return "MIPS_IFACE";
2889 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
2890 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
2891 case SHT_MIPS_SHDR: return "MIPS_SHDR";
2892 case SHT_MIPS_FDESC: return "MIPS_FDESC";
2893 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
2894 case SHT_MIPS_DENSE: return "MIPS_DENSE";
2895 case SHT_MIPS_PDESC: return "MIPS_PDESC";
2896 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
2897 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
2898 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
2899 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
2900 case SHT_MIPS_LINE: return "MIPS_LINE";
2901 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
2902 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
2903 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
2904 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
2905 case SHT_MIPS_DWARF: return "MIPS_DWARF";
2906 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
2907 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
2908 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
2909 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
2910 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
2911 case SHT_MIPS_XLATE: return "MIPS_XLATE";
2912 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
2913 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
2914 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
2915 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132
RH		 2916 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2917 default:
2918 break;
2919 }
2920 return NULL;
2921}
2922
103f02d3 2923static const char *
d3ba0551 2924get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 2925{
2926 switch (sh_type)
2927 {
2928 case SHT_PARISC_EXT: return "PARISC_EXT";
2929 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
2930 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 2931 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
2932 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
2933 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 2934 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 2935 default:
2936 break;
2937 }
2938 return NULL;
2939}
2940
4d6ed7c8 2941static const char *
d3ba0551 2942get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 2943{
18bd398b 2944 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 2945 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
2946 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 2947
4d6ed7c8
NC		 2948 switch (sh_type)
2949 {
148b93f2
NC		 2950 case SHT_IA_64_EXT: return "IA_64_EXT";
2951 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
2952 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
2953 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
2954 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
2955 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
2956 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
2957 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
2958 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
2959 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 2960 default:
2961 break;
2962 }
2963 return NULL;
2964}
2965
d2b2c203
DJ		 2966static const char *
2967get_x86_64_section_type_name (unsigned int sh_type)
2968{
2969 switch (sh_type)
2970 {
2971 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
2972 default:
2973 break;
2974 }
2975 return NULL;
2976}
2977
40a18ebd
NC		 2978static const char *
2979get_arm_section_type_name (unsigned int sh_type)
2980{
2981 switch (sh_type)
2982 {
7f6fed87
NC		 2983 case SHT_ARM_EXIDX: return "ARM_EXIDX";
2984 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
2985 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
2986 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
2987 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 2988 default:
2989 break;
2990 }
2991 return NULL;
2992}
2993
40b36596
JM		 2994static const char *
2995get_tic6x_section_type_name (unsigned int sh_type)
2996{
2997 switch (sh_type)
2998 {
2999 case SHT_C6000_UNWIND:
3000 return "C6000_UNWIND";
3001 case SHT_C6000_PREEMPTMAP:
3002 return "C6000_PREEMPTMAP";
3003 case SHT_C6000_ATTRIBUTES:
3004 return "C6000_ATTRIBUTES";
3005 case SHT_TI_ICODE:
3006 return "TI_ICODE";
3007 case SHT_TI_XREF:
3008 return "TI_XREF";
3009 case SHT_TI_HANDLER:
3010 return "TI_HANDLER";
3011 case SHT_TI_INITINFO:
3012 return "TI_INITINFO";
3013 case SHT_TI_PHATTRS:
3014 return "TI_PHATTRS";
3015 default:
3016 break;
3017 }
3018 return NULL;
3019}
3020
252b5132 3021static const char *
d3ba0551 3022get_section_type_name (unsigned int sh_type)
252b5132 3023{
b34976b6 3024 static char buff[32];
252b5132
RH		 3025
3026 switch (sh_type)
3027 {
3028 case SHT_NULL: return "NULL";
3029 case SHT_PROGBITS: return "PROGBITS";
3030 case SHT_SYMTAB: return "SYMTAB";
3031 case SHT_STRTAB: return "STRTAB";
3032 case SHT_RELA: return "RELA";
3033 case SHT_HASH: return "HASH";
3034 case SHT_DYNAMIC: return "DYNAMIC";
3035 case SHT_NOTE: return "NOTE";
3036 case SHT_NOBITS: return "NOBITS";
3037 case SHT_REL: return "REL";
3038 case SHT_SHLIB: return "SHLIB";
3039 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3040 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3041 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3042 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3043 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3044 case SHT_GROUP: return "GROUP";
3045 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3046 case SHT_GNU_verdef: return "VERDEF";
3047 case SHT_GNU_verneed: return "VERNEED";
3048 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3049 case 0x6ffffff0: return "VERSYM";
3050 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3051 case 0x7ffffffd: return "AUXILIARY";
3052 case 0x7fffffff: return "FILTER";
047b2264 3053 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3054
3055 default:
3056 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3057 {
2cf0635d 3058 const char * result;
252b5132
RH		 3059
3060 switch (elf_header.e_machine)
3061 {
3062 case EM_MIPS:
4fe85591 3063 case EM_MIPS_RS3_LE:
252b5132
RH		 3064 result = get_mips_section_type_name (sh_type);
3065 break;
103f02d3
UD		 3066 case EM_PARISC:
3067 result = get_parisc_section_type_name (sh_type);
3068 break;
4d6ed7c8
NC		 3069 case EM_IA_64:
3070 result = get_ia64_section_type_name (sh_type);
3071 break;
d2b2c203 3072 case EM_X86_64:
8a9036a4 3073 case EM_L1OM:
7a9068fe 3074 case EM_K1OM:
d2b2c203
DJ		 3075 result = get_x86_64_section_type_name (sh_type);
3076 break;
40a18ebd
NC		 3077 case EM_ARM:
3078 result = get_arm_section_type_name (sh_type);
3079 break;
40b36596
JM		 3080 case EM_TI_C6000:
3081 result = get_tic6x_section_type_name (sh_type);
3082 break;
252b5132
RH		 3083 default:
3084 result = NULL;
3085 break;
3086 }
3087
3088 if (result != NULL)
3089 return result;
3090
c91d0dfb 3091 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3092 }
3093 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3094 {
2cf0635d 3095 const char * result;
148b93f2
NC		 3096
3097 switch (elf_header.e_machine)
3098 {
3099 case EM_IA_64:
3100 result = get_ia64_section_type_name (sh_type);
3101 break;
3102 default:
3103 result = NULL;
3104 break;
3105 }
3106
3107 if (result != NULL)
3108 return result;
3109
3110 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3111 }
252b5132 3112 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
c91d0dfb 3113 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
252b5132 3114 else
a7dbfd1c
NC		 3115 /* This message is probably going to be displayed in a 15
3116 character wide field, so put the hex value first. */
3117 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3118
252b5132
RH		 3119 return buff;
3120 }
3121}
3122
2979dc34 3123#define OPTION_DEBUG_DUMP 512
2c610e4b 3124#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3125#define OPTION_DWARF_DEPTH 514
3126#define OPTION_DWARF_START 515
2979dc34 3127
85b1c36d 3128static struct option options[] =
252b5132 3129{
b34976b6 3130 {"all", no_argument, 0, 'a'},
252b5132
RH		 3131 {"file-header", no_argument, 0, 'h'},
3132 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3133 {"headers", no_argument, 0, 'e'},
3134 {"histogram", no_argument, 0, 'I'},
3135 {"segments", no_argument, 0, 'l'},
3136 {"sections", no_argument, 0, 'S'},
252b5132 3137 {"section-headers", no_argument, 0, 'S'},
f5842774 3138 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3139 {"section-details", no_argument, 0, 't'},
595cf52e 3140 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3141 {"symbols", no_argument, 0, 's'},
3142 {"syms", no_argument, 0, 's'},
2c610e4b 3143 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3144 {"relocs", no_argument, 0, 'r'},
3145 {"notes", no_argument, 0, 'n'},
3146 {"dynamic", no_argument, 0, 'd'},
a952a375 3147 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3148 {"version-info", no_argument, 0, 'V'},
3149 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3150 {"unwind", no_argument, 0, 'u'},
4145f1d5 3151 {"archive-index", no_argument, 0, 'c'},
b34976b6 3152 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3153 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3154 {"string-dump", required_argument, 0, 'p'},
252b5132
RH		 3155#ifdef SUPPORT_DISASSEMBLY
3156 {"instruction-dump", required_argument, 0, 'i'},
3157#endif
cf13d699 3158 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3159
fd2f0033
TT		 3160 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3161 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
3162
b34976b6
AM		 3163 {"version", no_argument, 0, 'v'},
3164 {"wide", no_argument, 0, 'W'},
3165 {"help", no_argument, 0, 'H'},
3166 {0, no_argument, 0, 0}
252b5132
RH		 3167};
3168
3169static void
2cf0635d 3170usage (FILE * stream)
252b5132 3171{
92f01d61
JM		 3172 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3173 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3174 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3175 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3176 -h --file-header Display the ELF file header\n\
3177 -l --program-headers Display the program headers\n\
3178 --segments An alias for --program-headers\n\
3179 -S --section-headers Display the sections' header\n\
3180 --sections An alias for --section-headers\n\
f5842774 3181 -g --section-groups Display the section groups\n\
5477e8a0 3182 -t --section-details Display the section details\n\
8b53311e
NC		 3183 -e --headers Equivalent to: -h -l -S\n\
3184 -s --syms Display the symbol table\n\
3f08eb35 3185 --symbols An alias for --syms\n\
2c610e4b 3186 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3187 -n --notes Display the core notes (if present)\n\
3188 -r --relocs Display the relocations (if present)\n\
3189 -u --unwind Display the unwind info (if present)\n\
b2d38a17 3190 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 3191 -V --version-info Display the version sections (if present)\n\
1b31d05e 3192 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 3193 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 3194 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 3195 -x --hex-dump=<number|name>\n\
3196 Dump the contents of section <number|name> as bytes\n\
3197 -p --string-dump=<number|name>\n\
3198 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 3199 -R --relocated-dump=<number|name>\n\
3200 Dump the contents of section <number|name> as relocated bytes\n\
f9f0e732 3201 -w[lLiaprmfFsoRt] or\n\
1ed06042 3202 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 3203 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
5bbdf3d5 3204 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges]\n\
8b53311e 3205 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 3206 fprintf (stream, _("\
3207 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3208 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3209 or deeper\n"));
252b5132 3210#ifdef SUPPORT_DISASSEMBLY
92f01d61 3211 fprintf (stream, _("\
09c11c86
NC		 3212 -i --instruction-dump=<number|name>\n\
3213 Disassemble the contents of section <number|name>\n"));
252b5132 3214#endif
92f01d61 3215 fprintf (stream, _("\
8b53311e
NC		 3216 -I --histogram Display histogram of bucket list lengths\n\
3217 -W --wide Allow output width to exceed 80 characters\n\
07012eee 3218 @<file> Read options from <file>\n\
8b53311e
NC		 3219 -H --help Display this information\n\
3220 -v --version Display the version number of readelf\n"));
1118d252 3221
92f01d61
JM		 3222 if (REPORT_BUGS_TO[0] && stream == stdout)
3223 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 3224
92f01d61 3225 exit (stream == stdout ? 0 : 1);
252b5132
RH		 3226}
3227
18bd398b
NC		 3228/* Record the fact that the user wants the contents of section number
3229 SECTION to be displayed using the method(s) encoded as flags bits
3230 in TYPE. Note, TYPE can be zero if we are creating the array for
3231 the first time. */
3232
252b5132 3233static void
09c11c86 3234request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 3235{
3236 if (section >= num_dump_sects)
3237 {
2cf0635d 3238 dump_type * new_dump_sects;
252b5132 3239
3f5e193b
NC		 3240 new_dump_sects = (dump_type *) calloc (section + 1,
3241 sizeof (* dump_sects));
252b5132
RH		 3242
3243 if (new_dump_sects == NULL)
591a748a 3244 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 3245 else
3246 {
3247 /* Copy current flag settings. */
09c11c86 3248 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 3249
3250 free (dump_sects);
3251
3252 dump_sects = new_dump_sects;
3253 num_dump_sects = section + 1;
3254 }
3255 }
3256
3257 if (dump_sects)
b34976b6 3258 dump_sects[section] |= type;
252b5132
RH		 3259
3260 return;
3261}
3262
aef1f6d0
DJ		 3263/* Request a dump by section name. */
3264
3265static void
2cf0635d 3266request_dump_byname (const char * section, dump_type type)
aef1f6d0 3267{
2cf0635d 3268 struct dump_list_entry * new_request;
aef1f6d0 3269
3f5e193b
NC		 3270 new_request = (struct dump_list_entry *)
3271 malloc (sizeof (struct dump_list_entry));
aef1f6d0 3272 if (!new_request)
591a748a 3273 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3274
3275 new_request->name = strdup (section);
3276 if (!new_request->name)
591a748a 3277 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3278
3279 new_request->type = type;
3280
3281 new_request->next = dump_sects_byname;
3282 dump_sects_byname = new_request;
3283}
3284
cf13d699
NC		 3285static inline void
3286request_dump (dump_type type)
3287{
3288 int section;
3289 char * cp;
3290
3291 do_dump++;
3292 section = strtoul (optarg, & cp, 0);
3293
3294 if (! *cp && section >= 0)
3295 request_dump_bynumber (section, type);
3296 else
3297 request_dump_byname (optarg, type);
3298}
3299
3300
252b5132 3301static void
2cf0635d 3302parse_args (int argc, char ** argv)
252b5132
RH		 3303{
3304 int c;
3305
3306 if (argc < 2)
92f01d61 3307 usage (stderr);
252b5132
RH		 3308
3309 while ((c = getopt_long
cf13d699 3310 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
252b5132 3311 {
252b5132
RH		 3312 switch (c)
3313 {
3314 case 0:
3315 /* Long options. */
3316 break;
3317 case 'H':
92f01d61 3318 usage (stdout);
252b5132
RH		 3319 break;
3320
3321 case 'a':
b34976b6
AM		 3322 do_syms++;
3323 do_reloc++;
3324 do_unwind++;
3325 do_dynamic++;
3326 do_header++;
3327 do_sections++;
f5842774 3328 do_section_groups++;
b34976b6
AM		 3329 do_segments++;
3330 do_version++;
3331 do_histogram++;
3332 do_arch++;
3333 do_notes++;
252b5132 3334 break;
f5842774
L		 3335 case 'g':
3336 do_section_groups++;
3337 break;
5477e8a0 3338 case 't':
595cf52e 3339 case 'N':
5477e8a0
L		 3340 do_sections++;
3341 do_section_details++;
595cf52e 3342 break;
252b5132 3343 case 'e':
b34976b6
AM		 3344 do_header++;
3345 do_sections++;
3346 do_segments++;
252b5132 3347 break;
a952a375 3348 case 'A':
b34976b6 3349 do_arch++;
a952a375 3350 break;
252b5132 3351 case 'D':
b34976b6 3352 do_using_dynamic++;
252b5132
RH		 3353 break;
3354 case 'r':
b34976b6 3355 do_reloc++;
252b5132 3356 break;
4d6ed7c8 3357 case 'u':
b34976b6 3358 do_unwind++;
4d6ed7c8 3359 break;
252b5132 3360 case 'h':
b34976b6 3361 do_header++;
252b5132
RH		 3362 break;
3363 case 'l':
b34976b6 3364 do_segments++;
252b5132
RH		 3365 break;
3366 case 's':
b34976b6 3367 do_syms++;
252b5132
RH		 3368 break;
3369 case 'S':
b34976b6 3370 do_sections++;
252b5132
RH		 3371 break;
3372 case 'd':
b34976b6 3373 do_dynamic++;
252b5132 3374 break;
a952a375 3375 case 'I':
b34976b6 3376 do_histogram++;
a952a375 3377 break;
779fe533 3378 case 'n':
b34976b6 3379 do_notes++;
779fe533 3380 break;
4145f1d5
NC		 3381 case 'c':
3382 do_archive_index++;
3383 break;
252b5132 3384 case 'x':
cf13d699 3385 request_dump (HEX_DUMP);
aef1f6d0 3386 break;
09c11c86 3387 case 'p':
cf13d699
NC		 3388 request_dump (STRING_DUMP);
3389 break;
3390 case 'R':
3391 request_dump (RELOC_DUMP);
09c11c86 3392 break;
252b5132 3393 case 'w':
b34976b6 3394 do_dump++;
252b5132 3395 if (optarg == 0)
613ff48b
CC		 3396 {
3397 do_debugging = 1;
3398 dwarf_select_sections_all ();
3399 }
252b5132
RH		 3400 else
3401 {
3402 do_debugging = 0;
4cb93e3b 3403 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 3404 }
3405 break;
2979dc34 3406 case OPTION_DEBUG_DUMP:
b34976b6 3407 do_dump++;
2979dc34
JJ		 3408 if (optarg == 0)
3409 do_debugging = 1;
3410 else
3411 {
2979dc34 3412 do_debugging = 0;
4cb93e3b 3413 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 3414 }
3415 break;
fd2f0033
TT		 3416 case OPTION_DWARF_DEPTH:
3417 {
3418 char *cp;
3419
3420 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3421 }
3422 break;
3423 case OPTION_DWARF_START:
3424 {
3425 char *cp;
3426
3427 dwarf_start_die = strtoul (optarg, & cp, 0);
3428 }
3429 break;
2c610e4b
L		 3430 case OPTION_DYN_SYMS:
3431 do_dyn_syms++;
3432 break;
252b5132
RH		 3433#ifdef SUPPORT_DISASSEMBLY
3434 case 'i':
cf13d699
NC		 3435 request_dump (DISASS_DUMP);
3436 break;
252b5132
RH		 3437#endif
3438 case 'v':
3439 print_version (program_name);
3440 break;
3441 case 'V':
b34976b6 3442 do_version++;
252b5132 3443 break;
d974e256 3444 case 'W':
b34976b6 3445 do_wide++;
d974e256 3446 break;
252b5132 3447 default:
252b5132
RH		 3448 /* xgettext:c-format */
3449 error (_("Invalid option '-%c'\n"), c);
3450 /* Drop through. */
3451 case '?':
92f01d61 3452 usage (stderr);
252b5132
RH		 3453 }
3454 }
3455
4d6ed7c8 3456 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 3457 && !do_segments && !do_header && !do_dump && !do_version
f5842774 3458 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 3459 && !do_section_groups && !do_archive_index
3460 && !do_dyn_syms)
92f01d61 3461 usage (stderr);
252b5132
RH		 3462 else if (argc < 3)
3463 {
3464 warn (_("Nothing to do.\n"));
92f01d61 3465 usage (stderr);
252b5132
RH		 3466 }
3467}
3468
3469static const char *
d3ba0551 3470get_elf_class (unsigned int elf_class)
252b5132 3471{
b34976b6 3472 static char buff[32];
103f02d3 3473
252b5132
RH		 3474 switch (elf_class)
3475 {
3476 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 3477 case ELFCLASS32: return "ELF32";
3478 case ELFCLASS64: return "ELF64";
ab5e7794 3479 default:
e9e44622 3480 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 3481 return buff;
252b5132
RH		 3482 }
3483}
3484
3485static const char *
d3ba0551 3486get_data_encoding (unsigned int encoding)
252b5132 3487{
b34976b6 3488 static char buff[32];
103f02d3 3489
252b5132
RH		 3490 switch (encoding)
3491 {
3492 case ELFDATANONE: return _("none");
33c63f9d
CM		 3493 case ELFDATA2LSB: return _("2's complement, little endian");
3494 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 3495 default:
e9e44622 3496 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 3497 return buff;
252b5132
RH		 3498 }
3499}
3500
252b5132 3501/* Decode the data held in 'elf_header'. */
ee42cf8c 3502
252b5132 3503static int
d3ba0551 3504process_file_header (void)
252b5132 3505{
b34976b6
AM		 3506 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3507 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3508 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3509 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 3510 {
3511 error
3512 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3513 return 0;
3514 }
3515
2dc4cec1
L		 3516 init_dwarf_regnames (elf_header.e_machine);
3517
252b5132
RH		 3518 if (do_header)
3519 {
3520 int i;
3521
3522 printf (_("ELF Header:\n"));
3523 printf (_(" Magic: "));
b34976b6
AM		 3524 for (i = 0; i < EI_NIDENT; i++)
3525 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 3526 printf ("\n");
3527 printf (_(" Class: %s\n"),
b34976b6 3528 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 3529 printf (_(" Data: %s\n"),
b34976b6 3530 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 3531 printf (_(" Version: %d %s\n"),
b34976b6
AM		 3532 elf_header.e_ident[EI_VERSION],
3533 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 3534 ? "(current)"
b34976b6 3535 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 3536 ? _("<unknown: %lx>")
789be9f7 3537 : "")));
252b5132 3538 printf (_(" OS/ABI: %s\n"),
b34976b6 3539 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 3540 printf (_(" ABI Version: %d\n"),
b34976b6 3541 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 3542 printf (_(" Type: %s\n"),
3543 get_file_type (elf_header.e_type));
3544 printf (_(" Machine: %s\n"),
3545 get_machine_name (elf_header.e_machine));
3546 printf (_(" Version: 0x%lx\n"),
3547 (unsigned long) elf_header.e_version);
76da6bbe 3548
f7a99963
NC		 3549 printf (_(" Entry point address: "));
3550 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3551 printf (_("\n Start of program headers: "));
3552 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3553 printf (_(" (bytes into file)\n Start of section headers: "));
3554 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3555 printf (_(" (bytes into file)\n"));
76da6bbe 3556
252b5132
RH		 3557 printf (_(" Flags: 0x%lx%s\n"),
3558 (unsigned long) elf_header.e_flags,
3559 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3560 printf (_(" Size of this header: %ld (bytes)\n"),
3561 (long) elf_header.e_ehsize);
3562 printf (_(" Size of program headers: %ld (bytes)\n"),
3563 (long) elf_header.e_phentsize);
2046a35d 3564 printf (_(" Number of program headers: %ld"),
252b5132 3565 (long) elf_header.e_phnum);
2046a35d
AM		 3566 if (section_headers != NULL
3567 && elf_header.e_phnum == PN_XNUM
3568 && section_headers[0].sh_info != 0)
cc5914eb 3569 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 3570 putc ('\n', stdout);
252b5132
RH		 3571 printf (_(" Size of section headers: %ld (bytes)\n"),
3572 (long) elf_header.e_shentsize);
560f3c1c 3573 printf (_(" Number of section headers: %ld"),
252b5132 3574 (long) elf_header.e_shnum);
4fbb74a6 3575 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 3576 printf (" (%ld)", (long) section_headers[0].sh_size);
3577 putc ('\n', stdout);
3578 printf (_(" Section header string table index: %ld"),
252b5132 3579 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 3580 if (section_headers != NULL
3581 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 3582 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 3583 else if (elf_header.e_shstrndx != SHN_UNDEF
3584 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 3585 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 3586 putc ('\n', stdout);
3587 }
3588
3589 if (section_headers != NULL)
3590 {
2046a35d
AM		 3591 if (elf_header.e_phnum == PN_XNUM
3592 && section_headers[0].sh_info != 0)
3593 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 3594 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 3595 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 3596 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 3597 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 3598 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 3599 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 3600 free (section_headers);
3601 section_headers = NULL;
252b5132 3602 }
103f02d3 3603
9ea033b2
NC		 3604 return 1;
3605}
3606
252b5132 3607
9ea033b2 3608static int
91d6fa6a 3609get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3610{
2cf0635d
NC		 3611 Elf32_External_Phdr * phdrs;
3612 Elf32_External_Phdr * external;
3613 Elf_Internal_Phdr * internal;
b34976b6 3614 unsigned int i;
103f02d3 3615
3f5e193b
NC		 3616 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3617 elf_header.e_phentsize,
3618 elf_header.e_phnum,
3619 _("program headers"));
a6e9f9df
AM		 3620 if (!phdrs)
3621 return 0;
9ea033b2 3622
91d6fa6a 3623 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3624 i < elf_header.e_phnum;
b34976b6 3625 i++, internal++, external++)
252b5132 3626 {
9ea033b2
NC		 3627 internal->p_type = BYTE_GET (external->p_type);
3628 internal->p_offset = BYTE_GET (external->p_offset);
3629 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3630 internal->p_paddr = BYTE_GET (external->p_paddr);
3631 internal->p_filesz = BYTE_GET (external->p_filesz);
3632 internal->p_memsz = BYTE_GET (external->p_memsz);
3633 internal->p_flags = BYTE_GET (external->p_flags);
3634 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 3635 }
3636
9ea033b2
NC		 3637 free (phdrs);
3638
252b5132
RH		 3639 return 1;
3640}
3641
9ea033b2 3642static int
91d6fa6a 3643get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3644{
2cf0635d
NC		 3645 Elf64_External_Phdr * phdrs;
3646 Elf64_External_Phdr * external;
3647 Elf_Internal_Phdr * internal;
b34976b6 3648 unsigned int i;
103f02d3 3649
3f5e193b
NC		 3650 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3651 elf_header.e_phentsize,
3652 elf_header.e_phnum,
3653 _("program headers"));
a6e9f9df
AM		 3654 if (!phdrs)
3655 return 0;
9ea033b2 3656
91d6fa6a 3657 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3658 i < elf_header.e_phnum;
b34976b6 3659 i++, internal++, external++)
9ea033b2
NC		 3660 {
3661 internal->p_type = BYTE_GET (external->p_type);
3662 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 3663 internal->p_offset = BYTE_GET (external->p_offset);
3664 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3665 internal->p_paddr = BYTE_GET (external->p_paddr);
3666 internal->p_filesz = BYTE_GET (external->p_filesz);
3667 internal->p_memsz = BYTE_GET (external->p_memsz);
3668 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 3669 }
3670
3671 free (phdrs);
3672
3673 return 1;
3674}
252b5132 3675
d93f0186
NC		 3676/* Returns 1 if the program headers were read into `program_headers'. */
3677
3678static int
2cf0635d 3679get_program_headers (FILE * file)
d93f0186 3680{
2cf0635d 3681 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 3682
3683 /* Check cache of prior read. */
3684 if (program_headers != NULL)
3685 return 1;
3686
3f5e193b
NC		 3687 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3688 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 3689
3690 if (phdrs == NULL)
3691 {
3692 error (_("Out of memory\n"));
3693 return 0;
3694 }
3695
3696 if (is_32bit_elf
3697 ? get_32bit_program_headers (file, phdrs)
3698 : get_64bit_program_headers (file, phdrs))
3699 {
3700 program_headers = phdrs;
3701 return 1;
3702 }
3703
3704 free (phdrs);
3705 return 0;
3706}
3707
2f62977e
NC		 3708/* Returns 1 if the program headers were loaded. */
3709
252b5132 3710static int
2cf0635d 3711process_program_headers (FILE * file)
252b5132 3712{
2cf0635d 3713 Elf_Internal_Phdr * segment;
b34976b6 3714 unsigned int i;
252b5132
RH		 3715
3716 if (elf_header.e_phnum == 0)
3717 {
82f2dbf7
NC		 3718 /* PR binutils/12467. */
3719 if (elf_header.e_phoff != 0)
3720 warn (_("possibly corrupt ELF header - it has a non-zero program"
3721 " header offset, but no program headers"));
3722 else if (do_segments)
252b5132 3723 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 3724 return 0;
252b5132
RH		 3725 }
3726
3727 if (do_segments && !do_header)
3728 {
f7a99963
NC		 3729 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3730 printf (_("Entry point "));
3731 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3732 printf (_("\nThere are %d program headers, starting at offset "),
3733 elf_header.e_phnum);
3734 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3735 printf ("\n");
252b5132
RH		 3736 }
3737
d93f0186 3738 if (! get_program_headers (file))
252b5132 3739 return 0;
103f02d3 3740
252b5132
RH		 3741 if (do_segments)
3742 {
3a1a2036
NC		 3743 if (elf_header.e_phnum > 1)
3744 printf (_("\nProgram Headers:\n"));
3745 else
3746 printf (_("\nProgram Headers:\n"));
76da6bbe 3747
f7a99963
NC		 3748 if (is_32bit_elf)
3749 printf
3750 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 3751 else if (do_wide)
3752 printf
3753 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 3754 else
3755 {
3756 printf
3757 (_(" Type Offset VirtAddr PhysAddr\n"));
3758 printf
3759 (_(" FileSiz MemSiz Flags Align\n"));
3760 }
252b5132
RH		 3761 }
3762
252b5132 3763 dynamic_addr = 0;
1b228002 3764 dynamic_size = 0;
252b5132
RH		 3765
3766 for (i = 0, segment = program_headers;
3767 i < elf_header.e_phnum;
b34976b6 3768 i++, segment++)
252b5132
RH		 3769 {
3770 if (do_segments)
3771 {
103f02d3 3772 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 3773
3774 if (is_32bit_elf)
3775 {
3776 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3777 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3778 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3779 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3780 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3781 printf ("%c%c%c ",
3782 (segment->p_flags & PF_R ? 'R' : ' '),
3783 (segment->p_flags & PF_W ? 'W' : ' '),
3784 (segment->p_flags & PF_X ? 'E' : ' '));
3785 printf ("%#lx", (unsigned long) segment->p_align);
3786 }
d974e256
JJ		 3787 else if (do_wide)
3788 {
3789 if ((unsigned long) segment->p_offset == segment->p_offset)
3790 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3791 else
3792 {
3793 print_vma (segment->p_offset, FULL_HEX);
3794 putchar (' ');
3795 }
3796
3797 print_vma (segment->p_vaddr, FULL_HEX);
3798 putchar (' ');
3799 print_vma (segment->p_paddr, FULL_HEX);
3800 putchar (' ');
3801
3802 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3803 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3804 else
3805 {
3806 print_vma (segment->p_filesz, FULL_HEX);
3807 putchar (' ');
3808 }
3809
3810 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3811 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3812 else
3813 {
f48e6c45 3814 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 3815 }
3816
3817 printf (" %c%c%c ",
3818 (segment->p_flags & PF_R ? 'R' : ' '),
3819 (segment->p_flags & PF_W ? 'W' : ' '),
3820 (segment->p_flags & PF_X ? 'E' : ' '));
3821
3822 if ((unsigned long) segment->p_align == segment->p_align)
3823 printf ("%#lx", (unsigned long) segment->p_align);
3824 else
3825 {
3826 print_vma (segment->p_align, PREFIX_HEX);
3827 }
3828 }
f7a99963
NC		 3829 else
3830 {
3831 print_vma (segment->p_offset, FULL_HEX);
3832 putchar (' ');
3833 print_vma (segment->p_vaddr, FULL_HEX);
3834 putchar (' ');
3835 print_vma (segment->p_paddr, FULL_HEX);
3836 printf ("\n ");
3837 print_vma (segment->p_filesz, FULL_HEX);
3838 putchar (' ');
3839 print_vma (segment->p_memsz, FULL_HEX);
3840 printf (" %c%c%c ",
3841 (segment->p_flags & PF_R ? 'R' : ' '),
3842 (segment->p_flags & PF_W ? 'W' : ' '),
3843 (segment->p_flags & PF_X ? 'E' : ' '));
3844 print_vma (segment->p_align, HEX);
3845 }
252b5132
RH		 3846 }
3847
3848 switch (segment->p_type)
3849 {
252b5132
RH		 3850 case PT_DYNAMIC:
3851 if (dynamic_addr)
3852 error (_("more than one dynamic segment\n"));
3853
20737c13
AM		 3854 /* By default, assume that the .dynamic section is the first
3855 section in the DYNAMIC segment. */
3856 dynamic_addr = segment->p_offset;
3857 dynamic_size = segment->p_filesz;
3858
b2d38a17
NC		 3859 /* Try to locate the .dynamic section. If there is
3860 a section header table, we can easily locate it. */
3861 if (section_headers != NULL)
3862 {
2cf0635d 3863 Elf_Internal_Shdr * sec;
b2d38a17 3864
89fac5e3
RS		 3865 sec = find_section (".dynamic");
3866 if (sec == NULL || sec->sh_size == 0)
b2d38a17 3867 {
28f997cf
TG		 3868 /* A corresponding .dynamic section is expected, but on
3869 IA-64/OpenVMS it is OK for it to be missing. */
3870 if (!is_ia64_vms ())
3871 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 3872 break;
3873 }
3874
42bb2e33 3875 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 3876 {
3877 dynamic_size = 0;
3878 break;
3879 }
42bb2e33 3880
b2d38a17
NC		 3881 dynamic_addr = sec->sh_offset;
3882 dynamic_size = sec->sh_size;
3883
3884 if (dynamic_addr < segment->p_offset
3885 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 3886 warn (_("the .dynamic section is not contained"
3887 " within the dynamic segment\n"));
b2d38a17 3888 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 3889 warn (_("the .dynamic section is not the first section"
3890 " in the dynamic segment.\n"));
b2d38a17 3891 }
252b5132
RH		 3892 break;
3893
3894 case PT_INTERP:
fb52b2f4
NC		 3895 if (fseek (file, archive_file_offset + (long) segment->p_offset,
3896 SEEK_SET))
252b5132
RH		 3897 error (_("Unable to find program interpreter name\n"));
3898 else
3899 {
f8eae8b2
L		 3900 char fmt [32];
3901 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
3902
3903 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 3904 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 3905
252b5132 3906 program_interpreter[0] = 0;
7bd7b3ef
AM		 3907 if (fscanf (file, fmt, program_interpreter) <= 0)
3908 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 3909
3910 if (do_segments)
3911 printf (_("\n [Requesting program interpreter: %s]"),
3912 program_interpreter);
3913 }
3914 break;
3915 }
3916
3917 if (do_segments)
3918 putc ('\n', stdout);
3919 }
3920
c256ffe7 3921 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 3922 {
3923 printf (_("\n Section to Segment mapping:\n"));
3924 printf (_(" Segment Sections...\n"));
3925
252b5132
RH		 3926 for (i = 0; i < elf_header.e_phnum; i++)
3927 {
9ad5cbcf 3928 unsigned int j;
2cf0635d 3929 Elf_Internal_Shdr * section;
252b5132
RH		 3930
3931 segment = program_headers + i;
b391a3e3 3932 section = section_headers + 1;
252b5132
RH		 3933
3934 printf (" %2.2d ", i);
3935
b34976b6 3936 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 3937 {
f4638467
AM		 3938 if (!ELF_TBSS_SPECIAL (section, segment)
3939 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
252b5132
RH		 3940 printf ("%s ", SECTION_NAME (section));
3941 }
3942
3943 putc ('\n',stdout);
3944 }
3945 }
3946
252b5132
RH		 3947 return 1;
3948}
3949
3950
d93f0186
NC		 3951/* Find the file offset corresponding to VMA by using the program headers. */
3952
3953static long
2cf0635d 3954offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 3955{
2cf0635d 3956 Elf_Internal_Phdr * seg;
d93f0186
NC		 3957
3958 if (! get_program_headers (file))
3959 {
3960 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3961 return (long) vma;
3962 }
3963
3964 for (seg = program_headers;
3965 seg < program_headers + elf_header.e_phnum;
3966 ++seg)
3967 {
3968 if (seg->p_type != PT_LOAD)
3969 continue;
3970
3971 if (vma >= (seg->p_vaddr & -seg->p_align)
3972 && vma + size <= seg->p_vaddr + seg->p_filesz)
3973 return vma - seg->p_vaddr + seg->p_offset;
3974 }
3975
3976 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 3977 (unsigned long) vma);
d93f0186
NC		 3978 return (long) vma;
3979}
3980
3981
252b5132 3982static int
2cf0635d 3983get_32bit_section_headers (FILE * file, unsigned int num)
252b5132 3984{
2cf0635d
NC		 3985 Elf32_External_Shdr * shdrs;
3986 Elf_Internal_Shdr * internal;
b34976b6 3987 unsigned int i;
252b5132 3988
3f5e193b
NC		 3989 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
3990 elf_header.e_shentsize, num,
3991 _("section headers"));
a6e9f9df
AM		 3992 if (!shdrs)
3993 return 0;
252b5132 3994
3f5e193b
NC		 3995 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
3996 sizeof (Elf_Internal_Shdr));
252b5132
RH		 3997
3998 if (section_headers == NULL)
3999 {
4000 error (_("Out of memory\n"));
4001 return 0;
4002 }
4003
4004 for (i = 0, internal = section_headers;
560f3c1c 4005 i < num;
b34976b6 4006 i++, internal++)
252b5132
RH		 4007 {
4008 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4009 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4010 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4011 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4012 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4013 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4014 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4015 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4016 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4017 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4018 }
4019
4020 free (shdrs);
4021
4022 return 1;
4023}
4024
9ea033b2 4025static int
2cf0635d 4026get_64bit_section_headers (FILE * file, unsigned int num)
9ea033b2 4027{
2cf0635d
NC		 4028 Elf64_External_Shdr * shdrs;
4029 Elf_Internal_Shdr * internal;
b34976b6 4030 unsigned int i;
9ea033b2 4031
3f5e193b
NC		 4032 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4033 elf_header.e_shentsize, num,
4034 _("section headers"));
a6e9f9df
AM		 4035 if (!shdrs)
4036 return 0;
9ea033b2 4037
3f5e193b
NC		 4038 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4039 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4040
4041 if (section_headers == NULL)
4042 {
4043 error (_("Out of memory\n"));
4044 return 0;
4045 }
4046
4047 for (i = 0, internal = section_headers;
560f3c1c 4048 i < num;
b34976b6 4049 i++, internal++)
9ea033b2
NC		 4050 {
4051 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4052 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4053 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4054 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4055 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4056 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4057 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4058 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4059 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4060 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4061 }
4062
4063 free (shdrs);
4064
4065 return 1;
4066}
4067
252b5132 4068static Elf_Internal_Sym *
ba5cdace
NC		 4069get_32bit_elf_symbols (FILE * file,
4070 Elf_Internal_Shdr * section,
4071 unsigned long * num_syms_return)
252b5132 4072{
ba5cdace 4073 unsigned long number = 0;
dd24e3da 4074 Elf32_External_Sym * esyms = NULL;
ba5cdace 4075 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 4076 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4077 Elf_Internal_Sym * psym;
b34976b6 4078 unsigned int j;
252b5132 4079
dd24e3da
NC		 4080 /* Run some sanity checks first. */
4081 if (section->sh_entsize == 0)
4082 {
4083 error (_("sh_entsize is zero\n"));
ba5cdace 4084 goto exit_point;
dd24e3da
NC		 4085 }
4086
4087 number = section->sh_size / section->sh_entsize;
4088
4089 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4090 {
4091 error (_("Invalid sh_entsize\n"));
ba5cdace 4092 goto exit_point;
dd24e3da
NC		 4093 }
4094
3f5e193b
NC		 4095 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4096 section->sh_size, _("symbols"));
dd24e3da 4097 if (esyms == NULL)
ba5cdace 4098 goto exit_point;
252b5132 4099
9ad5cbcf
AM		 4100 shndx = NULL;
4101 if (symtab_shndx_hdr != NULL
4102 && (symtab_shndx_hdr->sh_link
4fbb74a6 4103 == (unsigned long) (section - section_headers)))
9ad5cbcf 4104 {
3f5e193b
NC		 4105 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4106 symtab_shndx_hdr->sh_offset,
4107 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4108 _("symbol table section indicies"));
dd24e3da
NC		 4109 if (shndx == NULL)
4110 goto exit_point;
9ad5cbcf
AM		 4111 }
4112
3f5e193b 4113 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 4114
4115 if (isyms == NULL)
4116 {
4117 error (_("Out of memory\n"));
dd24e3da 4118 goto exit_point;
252b5132
RH		 4119 }
4120
dd24e3da 4121 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 4122 {
4123 psym->st_name = BYTE_GET (esyms[j].st_name);
4124 psym->st_value = BYTE_GET (esyms[j].st_value);
4125 psym->st_size = BYTE_GET (esyms[j].st_size);
4126 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4127 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4128 psym->st_shndx
4129 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4130 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4131 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 4132 psym->st_info = BYTE_GET (esyms[j].st_info);
4133 psym->st_other = BYTE_GET (esyms[j].st_other);
4134 }
4135
dd24e3da 4136 exit_point:
ba5cdace 4137 if (shndx != NULL)
9ad5cbcf 4138 free (shndx);
ba5cdace 4139 if (esyms != NULL)
dd24e3da 4140 free (esyms);
252b5132 4141
ba5cdace
NC		 4142 if (num_syms_return != NULL)
4143 * num_syms_return = isyms == NULL ? 0 : number;
4144
252b5132
RH		 4145 return isyms;
4146}
4147
9ea033b2 4148static Elf_Internal_Sym *
ba5cdace
NC		 4149get_64bit_elf_symbols (FILE * file,
4150 Elf_Internal_Shdr * section,
4151 unsigned long * num_syms_return)
9ea033b2 4152{
ba5cdace
NC		 4153 unsigned long number = 0;
4154 Elf64_External_Sym * esyms = NULL;
4155 Elf_External_Sym_Shndx * shndx = NULL;
4156 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4157 Elf_Internal_Sym * psym;
b34976b6 4158 unsigned int j;
9ea033b2 4159
dd24e3da
NC		 4160 /* Run some sanity checks first. */
4161 if (section->sh_entsize == 0)
4162 {
4163 error (_("sh_entsize is zero\n"));
ba5cdace 4164 goto exit_point;
dd24e3da
NC		 4165 }
4166
4167 number = section->sh_size / section->sh_entsize;
4168
4169 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4170 {
4171 error (_("Invalid sh_entsize\n"));
ba5cdace 4172 goto exit_point;
dd24e3da
NC		 4173 }
4174
3f5e193b
NC		 4175 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4176 section->sh_size, _("symbols"));
a6e9f9df 4177 if (!esyms)
ba5cdace 4178 goto exit_point;
9ea033b2 4179
9ad5cbcf
AM		 4180 if (symtab_shndx_hdr != NULL
4181 && (symtab_shndx_hdr->sh_link
4fbb74a6 4182 == (unsigned long) (section - section_headers)))
9ad5cbcf 4183 {
3f5e193b
NC		 4184 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4185 symtab_shndx_hdr->sh_offset,
4186 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4187 _("symbol table section indicies"));
ba5cdace
NC		 4188 if (shndx == NULL)
4189 goto exit_point;
9ad5cbcf
AM		 4190 }
4191
3f5e193b 4192 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 4193
4194 if (isyms == NULL)
4195 {
4196 error (_("Out of memory\n"));
ba5cdace 4197 goto exit_point;
9ea033b2
NC		 4198 }
4199
ba5cdace 4200 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 4201 {
4202 psym->st_name = BYTE_GET (esyms[j].st_name);
4203 psym->st_info = BYTE_GET (esyms[j].st_info);
4204 psym->st_other = BYTE_GET (esyms[j].st_other);
4205 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 4206
4fbb74a6 4207 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4208 psym->st_shndx
4209 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4210 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4211 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 4212
66543521
AM		 4213 psym->st_value = BYTE_GET (esyms[j].st_value);
4214 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 4215 }
4216
ba5cdace
NC		 4217 exit_point:
4218 if (shndx != NULL)
9ad5cbcf 4219 free (shndx);
ba5cdace
NC		 4220 if (esyms != NULL)
4221 free (esyms);
4222
4223 if (num_syms_return != NULL)
4224 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 4225
4226 return isyms;
4227}
4228
d1133906 4229static const char *
d3ba0551 4230get_elf_section_flags (bfd_vma sh_flags)
d1133906 4231{
5477e8a0 4232 static char buff[1024];
2cf0635d 4233 char * p = buff;
8d5ff12c 4234 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 4235 int sindex;
4236 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 4237 bfd_vma os_flags = 0;
4238 bfd_vma proc_flags = 0;
4239 bfd_vma unknown_flags = 0;
148b93f2 4240 static const struct
5477e8a0 4241 {
2cf0635d 4242 const char * str;
5477e8a0
L		 4243 int len;
4244 }
4245 flags [] =
4246 {
cfcac11d
NC		 4247 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4248 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4249 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4250 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4251 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4252 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4253 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4254 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4255 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4256 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4257 /* IA-64 specific. */
4258 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4259 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4260 /* IA-64 OpenVMS specific. */
4261 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4262 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4263 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4264 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4265 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4266 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 4267 /* Generic. */
cfcac11d 4268 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 4269 /* SPARC specific. */
cfcac11d 4270 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5477e8a0
L		 4271 };
4272
4273 if (do_section_details)
4274 {
8d5ff12c
L		 4275 sprintf (buff, "[%*.*lx]: ",
4276 field_size, field_size, (unsigned long) sh_flags);
4277 p += field_size + 4;
5477e8a0 4278 }
76da6bbe 4279
d1133906
NC		 4280 while (sh_flags)
4281 {
4282 bfd_vma flag;
4283
4284 flag = sh_flags & - sh_flags;
4285 sh_flags &= ~ flag;
76da6bbe 4286
5477e8a0 4287 if (do_section_details)
d1133906 4288 {
5477e8a0
L		 4289 switch (flag)
4290 {
91d6fa6a
NC		 4291 case SHF_WRITE: sindex = 0; break;
4292 case SHF_ALLOC: sindex = 1; break;
4293 case SHF_EXECINSTR: sindex = 2; break;
4294 case SHF_MERGE: sindex = 3; break;
4295 case SHF_STRINGS: sindex = 4; break;
4296 case SHF_INFO_LINK: sindex = 5; break;
4297 case SHF_LINK_ORDER: sindex = 6; break;
4298 case SHF_OS_NONCONFORMING: sindex = 7; break;
4299 case SHF_GROUP: sindex = 8; break;
4300 case SHF_TLS: sindex = 9; break;
18ae9cc1 4301 case SHF_EXCLUDE: sindex = 18; break;
76da6bbe 4302
5477e8a0 4303 default:
91d6fa6a 4304 sindex = -1;
cfcac11d 4305 switch (elf_header.e_machine)
148b93f2 4306 {
cfcac11d 4307 case EM_IA_64:
148b93f2 4308 if (flag == SHF_IA_64_SHORT)
91d6fa6a 4309 sindex = 10;
148b93f2 4310 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 4311 sindex = 11;
148b93f2
NC		 4312#ifdef BFD64
4313 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4314 switch (flag)
4315 {
91d6fa6a
NC		 4316 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4317 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4318 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4319 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4320 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4321 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 4322 default: break;
4323 }
4324#endif
cfcac11d
NC		 4325 break;
4326
caa83f8b
NC		 4327 case EM_386:
4328 case EM_486:
4329 case EM_X86_64:
7f502d6c 4330 case EM_L1OM:
7a9068fe 4331 case EM_K1OM:
cfcac11d
NC		 4332 case EM_OLD_SPARCV9:
4333 case EM_SPARC32PLUS:
4334 case EM_SPARCV9:
4335 case EM_SPARC:
18ae9cc1 4336 if (flag == SHF_ORDERED)
91d6fa6a 4337 sindex = 19;
cfcac11d
NC		 4338 break;
4339 default:
4340 break;
148b93f2 4341 }
5477e8a0
L		 4342 }
4343
91d6fa6a 4344 if (sindex != -1)
5477e8a0 4345 {
8d5ff12c
L		 4346 if (p != buff + field_size + 4)
4347 {
4348 if (size < (10 + 2))
4349 abort ();
4350 size -= 2;
4351 *p++ = ',';
4352 *p++ = ' ';
4353 }
4354
91d6fa6a
NC		 4355 size -= flags [sindex].len;
4356 p = stpcpy (p, flags [sindex].str);
5477e8a0 4357 }
3b22753a 4358 else if (flag & SHF_MASKOS)
8d5ff12c 4359 os_flags |= flag;
d1133906 4360 else if (flag & SHF_MASKPROC)
8d5ff12c 4361 proc_flags |= flag;
d1133906 4362 else
8d5ff12c 4363 unknown_flags |= flag;
5477e8a0
L		 4364 }
4365 else
4366 {
4367 switch (flag)
4368 {
4369 case SHF_WRITE: *p = 'W'; break;
4370 case SHF_ALLOC: *p = 'A'; break;
4371 case SHF_EXECINSTR: *p = 'X'; break;
4372 case SHF_MERGE: *p = 'M'; break;
4373 case SHF_STRINGS: *p = 'S'; break;
4374 case SHF_INFO_LINK: *p = 'I'; break;
4375 case SHF_LINK_ORDER: *p = 'L'; break;
4376 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4377 case SHF_GROUP: *p = 'G'; break;
4378 case SHF_TLS: *p = 'T'; break;
18ae9cc1 4379 case SHF_EXCLUDE: *p = 'E'; break;
5477e8a0
L		 4380
4381 default:
8a9036a4 4382 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 4383 || elf_header.e_machine == EM_L1OM
4384 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 4385 && flag == SHF_X86_64_LARGE)
4386 *p = 'l';
4387 else if (flag & SHF_MASKOS)
4388 {
4389 *p = 'o';
4390 sh_flags &= ~ SHF_MASKOS;
4391 }
4392 else if (flag & SHF_MASKPROC)
4393 {
4394 *p = 'p';
4395 sh_flags &= ~ SHF_MASKPROC;
4396 }
4397 else
4398 *p = 'x';
4399 break;
4400 }
4401 p++;
d1133906
NC		 4402 }
4403 }
76da6bbe 4404
8d5ff12c
L		 4405 if (do_section_details)
4406 {
4407 if (os_flags)
4408 {
4409 size -= 5 + field_size;
4410 if (p != buff + field_size + 4)
4411 {
4412 if (size < (2 + 1))
4413 abort ();
4414 size -= 2;
4415 *p++ = ',';
4416 *p++ = ' ';
4417 }
4418 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4419 (unsigned long) os_flags);
4420 p += 5 + field_size;
4421 }
4422 if (proc_flags)
4423 {
4424 size -= 7 + field_size;
4425 if (p != buff + field_size + 4)
4426 {
4427 if (size < (2 + 1))
4428 abort ();
4429 size -= 2;
4430 *p++ = ',';
4431 *p++ = ' ';
4432 }
4433 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4434 (unsigned long) proc_flags);
4435 p += 7 + field_size;
4436 }
4437 if (unknown_flags)
4438 {
4439 size -= 10 + field_size;
4440 if (p != buff + field_size + 4)
4441 {
4442 if (size < (2 + 1))
4443 abort ();
4444 size -= 2;
4445 *p++ = ',';
4446 *p++ = ' ';
4447 }
2b692964 4448 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 4449 (unsigned long) unknown_flags);
4450 p += 10 + field_size;
4451 }
4452 }
4453
e9e44622 4454 *p = '\0';
d1133906
NC		 4455 return buff;
4456}
4457
252b5132 4458static int
2cf0635d 4459process_section_headers (FILE * file)
252b5132 4460{
2cf0635d 4461 Elf_Internal_Shdr * section;
b34976b6 4462 unsigned int i;
252b5132
RH		 4463
4464 section_headers = NULL;
4465
4466 if (elf_header.e_shnum == 0)
4467 {
82f2dbf7
NC		 4468 /* PR binutils/12467. */
4469 if (elf_header.e_shoff != 0)
4470 warn (_("possibly corrupt ELF file header - it has a non-zero"
4471 " section header offset, but no section headers\n"));
4472 else if (do_sections)
252b5132
RH		 4473 printf (_("\nThere are no sections in this file.\n"));
4474
4475 return 1;
4476 }
4477
4478 if (do_sections && !do_header)
9ea033b2 4479 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 4480 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4481
9ea033b2
NC		 4482 if (is_32bit_elf)
4483 {
560f3c1c 4484 if (! get_32bit_section_headers (file, elf_header.e_shnum))
9ea033b2
NC		 4485 return 0;
4486 }
560f3c1c 4487 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
252b5132
RH		 4488 return 0;
4489
4490 /* Read in the string table, so that we have names to display. */
0b49d371 4491 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 4492 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 4493 {
4fbb74a6 4494 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 4495
c256ffe7
JJ		 4496 if (section->sh_size != 0)
4497 {
3f5e193b
NC		 4498 string_table = (char *) get_data (NULL, file, section->sh_offset,
4499 1, section->sh_size,
4500 _("string table"));
0de14b54 4501
c256ffe7
JJ		 4502 string_table_length = string_table != NULL ? section->sh_size : 0;
4503 }
252b5132
RH		 4504 }
4505
4506 /* Scan the sections for the dynamic symbol table
e3c8793a 4507 and dynamic string table and debug sections. */
252b5132
RH		 4508 dynamic_symbols = NULL;
4509 dynamic_strings = NULL;
4510 dynamic_syminfo = NULL;
f1ef08cb 4511 symtab_shndx_hdr = NULL;
103f02d3 4512
89fac5e3
RS		 4513 eh_addr_size = is_32bit_elf ? 4 : 8;
4514 switch (elf_header.e_machine)
4515 {
4516 case EM_MIPS:
4517 case EM_MIPS_RS3_LE:
4518 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4519 FDE addresses. However, the ABI also has a semi-official ILP32
4520 variant for which the normal FDE address size rules apply.
4521
4522 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4523 section, where XX is the size of longs in bits. Unfortunately,
4524 earlier compilers provided no way of distinguishing ILP32 objects
4525 from LP64 objects, so if there's any doubt, we should assume that
4526 the official LP64 form is being used. */
4527 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4528 && find_section (".gcc_compiled_long32") == NULL)
4529 eh_addr_size = 8;
4530 break;
0f56a26a
DD		 4531
4532 case EM_H8_300:
4533 case EM_H8_300H:
4534 switch (elf_header.e_flags & EF_H8_MACH)
4535 {
4536 case E_H8_MACH_H8300:
4537 case E_H8_MACH_H8300HN:
4538 case E_H8_MACH_H8300SN:
4539 case E_H8_MACH_H8300SXN:
4540 eh_addr_size = 2;
4541 break;
4542 case E_H8_MACH_H8300H:
4543 case E_H8_MACH_H8300S:
4544 case E_H8_MACH_H8300SX:
4545 eh_addr_size = 4;
4546 break;
4547 }
f4236fe4
DD		 4548 break;
4549
ff7eeb89 4550 case EM_M32C_OLD:
f4236fe4
DD		 4551 case EM_M32C:
4552 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4553 {
4554 case EF_M32C_CPU_M16C:
4555 eh_addr_size = 2;
4556 break;
4557 }
4558 break;
89fac5e3
RS		 4559 }
4560
08d8fa11
JJ		 4561#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4562 do \
4563 { \
4564 size_t expected_entsize \
4565 = is_32bit_elf ? size32 : size64; \
4566 if (section->sh_entsize != expected_entsize) \
4567 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4568 i, (unsigned long int) section->sh_entsize, \
4569 (unsigned long int) expected_entsize); \
4570 section->sh_entsize = expected_entsize; \
4571 } \
4572 while (0)
4573#define CHECK_ENTSIZE(section, i, type) \
4574 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4575 sizeof (Elf64_External_##type))
4576
252b5132
RH		 4577 for (i = 0, section = section_headers;
4578 i < elf_header.e_shnum;
b34976b6 4579 i++, section++)
252b5132 4580 {
2cf0635d 4581 char * name = SECTION_NAME (section);
252b5132
RH		 4582
4583 if (section->sh_type == SHT_DYNSYM)
4584 {
4585 if (dynamic_symbols != NULL)
4586 {
4587 error (_("File contains multiple dynamic symbol tables\n"));
4588 continue;
4589 }
4590
08d8fa11 4591 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 4592 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 4593 }
4594 else if (section->sh_type == SHT_STRTAB
18bd398b 4595 && streq (name, ".dynstr"))
252b5132
RH		 4596 {
4597 if (dynamic_strings != NULL)
4598 {
4599 error (_("File contains multiple dynamic string tables\n"));
4600 continue;
4601 }
4602
3f5e193b
NC		 4603 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4604 1, section->sh_size,
4605 _("dynamic strings"));
59245841 4606 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 4607 }
9ad5cbcf
AM		 4608 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4609 {
4610 if (symtab_shndx_hdr != NULL)
4611 {
4612 error (_("File contains multiple symtab shndx tables\n"));
4613 continue;
4614 }
4615 symtab_shndx_hdr = section;
4616 }
08d8fa11
JJ		 4617 else if (section->sh_type == SHT_SYMTAB)
4618 CHECK_ENTSIZE (section, i, Sym);
4619 else if (section->sh_type == SHT_GROUP)
4620 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4621 else if (section->sh_type == SHT_REL)
4622 CHECK_ENTSIZE (section, i, Rel);
4623 else if (section->sh_type == SHT_RELA)
4624 CHECK_ENTSIZE (section, i, Rela);
252b5132 4625 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 4626 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 4627 || do_debug_aranges || do_debug_frames || do_debug_macinfo
a262ae96 4628 || do_debug_str || do_debug_loc || do_debug_ranges)
1b315056
CS		 4629 && (const_strneq (name, ".debug_")
4630 || const_strneq (name, ".zdebug_")))
252b5132 4631 {
1b315056
CS		 4632 if (name[1] == 'z')
4633 name += sizeof (".zdebug_") - 1;
4634 else
4635 name += sizeof (".debug_") - 1;
252b5132
RH		 4636
4637 if (do_debugging
18bd398b 4638 || (do_debug_info && streq (name, "info"))
2b6f5997 4639 || (do_debug_info && streq (name, "types"))
18bd398b 4640 || (do_debug_abbrevs && streq (name, "abbrev"))
4cb93e3b 4641 || (do_debug_lines && streq (name, "line"))
18bd398b 4642 || (do_debug_pubnames && streq (name, "pubnames"))
f9f0e732 4643 || (do_debug_pubtypes && streq (name, "pubtypes"))
18bd398b
NC		 4644 || (do_debug_aranges && streq (name, "aranges"))
4645 || (do_debug_ranges && streq (name, "ranges"))
4646 || (do_debug_frames && streq (name, "frame"))
4647 || (do_debug_macinfo && streq (name, "macinfo"))
4ccf1e31 4648 || (do_debug_macinfo && streq (name, "macro"))
18bd398b
NC		 4649 || (do_debug_str && streq (name, "str"))
4650 || (do_debug_loc && streq (name, "loc"))
252b5132 4651 )
09c11c86 4652 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 4653 }
a262ae96 4654 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 4655 else if ((do_debugging || do_debug_info)
0112cd26 4656 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 4657 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 4658 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 4659 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 4660 else if (do_gdb_index && streq (name, ".gdb_index"))
4661 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 4662 /* Trace sections for Itanium VMS. */
4663 else if ((do_debugging || do_trace_info || do_trace_abbrevs
4664 || do_trace_aranges)
4665 && const_strneq (name, ".trace_"))
4666 {
4667 name += sizeof (".trace_") - 1;
4668
4669 if (do_debugging
4670 || (do_trace_info && streq (name, "info"))
4671 || (do_trace_abbrevs && streq (name, "abbrev"))
4672 || (do_trace_aranges && streq (name, "aranges"))
4673 )
4674 request_dump_bynumber (i, DEBUG_DUMP);
4675 }
4676
252b5132
RH		 4677 }
4678
4679 if (! do_sections)
4680 return 1;
4681
3a1a2036
NC		 4682 if (elf_header.e_shnum > 1)
4683 printf (_("\nSection Headers:\n"));
4684 else
4685 printf (_("\nSection Header:\n"));
76da6bbe 4686
f7a99963 4687 if (is_32bit_elf)
595cf52e 4688 {
5477e8a0 4689 if (do_section_details)
595cf52e
L		 4690 {
4691 printf (_(" [Nr] Name\n"));
5477e8a0 4692 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 4693 }
4694 else
4695 printf
4696 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4697 }
d974e256 4698 else if (do_wide)
595cf52e 4699 {
5477e8a0 4700 if (do_section_details)
595cf52e
L		 4701 {
4702 printf (_(" [Nr] Name\n"));
5477e8a0 4703 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 4704 }
4705 else
4706 printf
4707 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4708 }
f7a99963
NC		 4709 else
4710 {
5477e8a0 4711 if (do_section_details)
595cf52e
L		 4712 {
4713 printf (_(" [Nr] Name\n"));
5477e8a0
L		 4714 printf (_(" Type Address Offset Link\n"));
4715 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 4716 }
4717 else
4718 {
4719 printf (_(" [Nr] Name Type Address Offset\n"));
4720 printf (_(" Size EntSize Flags Link Info Align\n"));
4721 }
f7a99963 4722 }
252b5132 4723
5477e8a0
L		 4724 if (do_section_details)
4725 printf (_(" Flags\n"));
4726
252b5132
RH		 4727 for (i = 0, section = section_headers;
4728 i < elf_header.e_shnum;
b34976b6 4729 i++, section++)
252b5132 4730 {
5477e8a0 4731 if (do_section_details)
595cf52e
L		 4732 {
4733 printf (" [%2u] %s\n",
4fbb74a6 4734 i,
595cf52e
L		 4735 SECTION_NAME (section));
4736 if (is_32bit_elf || do_wide)
4737 printf (" %-15.15s ",
4738 get_section_type_name (section->sh_type));
4739 }
4740 else
b9eb56c1
NC		 4741 printf ((do_wide ? " [%2u] %-17s %-15s "
4742 : " [%2u] %-17.17s %-15.15s "),
4fbb74a6 4743 i,
595cf52e
L		 4744 SECTION_NAME (section),
4745 get_section_type_name (section->sh_type));
252b5132 4746
f7a99963
NC		 4747 if (is_32bit_elf)
4748 {
cfcac11d
NC		 4749 const char * link_too_big = NULL;
4750
f7a99963 4751 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 4752
f7a99963
NC		 4753 printf ( " %6.6lx %6.6lx %2.2lx",
4754 (unsigned long) section->sh_offset,
4755 (unsigned long) section->sh_size,
4756 (unsigned long) section->sh_entsize);
d1133906 4757
5477e8a0
L		 4758 if (do_section_details)
4759 fputs (" ", stdout);
4760 else
4761 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 4762
cfcac11d
NC		 4763 if (section->sh_link >= elf_header.e_shnum)
4764 {
4765 link_too_big = "";
4766 /* The sh_link value is out of range. Normally this indicates
caa83f8b 4767 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 4768 switch (elf_header.e_machine)
4769 {
caa83f8b
NC		 4770 case EM_386:
4771 case EM_486:
4772 case EM_X86_64:
7f502d6c 4773 case EM_L1OM:
7a9068fe 4774 case EM_K1OM:
cfcac11d
NC		 4775 case EM_OLD_SPARCV9:
4776 case EM_SPARC32PLUS:
4777 case EM_SPARCV9:
4778 case EM_SPARC:
4779 if (section->sh_link == (SHN_BEFORE & 0xffff))
4780 link_too_big = "BEFORE";
4781 else if (section->sh_link == (SHN_AFTER & 0xffff))
4782 link_too_big = "AFTER";
4783 break;
4784 default:
4785 break;
4786 }
4787 }
4788
4789 if (do_section_details)
4790 {
4791 if (link_too_big != NULL && * link_too_big)
4792 printf ("<%s> ", link_too_big);
4793 else
4794 printf ("%2u ", section->sh_link);
4795 printf ("%3u %2lu\n", section->sh_info,
4796 (unsigned long) section->sh_addralign);
4797 }
4798 else
4799 printf ("%2u %3u %2lu\n",
4800 section->sh_link,
4801 section->sh_info,
4802 (unsigned long) section->sh_addralign);
4803
4804 if (link_too_big && ! * link_too_big)
4805 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4806 i, section->sh_link);
f7a99963 4807 }
d974e256
JJ		 4808 else if (do_wide)
4809 {
4810 print_vma (section->sh_addr, LONG_HEX);
4811
4812 if ((long) section->sh_offset == section->sh_offset)
4813 printf (" %6.6lx", (unsigned long) section->sh_offset);
4814 else
4815 {
4816 putchar (' ');
4817 print_vma (section->sh_offset, LONG_HEX);
4818 }
4819
4820 if ((unsigned long) section->sh_size == section->sh_size)
4821 printf (" %6.6lx", (unsigned long) section->sh_size);
4822 else
4823 {
4824 putchar (' ');
4825 print_vma (section->sh_size, LONG_HEX);
4826 }
4827
4828 if ((unsigned long) section->sh_entsize == section->sh_entsize)
4829 printf (" %2.2lx", (unsigned long) section->sh_entsize);
4830 else
4831 {
4832 putchar (' ');
4833 print_vma (section->sh_entsize, LONG_HEX);
4834 }
4835
5477e8a0
L		 4836 if (do_section_details)
4837 fputs (" ", stdout);
4838 else
4839 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 4840
72de5009 4841 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 4842
4843 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 4844 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 4845 else
4846 {
4847 print_vma (section->sh_addralign, DEC);
4848 putchar ('\n');
4849 }
4850 }
5477e8a0 4851 else if (do_section_details)
595cf52e 4852 {
5477e8a0 4853 printf (" %-15.15s ",
595cf52e 4854 get_section_type_name (section->sh_type));
595cf52e
L		 4855 print_vma (section->sh_addr, LONG_HEX);
4856 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 4857 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 4858 else
4859 {
4860 printf (" ");
4861 print_vma (section->sh_offset, LONG_HEX);
4862 }
72de5009 4863 printf (" %u\n ", section->sh_link);
595cf52e 4864 print_vma (section->sh_size, LONG_HEX);
5477e8a0 4865 putchar (' ');
595cf52e
L		 4866 print_vma (section->sh_entsize, LONG_HEX);
4867
72de5009
AM		 4868 printf (" %-16u %lu\n",
4869 section->sh_info,
595cf52e
L		 4870 (unsigned long) section->sh_addralign);
4871 }
f7a99963
NC		 4872 else
4873 {
4874 putchar (' ');
4875 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 4876 if ((long) section->sh_offset == section->sh_offset)
4877 printf (" %8.8lx", (unsigned long) section->sh_offset);
4878 else
4879 {
4880 printf (" ");
4881 print_vma (section->sh_offset, LONG_HEX);
4882 }
f7a99963
NC		 4883 printf ("\n ");
4884 print_vma (section->sh_size, LONG_HEX);
4885 printf (" ");
4886 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 4887
d1133906 4888 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 4889
72de5009
AM		 4890 printf (" %2u %3u %lu\n",
4891 section->sh_link,
4892 section->sh_info,
f7a99963
NC		 4893 (unsigned long) section->sh_addralign);
4894 }
5477e8a0
L		 4895
4896 if (do_section_details)
4897 printf (" %s\n", get_elf_section_flags (section->sh_flags));
252b5132
RH		 4898 }
4899
5477e8a0 4900 if (!do_section_details)
3dbcc61d
NC		 4901 {
4902 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 4903 || elf_header.e_machine == EM_L1OM
4904 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 4905 printf (_("Key to Flags:\n\
4906 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
4907 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4908 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4909 else
4910 printf (_("Key to Flags:\n\
e3c8793a 4911 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 4912 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 4913 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3dbcc61d 4914 }
d1133906 4915
252b5132
RH		 4916 return 1;
4917}
4918
f5842774
L		 4919static const char *
4920get_group_flags (unsigned int flags)
4921{
4922 static char buff[32];
4923 switch (flags)
4924 {
220453ec
AM		 4925 case 0:
4926 return "";
4927
f5842774 4928 case GRP_COMDAT:
220453ec 4929 return "COMDAT ";
f5842774
L		 4930
4931 default:
220453ec 4932 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 4933 break;
4934 }
4935 return buff;
4936}
4937
4938static int
2cf0635d 4939process_section_groups (FILE * file)
f5842774 4940{
2cf0635d 4941 Elf_Internal_Shdr * section;
f5842774 4942 unsigned int i;
2cf0635d
NC		 4943 struct group * group;
4944 Elf_Internal_Shdr * symtab_sec;
4945 Elf_Internal_Shdr * strtab_sec;
4946 Elf_Internal_Sym * symtab;
ba5cdace 4947 unsigned long num_syms;
2cf0635d 4948 char * strtab;
c256ffe7 4949 size_t strtab_size;
d1f5c6e3
L		 4950
4951 /* Don't process section groups unless needed. */
4952 if (!do_unwind && !do_section_groups)
4953 return 1;
f5842774
L		 4954
4955 if (elf_header.e_shnum == 0)
4956 {
4957 if (do_section_groups)
82f2dbf7 4958 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 4959
4960 return 1;
4961 }
4962
4963 if (section_headers == NULL)
4964 {
4965 error (_("Section headers are not available!\n"));
fa1908fd
NC		 4966 /* PR 13622: This can happen with a corrupt ELF header. */
4967 return 0;
f5842774
L		 4968 }
4969
3f5e193b
NC		 4970 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
4971 sizeof (struct group *));
e4b17d5c
L		 4972
4973 if (section_headers_groups == NULL)
4974 {
4975 error (_("Out of memory\n"));
4976 return 0;
4977 }
4978
f5842774 4979 /* Scan the sections for the group section. */
d1f5c6e3 4980 group_count = 0;
f5842774
L		 4981 for (i = 0, section = section_headers;
4982 i < elf_header.e_shnum;
4983 i++, section++)
e4b17d5c
L		 4984 if (section->sh_type == SHT_GROUP)
4985 group_count++;
4986
d1f5c6e3
L		 4987 if (group_count == 0)
4988 {
4989 if (do_section_groups)
4990 printf (_("\nThere are no section groups in this file.\n"));
4991
4992 return 1;
4993 }
4994
3f5e193b 4995 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 4996
4997 if (section_groups == NULL)
4998 {
4999 error (_("Out of memory\n"));
5000 return 0;
5001 }
5002
d1f5c6e3
L		 5003 symtab_sec = NULL;
5004 strtab_sec = NULL;
5005 symtab = NULL;
ba5cdace 5006 num_syms = 0;
d1f5c6e3 5007 strtab = NULL;
c256ffe7 5008 strtab_size = 0;
e4b17d5c
L		 5009 for (i = 0, section = section_headers, group = section_groups;
5010 i < elf_header.e_shnum;
5011 i++, section++)
f5842774
L		 5012 {
5013 if (section->sh_type == SHT_GROUP)
5014 {
2cf0635d
NC		 5015 char * name = SECTION_NAME (section);
5016 char * group_name;
5017 unsigned char * start;
5018 unsigned char * indices;
f5842774 5019 unsigned int entry, j, size;
2cf0635d
NC		 5020 Elf_Internal_Shdr * sec;
5021 Elf_Internal_Sym * sym;
f5842774
L		 5022
5023 /* Get the symbol table. */
4fbb74a6
AM		 5024 if (section->sh_link >= elf_header.e_shnum
5025 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 5026 != SHT_SYMTAB))
f5842774
L		 5027 {
5028 error (_("Bad sh_link in group section `%s'\n"), name);
5029 continue;
5030 }
d1f5c6e3
L		 5031
5032 if (symtab_sec != sec)
5033 {
5034 symtab_sec = sec;
5035 if (symtab)
5036 free (symtab);
ba5cdace 5037 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 5038 }
f5842774 5039
dd24e3da
NC		 5040 if (symtab == NULL)
5041 {
5042 error (_("Corrupt header in group section `%s'\n"), name);
5043 continue;
5044 }
5045
ba5cdace
NC		 5046 if (section->sh_info >= num_syms)
5047 {
5048 error (_("Bad sh_info in group section `%s'\n"), name);
5049 continue;
5050 }
5051
f5842774
L		 5052 sym = symtab + section->sh_info;
5053
5054 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5055 {
4fbb74a6
AM		 5056 if (sym->st_shndx == 0
5057 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 5058 {
5059 error (_("Bad sh_info in group section `%s'\n"), name);
5060 continue;
5061 }
ba2685cc 5062
4fbb74a6 5063 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 5064 strtab_sec = NULL;
5065 if (strtab)
5066 free (strtab);
f5842774 5067 strtab = NULL;
c256ffe7 5068 strtab_size = 0;
f5842774
L		 5069 }
5070 else
5071 {
5072 /* Get the string table. */
4fbb74a6 5073 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 5074 {
5075 strtab_sec = NULL;
5076 if (strtab)
5077 free (strtab);
5078 strtab = NULL;
5079 strtab_size = 0;
5080 }
5081 else if (strtab_sec
4fbb74a6 5082 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 5083 {
5084 strtab_sec = sec;
5085 if (strtab)
5086 free (strtab);
3f5e193b
NC		 5087 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5088 1, strtab_sec->sh_size,
5089 _("string table"));
c256ffe7 5090 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 5091 }
c256ffe7 5092 group_name = sym->st_name < strtab_size
2b692964 5093 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 5094 }
5095
3f5e193b
NC		 5096 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5097 1, section->sh_size,
5098 _("section data"));
59245841
NC		 5099 if (start == NULL)
5100 continue;
f5842774
L		 5101
5102 indices = start;
5103 size = (section->sh_size / section->sh_entsize) - 1;
5104 entry = byte_get (indices, 4);
5105 indices += 4;
e4b17d5c
L		 5106
5107 if (do_section_groups)
5108 {
2b692964 5109 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 5110 get_group_flags (entry), i, name, group_name, size);
ba2685cc 5111
e4b17d5c
L		 5112 printf (_(" [Index] Name\n"));
5113 }
5114
5115 group->group_index = i;
5116
f5842774
L		 5117 for (j = 0; j < size; j++)
5118 {
2cf0635d 5119 struct group_list * g;
e4b17d5c 5120
f5842774
L		 5121 entry = byte_get (indices, 4);
5122 indices += 4;
5123
4fbb74a6 5124 if (entry >= elf_header.e_shnum)
391cb864
L		 5125 {
5126 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5127 entry, i, elf_header.e_shnum - 1);
5128 continue;
5129 }
391cb864 5130
4fbb74a6 5131 if (section_headers_groups [entry] != NULL)
e4b17d5c 5132 {
d1f5c6e3
L		 5133 if (entry)
5134 {
391cb864
L		 5135 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5136 entry, i,
4fbb74a6 5137 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5138 continue;
5139 }
5140 else
5141 {
5142 /* Intel C/C++ compiler may put section 0 in a
5143 section group. We just warn it the first time
5144 and ignore it afterwards. */
5145 static int warned = 0;
5146 if (!warned)
5147 {
5148 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 5149 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5150 warned++;
5151 }
5152 }
e4b17d5c
L		 5153 }
5154
4fbb74a6 5155 section_headers_groups [entry] = group;
e4b17d5c
L		 5156
5157 if (do_section_groups)
5158 {
4fbb74a6 5159 sec = section_headers + entry;
c256ffe7 5160 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
ba2685cc
AM		 5161 }
5162
3f5e193b 5163 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 5164 g->section_index = entry;
5165 g->next = group->root;
5166 group->root = g;
f5842774
L		 5167 }
5168
f5842774
L		 5169 if (start)
5170 free (start);
e4b17d5c
L		 5171
5172 group++;
f5842774
L		 5173 }
5174 }
5175
d1f5c6e3
L		 5176 if (symtab)
5177 free (symtab);
5178 if (strtab)
5179 free (strtab);
f5842774
L		 5180 return 1;
5181}
5182
28f997cf
TG		 5183/* Data used to display dynamic fixups. */
5184
5185struct ia64_vms_dynfixup
5186{
5187 bfd_vma needed_ident; /* Library ident number. */
5188 bfd_vma needed; /* Index in the dstrtab of the library name. */
5189 bfd_vma fixup_needed; /* Index of the library. */
5190 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5191 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5192};
5193
5194/* Data used to display dynamic relocations. */
5195
5196struct ia64_vms_dynimgrela
5197{
5198 bfd_vma img_rela_cnt; /* Number of relocations. */
5199 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5200};
5201
5202/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5203 library). */
5204
5205static void
5206dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5207 const char *strtab, unsigned int strtab_sz)
5208{
5209 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5210 long i;
5211 const char *lib_name;
5212
5213 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5214 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5215 _("dynamic section image fixups"));
5216 if (!imfs)
5217 return;
5218
5219 if (fixup->needed < strtab_sz)
5220 lib_name = strtab + fixup->needed;
5221 else
5222 {
5223 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 5224 (unsigned long) fixup->needed);
28f997cf
TG		 5225 lib_name = "???";
5226 }
5227 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5228 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5229 printf
5230 (_("Seg Offset Type SymVec DataType\n"));
5231
5232 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5233 {
5234 unsigned int type;
5235 const char *rtype;
5236
5237 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5238 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5239 type = BYTE_GET (imfs [i].type);
5240 rtype = elf_ia64_reloc_type (type);
5241 if (rtype == NULL)
5242 printf (" 0x%08x ", type);
5243 else
5244 printf (" %-32s ", rtype);
5245 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5246 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5247 }
5248
5249 free (imfs);
5250}
5251
5252/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5253
5254static void
5255dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5256{
5257 Elf64_External_VMS_IMAGE_RELA *imrs;
5258 long i;
5259
5260 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5261 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 5262 _("dynamic section image relocations"));
28f997cf
TG		 5263 if (!imrs)
5264 return;
5265
5266 printf (_("\nImage relocs\n"));
5267 printf
5268 (_("Seg Offset Type Addend Seg Sym Off\n"));
5269
5270 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5271 {
5272 unsigned int type;
5273 const char *rtype;
5274
5275 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5276 printf ("%08" BFD_VMA_FMT "x ",
5277 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5278 type = BYTE_GET (imrs [i].type);
5279 rtype = elf_ia64_reloc_type (type);
5280 if (rtype == NULL)
5281 printf ("0x%08x ", type);
5282 else
5283 printf ("%-31s ", rtype);
5284 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5285 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5286 printf ("%08" BFD_VMA_FMT "x\n",
5287 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5288 }
5289
5290 free (imrs);
5291}
5292
5293/* Display IA-64 OpenVMS dynamic relocations and fixups. */
5294
5295static int
5296process_ia64_vms_dynamic_relocs (FILE *file)
5297{
5298 struct ia64_vms_dynfixup fixup;
5299 struct ia64_vms_dynimgrela imgrela;
5300 Elf_Internal_Dyn *entry;
5301 int res = 0;
5302 bfd_vma strtab_off = 0;
5303 bfd_vma strtab_sz = 0;
5304 char *strtab = NULL;
5305
5306 memset (&fixup, 0, sizeof (fixup));
5307 memset (&imgrela, 0, sizeof (imgrela));
5308
5309 /* Note: the order of the entries is specified by the OpenVMS specs. */
5310 for (entry = dynamic_section;
5311 entry < dynamic_section + dynamic_nent;
5312 entry++)
5313 {
5314 switch (entry->d_tag)
5315 {
5316 case DT_IA_64_VMS_STRTAB_OFFSET:
5317 strtab_off = entry->d_un.d_val;
5318 break;
5319 case DT_STRSZ:
5320 strtab_sz = entry->d_un.d_val;
5321 if (strtab == NULL)
5322 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5323 1, strtab_sz, _("dynamic string section"));
5324 break;
5325
5326 case DT_IA_64_VMS_NEEDED_IDENT:
5327 fixup.needed_ident = entry->d_un.d_val;
5328 break;
5329 case DT_NEEDED:
5330 fixup.needed = entry->d_un.d_val;
5331 break;
5332 case DT_IA_64_VMS_FIXUP_NEEDED:
5333 fixup.fixup_needed = entry->d_un.d_val;
5334 break;
5335 case DT_IA_64_VMS_FIXUP_RELA_CNT:
5336 fixup.fixup_rela_cnt = entry->d_un.d_val;
5337 break;
5338 case DT_IA_64_VMS_FIXUP_RELA_OFF:
5339 fixup.fixup_rela_off = entry->d_un.d_val;
5340 res++;
5341 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5342 break;
5343
5344 case DT_IA_64_VMS_IMG_RELA_CNT:
5345 imgrela.img_rela_cnt = entry->d_un.d_val;
5346 break;
5347 case DT_IA_64_VMS_IMG_RELA_OFF:
5348 imgrela.img_rela_off = entry->d_un.d_val;
5349 res++;
5350 dump_ia64_vms_dynamic_relocs (file, &imgrela);
5351 break;
5352
5353 default:
5354 break;
5355 }
5356 }
5357
5358 if (strtab != NULL)
5359 free (strtab);
5360
5361 return res;
5362}
5363
85b1c36d 5364static struct
566b0d53 5365{
2cf0635d 5366 const char * name;
566b0d53
L		 5367 int reloc;
5368 int size;
5369 int rela;
5370} dynamic_relocations [] =
5371{
5372 { "REL", DT_REL, DT_RELSZ, FALSE },
5373 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5374 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5375};
5376
252b5132 5377/* Process the reloc section. */
18bd398b 5378
252b5132 5379static int
2cf0635d 5380process_relocs (FILE * file)
252b5132 5381{
b34976b6
AM		 5382 unsigned long rel_size;
5383 unsigned long rel_offset;
252b5132
RH		 5384
5385
5386 if (!do_reloc)
5387 return 1;
5388
5389 if (do_using_dynamic)
5390 {
566b0d53 5391 int is_rela;
2cf0635d 5392 const char * name;
566b0d53
L		 5393 int has_dynamic_reloc;
5394 unsigned int i;
0de14b54 5395
566b0d53 5396 has_dynamic_reloc = 0;
252b5132 5397
566b0d53 5398 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 5399 {
566b0d53
L		 5400 is_rela = dynamic_relocations [i].rela;
5401 name = dynamic_relocations [i].name;
5402 rel_size = dynamic_info [dynamic_relocations [i].size];
5403 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 5404
566b0d53
L		 5405 has_dynamic_reloc |= rel_size;
5406
5407 if (is_rela == UNKNOWN)
aa903cfb 5408 {
566b0d53
L		 5409 if (dynamic_relocations [i].reloc == DT_JMPREL)
5410 switch (dynamic_info[DT_PLTREL])
5411 {
5412 case DT_REL:
5413 is_rela = FALSE;
5414 break;
5415 case DT_RELA:
5416 is_rela = TRUE;
5417 break;
5418 }
aa903cfb 5419 }
252b5132 5420
566b0d53
L		 5421 if (rel_size)
5422 {
5423 printf
5424 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5425 name, rel_offset, rel_size);
252b5132 5426
d93f0186
NC		 5427 dump_relocations (file,
5428 offset_from_vma (file, rel_offset, rel_size),
5429 rel_size,
566b0d53 5430 dynamic_symbols, num_dynamic_syms,
d79b3d50 5431 dynamic_strings, dynamic_strings_length, is_rela);
566b0d53 5432 }
252b5132 5433 }
566b0d53 5434
28f997cf
TG		 5435 if (is_ia64_vms ())
5436 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5437
566b0d53 5438 if (! has_dynamic_reloc)
252b5132
RH		 5439 printf (_("\nThere are no dynamic relocations in this file.\n"));
5440 }
5441 else
5442 {
2cf0635d 5443 Elf_Internal_Shdr * section;
b34976b6
AM		 5444 unsigned long i;
5445 int found = 0;
252b5132
RH		 5446
5447 for (i = 0, section = section_headers;
5448 i < elf_header.e_shnum;
b34976b6 5449 i++, section++)
252b5132
RH		 5450 {
5451 if ( section->sh_type != SHT_RELA
5452 && section->sh_type != SHT_REL)
5453 continue;
5454
5455 rel_offset = section->sh_offset;
5456 rel_size = section->sh_size;
5457
5458 if (rel_size)
5459 {
2cf0635d 5460 Elf_Internal_Shdr * strsec;
b34976b6 5461 int is_rela;
103f02d3 5462
252b5132
RH		 5463 printf (_("\nRelocation section "));
5464
5465 if (string_table == NULL)
19936277 5466 printf ("%d", section->sh_name);
252b5132 5467 else
9cf03b7e 5468 printf ("'%s'", SECTION_NAME (section));
252b5132
RH		 5469
5470 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5471 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5472
d79b3d50
NC		 5473 is_rela = section->sh_type == SHT_RELA;
5474
4fbb74a6
AM		 5475 if (section->sh_link != 0
5476 && section->sh_link < elf_header.e_shnum)
af3fc3bc 5477 {
2cf0635d
NC		 5478 Elf_Internal_Shdr * symsec;
5479 Elf_Internal_Sym * symtab;
d79b3d50 5480 unsigned long nsyms;
c256ffe7 5481 unsigned long strtablen = 0;
2cf0635d 5482 char * strtab = NULL;
57346661 5483
4fbb74a6 5484 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 5485 if (symsec->sh_type != SHT_SYMTAB
5486 && symsec->sh_type != SHT_DYNSYM)
5487 continue;
5488
ba5cdace 5489 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 5490
af3fc3bc
AM		 5491 if (symtab == NULL)
5492 continue;
252b5132 5493
4fbb74a6
AM		 5494 if (symsec->sh_link != 0
5495 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 5496 {
4fbb74a6 5497 strsec = section_headers + symsec->sh_link;
103f02d3 5498
3f5e193b
NC		 5499 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5500 1, strsec->sh_size,
5501 _("string table"));
c256ffe7
JJ		 5502 strtablen = strtab == NULL ? 0 : strsec->sh_size;
5503 }
252b5132 5504
d79b3d50
NC		 5505 dump_relocations (file, rel_offset, rel_size,
5506 symtab, nsyms, strtab, strtablen, is_rela);
5507 if (strtab)
5508 free (strtab);
5509 free (symtab);
5510 }
5511 else
5512 dump_relocations (file, rel_offset, rel_size,
5513 NULL, 0, NULL, 0, is_rela);
252b5132
RH		 5514
5515 found = 1;
5516 }
5517 }
5518
5519 if (! found)
5520 printf (_("\nThere are no relocations in this file.\n"));
5521 }
5522
5523 return 1;
5524}
5525
57346661
AM		 5526/* Process the unwind section. */
5527
4d6ed7c8
NC		 5528#include "unwind-ia64.h"
5529
5530/* An absolute address consists of a section and an offset. If the
5531 section is NULL, the offset itself is the address, otherwise, the
5532 address equals to LOAD_ADDRESS(section) + offset. */
5533
5534struct absaddr
5535 {
5536 unsigned short section;
5537 bfd_vma offset;
5538 };
5539
1949de15
L		 5540#define ABSADDR(a) \
5541 ((a).section \
5542 ? section_headers [(a).section].sh_addr + (a).offset \
5543 : (a).offset)
5544
3f5e193b
NC		 5545struct ia64_unw_table_entry
5546 {
5547 struct absaddr start;
5548 struct absaddr end;
5549 struct absaddr info;
5550 };
5551
57346661 5552struct ia64_unw_aux_info
4d6ed7c8 5553 {
3f5e193b
NC		 5554
5555 struct ia64_unw_table_entry *table; /* Unwind table. */
b34976b6 5556 unsigned long table_len; /* Length of unwind table. */
2cf0635d 5557 unsigned char * info; /* Unwind info. */
b34976b6
AM		 5558 unsigned long info_size; /* Size of unwind info. */
5559 bfd_vma info_addr; /* starting address of unwind info. */
5560 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 5561 Elf_Internal_Sym * symtab; /* The symbol table. */
b34976b6 5562 unsigned long nsyms; /* Number of symbols. */
2cf0635d 5563 char * strtab; /* The string table. */
b34976b6 5564 unsigned long strtab_size; /* Size of string table. */
4d6ed7c8
NC		 5565 };
5566
4d6ed7c8 5567static void
2cf0635d 5568find_symbol_for_address (Elf_Internal_Sym * symtab,
57346661 5569 unsigned long nsyms,
2cf0635d 5570 const char * strtab,
57346661 5571 unsigned long strtab_size,
d3ba0551 5572 struct absaddr addr,
2cf0635d
NC		 5573 const char ** symname,
5574 bfd_vma * offset)
4d6ed7c8 5575{
d3ba0551 5576 bfd_vma dist = 0x100000;
2cf0635d
NC		 5577 Elf_Internal_Sym * sym;
5578 Elf_Internal_Sym * best = NULL;
4d6ed7c8
NC		 5579 unsigned long i;
5580
0b6ae522
DJ		 5581 REMOVE_ARCH_BITS (addr.offset);
5582
57346661 5583 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4d6ed7c8 5584 {
0b6ae522
DJ		 5585 bfd_vma value = sym->st_value;
5586
5587 REMOVE_ARCH_BITS (value);
5588
4d6ed7c8
NC		 5589 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5590 && sym->st_name != 0
5591 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 5592 && addr.offset >= value
5593 && addr.offset - value < dist)
4d6ed7c8
NC		 5594 {
5595 best = sym;
0b6ae522 5596 dist = addr.offset - value;
4d6ed7c8
NC		 5597 if (!dist)
5598 break;
5599 }
5600 }
1b31d05e 5601
4d6ed7c8
NC		 5602 if (best)
5603 {
57346661 5604 *symname = (best->st_name >= strtab_size
2b692964 5605 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 5606 *offset = dist;
5607 return;
5608 }
1b31d05e 5609
4d6ed7c8
NC		 5610 *symname = NULL;
5611 *offset = addr.offset;
5612}
5613
5614static void
2cf0635d 5615dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 5616{
2cf0635d 5617 struct ia64_unw_table_entry * tp;
4d6ed7c8 5618 int in_body;
7036c0e1 5619
4d6ed7c8
NC		 5620 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5621 {
5622 bfd_vma stamp;
5623 bfd_vma offset;
2cf0635d
NC		 5624 const unsigned char * dp;
5625 const unsigned char * head;
5626 const char * procname;
4d6ed7c8 5627
57346661
AM		 5628 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5629 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 5630
5631 fputs ("\n<", stdout);
5632
5633 if (procname)
5634 {
5635 fputs (procname, stdout);
5636
5637 if (offset)
5638 printf ("+%lx", (unsigned long) offset);
5639 }
5640
5641 fputs (">: [", stdout);
5642 print_vma (tp->start.offset, PREFIX_HEX);
5643 fputc ('-', stdout);
5644 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 5645 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 5646 (unsigned long) (tp->info.offset - aux->seg_base));
5647
1949de15 5648 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 5649 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 5650
86f55779 5651 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 5652 (unsigned) UNW_VER (stamp),
5653 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5654 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5655 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 5656 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 5657
5658 if (UNW_VER (stamp) != 1)
5659 {
2b692964 5660 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 5661 continue;
5662 }
5663
5664 in_body = 0;
89fac5e3 5665 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
4d6ed7c8
NC		 5666 dp = unw_decode (dp, in_body, & in_body);
5667 }
5668}
5669
5670static int
2cf0635d
NC		 5671slurp_ia64_unwind_table (FILE * file,
5672 struct ia64_unw_aux_info * aux,
5673 Elf_Internal_Shdr * sec)
4d6ed7c8 5674{
89fac5e3 5675 unsigned long size, nrelas, i;
2cf0635d
NC		 5676 Elf_Internal_Phdr * seg;
5677 struct ia64_unw_table_entry * tep;
5678 Elf_Internal_Shdr * relsec;
5679 Elf_Internal_Rela * rela;
5680 Elf_Internal_Rela * rp;
5681 unsigned char * table;
5682 unsigned char * tp;
5683 Elf_Internal_Sym * sym;
5684 const char * relname;
4d6ed7c8 5685
4d6ed7c8
NC		 5686 /* First, find the starting address of the segment that includes
5687 this section: */
5688
5689 if (elf_header.e_phnum)
5690 {
d93f0186 5691 if (! get_program_headers (file))
4d6ed7c8 5692 return 0;
4d6ed7c8 5693
d93f0186
NC		 5694 for (seg = program_headers;
5695 seg < program_headers + elf_header.e_phnum;
5696 ++seg)
4d6ed7c8
NC		 5697 {
5698 if (seg->p_type != PT_LOAD)
5699 continue;
5700
5701 if (sec->sh_addr >= seg->p_vaddr
5702 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5703 {
5704 aux->seg_base = seg->p_vaddr;
5705 break;
5706 }
5707 }
4d6ed7c8
NC		 5708 }
5709
5710 /* Second, build the unwind table from the contents of the unwind section: */
5711 size = sec->sh_size;
3f5e193b
NC		 5712 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5713 _("unwind table"));
a6e9f9df
AM		 5714 if (!table)
5715 return 0;
4d6ed7c8 5716
3f5e193b
NC		 5717 aux->table = (struct ia64_unw_table_entry *)
5718 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
89fac5e3 5719 tep = aux->table;
c6a0c689 5720 for (tp = table; tp < table + size; ++tep)
4d6ed7c8
NC		 5721 {
5722 tep->start.section = SHN_UNDEF;
5723 tep->end.section = SHN_UNDEF;
5724 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 5725 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5726 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5727 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 5728 tep->start.offset += aux->seg_base;
5729 tep->end.offset += aux->seg_base;
5730 tep->info.offset += aux->seg_base;
5731 }
5732 free (table);
5733
41e92641 5734 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 5735 for (relsec = section_headers;
5736 relsec < section_headers + elf_header.e_shnum;
5737 ++relsec)
5738 {
5739 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 5740 || relsec->sh_info >= elf_header.e_shnum
5741 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 5742 continue;
5743
5744 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5745 & rela, & nrelas))
5746 return 0;
5747
5748 for (rp = rela; rp < rela + nrelas; ++rp)
5749 {
aca88567
NC		 5750 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5751 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 5752
0112cd26 5753 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 5754 {
e5fb9629 5755 warn (_("Skipping unexpected relocation type %s\n"), relname);
4d6ed7c8
NC		 5756 continue;
5757 }
5758
89fac5e3 5759 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 5760
89fac5e3 5761 switch (rp->r_offset/eh_addr_size % 3)
4d6ed7c8
NC		 5762 {
5763 case 0:
5764 aux->table[i].start.section = sym->st_shndx;
e466bc6e 5765 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5766 break;
5767 case 1:
5768 aux->table[i].end.section = sym->st_shndx;
e466bc6e 5769 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5770 break;
5771 case 2:
5772 aux->table[i].info.section = sym->st_shndx;
e466bc6e 5773 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5774 break;
5775 default:
5776 break;
5777 }
5778 }
5779
5780 free (rela);
5781 }
5782
89fac5e3 5783 aux->table_len = size / (3 * eh_addr_size);
4d6ed7c8
NC		 5784 return 1;
5785}
5786
1b31d05e 5787static void
2cf0635d 5788ia64_process_unwind (FILE * file)
4d6ed7c8 5789{
2cf0635d
NC		 5790 Elf_Internal_Shdr * sec;
5791 Elf_Internal_Shdr * unwsec = NULL;
5792 Elf_Internal_Shdr * strsec;
89fac5e3 5793 unsigned long i, unwcount = 0, unwstart = 0;
57346661 5794 struct ia64_unw_aux_info aux;
f1467e33 5795
4d6ed7c8
NC		 5796 memset (& aux, 0, sizeof (aux));
5797
4d6ed7c8
NC		 5798 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5799 {
c256ffe7 5800 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 5801 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 5802 {
ba5cdace 5803 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 5804
4fbb74a6 5805 strsec = section_headers + sec->sh_link;
59245841 5806 assert (aux.strtab == NULL);
3f5e193b
NC		 5807 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5808 1, strsec->sh_size,
5809 _("string table"));
c256ffe7 5810 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 5811 }
5812 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 5813 unwcount++;
5814 }
5815
5816 if (!unwcount)
5817 printf (_("\nThere are no unwind sections in this file.\n"));
5818
5819 while (unwcount-- > 0)
5820 {
2cf0635d 5821 char * suffix;
579f31ac
JJ		 5822 size_t len, len2;
5823
5824 for (i = unwstart, sec = section_headers + unwstart;
5825 i < elf_header.e_shnum; ++i, ++sec)
5826 if (sec->sh_type == SHT_IA_64_UNWIND)
5827 {
5828 unwsec = sec;
5829 break;
5830 }
5831
5832 unwstart = i + 1;
5833 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
5834
e4b17d5c
L		 5835 if ((unwsec->sh_flags & SHF_GROUP) != 0)
5836 {
5837 /* We need to find which section group it is in. */
2cf0635d 5838 struct group_list * g = section_headers_groups [i]->root;
e4b17d5c
L		 5839
5840 for (; g != NULL; g = g->next)
5841 {
4fbb74a6 5842 sec = section_headers + g->section_index;
18bd398b
NC		 5843
5844 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
57346661 5845 break;
e4b17d5c
L		 5846 }
5847
5848 if (g == NULL)
5849 i = elf_header.e_shnum;
5850 }
18bd398b 5851 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 5852 {
18bd398b 5853 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 5854 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
5855 suffix = SECTION_NAME (unwsec) + len;
5856 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5857 ++i, ++sec)
18bd398b
NC		 5858 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
5859 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 5860 break;
5861 }
5862 else
5863 {
5864 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 5865 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 5866 len = sizeof (ELF_STRING_ia64_unwind) - 1;
5867 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
5868 suffix = "";
18bd398b 5869 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 5870 suffix = SECTION_NAME (unwsec) + len;
5871 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5872 ++i, ++sec)
18bd398b
NC		 5873 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
5874 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 5875 break;
5876 }
5877
5878 if (i == elf_header.e_shnum)
5879 {
5880 printf (_("\nCould not find unwind info section for "));
5881
5882 if (string_table == NULL)
5883 printf ("%d", unwsec->sh_name);
5884 else
3a1a2036 5885 printf (_("'%s'"), SECTION_NAME (unwsec));
579f31ac
JJ		 5886 }
5887 else
4d6ed7c8 5888 {
4d6ed7c8 5889 aux.info_addr = sec->sh_addr;
3f5e193b 5890 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
59245841 5891 sec->sh_size,
3f5e193b 5892 _("unwind info"));
59245841 5893 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 5894
579f31ac 5895 printf (_("\nUnwind section "));
4d6ed7c8 5896
579f31ac
JJ		 5897 if (string_table == NULL)
5898 printf ("%d", unwsec->sh_name);
5899 else
3a1a2036 5900 printf (_("'%s'"), SECTION_NAME (unwsec));
4d6ed7c8 5901
579f31ac 5902 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 5903 (unsigned long) unwsec->sh_offset,
89fac5e3 5904 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 5905
579f31ac 5906 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4d6ed7c8 5907
579f31ac
JJ		 5908 if (aux.table_len > 0)
5909 dump_ia64_unwind (& aux);
5910
5911 if (aux.table)
5912 free ((char *) aux.table);
5913 if (aux.info)
5914 free ((char *) aux.info);
5915 aux.table = NULL;
5916 aux.info = NULL;
5917 }
4d6ed7c8 5918 }
4d6ed7c8 5919
4d6ed7c8
NC		 5920 if (aux.symtab)
5921 free (aux.symtab);
5922 if (aux.strtab)
5923 free ((char *) aux.strtab);
4d6ed7c8
NC		 5924}
5925
3f5e193b
NC		 5926struct hppa_unw_table_entry
5927 {
5928 struct absaddr start;
5929 struct absaddr end;
5930 unsigned int Cannot_unwind:1; /* 0 */
5931 unsigned int Millicode:1; /* 1 */
5932 unsigned int Millicode_save_sr0:1; /* 2 */
5933 unsigned int Region_description:2; /* 3..4 */
5934 unsigned int reserved1:1; /* 5 */
5935 unsigned int Entry_SR:1; /* 6 */
5936 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
5937 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
5938 unsigned int Args_stored:1; /* 16 */
5939 unsigned int Variable_Frame:1; /* 17 */
5940 unsigned int Separate_Package_Body:1; /* 18 */
5941 unsigned int Frame_Extension_Millicode:1; /* 19 */
5942 unsigned int Stack_Overflow_Check:1; /* 20 */
5943 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
5944 unsigned int Ada_Region:1; /* 22 */
5945 unsigned int cxx_info:1; /* 23 */
5946 unsigned int cxx_try_catch:1; /* 24 */
5947 unsigned int sched_entry_seq:1; /* 25 */
5948 unsigned int reserved2:1; /* 26 */
5949 unsigned int Save_SP:1; /* 27 */
5950 unsigned int Save_RP:1; /* 28 */
5951 unsigned int Save_MRP_in_frame:1; /* 29 */
5952 unsigned int extn_ptr_defined:1; /* 30 */
5953 unsigned int Cleanup_defined:1; /* 31 */
5954
5955 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
5956 unsigned int HP_UX_interrupt_marker:1; /* 1 */
5957 unsigned int Large_frame:1; /* 2 */
5958 unsigned int Pseudo_SP_Set:1; /* 3 */
5959 unsigned int reserved4:1; /* 4 */
5960 unsigned int Total_frame_size:27; /* 5..31 */
5961 };
5962
57346661
AM		 5963struct hppa_unw_aux_info
5964 {
3f5e193b 5965 struct hppa_unw_table_entry *table; /* Unwind table. */
57346661
AM		 5966 unsigned long table_len; /* Length of unwind table. */
5967 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 5968 Elf_Internal_Sym * symtab; /* The symbol table. */
57346661 5969 unsigned long nsyms; /* Number of symbols. */
2cf0635d 5970 char * strtab; /* The string table. */
57346661
AM		 5971 unsigned long strtab_size; /* Size of string table. */
5972 };
5973
5974static void
2cf0635d 5975dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 5976{
2cf0635d 5977 struct hppa_unw_table_entry * tp;
57346661 5978
57346661
AM		 5979 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5980 {
5981 bfd_vma offset;
2cf0635d 5982 const char * procname;
57346661
AM		 5983
5984 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5985 aux->strtab_size, tp->start, &procname,
5986 &offset);
5987
5988 fputs ("\n<", stdout);
5989
5990 if (procname)
5991 {
5992 fputs (procname, stdout);
5993
5994 if (offset)
5995 printf ("+%lx", (unsigned long) offset);
5996 }
5997
5998 fputs (">: [", stdout);
5999 print_vma (tp->start.offset, PREFIX_HEX);
6000 fputc ('-', stdout);
6001 print_vma (tp->end.offset, PREFIX_HEX);
6002 printf ("]\n\t");
6003
18bd398b
NC		 6004#define PF(_m) if (tp->_m) printf (#_m " ");
6005#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 6006 PF(Cannot_unwind);
6007 PF(Millicode);
6008 PF(Millicode_save_sr0);
18bd398b 6009 /* PV(Region_description); */
57346661
AM		 6010 PF(Entry_SR);
6011 PV(Entry_FR);
6012 PV(Entry_GR);
6013 PF(Args_stored);
6014 PF(Variable_Frame);
6015 PF(Separate_Package_Body);
6016 PF(Frame_Extension_Millicode);
6017 PF(Stack_Overflow_Check);
6018 PF(Two_Instruction_SP_Increment);
6019 PF(Ada_Region);
6020 PF(cxx_info);
6021 PF(cxx_try_catch);
6022 PF(sched_entry_seq);
6023 PF(Save_SP);
6024 PF(Save_RP);
6025 PF(Save_MRP_in_frame);
6026 PF(extn_ptr_defined);
6027 PF(Cleanup_defined);
6028 PF(MPE_XL_interrupt_marker);
6029 PF(HP_UX_interrupt_marker);
6030 PF(Large_frame);
6031 PF(Pseudo_SP_Set);
6032 PV(Total_frame_size);
6033#undef PF
6034#undef PV
6035 }
6036
18bd398b 6037 printf ("\n");
57346661
AM		 6038}
6039
6040static int
2cf0635d
NC		 6041slurp_hppa_unwind_table (FILE * file,
6042 struct hppa_unw_aux_info * aux,
6043 Elf_Internal_Shdr * sec)
57346661 6044{
1c0751b2 6045 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 6046 Elf_Internal_Phdr * seg;
6047 struct hppa_unw_table_entry * tep;
6048 Elf_Internal_Shdr * relsec;
6049 Elf_Internal_Rela * rela;
6050 Elf_Internal_Rela * rp;
6051 unsigned char * table;
6052 unsigned char * tp;
6053 Elf_Internal_Sym * sym;
6054 const char * relname;
57346661 6055
57346661
AM		 6056 /* First, find the starting address of the segment that includes
6057 this section. */
6058
6059 if (elf_header.e_phnum)
6060 {
6061 if (! get_program_headers (file))
6062 return 0;
6063
6064 for (seg = program_headers;
6065 seg < program_headers + elf_header.e_phnum;
6066 ++seg)
6067 {
6068 if (seg->p_type != PT_LOAD)
6069 continue;
6070
6071 if (sec->sh_addr >= seg->p_vaddr
6072 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6073 {
6074 aux->seg_base = seg->p_vaddr;
6075 break;
6076 }
6077 }
6078 }
6079
6080 /* Second, build the unwind table from the contents of the unwind
6081 section. */
6082 size = sec->sh_size;
3f5e193b
NC		 6083 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6084 _("unwind table"));
57346661
AM		 6085 if (!table)
6086 return 0;
6087
1c0751b2
DA		 6088 unw_ent_size = 16;
6089 nentries = size / unw_ent_size;
6090 size = unw_ent_size * nentries;
57346661 6091
3f5e193b
NC		 6092 tep = aux->table = (struct hppa_unw_table_entry *)
6093 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 6094
1c0751b2 6095 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 6096 {
6097 unsigned int tmp1, tmp2;
6098
6099 tep->start.section = SHN_UNDEF;
6100 tep->end.section = SHN_UNDEF;
6101
1c0751b2
DA		 6102 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6103 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6104 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6105 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6106
6107 tep->start.offset += aux->seg_base;
6108 tep->end.offset += aux->seg_base;
57346661
AM		 6109
6110 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6111 tep->Millicode = (tmp1 >> 30) & 0x1;
6112 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6113 tep->Region_description = (tmp1 >> 27) & 0x3;
6114 tep->reserved1 = (tmp1 >> 26) & 0x1;
6115 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6116 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6117 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6118 tep->Args_stored = (tmp1 >> 15) & 0x1;
6119 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6120 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6121 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6122 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6123 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6124 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6125 tep->cxx_info = (tmp1 >> 8) & 0x1;
6126 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6127 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6128 tep->reserved2 = (tmp1 >> 5) & 0x1;
6129 tep->Save_SP = (tmp1 >> 4) & 0x1;
6130 tep->Save_RP = (tmp1 >> 3) & 0x1;
6131 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6132 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6133 tep->Cleanup_defined = tmp1 & 0x1;
6134
6135 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6136 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6137 tep->Large_frame = (tmp2 >> 29) & 0x1;
6138 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6139 tep->reserved4 = (tmp2 >> 27) & 0x1;
6140 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 6141 }
6142 free (table);
6143
6144 /* Third, apply any relocations to the unwind table. */
57346661
AM		 6145 for (relsec = section_headers;
6146 relsec < section_headers + elf_header.e_shnum;
6147 ++relsec)
6148 {
6149 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6150 || relsec->sh_info >= elf_header.e_shnum
6151 || section_headers + relsec->sh_info != sec)
57346661
AM		 6152 continue;
6153
6154 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6155 & rela, & nrelas))
6156 return 0;
6157
6158 for (rp = rela; rp < rela + nrelas; ++rp)
6159 {
aca88567
NC		 6160 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6161 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 6162
6163 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 6164 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 6165 {
6166 warn (_("Skipping unexpected relocation type %s\n"), relname);
6167 continue;
6168 }
6169
6170 i = rp->r_offset / unw_ent_size;
6171
89fac5e3 6172 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 6173 {
6174 case 0:
6175 aux->table[i].start.section = sym->st_shndx;
1e456d54 6176 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 6177 break;
6178 case 1:
6179 aux->table[i].end.section = sym->st_shndx;
1e456d54 6180 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 6181 break;
6182 default:
6183 break;
6184 }
6185 }
6186
6187 free (rela);
6188 }
6189
1c0751b2 6190 aux->table_len = nentries;
57346661
AM		 6191
6192 return 1;
6193}
6194
1b31d05e 6195static void
2cf0635d 6196hppa_process_unwind (FILE * file)
57346661 6197{
57346661 6198 struct hppa_unw_aux_info aux;
2cf0635d
NC		 6199 Elf_Internal_Shdr * unwsec = NULL;
6200 Elf_Internal_Shdr * strsec;
6201 Elf_Internal_Shdr * sec;
18bd398b 6202 unsigned long i;
57346661 6203
c256ffe7 6204 if (string_table == NULL)
1b31d05e
NC		 6205 return;
6206
6207 memset (& aux, 0, sizeof (aux));
57346661
AM		 6208
6209 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6210 {
c256ffe7 6211 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6212 && sec->sh_link < elf_header.e_shnum)
57346661 6213 {
ba5cdace 6214 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 6215
4fbb74a6 6216 strsec = section_headers + sec->sh_link;
59245841 6217 assert (aux.strtab == NULL);
3f5e193b
NC		 6218 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6219 1, strsec->sh_size,
6220 _("string table"));
c256ffe7 6221 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 6222 }
18bd398b 6223 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 6224 unwsec = sec;
6225 }
6226
6227 if (!unwsec)
6228 printf (_("\nThere are no unwind sections in this file.\n"));
6229
6230 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6231 {
18bd398b 6232 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 6233 {
57346661
AM		 6234 printf (_("\nUnwind section "));
6235 printf (_("'%s'"), SECTION_NAME (sec));
6236
6237 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6238 (unsigned long) sec->sh_offset,
89fac5e3 6239 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 6240
6241 slurp_hppa_unwind_table (file, &aux, sec);
6242 if (aux.table_len > 0)
6243 dump_hppa_unwind (&aux);
6244
6245 if (aux.table)
6246 free ((char *) aux.table);
6247 aux.table = NULL;
6248 }
6249 }
6250
6251 if (aux.symtab)
6252 free (aux.symtab);
6253 if (aux.strtab)
6254 free ((char *) aux.strtab);
57346661
AM		 6255}
6256
0b6ae522
DJ		 6257struct arm_section
6258{
a734115a
NC		 6259 unsigned char * data; /* The unwind data. */
6260 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
6261 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
6262 unsigned long nrelas; /* The number of relocations. */
6263 unsigned int rel_type; /* REL or RELA ? */
6264 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 6265};
6266
6267struct arm_unw_aux_info
6268{
a734115a
NC		 6269 FILE * file; /* The file containing the unwind sections. */
6270 Elf_Internal_Sym * symtab; /* The file's symbol table. */
6271 unsigned long nsyms; /* Number of symbols. */
6272 char * strtab; /* The file's string table. */
6273 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 6274};
6275
6276static const char *
6277arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6278 bfd_vma fn, struct absaddr addr)
6279{
6280 const char *procname;
6281 bfd_vma sym_offset;
6282
6283 if (addr.section == SHN_UNDEF)
6284 addr.offset = fn;
6285
6286 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6287 aux->strtab_size, addr, &procname,
6288 &sym_offset);
6289
6290 print_vma (fn, PREFIX_HEX);
6291
6292 if (procname)
6293 {
6294 fputs (" <", stdout);
6295 fputs (procname, stdout);
6296
6297 if (sym_offset)
6298 printf ("+0x%lx", (unsigned long) sym_offset);
6299 fputc ('>', stdout);
6300 }
6301
6302 return procname;
6303}
6304
6305static void
6306arm_free_section (struct arm_section *arm_sec)
6307{
6308 if (arm_sec->data != NULL)
6309 free (arm_sec->data);
6310
6311 if (arm_sec->rela != NULL)
6312 free (arm_sec->rela);
6313}
6314
a734115a
NC		 6315/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6316 cached section and install SEC instead.
6317 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6318 and return its valued in * WORDP, relocating if necessary.
1b31d05e 6319 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 6320 relocation's offset in ADDR.
1b31d05e
NC		 6321 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6322 into the string table of the symbol associated with the reloc. If no
6323 reloc was applied store -1 there.
6324 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 6325
6326static bfd_boolean
1b31d05e
NC		 6327get_unwind_section_word (struct arm_unw_aux_info * aux,
6328 struct arm_section * arm_sec,
6329 Elf_Internal_Shdr * sec,
6330 bfd_vma word_offset,
6331 unsigned int * wordp,
6332 struct absaddr * addr,
6333 bfd_vma * sym_name)
0b6ae522
DJ		 6334{
6335 Elf_Internal_Rela *rp;
6336 Elf_Internal_Sym *sym;
6337 const char * relname;
6338 unsigned int word;
6339 bfd_boolean wrapped;
6340
6341 addr->section = SHN_UNDEF;
6342 addr->offset = 0;
6343
1b31d05e
NC		 6344 if (sym_name != NULL)
6345 *sym_name = (bfd_vma) -1;
6346
a734115a 6347 /* If necessary, update the section cache. */
0b6ae522
DJ		 6348 if (sec != arm_sec->sec)
6349 {
6350 Elf_Internal_Shdr *relsec;
6351
6352 arm_free_section (arm_sec);
6353
6354 arm_sec->sec = sec;
6355 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6356 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 6357 arm_sec->rela = NULL;
6358 arm_sec->nrelas = 0;
6359
6360 for (relsec = section_headers;
6361 relsec < section_headers + elf_header.e_shnum;
6362 ++relsec)
6363 {
6364 if (relsec->sh_info >= elf_header.e_shnum
6365 || section_headers + relsec->sh_info != sec)
6366 continue;
6367
a734115a 6368 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 6369 if (relsec->sh_type == SHT_REL)
6370 {
6371 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6372 relsec->sh_size,
6373 & arm_sec->rela, & arm_sec->nrelas))
a734115a 6374 return FALSE;
0b6ae522
DJ		 6375 break;
6376 }
6377 else if (relsec->sh_type == SHT_RELA)
6378 {
6379 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6380 relsec->sh_size,
6381 & arm_sec->rela, & arm_sec->nrelas))
a734115a 6382 return FALSE;
0b6ae522
DJ		 6383 break;
6384 }
a734115a
NC		 6385 else
6386 warn (_("unexpected relocation type (%d) for section %d"),
6387 relsec->sh_type, relsec->sh_info);
0b6ae522
DJ		 6388 }
6389
6390 arm_sec->next_rela = arm_sec->rela;
6391 }
6392
a734115a 6393 /* If there is no unwind data we can do nothing. */
0b6ae522 6394 if (arm_sec->data == NULL)
a734115a 6395 return FALSE;
0b6ae522 6396
a734115a 6397 /* Get the word at the required offset. */
0b6ae522
DJ		 6398 word = byte_get (arm_sec->data + word_offset, 4);
6399
a734115a 6400 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 6401 wrapped = FALSE;
6402 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6403 {
6404 bfd_vma prelval, offset;
6405
6406 if (rp->r_offset > word_offset && !wrapped)
6407 {
6408 rp = arm_sec->rela;
6409 wrapped = TRUE;
6410 }
6411 if (rp->r_offset > word_offset)
6412 break;
6413
6414 if (rp->r_offset & 3)
6415 {
6416 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6417 (unsigned long) rp->r_offset);
6418 continue;
6419 }
6420
6421 if (rp->r_offset < word_offset)
6422 continue;
6423
0b6ae522
DJ		 6424 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6425
6426 if (arm_sec->rel_type == SHT_REL)
6427 {
6428 offset = word & 0x7fffffff;
6429 if (offset & 0x40000000)
6430 offset |= ~ (bfd_vma) 0x7fffffff;
6431 }
a734115a 6432 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 6433 offset = rp->r_addend;
a734115a
NC		 6434 else
6435 abort ();
0b6ae522
DJ		 6436
6437 offset += sym->st_value;
6438 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6439
a734115a
NC		 6440 /* Check that we are processing the expected reloc type. */
6441 if (elf_header.e_machine == EM_ARM)
6442 {
6443 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6444
6445 if (streq (relname, "R_ARM_NONE"))
6446 continue;
6447
6448 if (! streq (relname, "R_ARM_PREL31"))
6449 {
6450 warn (_("Skipping unexpected relocation type %s\n"), relname);
6451 continue;
6452 }
6453 }
6454 else if (elf_header.e_machine == EM_TI_C6000)
6455 {
6456 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6457
6458 if (streq (relname, "R_C6000_NONE"))
6459 continue;
6460
6461 if (! streq (relname, "R_C6000_PREL31"))
6462 {
6463 warn (_("Skipping unexpected relocation type %s\n"), relname);
6464 continue;
6465 }
6466
6467 prelval >>= 1;
6468 }
6469 else
6470 /* This function currently only supports ARM and TI unwinders. */
6471 abort ();
fa197c1c 6472
0b6ae522
DJ		 6473 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6474 addr->section = sym->st_shndx;
6475 addr->offset = offset;
1b31d05e
NC		 6476 if (sym_name)
6477 * sym_name = sym->st_name;
0b6ae522
DJ		 6478 break;
6479 }
6480
6481 *wordp = word;
6482 arm_sec->next_rela = rp;
6483
a734115a 6484 return TRUE;
0b6ae522
DJ		 6485}
6486
a734115a
NC		 6487static const char *tic6x_unwind_regnames[16] =
6488{
6489 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6490 "A14", "A13", "A12", "A11", "A10",
6491 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6492};
fa197c1c 6493
0b6ae522 6494static void
fa197c1c 6495decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 6496{
fa197c1c
PB		 6497 int i;
6498
6499 for (i = 12; mask; mask >>= 1, i--)
6500 {
6501 if (mask & 1)
6502 {
6503 fputs (tic6x_unwind_regnames[i], stdout);
6504 if (mask > 1)
6505 fputs (", ", stdout);
6506 }
6507 }
6508}
0b6ae522
DJ		 6509
6510#define ADVANCE \
6511 if (remaining == 0 && more_words) \
6512 { \
6513 data_offset += 4; \
1b31d05e
NC		 6514 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
6515 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 6516 return; \
6517 remaining = 4; \
6518 more_words--; \
6519 } \
6520
6521#define GET_OP(OP) \
6522 ADVANCE; \
6523 if (remaining) \
6524 { \
6525 remaining--; \
6526 (OP) = word >> 24; \
6527 word <<= 8; \
6528 } \
6529 else \
6530 { \
2b692964 6531 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 6532 return; \
6533 } \
cc5914eb 6534 printf ("0x%02x ", OP)
0b6ae522 6535
fa197c1c
PB		 6536static void
6537decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
6538 unsigned int word, unsigned int remaining,
6539 unsigned int more_words,
6540 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6541 struct arm_section *data_arm_sec)
6542{
6543 struct absaddr addr;
0b6ae522
DJ		 6544
6545 /* Decode the unwinding instructions. */
6546 while (1)
6547 {
6548 unsigned int op, op2;
6549
6550 ADVANCE;
6551 if (remaining == 0)
6552 break;
6553 remaining--;
6554 op = word >> 24;
6555 word <<= 8;
6556
cc5914eb 6557 printf (" 0x%02x ", op);
0b6ae522
DJ		 6558
6559 if ((op & 0xc0) == 0x00)
6560 {
6561 int offset = ((op & 0x3f) << 2) + 4;
61865e30 6562
cc5914eb 6563 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 6564 }
6565 else if ((op & 0xc0) == 0x40)
6566 {
6567 int offset = ((op & 0x3f) << 2) + 4;
61865e30 6568
cc5914eb 6569 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 6570 }
6571 else if ((op & 0xf0) == 0x80)
6572 {
6573 GET_OP (op2);
6574 if (op == 0x80 && op2 == 0)
6575 printf (_("Refuse to unwind"));
6576 else
6577 {
6578 unsigned int mask = ((op & 0x0f) << 8) | op2;
6579 int first = 1;
6580 int i;
2b692964 6581
0b6ae522
DJ		 6582 printf ("pop {");
6583 for (i = 0; i < 12; i++)
6584 if (mask & (1 << i))
6585 {
6586 if (first)
6587 first = 0;
6588 else
6589 printf (", ");
6590 printf ("r%d", 4 + i);
6591 }
6592 printf ("}");
6593 }
6594 }
6595 else if ((op & 0xf0) == 0x90)
6596 {
6597 if (op == 0x9d || op == 0x9f)
6598 printf (_(" [Reserved]"));
6599 else
cc5914eb 6600 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 6601 }
6602 else if ((op & 0xf0) == 0xa0)
6603 {
6604 int end = 4 + (op & 0x07);
6605 int first = 1;
6606 int i;
61865e30 6607
0b6ae522
DJ		 6608 printf (" pop {");
6609 for (i = 4; i <= end; i++)
6610 {
6611 if (first)
6612 first = 0;
6613 else
6614 printf (", ");
6615 printf ("r%d", i);
6616 }
6617 if (op & 0x08)
6618 {
1b31d05e 6619 if (!first)
0b6ae522
DJ		 6620 printf (", ");
6621 printf ("r14");
6622 }
6623 printf ("}");
6624 }
6625 else if (op == 0xb0)
6626 printf (_(" finish"));
6627 else if (op == 0xb1)
6628 {
6629 GET_OP (op2);
6630 if (op2 == 0 || (op2 & 0xf0) != 0)
6631 printf (_("[Spare]"));
6632 else
6633 {
6634 unsigned int mask = op2 & 0x0f;
6635 int first = 1;
6636 int i;
61865e30 6637
0b6ae522
DJ		 6638 printf ("pop {");
6639 for (i = 0; i < 12; i++)
6640 if (mask & (1 << i))
6641 {
6642 if (first)
6643 first = 0;
6644 else
6645 printf (", ");
6646 printf ("r%d", i);
6647 }
6648 printf ("}");
6649 }
6650 }
6651 else if (op == 0xb2)
6652 {
b115cf96 6653 unsigned char buf[9];
0b6ae522
DJ		 6654 unsigned int i, len;
6655 unsigned long offset;
61865e30 6656
b115cf96 6657 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 6658 {
6659 GET_OP (buf[i]);
6660 if ((buf[i] & 0x80) == 0)
6661 break;
6662 }
6663 assert (i < sizeof (buf));
6664 offset = read_uleb128 (buf, &len);
6665 assert (len == i + 1);
6666 offset = offset * 4 + 0x204;
cc5914eb 6667 printf ("vsp = vsp + %ld", offset);
0b6ae522 6668 }
61865e30 6669 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 6670 {
61865e30
NC		 6671 unsigned int first, last;
6672
6673 GET_OP (op2);
6674 first = op2 >> 4;
6675 last = op2 & 0x0f;
6676 if (op == 0xc8)
6677 first = first + 16;
6678 printf ("pop {D%d", first);
6679 if (last)
6680 printf ("-D%d", first + last);
6681 printf ("}");
6682 }
6683 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
6684 {
6685 unsigned int count = op & 0x07;
6686
6687 printf ("pop {D8");
6688 if (count)
6689 printf ("-D%d", 8 + count);
6690 printf ("}");
6691 }
6692 else if (op >= 0xc0 && op <= 0xc5)
6693 {
6694 unsigned int count = op & 0x07;
6695
6696 printf (" pop {wR10");
6697 if (count)
6698 printf ("-wR%d", 10 + count);
6699 printf ("}");
6700 }
6701 else if (op == 0xc6)
6702 {
6703 unsigned int first, last;
6704
6705 GET_OP (op2);
6706 first = op2 >> 4;
6707 last = op2 & 0x0f;
6708 printf ("pop {wR%d", first);
6709 if (last)
6710 printf ("-wR%d", first + last);
6711 printf ("}");
6712 }
6713 else if (op == 0xc7)
6714 {
6715 GET_OP (op2);
6716 if (op2 == 0 || (op2 & 0xf0) != 0)
6717 printf (_("[Spare]"));
0b6ae522
DJ		 6718 else
6719 {
61865e30
NC		 6720 unsigned int mask = op2 & 0x0f;
6721 int first = 1;
6722 int i;
6723
6724 printf ("pop {");
6725 for (i = 0; i < 4; i++)
6726 if (mask & (1 << i))
6727 {
6728 if (first)
6729 first = 0;
6730 else
6731 printf (", ");
6732 printf ("wCGR%d", i);
6733 }
6734 printf ("}");
0b6ae522
DJ		 6735 }
6736 }
61865e30
NC		 6737 else
6738 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 6739 printf ("\n");
6740 }
fa197c1c
PB		 6741}
6742
6743static void
6744decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
6745 unsigned int word, unsigned int remaining,
6746 unsigned int more_words,
6747 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6748 struct arm_section *data_arm_sec)
6749{
6750 struct absaddr addr;
6751
6752 /* Decode the unwinding instructions. */
6753 while (1)
6754 {
6755 unsigned int op, op2;
6756
6757 ADVANCE;
6758 if (remaining == 0)
6759 break;
6760 remaining--;
6761 op = word >> 24;
6762 word <<= 8;
6763
9cf03b7e 6764 printf (" 0x%02x ", op);
fa197c1c
PB		 6765
6766 if ((op & 0xc0) == 0x00)
6767 {
6768 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 6769 printf (" sp = sp + %d", offset);
fa197c1c
PB		 6770 }
6771 else if ((op & 0xc0) == 0x80)
6772 {
6773 GET_OP (op2);
6774 if (op == 0x80 && op2 == 0)
6775 printf (_("Refuse to unwind"));
6776 else
6777 {
6778 unsigned int mask = ((op & 0x1f) << 8) | op2;
6779 if (op & 0x20)
6780 printf ("pop compact {");
6781 else
6782 printf ("pop {");
6783
6784 decode_tic6x_unwind_regmask (mask);
6785 printf("}");
6786 }
6787 }
6788 else if ((op & 0xf0) == 0xc0)
6789 {
6790 unsigned int reg;
6791 unsigned int nregs;
6792 unsigned int i;
6793 const char *name;
a734115a
NC		 6794 struct
6795 {
fa197c1c
PB		 6796 unsigned int offset;
6797 unsigned int reg;
6798 } regpos[16];
6799
6800 /* Scan entire instruction first so that GET_OP output is not
6801 interleaved with disassembly. */
6802 nregs = 0;
6803 for (i = 0; nregs < (op & 0xf); i++)
6804 {
6805 GET_OP (op2);
6806 reg = op2 >> 4;
6807 if (reg != 0xf)
6808 {
6809 regpos[nregs].offset = i * 2;
6810 regpos[nregs].reg = reg;
6811 nregs++;
6812 }
6813
6814 reg = op2 & 0xf;
6815 if (reg != 0xf)
6816 {
6817 regpos[nregs].offset = i * 2 + 1;
6818 regpos[nregs].reg = reg;
6819 nregs++;
6820 }
6821 }
6822
6823 printf (_("pop frame {"));
6824 reg = nregs - 1;
6825 for (i = i * 2; i > 0; i--)
6826 {
6827 if (regpos[reg].offset == i - 1)
6828 {
6829 name = tic6x_unwind_regnames[regpos[reg].reg];
6830 if (reg > 0)
6831 reg--;
6832 }
6833 else
6834 name = _("[pad]");
6835
6836 fputs (name, stdout);
6837 if (i > 1)
6838 printf (", ");
6839 }
6840
6841 printf ("}");
6842 }
6843 else if (op == 0xd0)
6844 printf (" MOV FP, SP");
6845 else if (op == 0xd1)
6846 printf (" __c6xabi_pop_rts");
6847 else if (op == 0xd2)
6848 {
6849 unsigned char buf[9];
6850 unsigned int i, len;
6851 unsigned long offset;
a734115a 6852
fa197c1c
PB		 6853 for (i = 0; i < sizeof (buf); i++)
6854 {
6855 GET_OP (buf[i]);
6856 if ((buf[i] & 0x80) == 0)
6857 break;
6858 }
6859 assert (i < sizeof (buf));
6860 offset = read_uleb128 (buf, &len);
6861 assert (len == i + 1);
6862 offset = offset * 8 + 0x408;
6863 printf (_("sp = sp + %ld"), offset);
6864 }
6865 else if ((op & 0xf0) == 0xe0)
6866 {
6867 if ((op & 0x0f) == 7)
6868 printf (" RETURN");
6869 else
6870 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
6871 }
6872 else
6873 {
6874 printf (_(" [unsupported opcode]"));
6875 }
6876 putchar ('\n');
6877 }
6878}
6879
6880static bfd_vma
a734115a 6881arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 6882{
6883 bfd_vma offset;
6884
6885 offset = word & 0x7fffffff;
6886 if (offset & 0x40000000)
6887 offset |= ~ (bfd_vma) 0x7fffffff;
6888
6889 if (elf_header.e_machine == EM_TI_C6000)
6890 offset <<= 1;
6891
6892 return offset + where;
6893}
6894
6895static void
1b31d05e
NC		 6896decode_arm_unwind (struct arm_unw_aux_info * aux,
6897 unsigned int word,
6898 unsigned int remaining,
6899 bfd_vma data_offset,
6900 Elf_Internal_Shdr * data_sec,
6901 struct arm_section * data_arm_sec)
fa197c1c
PB		 6902{
6903 int per_index;
6904 unsigned int more_words = 0;
6905 struct absaddr addr;
1b31d05e 6906 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 6907
6908 if (remaining == 0)
6909 {
1b31d05e
NC		 6910 /* Fetch the first word.
6911 Note - when decoding an object file the address extracted
6912 here will always be 0. So we also pass in the sym_name
6913 parameter so that we can find the symbol associated with
6914 the personality routine. */
6915 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
6916 & word, & addr, & sym_name))
fa197c1c 6917 return;
1b31d05e 6918
fa197c1c
PB		 6919 remaining = 4;
6920 }
6921
6922 if ((word & 0x80000000) == 0)
6923 {
6924 /* Expand prel31 for personality routine. */
6925 bfd_vma fn;
6926 const char *procname;
6927
a734115a 6928 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 6929 printf (_(" Personality routine: "));
1b31d05e
NC		 6930 if (fn == 0
6931 && addr.section == SHN_UNDEF && addr.offset == 0
6932 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
6933 {
6934 procname = aux->strtab + sym_name;
6935 print_vma (fn, PREFIX_HEX);
6936 if (procname)
6937 {
6938 fputs (" <", stdout);
6939 fputs (procname, stdout);
6940 fputc ('>', stdout);
6941 }
6942 }
6943 else
6944 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 6945 fputc ('\n', stdout);
6946
6947 /* The GCC personality routines use the standard compact
6948 encoding, starting with one byte giving the number of
6949 words. */
6950 if (procname != NULL
6951 && (const_strneq (procname, "__gcc_personality_v0")
6952 || const_strneq (procname, "__gxx_personality_v0")
6953 || const_strneq (procname, "__gcj_personality_v0")
6954 || const_strneq (procname, "__gnu_objc_personality_v0")))
6955 {
6956 remaining = 0;
6957 more_words = 1;
6958 ADVANCE;
6959 if (!remaining)
6960 {
6961 printf (_(" [Truncated data]\n"));
6962 return;
6963 }
6964 more_words = word >> 24;
6965 word <<= 8;
6966 remaining--;
6967 per_index = -1;
6968 }
6969 else
6970 return;
6971 }
6972 else
6973 {
1b31d05e
NC		 6974 /* ARM EHABI Section 6.3:
6975
6976 An exception-handling table entry for the compact model looks like:
6977
6978 31 30-28 27-24 23-0
6979 -- ----- ----- ----
6980 1 0 index Data for personalityRoutine[index] */
6981
6982 if (elf_header.e_machine == EM_ARM
6983 && (word & 0x70000000))
83c257ca 6984 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 6985
fa197c1c 6986 per_index = (word >> 24) & 0x7f;
1b31d05e 6987 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 6988 if (per_index == 0)
6989 {
6990 more_words = 0;
6991 word <<= 8;
6992 remaining--;
6993 }
6994 else if (per_index < 3)
6995 {
6996 more_words = (word >> 16) & 0xff;
6997 word <<= 16;
6998 remaining -= 2;
6999 }
7000 }
7001
7002 switch (elf_header.e_machine)
7003 {
7004 case EM_ARM:
7005 if (per_index < 3)
7006 {
7007 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7008 data_offset, data_sec, data_arm_sec);
7009 }
7010 else
1b31d05e
NC		 7011 {
7012 warn (_("Unknown ARM compact model index encountered\n"));
7013 printf (_(" [reserved]\n"));
7014 }
fa197c1c
PB		 7015 break;
7016
7017 case EM_TI_C6000:
7018 if (per_index < 3)
7019 {
7020 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 7021 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 7022 }
7023 else if (per_index < 5)
7024 {
7025 if (((word >> 17) & 0x7f) == 0x7f)
7026 printf (_(" Restore stack from frame pointer\n"));
7027 else
7028 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
7029 printf (_(" Registers restored: "));
7030 if (per_index == 4)
7031 printf (" (compact) ");
7032 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7033 putchar ('\n');
7034 printf (_(" Return register: %s\n"),
7035 tic6x_unwind_regnames[word & 0xf]);
7036 }
7037 else
1b31d05e 7038 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 7039 break;
7040
7041 default:
1b31d05e
NC		 7042 error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7043 elf_header.e_machine);
fa197c1c 7044 }
0b6ae522
DJ		 7045
7046 /* Decode the descriptors. Not implemented. */
7047}
7048
7049static void
7050dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7051{
7052 struct arm_section exidx_arm_sec, extab_arm_sec;
7053 unsigned int i, exidx_len;
7054
7055 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7056 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7057 exidx_len = exidx_sec->sh_size / 8;
7058
7059 for (i = 0; i < exidx_len; i++)
7060 {
7061 unsigned int exidx_fn, exidx_entry;
7062 struct absaddr fn_addr, entry_addr;
7063 bfd_vma fn;
7064
7065 fputc ('\n', stdout);
7066
1b31d05e
NC		 7067 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7068 8 * i, & exidx_fn, & fn_addr, NULL)
7069 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7070 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 7071 {
1b31d05e
NC		 7072 arm_free_section (& exidx_arm_sec);
7073 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 7074 return;
7075 }
7076
83c257ca
NC		 7077 /* ARM EHABI, Section 5:
7078 An index table entry consists of 2 words.
7079 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7080 if (exidx_fn & 0x80000000)
7081 warn (_("corrupt index table entry: %x\n"), exidx_fn);
7082
a734115a 7083 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 7084
a734115a 7085 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 7086 fputs (": ", stdout);
7087
7088 if (exidx_entry == 1)
7089 {
7090 print_vma (exidx_entry, PREFIX_HEX);
7091 fputs (" [cantunwind]\n", stdout);
7092 }
7093 else if (exidx_entry & 0x80000000)
7094 {
7095 print_vma (exidx_entry, PREFIX_HEX);
7096 fputc ('\n', stdout);
7097 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7098 }
7099 else
7100 {
8f73510c 7101 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 7102 Elf_Internal_Shdr *table_sec;
7103
7104 fputs ("@", stdout);
a734115a 7105 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 7106 print_vma (table, PREFIX_HEX);
7107 printf ("\n");
7108
7109 /* Locate the matching .ARM.extab. */
7110 if (entry_addr.section != SHN_UNDEF
7111 && entry_addr.section < elf_header.e_shnum)
7112 {
7113 table_sec = section_headers + entry_addr.section;
7114 table_offset = entry_addr.offset;
7115 }
7116 else
7117 {
7118 table_sec = find_section_by_address (table);
7119 if (table_sec != NULL)
7120 table_offset = table - table_sec->sh_addr;
7121 }
7122 if (table_sec == NULL)
7123 {
7124 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7125 (unsigned long) table);
7126 continue;
7127 }
7128 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7129 &extab_arm_sec);
7130 }
7131 }
7132
7133 printf ("\n");
7134
7135 arm_free_section (&exidx_arm_sec);
7136 arm_free_section (&extab_arm_sec);
7137}
7138
fa197c1c 7139/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 7140
7141static void
0b6ae522
DJ		 7142arm_process_unwind (FILE *file)
7143{
7144 struct arm_unw_aux_info aux;
7145 Elf_Internal_Shdr *unwsec = NULL;
7146 Elf_Internal_Shdr *strsec;
7147 Elf_Internal_Shdr *sec;
7148 unsigned long i;
fa197c1c 7149 unsigned int sec_type;
0b6ae522 7150
fa197c1c
PB		 7151 switch (elf_header.e_machine)
7152 {
7153 case EM_ARM:
7154 sec_type = SHT_ARM_EXIDX;
7155 break;
7156
7157 case EM_TI_C6000:
7158 sec_type = SHT_C6000_UNWIND;
7159 break;
7160
1b31d05e
NC		 7161 default:
7162 error (_("Unsupported architecture type %d encountered when processing unwind table"),
7163 elf_header.e_machine);
7164 return;
fa197c1c
PB		 7165 }
7166
0b6ae522 7167 if (string_table == NULL)
1b31d05e
NC		 7168 return;
7169
7170 memset (& aux, 0, sizeof (aux));
7171 aux.file = file;
0b6ae522
DJ		 7172
7173 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7174 {
7175 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7176 {
ba5cdace 7177 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 7178
7179 strsec = section_headers + sec->sh_link;
59245841 7180 assert (aux.strtab == NULL);
0b6ae522
DJ		 7181 aux.strtab = get_data (NULL, file, strsec->sh_offset,
7182 1, strsec->sh_size, _("string table"));
7183 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7184 }
fa197c1c 7185 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 7186 unwsec = sec;
7187 }
7188
1b31d05e 7189 if (unwsec == NULL)
0b6ae522 7190 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 7191 else
7192 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7193 {
7194 if (sec->sh_type == sec_type)
7195 {
7196 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7197 SECTION_NAME (sec),
7198 (unsigned long) sec->sh_offset,
7199 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 7200
1b31d05e
NC		 7201 dump_arm_unwind (&aux, sec);
7202 }
7203 }
0b6ae522
DJ		 7204
7205 if (aux.symtab)
7206 free (aux.symtab);
7207 if (aux.strtab)
7208 free ((char *) aux.strtab);
0b6ae522
DJ		 7209}
7210
1b31d05e 7211static void
2cf0635d 7212process_unwind (FILE * file)
57346661 7213{
2cf0635d
NC		 7214 struct unwind_handler
7215 {
57346661 7216 int machtype;
1b31d05e 7217 void (* handler)(FILE *);
2cf0635d
NC		 7218 } handlers[] =
7219 {
0b6ae522 7220 { EM_ARM, arm_process_unwind },
57346661
AM		 7221 { EM_IA_64, ia64_process_unwind },
7222 { EM_PARISC, hppa_process_unwind },
fa197c1c 7223 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 7224 { 0, 0 }
7225 };
7226 int i;
7227
7228 if (!do_unwind)
1b31d05e 7229 return;
57346661
AM		 7230
7231 for (i = 0; handlers[i].handler != NULL; i++)
7232 if (elf_header.e_machine == handlers[i].machtype)
18bd398b 7233 return handlers[i].handler (file);
57346661 7234
1b31d05e
NC		 7235 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7236 get_machine_name (elf_header.e_machine));
57346661
AM		 7237}
7238
252b5132 7239static void
2cf0635d 7240dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 7241{
7242 switch (entry->d_tag)
7243 {
7244 case DT_MIPS_FLAGS:
7245 if (entry->d_un.d_val == 0)
4b68bca3 7246 printf (_("NONE"));
252b5132
RH		 7247 else
7248 {
7249 static const char * opts[] =
7250 {
7251 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7252 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7253 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7254 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7255 "RLD_ORDER_SAFE"
7256 };
7257 unsigned int cnt;
7258 int first = 1;
2b692964 7259
60bca95a 7260 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 7261 if (entry->d_un.d_val & (1 << cnt))
7262 {
7263 printf ("%s%s", first ? "" : " ", opts[cnt]);
7264 first = 0;
7265 }
252b5132
RH		 7266 }
7267 break;
103f02d3 7268
252b5132 7269 case DT_MIPS_IVERSION:
d79b3d50 7270 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 7271 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 7272 else
4b68bca3 7273 printf (_("<corrupt: %" BFD_VMA_FMT "d>"), entry->d_un.d_ptr);
252b5132 7274 break;
103f02d3 7275
252b5132
RH		 7276 case DT_MIPS_TIME_STAMP:
7277 {
7278 char timebuf[20];
2cf0635d 7279 struct tm * tmp;
50da7a9c 7280
91d6fa6a
NC		 7281 time_t atime = entry->d_un.d_val;
7282 tmp = gmtime (&atime);
e9e44622
JJ		 7283 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7284 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7285 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 7286 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 7287 }
7288 break;
103f02d3 7289
252b5132
RH		 7290 case DT_MIPS_RLD_VERSION:
7291 case DT_MIPS_LOCAL_GOTNO:
7292 case DT_MIPS_CONFLICTNO:
7293 case DT_MIPS_LIBLISTNO:
7294 case DT_MIPS_SYMTABNO:
7295 case DT_MIPS_UNREFEXTNO:
7296 case DT_MIPS_HIPAGENO:
7297 case DT_MIPS_DELTA_CLASS_NO:
7298 case DT_MIPS_DELTA_INSTANCE_NO:
7299 case DT_MIPS_DELTA_RELOC_NO:
7300 case DT_MIPS_DELTA_SYM_NO:
7301 case DT_MIPS_DELTA_CLASSSYM_NO:
7302 case DT_MIPS_COMPACT_SIZE:
4b68bca3 7303 print_vma (entry->d_un.d_ptr, DEC);
252b5132 7304 break;
103f02d3
UD		 7305
7306 default:
4b68bca3 7307 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 7308 }
4b68bca3 7309 putchar ('\n');
103f02d3
UD		 7310}
7311
103f02d3 7312static void
2cf0635d 7313dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 7314{
7315 switch (entry->d_tag)
7316 {
7317 case DT_HP_DLD_FLAGS:
7318 {
7319 static struct
7320 {
7321 long int bit;
2cf0635d 7322 const char * str;
5e220199
NC		 7323 }
7324 flags[] =
7325 {
7326 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7327 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7328 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7329 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7330 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7331 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7332 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7333 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7334 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7335 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 7336 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7337 { DT_HP_GST, "HP_GST" },
7338 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7339 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7340 { DT_HP_NODELETE, "HP_NODELETE" },
7341 { DT_HP_GROUP, "HP_GROUP" },
7342 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 7343 };
103f02d3 7344 int first = 1;
5e220199 7345 size_t cnt;
f7a99963 7346 bfd_vma val = entry->d_un.d_val;
103f02d3 7347
60bca95a 7348 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 7349 if (val & flags[cnt].bit)
30800947
NC		 7350 {
7351 if (! first)
7352 putchar (' ');
7353 fputs (flags[cnt].str, stdout);
7354 first = 0;
7355 val ^= flags[cnt].bit;
7356 }
76da6bbe 7357
103f02d3 7358 if (val != 0 || first)
f7a99963
NC		 7359 {
7360 if (! first)
7361 putchar (' ');
7362 print_vma (val, HEX);
7363 }
103f02d3
UD		 7364 }
7365 break;
76da6bbe 7366
252b5132 7367 default:
f7a99963
NC		 7368 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7369 break;
252b5132 7370 }
35b1837e 7371 putchar ('\n');
252b5132
RH		 7372}
7373
28f997cf
TG		 7374#ifdef BFD64
7375
7376/* VMS vs Unix time offset and factor. */
7377
7378#define VMS_EPOCH_OFFSET 35067168000000000LL
7379#define VMS_GRANULARITY_FACTOR 10000000
7380
7381/* Display a VMS time in a human readable format. */
7382
7383static void
7384print_vms_time (bfd_int64_t vmstime)
7385{
7386 struct tm *tm;
7387 time_t unxtime;
7388
7389 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7390 tm = gmtime (&unxtime);
7391 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7392 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7393 tm->tm_hour, tm->tm_min, tm->tm_sec);
7394}
7395#endif /* BFD64 */
7396
ecc51f48 7397static void
2cf0635d 7398dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 7399{
7400 switch (entry->d_tag)
7401 {
0de14b54 7402 case DT_IA_64_PLT_RESERVE:
bdf4d63a 7403 /* First 3 slots reserved. */
ecc51f48
NC		 7404 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7405 printf (" -- ");
7406 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 7407 break;
7408
28f997cf
TG		 7409 case DT_IA_64_VMS_LINKTIME:
7410#ifdef BFD64
7411 print_vms_time (entry->d_un.d_val);
7412#endif
7413 break;
7414
7415 case DT_IA_64_VMS_LNKFLAGS:
7416 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7417 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7418 printf (" CALL_DEBUG");
7419 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7420 printf (" NOP0BUFS");
7421 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7422 printf (" P0IMAGE");
7423 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7424 printf (" MKTHREADS");
7425 if (entry->d_un.d_val & VMS_LF_UPCALLS)
7426 printf (" UPCALLS");
7427 if (entry->d_un.d_val & VMS_LF_IMGSTA)
7428 printf (" IMGSTA");
7429 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7430 printf (" INITIALIZE");
7431 if (entry->d_un.d_val & VMS_LF_MAIN)
7432 printf (" MAIN");
7433 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7434 printf (" EXE_INIT");
7435 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7436 printf (" TBK_IN_IMG");
7437 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7438 printf (" DBG_IN_IMG");
7439 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7440 printf (" TBK_IN_DSF");
7441 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7442 printf (" DBG_IN_DSF");
7443 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7444 printf (" SIGNATURES");
7445 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7446 printf (" REL_SEG_OFF");
7447 break;
7448
bdf4d63a
JJ		 7449 default:
7450 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7451 break;
ecc51f48 7452 }
bdf4d63a 7453 putchar ('\n');
ecc51f48
NC		 7454}
7455
252b5132 7456static int
2cf0635d 7457get_32bit_dynamic_section (FILE * file)
252b5132 7458{
2cf0635d
NC		 7459 Elf32_External_Dyn * edyn;
7460 Elf32_External_Dyn * ext;
7461 Elf_Internal_Dyn * entry;
103f02d3 7462
3f5e193b
NC		 7463 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7464 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 7465 if (!edyn)
7466 return 0;
103f02d3 7467
ba2685cc
AM		 7468/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7469 might not have the luxury of section headers. Look for the DT_NULL
7470 terminator to determine the number of entries. */
7471 for (ext = edyn, dynamic_nent = 0;
7472 (char *) ext < (char *) edyn + dynamic_size;
7473 ext++)
7474 {
7475 dynamic_nent++;
7476 if (BYTE_GET (ext->d_tag) == DT_NULL)
7477 break;
7478 }
252b5132 7479
3f5e193b
NC		 7480 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7481 sizeof (* entry));
b2d38a17 7482 if (dynamic_section == NULL)
252b5132 7483 {
9ea033b2
NC		 7484 error (_("Out of memory\n"));
7485 free (edyn);
7486 return 0;
7487 }
252b5132 7488
fb514b26 7489 for (ext = edyn, entry = dynamic_section;
ba2685cc 7490 entry < dynamic_section + dynamic_nent;
fb514b26 7491 ext++, entry++)
9ea033b2 7492 {
fb514b26
AM		 7493 entry->d_tag = BYTE_GET (ext->d_tag);
7494 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 7495 }
7496
9ea033b2
NC		 7497 free (edyn);
7498
7499 return 1;
7500}
7501
7502static int
2cf0635d 7503get_64bit_dynamic_section (FILE * file)
9ea033b2 7504{
2cf0635d
NC		 7505 Elf64_External_Dyn * edyn;
7506 Elf64_External_Dyn * ext;
7507 Elf_Internal_Dyn * entry;
103f02d3 7508
3f5e193b
NC		 7509 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7510 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 7511 if (!edyn)
7512 return 0;
103f02d3 7513
ba2685cc
AM		 7514/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7515 might not have the luxury of section headers. Look for the DT_NULL
7516 terminator to determine the number of entries. */
7517 for (ext = edyn, dynamic_nent = 0;
7518 (char *) ext < (char *) edyn + dynamic_size;
7519 ext++)
7520 {
7521 dynamic_nent++;
66543521 7522 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 7523 break;
7524 }
252b5132 7525
3f5e193b
NC		 7526 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7527 sizeof (* entry));
b2d38a17 7528 if (dynamic_section == NULL)
252b5132
RH		 7529 {
7530 error (_("Out of memory\n"));
7531 free (edyn);
7532 return 0;
7533 }
7534
fb514b26 7535 for (ext = edyn, entry = dynamic_section;
ba2685cc 7536 entry < dynamic_section + dynamic_nent;
fb514b26 7537 ext++, entry++)
252b5132 7538 {
66543521
AM		 7539 entry->d_tag = BYTE_GET (ext->d_tag);
7540 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 7541 }
7542
7543 free (edyn);
7544
9ea033b2
NC		 7545 return 1;
7546}
7547
e9e44622
JJ		 7548static void
7549print_dynamic_flags (bfd_vma flags)
d1133906 7550{
e9e44622 7551 int first = 1;
13ae64f3 7552
d1133906
NC		 7553 while (flags)
7554 {
7555 bfd_vma flag;
7556
7557 flag = flags & - flags;
7558 flags &= ~ flag;
7559
e9e44622
JJ		 7560 if (first)
7561 first = 0;
7562 else
7563 putc (' ', stdout);
13ae64f3 7564
d1133906
NC		 7565 switch (flag)
7566 {
e9e44622
JJ		 7567 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
7568 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
7569 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
7570 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
7571 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 7572 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 7573 }
7574 }
e9e44622 7575 puts ("");
d1133906
NC		 7576}
7577
b2d38a17
NC		 7578/* Parse and display the contents of the dynamic section. */
7579
9ea033b2 7580static int
2cf0635d 7581process_dynamic_section (FILE * file)
9ea033b2 7582{
2cf0635d 7583 Elf_Internal_Dyn * entry;
9ea033b2
NC		 7584
7585 if (dynamic_size == 0)
7586 {
7587 if (do_dynamic)
b2d38a17 7588 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 7589
7590 return 1;
7591 }
7592
7593 if (is_32bit_elf)
7594 {
b2d38a17 7595 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 7596 return 0;
7597 }
b2d38a17 7598 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 7599 return 0;
7600
252b5132
RH		 7601 /* Find the appropriate symbol table. */
7602 if (dynamic_symbols == NULL)
7603 {
86dba8ee
AM		 7604 for (entry = dynamic_section;
7605 entry < dynamic_section + dynamic_nent;
7606 ++entry)
252b5132 7607 {
c8286bd1 7608 Elf_Internal_Shdr section;
252b5132
RH		 7609
7610 if (entry->d_tag != DT_SYMTAB)
7611 continue;
7612
7613 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7614
7615 /* Since we do not know how big the symbol table is,
7616 we default to reading in the entire file (!) and
7617 processing that. This is overkill, I know, but it
e3c8793a 7618 should work. */
d93f0186 7619 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 7620
fb52b2f4
NC		 7621 if (archive_file_offset != 0)
7622 section.sh_size = archive_file_size - section.sh_offset;
7623 else
7624 {
7625 if (fseek (file, 0, SEEK_END))
591a748a 7626 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 7627
7628 section.sh_size = ftell (file) - section.sh_offset;
7629 }
252b5132 7630
9ea033b2 7631 if (is_32bit_elf)
9ad5cbcf 7632 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 7633 else
9ad5cbcf 7634 section.sh_entsize = sizeof (Elf64_External_Sym);
252b5132 7635
ba5cdace 7636 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 7637 if (num_dynamic_syms < 1)
252b5132
RH		 7638 {
7639 error (_("Unable to determine the number of symbols to load\n"));
7640 continue;
7641 }
252b5132
RH		 7642 }
7643 }
7644
7645 /* Similarly find a string table. */
7646 if (dynamic_strings == NULL)
7647 {
86dba8ee
AM		 7648 for (entry = dynamic_section;
7649 entry < dynamic_section + dynamic_nent;
7650 ++entry)
252b5132
RH		 7651 {
7652 unsigned long offset;
b34976b6 7653 long str_tab_len;
252b5132
RH		 7654
7655 if (entry->d_tag != DT_STRTAB)
7656 continue;
7657
7658 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7659
7660 /* Since we do not know how big the string table is,
7661 we default to reading in the entire file (!) and
7662 processing that. This is overkill, I know, but it
e3c8793a 7663 should work. */
252b5132 7664
d93f0186 7665 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 7666
7667 if (archive_file_offset != 0)
7668 str_tab_len = archive_file_size - offset;
7669 else
7670 {
7671 if (fseek (file, 0, SEEK_END))
7672 error (_("Unable to seek to end of file\n"));
7673 str_tab_len = ftell (file) - offset;
7674 }
252b5132
RH		 7675
7676 if (str_tab_len < 1)
7677 {
7678 error
7679 (_("Unable to determine the length of the dynamic string table\n"));
7680 continue;
7681 }
7682
3f5e193b
NC		 7683 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7684 str_tab_len,
7685 _("dynamic string table"));
59245841 7686 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 7687 break;
7688 }
7689 }
7690
7691 /* And find the syminfo section if available. */
7692 if (dynamic_syminfo == NULL)
7693 {
3e8bba36 7694 unsigned long syminsz = 0;
252b5132 7695
86dba8ee
AM		 7696 for (entry = dynamic_section;
7697 entry < dynamic_section + dynamic_nent;
7698 ++entry)
252b5132
RH		 7699 {
7700 if (entry->d_tag == DT_SYMINENT)
7701 {
7702 /* Note: these braces are necessary to avoid a syntax
7703 error from the SunOS4 C compiler. */
7704 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7705 }
7706 else if (entry->d_tag == DT_SYMINSZ)
7707 syminsz = entry->d_un.d_val;
7708 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 7709 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7710 syminsz);
252b5132
RH		 7711 }
7712
7713 if (dynamic_syminfo_offset != 0 && syminsz != 0)
7714 {
2cf0635d
NC		 7715 Elf_External_Syminfo * extsyminfo;
7716 Elf_External_Syminfo * extsym;
7717 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 7718
7719 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 7720 extsyminfo = (Elf_External_Syminfo *)
7721 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
7722 _("symbol information"));
a6e9f9df
AM		 7723 if (!extsyminfo)
7724 return 0;
252b5132 7725
3f5e193b 7726 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 7727 if (dynamic_syminfo == NULL)
7728 {
7729 error (_("Out of memory\n"));
7730 return 0;
7731 }
7732
7733 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 7734 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
7735 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
7736 ++syminfo, ++extsym)
252b5132 7737 {
86dba8ee
AM		 7738 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
7739 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 7740 }
7741
7742 free (extsyminfo);
7743 }
7744 }
7745
7746 if (do_dynamic && dynamic_addr)
86dba8ee
AM		 7747 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7748 dynamic_addr, dynamic_nent);
252b5132
RH		 7749 if (do_dynamic)
7750 printf (_(" Tag Type Name/Value\n"));
7751
86dba8ee
AM		 7752 for (entry = dynamic_section;
7753 entry < dynamic_section + dynamic_nent;
7754 entry++)
252b5132
RH		 7755 {
7756 if (do_dynamic)
f7a99963 7757 {
2cf0635d 7758 const char * dtype;
e699b9ff 7759
f7a99963
NC		 7760 putchar (' ');
7761 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 7762 dtype = get_dynamic_type (entry->d_tag);
7763 printf (" (%s)%*s", dtype,
7764 ((is_32bit_elf ? 27 : 19)
7765 - (int) strlen (dtype)),
f7a99963
NC		 7766 " ");
7767 }
252b5132
RH		 7768
7769 switch (entry->d_tag)
7770 {
d1133906
NC		 7771 case DT_FLAGS:
7772 if (do_dynamic)
e9e44622 7773 print_dynamic_flags (entry->d_un.d_val);
d1133906 7774 break;
76da6bbe 7775
252b5132
RH		 7776 case DT_AUXILIARY:
7777 case DT_FILTER:
019148e4
L		 7778 case DT_CONFIG:
7779 case DT_DEPAUDIT:
7780 case DT_AUDIT:
252b5132
RH		 7781 if (do_dynamic)
7782 {
019148e4 7783 switch (entry->d_tag)
b34976b6 7784 {
019148e4
L		 7785 case DT_AUXILIARY:
7786 printf (_("Auxiliary library"));
7787 break;
7788
7789 case DT_FILTER:
7790 printf (_("Filter library"));
7791 break;
7792
b34976b6 7793 case DT_CONFIG:
019148e4
L		 7794 printf (_("Configuration file"));
7795 break;
7796
7797 case DT_DEPAUDIT:
7798 printf (_("Dependency audit library"));
7799 break;
7800
7801 case DT_AUDIT:
7802 printf (_("Audit library"));
7803 break;
7804 }
252b5132 7805
d79b3d50
NC		 7806 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7807 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 7808 else
f7a99963
NC		 7809 {
7810 printf (": ");
7811 print_vma (entry->d_un.d_val, PREFIX_HEX);
7812 putchar ('\n');
7813 }
252b5132
RH		 7814 }
7815 break;
7816
dcefbbbd 7817 case DT_FEATURE:
252b5132
RH		 7818 if (do_dynamic)
7819 {
7820 printf (_("Flags:"));
86f55779 7821
252b5132
RH		 7822 if (entry->d_un.d_val == 0)
7823 printf (_(" None\n"));
7824 else
7825 {
7826 unsigned long int val = entry->d_un.d_val;
86f55779 7827
252b5132
RH		 7828 if (val & DTF_1_PARINIT)
7829 {
7830 printf (" PARINIT");
7831 val ^= DTF_1_PARINIT;
7832 }
dcefbbbd
L		 7833 if (val & DTF_1_CONFEXP)
7834 {
7835 printf (" CONFEXP");
7836 val ^= DTF_1_CONFEXP;
7837 }
252b5132
RH		 7838 if (val != 0)
7839 printf (" %lx", val);
7840 puts ("");
7841 }
7842 }
7843 break;
7844
7845 case DT_POSFLAG_1:
7846 if (do_dynamic)
7847 {
7848 printf (_("Flags:"));
86f55779 7849
252b5132
RH		 7850 if (entry->d_un.d_val == 0)
7851 printf (_(" None\n"));
7852 else
7853 {
7854 unsigned long int val = entry->d_un.d_val;
86f55779 7855
252b5132
RH		 7856 if (val & DF_P1_LAZYLOAD)
7857 {
7858 printf (" LAZYLOAD");
7859 val ^= DF_P1_LAZYLOAD;
7860 }
7861 if (val & DF_P1_GROUPPERM)
7862 {
7863 printf (" GROUPPERM");
7864 val ^= DF_P1_GROUPPERM;
7865 }
7866 if (val != 0)
7867 printf (" %lx", val);
7868 puts ("");
7869 }
7870 }
7871 break;
7872
7873 case DT_FLAGS_1:
7874 if (do_dynamic)
7875 {
7876 printf (_("Flags:"));
7877 if (entry->d_un.d_val == 0)
7878 printf (_(" None\n"));
7879 else
7880 {
7881 unsigned long int val = entry->d_un.d_val;
86f55779 7882
252b5132
RH		 7883 if (val & DF_1_NOW)
7884 {
7885 printf (" NOW");
7886 val ^= DF_1_NOW;
7887 }
7888 if (val & DF_1_GLOBAL)
7889 {
7890 printf (" GLOBAL");
7891 val ^= DF_1_GLOBAL;
7892 }
7893 if (val & DF_1_GROUP)
7894 {
7895 printf (" GROUP");
7896 val ^= DF_1_GROUP;
7897 }
7898 if (val & DF_1_NODELETE)
7899 {
7900 printf (" NODELETE");
7901 val ^= DF_1_NODELETE;
7902 }
7903 if (val & DF_1_LOADFLTR)
7904 {
7905 printf (" LOADFLTR");
7906 val ^= DF_1_LOADFLTR;
7907 }
7908 if (val & DF_1_INITFIRST)
7909 {
7910 printf (" INITFIRST");
7911 val ^= DF_1_INITFIRST;
7912 }
7913 if (val & DF_1_NOOPEN)
7914 {
7915 printf (" NOOPEN");
7916 val ^= DF_1_NOOPEN;
7917 }
7918 if (val & DF_1_ORIGIN)
7919 {
7920 printf (" ORIGIN");
7921 val ^= DF_1_ORIGIN;
7922 }
7923 if (val & DF_1_DIRECT)
7924 {
7925 printf (" DIRECT");
7926 val ^= DF_1_DIRECT;
7927 }
7928 if (val & DF_1_TRANS)
7929 {
7930 printf (" TRANS");
7931 val ^= DF_1_TRANS;
7932 }
7933 if (val & DF_1_INTERPOSE)
7934 {
7935 printf (" INTERPOSE");
7936 val ^= DF_1_INTERPOSE;
7937 }
f7db6139 7938 if (val & DF_1_NODEFLIB)
dcefbbbd 7939 {
f7db6139
L		 7940 printf (" NODEFLIB");
7941 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 7942 }
7943 if (val & DF_1_NODUMP)
7944 {
7945 printf (" NODUMP");
7946 val ^= DF_1_NODUMP;
7947 }
7948 if (val & DF_1_CONLFAT)
7949 {
7950 printf (" CONLFAT");
7951 val ^= DF_1_CONLFAT;
7952 }
252b5132
RH		 7953 if (val != 0)
7954 printf (" %lx", val);
7955 puts ("");
7956 }
7957 }
7958 break;
7959
7960 case DT_PLTREL:
566b0d53 7961 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 7962 if (do_dynamic)
7963 puts (get_dynamic_type (entry->d_un.d_val));
7964 break;
7965
7966 case DT_NULL :
7967 case DT_NEEDED :
7968 case DT_PLTGOT :
7969 case DT_HASH :
7970 case DT_STRTAB :
7971 case DT_SYMTAB :
7972 case DT_RELA :
7973 case DT_INIT :
7974 case DT_FINI :
7975 case DT_SONAME :
7976 case DT_RPATH :
7977 case DT_SYMBOLIC:
7978 case DT_REL :
7979 case DT_DEBUG :
7980 case DT_TEXTREL :
7981 case DT_JMPREL :
019148e4 7982 case DT_RUNPATH :
252b5132
RH		 7983 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7984
7985 if (do_dynamic)
7986 {
2cf0635d 7987 char * name;
252b5132 7988
d79b3d50
NC		 7989 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7990 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 7991 else
d79b3d50 7992 name = NULL;
252b5132
RH		 7993
7994 if (name)
7995 {
7996 switch (entry->d_tag)
7997 {
7998 case DT_NEEDED:
7999 printf (_("Shared library: [%s]"), name);
8000
18bd398b 8001 if (streq (name, program_interpreter))
f7a99963 8002 printf (_(" program interpreter"));
252b5132
RH		 8003 break;
8004
8005 case DT_SONAME:
f7a99963 8006 printf (_("Library soname: [%s]"), name);
252b5132
RH		 8007 break;
8008
8009 case DT_RPATH:
f7a99963 8010 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 8011 break;
8012
019148e4
L		 8013 case DT_RUNPATH:
8014 printf (_("Library runpath: [%s]"), name);
8015 break;
8016
252b5132 8017 default:
f7a99963
NC		 8018 print_vma (entry->d_un.d_val, PREFIX_HEX);
8019 break;
252b5132
RH		 8020 }
8021 }
8022 else
f7a99963
NC		 8023 print_vma (entry->d_un.d_val, PREFIX_HEX);
8024
8025 putchar ('\n');
252b5132
RH		 8026 }
8027 break;
8028
8029 case DT_PLTRELSZ:
8030 case DT_RELASZ :
8031 case DT_STRSZ :
8032 case DT_RELSZ :
8033 case DT_RELAENT :
8034 case DT_SYMENT :
8035 case DT_RELENT :
566b0d53 8036 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 8037 case DT_PLTPADSZ:
8038 case DT_MOVEENT :
8039 case DT_MOVESZ :
8040 case DT_INIT_ARRAYSZ:
8041 case DT_FINI_ARRAYSZ:
047b2264
JJ		 8042 case DT_GNU_CONFLICTSZ:
8043 case DT_GNU_LIBLISTSZ:
252b5132 8044 if (do_dynamic)
f7a99963
NC		 8045 {
8046 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 8047 printf (_(" (bytes)\n"));
f7a99963 8048 }
252b5132
RH		 8049 break;
8050
8051 case DT_VERDEFNUM:
8052 case DT_VERNEEDNUM:
8053 case DT_RELACOUNT:
8054 case DT_RELCOUNT:
8055 if (do_dynamic)
f7a99963
NC		 8056 {
8057 print_vma (entry->d_un.d_val, UNSIGNED);
8058 putchar ('\n');
8059 }
252b5132
RH		 8060 break;
8061
8062 case DT_SYMINSZ:
8063 case DT_SYMINENT:
8064 case DT_SYMINFO:
8065 case DT_USED:
8066 case DT_INIT_ARRAY:
8067 case DT_FINI_ARRAY:
8068 if (do_dynamic)
8069 {
d79b3d50
NC		 8070 if (entry->d_tag == DT_USED
8071 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 8072 {
2cf0635d 8073 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 8074
b34976b6 8075 if (*name)
252b5132
RH		 8076 {
8077 printf (_("Not needed object: [%s]\n"), name);
8078 break;
8079 }
8080 }
103f02d3 8081
f7a99963
NC		 8082 print_vma (entry->d_un.d_val, PREFIX_HEX);
8083 putchar ('\n');
252b5132
RH		 8084 }
8085 break;
8086
8087 case DT_BIND_NOW:
8088 /* The value of this entry is ignored. */
35b1837e
AM		 8089 if (do_dynamic)
8090 putchar ('\n');
252b5132 8091 break;
103f02d3 8092
047b2264
JJ		 8093 case DT_GNU_PRELINKED:
8094 if (do_dynamic)
8095 {
2cf0635d 8096 struct tm * tmp;
91d6fa6a 8097 time_t atime = entry->d_un.d_val;
047b2264 8098
91d6fa6a 8099 tmp = gmtime (&atime);
047b2264
JJ		 8100 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8101 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8102 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8103
8104 }
8105 break;
8106
fdc90cb4
JJ		 8107 case DT_GNU_HASH:
8108 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8109 if (do_dynamic)
8110 {
8111 print_vma (entry->d_un.d_val, PREFIX_HEX);
8112 putchar ('\n');
8113 }
8114 break;
8115
252b5132
RH		 8116 default:
8117 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 8118 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 8119 entry->d_un.d_val;
8120
8121 if (do_dynamic)
8122 {
8123 switch (elf_header.e_machine)
8124 {
8125 case EM_MIPS:
4fe85591 8126 case EM_MIPS_RS3_LE:
b2d38a17 8127 dynamic_section_mips_val (entry);
252b5132 8128 break;
103f02d3 8129 case EM_PARISC:
b2d38a17 8130 dynamic_section_parisc_val (entry);
103f02d3 8131 break;
ecc51f48 8132 case EM_IA_64:
b2d38a17 8133 dynamic_section_ia64_val (entry);
ecc51f48 8134 break;
252b5132 8135 default:
f7a99963
NC		 8136 print_vma (entry->d_un.d_val, PREFIX_HEX);
8137 putchar ('\n');
252b5132
RH		 8138 }
8139 }
8140 break;
8141 }
8142 }
8143
8144 return 1;
8145}
8146
8147static char *
d3ba0551 8148get_ver_flags (unsigned int flags)
252b5132 8149{
b34976b6 8150 static char buff[32];
252b5132
RH		 8151
8152 buff[0] = 0;
8153
8154 if (flags == 0)
8155 return _("none");
8156
8157 if (flags & VER_FLG_BASE)
8158 strcat (buff, "BASE ");
8159
8160 if (flags & VER_FLG_WEAK)
8161 {
8162 if (flags & VER_FLG_BASE)
8163 strcat (buff, "| ");
8164
8165 strcat (buff, "WEAK ");
8166 }
8167
44ec90b9
RO		 8168 if (flags & VER_FLG_INFO)
8169 {
8170 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8171 strcat (buff, "| ");
8172
8173 strcat (buff, "INFO ");
8174 }
8175
8176 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 8177 strcat (buff, _("| <unknown>"));
252b5132
RH		 8178
8179 return buff;
8180}
8181
8182/* Display the contents of the version sections. */
98fb390a 8183
252b5132 8184static int
2cf0635d 8185process_version_sections (FILE * file)
252b5132 8186{
2cf0635d 8187 Elf_Internal_Shdr * section;
b34976b6
AM		 8188 unsigned i;
8189 int found = 0;
252b5132
RH		 8190
8191 if (! do_version)
8192 return 1;
8193
8194 for (i = 0, section = section_headers;
8195 i < elf_header.e_shnum;
b34976b6 8196 i++, section++)
252b5132
RH		 8197 {
8198 switch (section->sh_type)
8199 {
8200 case SHT_GNU_verdef:
8201 {
2cf0635d 8202 Elf_External_Verdef * edefs;
b34976b6
AM		 8203 unsigned int idx;
8204 unsigned int cnt;
2cf0635d 8205 char * endbuf;
252b5132
RH		 8206
8207 found = 1;
8208
8209 printf
72de5009 8210 (_("\nVersion definition section '%s' contains %u entries:\n"),
252b5132
RH		 8211 SECTION_NAME (section), section->sh_info);
8212
8213 printf (_(" Addr: 0x"));
8214 printf_vma (section->sh_addr);
72de5009 8215 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8216 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8217 section->sh_link < elf_header.e_shnum
8218 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8219 : _("<corrupt>"));
252b5132 8220
3f5e193b
NC		 8221 edefs = (Elf_External_Verdef *)
8222 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8223 _("version definition section"));
a6e9f9df
AM		 8224 if (!edefs)
8225 break;
59245841 8226 endbuf = (char *) edefs + section->sh_size;
252b5132 8227
b34976b6 8228 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 8229 {
2cf0635d
NC		 8230 char * vstart;
8231 Elf_External_Verdef * edef;
b34976b6 8232 Elf_Internal_Verdef ent;
2cf0635d 8233 Elf_External_Verdaux * eaux;
b34976b6
AM		 8234 Elf_Internal_Verdaux aux;
8235 int j;
8236 int isum;
103f02d3 8237
dd24e3da
NC		 8238 /* Check for negative or very large indicies. */
8239 if ((unsigned char *) edefs + idx < (unsigned char *) edefs)
8240 break;
8241
252b5132 8242 vstart = ((char *) edefs) + idx;
54806181
AM		 8243 if (vstart + sizeof (*edef) > endbuf)
8244 break;
252b5132
RH		 8245
8246 edef = (Elf_External_Verdef *) vstart;
8247
8248 ent.vd_version = BYTE_GET (edef->vd_version);
8249 ent.vd_flags = BYTE_GET (edef->vd_flags);
8250 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
8251 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
8252 ent.vd_hash = BYTE_GET (edef->vd_hash);
8253 ent.vd_aux = BYTE_GET (edef->vd_aux);
8254 ent.vd_next = BYTE_GET (edef->vd_next);
8255
8256 printf (_(" %#06x: Rev: %d Flags: %s"),
8257 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8258
8259 printf (_(" Index: %d Cnt: %d "),
8260 ent.vd_ndx, ent.vd_cnt);
8261
dd24e3da
NC		 8262 /* Check for overflow. */
8263 if ((unsigned char *)(vstart + ent.vd_aux) < (unsigned char *) vstart
8264 || (unsigned char *)(vstart + ent.vd_aux) > (unsigned char *) endbuf)
8265 break;
8266
252b5132
RH		 8267 vstart += ent.vd_aux;
8268
8269 eaux = (Elf_External_Verdaux *) vstart;
8270
8271 aux.vda_name = BYTE_GET (eaux->vda_name);
8272 aux.vda_next = BYTE_GET (eaux->vda_next);
8273
d79b3d50
NC		 8274 if (VALID_DYNAMIC_NAME (aux.vda_name))
8275 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8276 else
8277 printf (_("Name index: %ld\n"), aux.vda_name);
8278
8279 isum = idx + ent.vd_aux;
8280
b34976b6 8281 for (j = 1; j < ent.vd_cnt; j++)
252b5132 8282 {
dd24e3da
NC		 8283 /* Check for overflow. */
8284 if ((unsigned char *)(vstart + aux.vda_next) < (unsigned char *) vstart
8285 || (unsigned char *)(vstart + aux.vda_next) > (unsigned char *) endbuf)
8286 break;
8287
252b5132
RH		 8288 isum += aux.vda_next;
8289 vstart += aux.vda_next;
8290
8291 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 8292 if (vstart + sizeof (*eaux) > endbuf)
8293 break;
252b5132
RH		 8294
8295 aux.vda_name = BYTE_GET (eaux->vda_name);
8296 aux.vda_next = BYTE_GET (eaux->vda_next);
8297
d79b3d50 8298 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 8299 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 8300 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8301 else
8302 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8303 isum, j, aux.vda_name);
8304 }
dd24e3da 8305
54806181
AM		 8306 if (j < ent.vd_cnt)
8307 printf (_(" Version def aux past end of section\n"));
252b5132
RH		 8308
8309 idx += ent.vd_next;
8310 }
dd24e3da 8311
54806181
AM		 8312 if (cnt < section->sh_info)
8313 printf (_(" Version definition past end of section\n"));
252b5132
RH		 8314
8315 free (edefs);
8316 }
8317 break;
103f02d3 8318
252b5132
RH		 8319 case SHT_GNU_verneed:
8320 {
2cf0635d 8321 Elf_External_Verneed * eneed;
b34976b6
AM		 8322 unsigned int idx;
8323 unsigned int cnt;
2cf0635d 8324 char * endbuf;
252b5132
RH		 8325
8326 found = 1;
8327
72de5009 8328 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
252b5132
RH		 8329 SECTION_NAME (section), section->sh_info);
8330
8331 printf (_(" Addr: 0x"));
8332 printf_vma (section->sh_addr);
72de5009 8333 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8334 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8335 section->sh_link < elf_header.e_shnum
8336 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8337 : _("<corrupt>"));
252b5132 8338
3f5e193b
NC		 8339 eneed = (Elf_External_Verneed *) get_data (NULL, file,
8340 section->sh_offset, 1,
8341 section->sh_size,
9cf03b7e 8342 _("Version Needs section"));
a6e9f9df
AM		 8343 if (!eneed)
8344 break;
59245841 8345 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 8346
8347 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8348 {
2cf0635d 8349 Elf_External_Verneed * entry;
b34976b6
AM		 8350 Elf_Internal_Verneed ent;
8351 int j;
8352 int isum;
2cf0635d 8353 char * vstart;
252b5132 8354
dd24e3da
NC		 8355 if ((unsigned char *) eneed + idx < (unsigned char *) eneed)
8356 break;
8357
252b5132 8358 vstart = ((char *) eneed) + idx;
54806181
AM		 8359 if (vstart + sizeof (*entry) > endbuf)
8360 break;
252b5132
RH		 8361
8362 entry = (Elf_External_Verneed *) vstart;
8363
8364 ent.vn_version = BYTE_GET (entry->vn_version);
8365 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
8366 ent.vn_file = BYTE_GET (entry->vn_file);
8367 ent.vn_aux = BYTE_GET (entry->vn_aux);
8368 ent.vn_next = BYTE_GET (entry->vn_next);
8369
8370 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
8371
d79b3d50
NC		 8372 if (VALID_DYNAMIC_NAME (ent.vn_file))
8373 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 8374 else
8375 printf (_(" File: %lx"), ent.vn_file);
8376
8377 printf (_(" Cnt: %d\n"), ent.vn_cnt);
8378
dd24e3da
NC		 8379 /* Check for overflow. */
8380 if ((unsigned char *)(vstart + ent.vn_aux) < (unsigned char *) vstart
8381 || (unsigned char *)(vstart + ent.vn_aux) > (unsigned char *) endbuf)
8382 break;
8383
252b5132
RH		 8384 vstart += ent.vn_aux;
8385
8386 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8387 {
2cf0635d 8388 Elf_External_Vernaux * eaux;
b34976b6 8389 Elf_Internal_Vernaux aux;
252b5132 8390
54806181
AM		 8391 if (vstart + sizeof (*eaux) > endbuf)
8392 break;
252b5132
RH		 8393 eaux = (Elf_External_Vernaux *) vstart;
8394
8395 aux.vna_hash = BYTE_GET (eaux->vna_hash);
8396 aux.vna_flags = BYTE_GET (eaux->vna_flags);
8397 aux.vna_other = BYTE_GET (eaux->vna_other);
8398 aux.vna_name = BYTE_GET (eaux->vna_name);
8399 aux.vna_next = BYTE_GET (eaux->vna_next);
8400
d79b3d50 8401 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 8402 printf (_(" %#06x: Name: %s"),
d79b3d50 8403 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 8404 else
ecc2063b 8405 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 8406 isum, aux.vna_name);
8407
8408 printf (_(" Flags: %s Version: %d\n"),
8409 get_ver_flags (aux.vna_flags), aux.vna_other);
8410
dd24e3da
NC		 8411 /* Check for overflow. */
8412 if ((unsigned char *)(vstart + aux.vna_next) < (unsigned char *) vstart
8413 || (unsigned char *)(vstart + aux.vna_next) > (unsigned char *) endbuf)
8414 break;
8415
252b5132
RH		 8416 isum += aux.vna_next;
8417 vstart += aux.vna_next;
8418 }
9cf03b7e 8419
54806181 8420 if (j < ent.vn_cnt)
9cf03b7e 8421 warn (_("Missing Version Needs auxillary information\n"));
252b5132
RH		 8422
8423 idx += ent.vn_next;
8424 }
9cf03b7e 8425
54806181 8426 if (cnt < section->sh_info)
9cf03b7e 8427 warn (_("Missing Version Needs information\n"));
103f02d3 8428
252b5132
RH		 8429 free (eneed);
8430 }
8431 break;
8432
8433 case SHT_GNU_versym:
8434 {
2cf0635d 8435 Elf_Internal_Shdr * link_section;
b34976b6
AM		 8436 int total;
8437 int cnt;
2cf0635d
NC		 8438 unsigned char * edata;
8439 unsigned short * data;
8440 char * strtab;
8441 Elf_Internal_Sym * symbols;
8442 Elf_Internal_Shdr * string_sec;
ba5cdace 8443 unsigned long num_syms;
d3ba0551 8444 long off;
252b5132 8445
4fbb74a6 8446 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 8447 break;
8448
4fbb74a6 8449 link_section = section_headers + section->sh_link;
08d8fa11 8450 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 8451
4fbb74a6 8452 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 8453 break;
8454
252b5132
RH		 8455 found = 1;
8456
ba5cdace 8457 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 8458 if (symbols == NULL)
8459 break;
252b5132 8460
4fbb74a6 8461 string_sec = section_headers + link_section->sh_link;
252b5132 8462
3f5e193b
NC		 8463 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8464 string_sec->sh_size,
8465 _("version string table"));
a6e9f9df 8466 if (!strtab)
0429c154
MS		 8467 {
8468 free (symbols);
8469 break;
8470 }
252b5132
RH		 8471
8472 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8473 SECTION_NAME (section), total);
8474
8475 printf (_(" Addr: "));
8476 printf_vma (section->sh_addr);
72de5009 8477 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8478 (unsigned long) section->sh_offset, section->sh_link,
252b5132
RH		 8479 SECTION_NAME (link_section));
8480
d3ba0551
AM		 8481 off = offset_from_vma (file,
8482 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8483 total * sizeof (short));
3f5e193b
NC		 8484 edata = (unsigned char *) get_data (NULL, file, off, total,
8485 sizeof (short),
8486 _("version symbol data"));
a6e9f9df
AM		 8487 if (!edata)
8488 {
8489 free (strtab);
0429c154 8490 free (symbols);
a6e9f9df
AM		 8491 break;
8492 }
252b5132 8493
3f5e193b 8494 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 8495
8496 for (cnt = total; cnt --;)
b34976b6
AM		 8497 data[cnt] = byte_get (edata + cnt * sizeof (short),
8498 sizeof (short));
252b5132
RH		 8499
8500 free (edata);
8501
8502 for (cnt = 0; cnt < total; cnt += 4)
8503 {
8504 int j, nn;
00d93f34 8505 int check_def, check_need;
2cf0635d 8506 char * name;
252b5132
RH		 8507
8508 printf (" %03x:", cnt);
8509
8510 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 8511 switch (data[cnt + j])
252b5132
RH		 8512 {
8513 case 0:
8514 fputs (_(" 0 (*local*) "), stdout);
8515 break;
8516
8517 case 1:
8518 fputs (_(" 1 (*global*) "), stdout);
8519 break;
8520
8521 default:
c244d050
NC		 8522 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8523 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 8524
dd24e3da 8525 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 8526 array, break to avoid an out-of-bounds read. */
8527 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 8528 {
8529 warn (_("invalid index into symbol array\n"));
8530 break;
8531 }
8532
00d93f34
JJ		 8533 check_def = 1;
8534 check_need = 1;
4fbb74a6
AM		 8535 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8536 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 8537 != SHT_NOBITS)
252b5132 8538 {
b34976b6 8539 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 8540 check_def = 0;
8541 else
8542 check_need = 0;
252b5132 8543 }
00d93f34
JJ		 8544
8545 if (check_need
b34976b6 8546 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 8547 {
b34976b6
AM		 8548 Elf_Internal_Verneed ivn;
8549 unsigned long offset;
252b5132 8550
d93f0186
NC		 8551 offset = offset_from_vma
8552 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8553 sizeof (Elf_External_Verneed));
252b5132 8554
b34976b6 8555 do
252b5132 8556 {
b34976b6
AM		 8557 Elf_Internal_Vernaux ivna;
8558 Elf_External_Verneed evn;
8559 Elf_External_Vernaux evna;
8560 unsigned long a_off;
252b5132 8561
59245841
NC		 8562 if (get_data (&evn, file, offset, sizeof (evn), 1,
8563 _("version need")) == NULL)
8564 break;
8565
252b5132
RH		 8566 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8567 ivn.vn_next = BYTE_GET (evn.vn_next);
8568
8569 a_off = offset + ivn.vn_aux;
8570
8571 do
8572 {
59245841
NC		 8573 if (get_data (&evna, file, a_off, sizeof (evna),
8574 1, _("version need aux (2)")) == NULL)
8575 {
8576 ivna.vna_next = 0;
8577 ivna.vna_other = 0;
8578 }
8579 else
8580 {
8581 ivna.vna_next = BYTE_GET (evna.vna_next);
8582 ivna.vna_other = BYTE_GET (evna.vna_other);
8583 }
252b5132
RH		 8584
8585 a_off += ivna.vna_next;
8586 }
b34976b6 8587 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 8588 && ivna.vna_next != 0);
8589
b34976b6 8590 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 8591 {
8592 ivna.vna_name = BYTE_GET (evna.vna_name);
8593
54806181
AM		 8594 if (ivna.vna_name >= string_sec->sh_size)
8595 name = _("*invalid*");
8596 else
8597 name = strtab + ivna.vna_name;
252b5132 8598 nn += printf ("(%s%-*s",
16062207
ILT		 8599 name,
8600 12 - (int) strlen (name),
252b5132 8601 ")");
00d93f34 8602 check_def = 0;
252b5132
RH		 8603 break;
8604 }
8605
8606 offset += ivn.vn_next;
8607 }
8608 while (ivn.vn_next);
8609 }
00d93f34 8610
b34976b6
AM		 8611 if (check_def && data[cnt + j] != 0x8001
8612 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 8613 {
b34976b6
AM		 8614 Elf_Internal_Verdef ivd;
8615 Elf_External_Verdef evd;
8616 unsigned long offset;
252b5132 8617
d93f0186
NC		 8618 offset = offset_from_vma
8619 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8620 sizeof evd);
252b5132
RH		 8621
8622 do
8623 {
59245841
NC		 8624 if (get_data (&evd, file, offset, sizeof (evd), 1,
8625 _("version def")) == NULL)
8626 {
8627 ivd.vd_next = 0;
8628 ivd.vd_ndx = 0;
8629 }
8630 else
8631 {
8632 ivd.vd_next = BYTE_GET (evd.vd_next);
8633 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8634 }
252b5132
RH		 8635
8636 offset += ivd.vd_next;
8637 }
c244d050 8638 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 8639 && ivd.vd_next != 0);
8640
c244d050 8641 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 8642 {
b34976b6
AM		 8643 Elf_External_Verdaux evda;
8644 Elf_Internal_Verdaux ivda;
252b5132
RH		 8645
8646 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8647
59245841
NC		 8648 if (get_data (&evda, file,
8649 offset - ivd.vd_next + ivd.vd_aux,
8650 sizeof (evda), 1,
8651 _("version def aux")) == NULL)
8652 break;
252b5132
RH		 8653
8654 ivda.vda_name = BYTE_GET (evda.vda_name);
8655
54806181
AM		 8656 if (ivda.vda_name >= string_sec->sh_size)
8657 name = _("*invalid*");
8658 else
8659 name = strtab + ivda.vda_name;
252b5132 8660 nn += printf ("(%s%-*s",
16062207
ILT		 8661 name,
8662 12 - (int) strlen (name),
252b5132
RH		 8663 ")");
8664 }
8665 }
8666
8667 if (nn < 18)
8668 printf ("%*c", 18 - nn, ' ');
8669 }
8670
8671 putchar ('\n');
8672 }
8673
8674 free (data);
8675 free (strtab);
8676 free (symbols);
8677 }
8678 break;
103f02d3 8679
252b5132
RH		 8680 default:
8681 break;
8682 }
8683 }
8684
8685 if (! found)
8686 printf (_("\nNo version information found in this file.\n"));
8687
8688 return 1;
8689}
8690
d1133906 8691static const char *
d3ba0551 8692get_symbol_binding (unsigned int binding)
252b5132 8693{
b34976b6 8694 static char buff[32];
252b5132
RH		 8695
8696 switch (binding)
8697 {
b34976b6
AM		 8698 case STB_LOCAL: return "LOCAL";
8699 case STB_GLOBAL: return "GLOBAL";
8700 case STB_WEAK: return "WEAK";
252b5132
RH		 8701 default:
8702 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 8703 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
8704 binding);
252b5132 8705 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 8706 {
8707 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 8708 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
8709 /* GNU is still using the default value 0. */
3e7a7d11
NC		 8710 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8711 return "UNIQUE";
8712 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
8713 }
252b5132 8714 else
e9e44622 8715 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 8716 return buff;
8717 }
8718}
8719
d1133906 8720static const char *
d3ba0551 8721get_symbol_type (unsigned int type)
252b5132 8722{
b34976b6 8723 static char buff[32];
252b5132
RH		 8724
8725 switch (type)
8726 {
b34976b6
AM		 8727 case STT_NOTYPE: return "NOTYPE";
8728 case STT_OBJECT: return "OBJECT";
8729 case STT_FUNC: return "FUNC";
8730 case STT_SECTION: return "SECTION";
8731 case STT_FILE: return "FILE";
8732 case STT_COMMON: return "COMMON";
8733 case STT_TLS: return "TLS";
15ab5209
DB		 8734 case STT_RELC: return "RELC";
8735 case STT_SRELC: return "SRELC";
252b5132
RH		 8736 default:
8737 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af
NC		 8738 {
8739 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
103f02d3
UD		 8740 return "THUMB_FUNC";
8741
351b4b40 8742 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 8743 return "REGISTER";
8744
8745 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
8746 return "PARISC_MILLI";
8747
e9e44622 8748 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 8749 }
252b5132 8750 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 8751 {
8752 if (elf_header.e_machine == EM_PARISC)
8753 {
8754 if (type == STT_HP_OPAQUE)
8755 return "HP_OPAQUE";
8756 if (type == STT_HP_STUB)
8757 return "HP_STUB";
8758 }
8759
d8045f23 8760 if (type == STT_GNU_IFUNC
9c55345c 8761 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 8762 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 8763 /* GNU is still using the default value 0. */
d8045f23
NC		 8764 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8765 return "IFUNC";
8766
e9e44622 8767 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 8768 }
252b5132 8769 else
e9e44622 8770 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 8771 return buff;
8772 }
8773}
8774
d1133906 8775static const char *
d3ba0551 8776get_symbol_visibility (unsigned int visibility)
d1133906
NC		 8777{
8778 switch (visibility)
8779 {
b34976b6
AM		 8780 case STV_DEFAULT: return "DEFAULT";
8781 case STV_INTERNAL: return "INTERNAL";
8782 case STV_HIDDEN: return "HIDDEN";
d1133906
NC		 8783 case STV_PROTECTED: return "PROTECTED";
8784 default: abort ();
8785 }
8786}
8787
5e2b0d47
NC		 8788static const char *
8789get_mips_symbol_other (unsigned int other)
8790{
8791 switch (other)
8792 {
df58fc94
RS		 8793 case STO_OPTIONAL:
8794 return "OPTIONAL";
8795 case STO_MIPS_PLT:
8796 return "MIPS PLT";
8797 case STO_MIPS_PIC:
8798 return "MIPS PIC";
8799 case STO_MICROMIPS:
8800 return "MICROMIPS";
8801 case STO_MICROMIPS | STO_MIPS_PIC:
8802 return "MICROMIPS, MIPS PIC";
8803 case STO_MIPS16:
8804 return "MIPS16";
8805 default:
8806 return NULL;
5e2b0d47
NC		 8807 }
8808}
8809
28f997cf
TG		 8810static const char *
8811get_ia64_symbol_other (unsigned int other)
8812{
8813 if (is_ia64_vms ())
8814 {
8815 static char res[32];
8816
8817 res[0] = 0;
8818
8819 /* Function types is for images and .STB files only. */
8820 switch (elf_header.e_type)
8821 {
8822 case ET_DYN:
8823 case ET_EXEC:
8824 switch (VMS_ST_FUNC_TYPE (other))
8825 {
8826 case VMS_SFT_CODE_ADDR:
8827 strcat (res, " CA");
8828 break;
8829 case VMS_SFT_SYMV_IDX:
8830 strcat (res, " VEC");
8831 break;
8832 case VMS_SFT_FD:
8833 strcat (res, " FD");
8834 break;
8835 case VMS_SFT_RESERVE:
8836 strcat (res, " RSV");
8837 break;
8838 default:
8839 abort ();
8840 }
8841 break;
8842 default:
8843 break;
8844 }
8845 switch (VMS_ST_LINKAGE (other))
8846 {
8847 case VMS_STL_IGNORE:
8848 strcat (res, " IGN");
8849 break;
8850 case VMS_STL_RESERVE:
8851 strcat (res, " RSV");
8852 break;
8853 case VMS_STL_STD:
8854 strcat (res, " STD");
8855 break;
8856 case VMS_STL_LNK:
8857 strcat (res, " LNK");
8858 break;
8859 default:
8860 abort ();
8861 }
8862
8863 if (res[0] != 0)
8864 return res + 1;
8865 else
8866 return res;
8867 }
8868 return NULL;
8869}
8870
5e2b0d47
NC		 8871static const char *
8872get_symbol_other (unsigned int other)
8873{
8874 const char * result = NULL;
8875 static char buff [32];
8876
8877 if (other == 0)
8878 return "";
8879
8880 switch (elf_header.e_machine)
8881 {
8882 case EM_MIPS:
8883 result = get_mips_symbol_other (other);
28f997cf
TG		 8884 break;
8885 case EM_IA_64:
8886 result = get_ia64_symbol_other (other);
8887 break;
5e2b0d47
NC		 8888 default:
8889 break;
8890 }
8891
8892 if (result)
8893 return result;
8894
8895 snprintf (buff, sizeof buff, _("<other>: %x"), other);
8896 return buff;
8897}
8898
d1133906 8899static const char *
d3ba0551 8900get_symbol_index_type (unsigned int type)
252b5132 8901{
b34976b6 8902 static char buff[32];
5cf1065c 8903
252b5132
RH		 8904 switch (type)
8905 {
b34976b6
AM		 8906 case SHN_UNDEF: return "UND";
8907 case SHN_ABS: return "ABS";
8908 case SHN_COMMON: return "COM";
252b5132 8909 default:
9ce701e2
L		 8910 if (type == SHN_IA_64_ANSI_COMMON
8911 && elf_header.e_machine == EM_IA_64
8912 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
8913 return "ANSI_COM";
8a9036a4 8914 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 8915 || elf_header.e_machine == EM_L1OM
8916 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 8917 && type == SHN_X86_64_LCOMMON)
8918 return "LARGE_COM";
ac145307
BS		 8919 else if ((type == SHN_MIPS_SCOMMON
8920 && elf_header.e_machine == EM_MIPS)
8921 || (type == SHN_TIC6X_SCOMMON
8922 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 8923 return "SCOM";
8924 else if (type == SHN_MIPS_SUNDEFINED
8925 && elf_header.e_machine == EM_MIPS)
8926 return "SUND";
9ce701e2 8927 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 8928 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 8929 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 8930 sprintf (buff, "OS [0x%04x]", type & 0xffff);
8931 else if (type >= SHN_LORESERVE)
8932 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
252b5132 8933 else
232e7cb8 8934 sprintf (buff, "%3d", type);
5cf1065c 8935 break;
252b5132 8936 }
5cf1065c
NC		 8937
8938 return buff;
252b5132
RH		 8939}
8940
66543521 8941static bfd_vma *
2cf0635d 8942get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
252b5132 8943{
2cf0635d
NC		 8944 unsigned char * e_data;
8945 bfd_vma * i_data;
252b5132 8946
3f5e193b 8947 e_data = (unsigned char *) cmalloc (number, ent_size);
252b5132
RH		 8948
8949 if (e_data == NULL)
8950 {
8951 error (_("Out of memory\n"));
8952 return NULL;
8953 }
8954
66543521 8955 if (fread (e_data, ent_size, number, file) != number)
252b5132
RH		 8956 {
8957 error (_("Unable to read in dynamic data\n"));
8958 return NULL;
8959 }
8960
3f5e193b 8961 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
252b5132
RH		 8962
8963 if (i_data == NULL)
8964 {
8965 error (_("Out of memory\n"));
8966 free (e_data);
8967 return NULL;
8968 }
8969
8970 while (number--)
66543521 8971 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 8972
8973 free (e_data);
8974
8975 return i_data;
8976}
8977
6bd1a22c
L		 8978static void
8979print_dynamic_symbol (bfd_vma si, unsigned long hn)
8980{
2cf0635d 8981 Elf_Internal_Sym * psym;
6bd1a22c
L		 8982 int n;
8983
8984 psym = dynamic_symbols + si;
8985
8986 n = print_vma (si, DEC_5);
8987 if (n < 5)
8988 fputs (" " + n, stdout);
8989 printf (" %3lu: ", hn);
8990 print_vma (psym->st_value, LONG_HEX);
8991 putchar (' ');
8992 print_vma (psym->st_size, DEC_5);
8993
f4be36b3
AM		 8994 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
8995 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
8996 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 8997 /* Check to see if any other bits in the st_other field are set.
8998 Note - displaying this information disrupts the layout of the
8999 table being generated, but for the moment this case is very
9000 rare. */
9001 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9002 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9003 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9004 if (VALID_DYNAMIC_NAME (psym->st_name))
9005 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9006 else
2b692964 9007 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 9008 putchar ('\n');
9009}
9010
e3c8793a 9011/* Dump the symbol table. */
252b5132 9012static int
2cf0635d 9013process_symbol_table (FILE * file)
252b5132 9014{
2cf0635d 9015 Elf_Internal_Shdr * section;
66543521
AM		 9016 bfd_vma nbuckets = 0;
9017 bfd_vma nchains = 0;
2cf0635d
NC		 9018 bfd_vma * buckets = NULL;
9019 bfd_vma * chains = NULL;
fdc90cb4 9020 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 9021 bfd_vma * gnubuckets = NULL;
9022 bfd_vma * gnuchains = NULL;
6bd1a22c 9023 bfd_vma gnusymidx = 0;
252b5132 9024
2c610e4b 9025 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 9026 return 1;
9027
6bd1a22c
L		 9028 if (dynamic_info[DT_HASH]
9029 && (do_histogram
2c610e4b
L		 9030 || (do_using_dynamic
9031 && !do_dyn_syms
9032 && dynamic_strings != NULL)))
252b5132 9033 {
66543521
AM		 9034 unsigned char nb[8];
9035 unsigned char nc[8];
9036 int hash_ent_size = 4;
9037
9038 if ((elf_header.e_machine == EM_ALPHA
9039 || elf_header.e_machine == EM_S390
9040 || elf_header.e_machine == EM_S390_OLD)
9041 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
9042 hash_ent_size = 8;
9043
fb52b2f4
NC		 9044 if (fseek (file,
9045 (archive_file_offset
9046 + offset_from_vma (file, dynamic_info[DT_HASH],
9047 sizeof nb + sizeof nc)),
d93f0186 9048 SEEK_SET))
252b5132 9049 {
591a748a 9050 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9051 goto no_hash;
252b5132
RH		 9052 }
9053
66543521 9054 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 9055 {
9056 error (_("Failed to read in number of buckets\n"));
d3a44ec6 9057 goto no_hash;
252b5132
RH		 9058 }
9059
66543521 9060 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 9061 {
9062 error (_("Failed to read in number of chains\n"));
d3a44ec6 9063 goto no_hash;
252b5132
RH		 9064 }
9065
66543521
AM		 9066 nbuckets = byte_get (nb, hash_ent_size);
9067 nchains = byte_get (nc, hash_ent_size);
252b5132 9068
66543521
AM		 9069 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
9070 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 9071
d3a44ec6 9072 no_hash:
252b5132 9073 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 9074 {
9075 if (do_using_dynamic)
9076 return 0;
9077 free (buckets);
9078 free (chains);
9079 buckets = NULL;
9080 chains = NULL;
9081 nbuckets = 0;
9082 nchains = 0;
9083 }
252b5132
RH		 9084 }
9085
6bd1a22c
L		 9086 if (dynamic_info_DT_GNU_HASH
9087 && (do_histogram
2c610e4b
L		 9088 || (do_using_dynamic
9089 && !do_dyn_syms
9090 && dynamic_strings != NULL)))
252b5132 9091 {
6bd1a22c
L		 9092 unsigned char nb[16];
9093 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
9094 bfd_vma buckets_vma;
9095
9096 if (fseek (file,
9097 (archive_file_offset
9098 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
9099 sizeof nb)),
9100 SEEK_SET))
9101 {
9102 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9103 goto no_gnu_hash;
6bd1a22c 9104 }
252b5132 9105
6bd1a22c
L		 9106 if (fread (nb, 16, 1, file) != 1)
9107 {
9108 error (_("Failed to read in number of buckets\n"));
d3a44ec6 9109 goto no_gnu_hash;
6bd1a22c
L		 9110 }
9111
9112 ngnubuckets = byte_get (nb, 4);
9113 gnusymidx = byte_get (nb + 4, 4);
9114 bitmaskwords = byte_get (nb + 8, 4);
9115 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 9116 if (is_32bit_elf)
6bd1a22c 9117 buckets_vma += bitmaskwords * 4;
f7a99963 9118 else
6bd1a22c 9119 buckets_vma += bitmaskwords * 8;
252b5132 9120
6bd1a22c
L		 9121 if (fseek (file,
9122 (archive_file_offset
9123 + offset_from_vma (file, buckets_vma, 4)),
9124 SEEK_SET))
252b5132 9125 {
6bd1a22c 9126 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9127 goto no_gnu_hash;
6bd1a22c
L		 9128 }
9129
9130 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 9131
6bd1a22c 9132 if (gnubuckets == NULL)
d3a44ec6 9133 goto no_gnu_hash;
6bd1a22c
L		 9134
9135 for (i = 0; i < ngnubuckets; i++)
9136 if (gnubuckets[i] != 0)
9137 {
9138 if (gnubuckets[i] < gnusymidx)
9139 return 0;
9140
9141 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9142 maxchain = gnubuckets[i];
9143 }
9144
9145 if (maxchain == 0xffffffff)
d3a44ec6 9146 goto no_gnu_hash;
6bd1a22c
L		 9147
9148 maxchain -= gnusymidx;
9149
9150 if (fseek (file,
9151 (archive_file_offset
9152 + offset_from_vma (file, buckets_vma
9153 + 4 * (ngnubuckets + maxchain), 4)),
9154 SEEK_SET))
9155 {
9156 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9157 goto no_gnu_hash;
6bd1a22c
L		 9158 }
9159
9160 do
9161 {
9162 if (fread (nb, 4, 1, file) != 1)
252b5132 9163 {
6bd1a22c 9164 error (_("Failed to determine last chain length\n"));
d3a44ec6 9165 goto no_gnu_hash;
6bd1a22c 9166 }
252b5132 9167
6bd1a22c 9168 if (maxchain + 1 == 0)
d3a44ec6 9169 goto no_gnu_hash;
252b5132 9170
6bd1a22c
L		 9171 ++maxchain;
9172 }
9173 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 9174
6bd1a22c
L		 9175 if (fseek (file,
9176 (archive_file_offset
9177 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9178 SEEK_SET))
9179 {
9180 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9181 goto no_gnu_hash;
6bd1a22c
L		 9182 }
9183
9184 gnuchains = get_dynamic_data (file, maxchain, 4);
9185
d3a44ec6 9186 no_gnu_hash:
6bd1a22c 9187 if (gnuchains == NULL)
d3a44ec6
JJ		 9188 {
9189 free (gnubuckets);
d3a44ec6
JJ		 9190 gnubuckets = NULL;
9191 ngnubuckets = 0;
f64fddf1
NC		 9192 if (do_using_dynamic)
9193 return 0;
d3a44ec6 9194 }
6bd1a22c
L		 9195 }
9196
9197 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9198 && do_syms
9199 && do_using_dynamic
9200 && dynamic_strings != NULL)
9201 {
9202 unsigned long hn;
9203
9204 if (dynamic_info[DT_HASH])
9205 {
9206 bfd_vma si;
9207
9208 printf (_("\nSymbol table for image:\n"));
9209 if (is_32bit_elf)
9210 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9211 else
9212 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9213
9214 for (hn = 0; hn < nbuckets; hn++)
9215 {
9216 if (! buckets[hn])
9217 continue;
9218
9219 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9220 print_dynamic_symbol (si, hn);
252b5132
RH		 9221 }
9222 }
6bd1a22c
L		 9223
9224 if (dynamic_info_DT_GNU_HASH)
9225 {
9226 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9227 if (is_32bit_elf)
9228 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9229 else
9230 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9231
9232 for (hn = 0; hn < ngnubuckets; ++hn)
9233 if (gnubuckets[hn] != 0)
9234 {
9235 bfd_vma si = gnubuckets[hn];
9236 bfd_vma off = si - gnusymidx;
9237
9238 do
9239 {
9240 print_dynamic_symbol (si, hn);
9241 si++;
9242 }
9243 while ((gnuchains[off++] & 1) == 0);
9244 }
9245 }
252b5132 9246 }
2c610e4b 9247 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
252b5132 9248 {
b34976b6 9249 unsigned int i;
252b5132
RH		 9250
9251 for (i = 0, section = section_headers;
9252 i < elf_header.e_shnum;
9253 i++, section++)
9254 {
b34976b6 9255 unsigned int si;
2cf0635d 9256 char * strtab = NULL;
c256ffe7 9257 unsigned long int strtab_size = 0;
2cf0635d
NC		 9258 Elf_Internal_Sym * symtab;
9259 Elf_Internal_Sym * psym;
ba5cdace 9260 unsigned long num_syms;
252b5132 9261
2c610e4b
L		 9262 if ((section->sh_type != SHT_SYMTAB
9263 && section->sh_type != SHT_DYNSYM)
9264 || (!do_syms
9265 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 9266 continue;
9267
dd24e3da
NC		 9268 if (section->sh_entsize == 0)
9269 {
9270 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9271 SECTION_NAME (section));
9272 continue;
9273 }
9274
252b5132
RH		 9275 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9276 SECTION_NAME (section),
9277 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 9278
f7a99963 9279 if (is_32bit_elf)
ca47b30c 9280 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 9281 else
ca47b30c 9282 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 9283
ba5cdace 9284 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 9285 if (symtab == NULL)
9286 continue;
9287
9288 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 9289 {
9290 strtab = string_table;
9291 strtab_size = string_table_length;
9292 }
4fbb74a6 9293 else if (section->sh_link < elf_header.e_shnum)
252b5132 9294 {
2cf0635d 9295 Elf_Internal_Shdr * string_sec;
252b5132 9296
4fbb74a6 9297 string_sec = section_headers + section->sh_link;
252b5132 9298
3f5e193b
NC		 9299 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9300 1, string_sec->sh_size,
9301 _("string table"));
c256ffe7 9302 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 9303 }
9304
ba5cdace 9305 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 9306 {
5e220199 9307 printf ("%6d: ", si);
f7a99963
NC		 9308 print_vma (psym->st_value, LONG_HEX);
9309 putchar (' ');
9310 print_vma (psym->st_size, DEC_5);
d1133906
NC		 9311 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9312 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 9313 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 9314 /* Check to see if any other bits in the st_other field are set.
9315 Note - displaying this information disrupts the layout of the
9316 table being generated, but for the moment this case is very rare. */
9317 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9318 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 9319 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 9320 print_symbol (25, psym->st_name < strtab_size
2b692964 9321 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 9322
59245841
NC		 9323 if (section->sh_type == SHT_DYNSYM
9324 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
252b5132 9325 {
b34976b6
AM		 9326 unsigned char data[2];
9327 unsigned short vers_data;
9328 unsigned long offset;
9329 int is_nobits;
9330 int check_def;
252b5132 9331
d93f0186
NC		 9332 offset = offset_from_vma
9333 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9334 sizeof data + si * sizeof (vers_data));
252b5132 9335
59245841
NC		 9336 if (get_data (&data, file, offset + si * sizeof (vers_data),
9337 sizeof (data), 1, _("version data")) == NULL)
9338 break;
252b5132
RH		 9339
9340 vers_data = byte_get (data, 2);
9341
4fbb74a6
AM		 9342 is_nobits = (psym->st_shndx < elf_header.e_shnum
9343 && section_headers[psym->st_shndx].sh_type
c256ffe7 9344 == SHT_NOBITS);
252b5132
RH		 9345
9346 check_def = (psym->st_shndx != SHN_UNDEF);
9347
c244d050 9348 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
252b5132 9349 {
b34976b6 9350 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
00d93f34 9351 && (is_nobits || ! check_def))
252b5132 9352 {
b34976b6
AM		 9353 Elf_External_Verneed evn;
9354 Elf_Internal_Verneed ivn;
9355 Elf_Internal_Vernaux ivna;
252b5132
RH		 9356
9357 /* We must test both. */
d93f0186
NC		 9358 offset = offset_from_vma
9359 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9360 sizeof evn);
252b5132 9361
252b5132
RH		 9362 do
9363 {
b34976b6 9364 unsigned long vna_off;
252b5132 9365
59245841
NC		 9366 if (get_data (&evn, file, offset, sizeof (evn), 1,
9367 _("version need")) == NULL)
9368 {
9369 ivna.vna_next = 0;
9370 ivna.vna_other = 0;
9371 ivna.vna_name = 0;
9372 break;
9373 }
dd27201e
L		 9374
9375 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9376 ivn.vn_next = BYTE_GET (evn.vn_next);
9377
252b5132
RH		 9378 vna_off = offset + ivn.vn_aux;
9379
9380 do
9381 {
b34976b6 9382 Elf_External_Vernaux evna;
252b5132 9383
59245841
NC		 9384 if (get_data (&evna, file, vna_off,
9385 sizeof (evna), 1,
9386 _("version need aux (3)")) == NULL)
9387 {
9388 ivna.vna_next = 0;
9389 ivna.vna_other = 0;
9390 ivna.vna_name = 0;
9391 }
9392 else
9393 {
9394 ivna.vna_other = BYTE_GET (evna.vna_other);
9395 ivna.vna_next = BYTE_GET (evna.vna_next);
9396 ivna.vna_name = BYTE_GET (evna.vna_name);
9397 }
252b5132
RH		 9398
9399 vna_off += ivna.vna_next;
9400 }
9401 while (ivna.vna_other != vers_data
9402 && ivna.vna_next != 0);
9403
9404 if (ivna.vna_other == vers_data)
9405 break;
9406
9407 offset += ivn.vn_next;
9408 }
9409 while (ivn.vn_next != 0);
9410
9411 if (ivna.vna_other == vers_data)
9412 {
9413 printf ("@%s (%d)",
c256ffe7 9414 ivna.vna_name < strtab_size
2b692964 9415 ? strtab + ivna.vna_name : _("<corrupt>"),
c256ffe7 9416 ivna.vna_other);
252b5132
RH		 9417 check_def = 0;
9418 }
9419 else if (! is_nobits)
591a748a 9420 error (_("bad dynamic symbol\n"));
252b5132
RH		 9421 else
9422 check_def = 1;
9423 }
9424
9425 if (check_def)
9426 {
00d93f34 9427 if (vers_data != 0x8001
b34976b6 9428 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9429 {
b34976b6
AM		 9430 Elf_Internal_Verdef ivd;
9431 Elf_Internal_Verdaux ivda;
9432 Elf_External_Verdaux evda;
91d6fa6a 9433 unsigned long off;
252b5132 9434
91d6fa6a 9435 off = offset_from_vma
d93f0186
NC		 9436 (file,
9437 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9438 sizeof (Elf_External_Verdef));
252b5132
RH		 9439
9440 do
9441 {
b34976b6 9442 Elf_External_Verdef evd;
252b5132 9443
59245841
NC		 9444 if (get_data (&evd, file, off, sizeof (evd),
9445 1, _("version def")) == NULL)
9446 {
9447 ivd.vd_ndx = 0;
9448 ivd.vd_aux = 0;
9449 ivd.vd_next = 0;
9450 }
9451 else
9452 {
9453 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9454 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9455 ivd.vd_next = BYTE_GET (evd.vd_next);
9456 }
252b5132 9457
91d6fa6a 9458 off += ivd.vd_next;
252b5132 9459 }
c244d050 9460 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
252b5132
RH		 9461 && ivd.vd_next != 0);
9462
91d6fa6a
NC		 9463 off -= ivd.vd_next;
9464 off += ivd.vd_aux;
252b5132 9465
59245841
NC		 9466 if (get_data (&evda, file, off, sizeof (evda),
9467 1, _("version def aux")) == NULL)
9468 break;
252b5132
RH		 9469
9470 ivda.vda_name = BYTE_GET (evda.vda_name);
9471
9472 if (psym->st_name != ivda.vda_name)
c244d050 9473 printf ((vers_data & VERSYM_HIDDEN)
252b5132 9474 ? "@%s" : "@@%s",
c256ffe7 9475 ivda.vda_name < strtab_size
2b692964 9476 ? strtab + ivda.vda_name : _("<corrupt>"));
252b5132
RH		 9477 }
9478 }
9479 }
9480 }
9481
9482 putchar ('\n');
9483 }
9484
9485 free (symtab);
9486 if (strtab != string_table)
9487 free (strtab);
9488 }
9489 }
9490 else if (do_syms)
9491 printf
9492 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9493
9494 if (do_histogram && buckets != NULL)
9495 {
2cf0635d
NC		 9496 unsigned long * lengths;
9497 unsigned long * counts;
66543521
AM		 9498 unsigned long hn;
9499 bfd_vma si;
9500 unsigned long maxlength = 0;
9501 unsigned long nzero_counts = 0;
9502 unsigned long nsyms = 0;
252b5132 9503
66543521
AM		 9504 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9505 (unsigned long) nbuckets);
252b5132
RH		 9506 printf (_(" Length Number %% of total Coverage\n"));
9507
3f5e193b 9508 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 9509 if (lengths == NULL)
9510 {
591a748a 9511 error (_("Out of memory\n"));
252b5132
RH		 9512 return 0;
9513 }
9514 for (hn = 0; hn < nbuckets; ++hn)
9515 {
f7a99963 9516 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
252b5132 9517 {
b34976b6 9518 ++nsyms;
252b5132 9519 if (maxlength < ++lengths[hn])
b34976b6 9520 ++maxlength;
252b5132
RH		 9521 }
9522 }
9523
3f5e193b 9524 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 9525 if (counts == NULL)
9526 {
591a748a 9527 error (_("Out of memory\n"));
252b5132
RH		 9528 return 0;
9529 }
9530
9531 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 9532 ++counts[lengths[hn]];
252b5132 9533
103f02d3 9534 if (nbuckets > 0)
252b5132 9535 {
66543521
AM		 9536 unsigned long i;
9537 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 9538 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 9539 for (i = 1; i <= maxlength; ++i)
103f02d3 9540 {
66543521
AM		 9541 nzero_counts += counts[i] * i;
9542 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9543 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 9544 (nzero_counts * 100.0) / nsyms);
9545 }
252b5132
RH		 9546 }
9547
9548 free (counts);
9549 free (lengths);
9550 }
9551
9552 if (buckets != NULL)
9553 {
9554 free (buckets);
9555 free (chains);
9556 }
9557
d3a44ec6 9558 if (do_histogram && gnubuckets != NULL)
fdc90cb4 9559 {
2cf0635d
NC		 9560 unsigned long * lengths;
9561 unsigned long * counts;
fdc90cb4
JJ		 9562 unsigned long hn;
9563 unsigned long maxlength = 0;
9564 unsigned long nzero_counts = 0;
9565 unsigned long nsyms = 0;
fdc90cb4 9566
3f5e193b 9567 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 9568 if (lengths == NULL)
9569 {
591a748a 9570 error (_("Out of memory\n"));
fdc90cb4
JJ		 9571 return 0;
9572 }
9573
9574 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9575 (unsigned long) ngnubuckets);
9576 printf (_(" Length Number %% of total Coverage\n"));
9577
9578 for (hn = 0; hn < ngnubuckets; ++hn)
9579 if (gnubuckets[hn] != 0)
9580 {
9581 bfd_vma off, length = 1;
9582
6bd1a22c 9583 for (off = gnubuckets[hn] - gnusymidx;
fdc90cb4
JJ		 9584 (gnuchains[off] & 1) == 0; ++off)
9585 ++length;
9586 lengths[hn] = length;
9587 if (length > maxlength)
9588 maxlength = length;
9589 nsyms += length;
9590 }
9591
3f5e193b 9592 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 9593 if (counts == NULL)
9594 {
591a748a 9595 error (_("Out of memory\n"));
fdc90cb4
JJ		 9596 return 0;
9597 }
9598
9599 for (hn = 0; hn < ngnubuckets; ++hn)
9600 ++counts[lengths[hn]];
9601
9602 if (ngnubuckets > 0)
9603 {
9604 unsigned long j;
9605 printf (" 0 %-10lu (%5.1f%%)\n",
9606 counts[0], (counts[0] * 100.0) / ngnubuckets);
9607 for (j = 1; j <= maxlength; ++j)
9608 {
9609 nzero_counts += counts[j] * j;
9610 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9611 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9612 (nzero_counts * 100.0) / nsyms);
9613 }
9614 }
9615
9616 free (counts);
9617 free (lengths);
9618 free (gnubuckets);
9619 free (gnuchains);
9620 }
9621
252b5132
RH		 9622 return 1;
9623}
9624
9625static int
2cf0635d 9626process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 9627{
b4c96d0d 9628 unsigned int i;
252b5132
RH		 9629
9630 if (dynamic_syminfo == NULL
9631 || !do_dynamic)
9632 /* No syminfo, this is ok. */
9633 return 1;
9634
9635 /* There better should be a dynamic symbol section. */
9636 if (dynamic_symbols == NULL || dynamic_strings == NULL)
9637 return 0;
9638
9639 if (dynamic_addr)
9640 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9641 dynamic_syminfo_offset, dynamic_syminfo_nent);
9642
9643 printf (_(" Num: Name BoundTo Flags\n"));
9644 for (i = 0; i < dynamic_syminfo_nent; ++i)
9645 {
9646 unsigned short int flags = dynamic_syminfo[i].si_flags;
9647
31104126 9648 printf ("%4d: ", i);
d79b3d50
NC		 9649 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9650 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9651 else
2b692964 9652 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 9653 putchar (' ');
252b5132
RH		 9654
9655 switch (dynamic_syminfo[i].si_boundto)
9656 {
9657 case SYMINFO_BT_SELF:
9658 fputs ("SELF ", stdout);
9659 break;
9660 case SYMINFO_BT_PARENT:
9661 fputs ("PARENT ", stdout);
9662 break;
9663 default:
9664 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 9665 && dynamic_syminfo[i].si_boundto < dynamic_nent
9666 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 9667 {
d79b3d50 9668 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 9669 putchar (' ' );
9670 }
252b5132
RH		 9671 else
9672 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
9673 break;
9674 }
9675
9676 if (flags & SYMINFO_FLG_DIRECT)
9677 printf (" DIRECT");
9678 if (flags & SYMINFO_FLG_PASSTHRU)
9679 printf (" PASSTHRU");
9680 if (flags & SYMINFO_FLG_COPY)
9681 printf (" COPY");
9682 if (flags & SYMINFO_FLG_LAZYLOAD)
9683 printf (" LAZYLOAD");
9684
9685 puts ("");
9686 }
9687
9688 return 1;
9689}
9690
cf13d699
NC		 9691/* Check to see if the given reloc needs to be handled in a target specific
9692 manner. If so then process the reloc and return TRUE otherwise return
9693 FALSE. */
09c11c86 9694
cf13d699
NC		 9695static bfd_boolean
9696target_specific_reloc_handling (Elf_Internal_Rela * reloc,
9697 unsigned char * start,
9698 Elf_Internal_Sym * symtab)
252b5132 9699{
cf13d699 9700 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 9701
cf13d699 9702 switch (elf_header.e_machine)
252b5132 9703 {
cf13d699
NC		 9704 case EM_MN10300:
9705 case EM_CYGNUS_MN10300:
9706 {
9707 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 9708
cf13d699
NC		 9709 switch (reloc_type)
9710 {
9711 case 34: /* R_MN10300_ALIGN */
9712 return TRUE;
9713 case 33: /* R_MN10300_SYM_DIFF */
9714 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
9715 return TRUE;
9716 case 1: /* R_MN10300_32 */
9717 case 2: /* R_MN10300_16 */
9718 if (saved_sym != NULL)
9719 {
9720 bfd_vma value;
252b5132 9721
cf13d699
NC		 9722 value = reloc->r_addend
9723 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
9724 - saved_sym->st_value);
252b5132 9725
cf13d699 9726 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 9727
cf13d699
NC		 9728 saved_sym = NULL;
9729 return TRUE;
9730 }
9731 break;
9732 default:
9733 if (saved_sym != NULL)
9734 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9735 break;
9736 }
9737 break;
9738 }
252b5132
RH		 9739 }
9740
cf13d699 9741 return FALSE;
252b5132
RH		 9742}
9743
aca88567
NC		 9744/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9745 DWARF debug sections. This is a target specific test. Note - we do not
9746 go through the whole including-target-headers-multiple-times route, (as
9747 we have already done with <elf/h8.h>) because this would become very
9748 messy and even then this function would have to contain target specific
9749 information (the names of the relocs instead of their numeric values).
9750 FIXME: This is not the correct way to solve this problem. The proper way
9751 is to have target specific reloc sizing and typing functions created by
9752 the reloc-macros.h header, in the same way that it already creates the
9753 reloc naming functions. */
9754
9755static bfd_boolean
9756is_32bit_abs_reloc (unsigned int reloc_type)
9757{
9758 switch (elf_header.e_machine)
9759 {
41e92641
NC		 9760 case EM_386:
9761 case EM_486:
9762 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 9763 case EM_68K:
9764 return reloc_type == 1; /* R_68K_32. */
9765 case EM_860:
9766 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 9767 case EM_960:
9768 return reloc_type == 2; /* R_960_32. */
aca88567 9769 case EM_ALPHA:
137b6b5f 9770 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 9771 case EM_ARC:
9772 return reloc_type == 1; /* R_ARC_32. */
9773 case EM_ARM:
9774 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 9775 case EM_AVR_OLD:
aca88567
NC		 9776 case EM_AVR:
9777 return reloc_type == 1;
cfb8c092
NC		 9778 case EM_ADAPTEVA_EPIPHANY:
9779 return reloc_type == 3;
aca88567
NC		 9780 case EM_BLACKFIN:
9781 return reloc_type == 0x12; /* R_byte4_data. */
9782 case EM_CRIS:
9783 return reloc_type == 3; /* R_CRIS_32. */
9784 case EM_CR16:
9785 return reloc_type == 3; /* R_CR16_NUM32. */
9786 case EM_CRX:
9787 return reloc_type == 15; /* R_CRX_NUM32. */
9788 case EM_CYGNUS_FRV:
9789 return reloc_type == 1;
41e92641
NC		 9790 case EM_CYGNUS_D10V:
9791 case EM_D10V:
9792 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 9793 case EM_CYGNUS_D30V:
9794 case EM_D30V:
9795 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 9796 case EM_DLX:
9797 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 9798 case EM_CYGNUS_FR30:
9799 case EM_FR30:
9800 return reloc_type == 3; /* R_FR30_32. */
9801 case EM_H8S:
9802 case EM_H8_300:
9803 case EM_H8_300H:
9804 return reloc_type == 1; /* R_H8_DIR32. */
3730236a
NC		 9805 case EM_IA_64:
9806 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
aca88567
NC		 9807 case EM_IP2K_OLD:
9808 case EM_IP2K:
9809 return reloc_type == 2; /* R_IP2K_32. */
9810 case EM_IQ2000:
9811 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 9812 case EM_LATTICEMICO32:
9813 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 9814 case EM_M32C_OLD:
aca88567
NC		 9815 case EM_M32C:
9816 return reloc_type == 3; /* R_M32C_32. */
9817 case EM_M32R:
9818 return reloc_type == 34; /* R_M32R_32_RELA. */
9819 case EM_MCORE:
9820 return reloc_type == 1; /* R_MCORE_ADDR32. */
9821 case EM_CYGNUS_MEP:
9822 return reloc_type == 4; /* R_MEP_32. */
137b6b5f
AM		 9823 case EM_MICROBLAZE:
9824 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 9825 case EM_MIPS:
9826 return reloc_type == 2; /* R_MIPS_32. */
9827 case EM_MMIX:
9828 return reloc_type == 4; /* R_MMIX_32. */
9829 case EM_CYGNUS_MN10200:
9830 case EM_MN10200:
9831 return reloc_type == 1; /* R_MN10200_32. */
9832 case EM_CYGNUS_MN10300:
9833 case EM_MN10300:
9834 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 9835 case EM_MOXIE:
9836 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 9837 case EM_MSP430_OLD:
9838 case EM_MSP430:
9839 return reloc_type == 1; /* R_MSP43_32. */
9840 case EM_MT:
9841 return reloc_type == 2; /* R_MT_32. */
3e0873ac
NC		 9842 case EM_ALTERA_NIOS2:
9843 case EM_NIOS32:
9844 return reloc_type == 1; /* R_NIOS_32. */
41e92641
NC		 9845 case EM_OPENRISC:
9846 case EM_OR32:
9847 return reloc_type == 1; /* R_OR32_32. */
aca88567 9848 case EM_PARISC:
5fda8eca
NC		 9849 return (reloc_type == 1 /* R_PARISC_DIR32. */
9850 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 9851 case EM_PJ:
9852 case EM_PJ_OLD:
9853 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
9854 case EM_PPC64:
9855 return reloc_type == 1; /* R_PPC64_ADDR32. */
9856 case EM_PPC:
9857 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 9858 case EM_RL78:
9859 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 9860 case EM_RX:
9861 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 9862 case EM_S370:
9863 return reloc_type == 1; /* R_I370_ADDR31. */
9864 case EM_S390_OLD:
9865 case EM_S390:
9866 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 9867 case EM_SCORE:
9868 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 9869 case EM_SH:
9870 return reloc_type == 1; /* R_SH_DIR32. */
9871 case EM_SPARC32PLUS:
9872 case EM_SPARCV9:
9873 case EM_SPARC:
9874 return reloc_type == 3 /* R_SPARC_32. */
9875 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 9876 case EM_SPU:
9877 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 9878 case EM_TI_C6000:
9879 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 9880 case EM_TILEGX:
9881 return reloc_type == 2; /* R_TILEGX_32. */
9882 case EM_TILEPRO:
9883 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 9884 case EM_CYGNUS_V850:
9885 case EM_V850:
9886 return reloc_type == 6; /* R_V850_ABS32. */
9887 case EM_VAX:
9888 return reloc_type == 1; /* R_VAX_32. */
9889 case EM_X86_64:
8a9036a4 9890 case EM_L1OM:
7a9068fe 9891 case EM_K1OM:
aca88567 9892 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 9893 case EM_XC16X:
9894 case EM_C166:
9895 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 9896 case EM_XGATE:
9897 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 9898 case EM_XSTORMY16:
9899 return reloc_type == 1; /* R_XSTROMY16_32. */
9900 case EM_XTENSA_OLD:
9901 case EM_XTENSA:
9902 return reloc_type == 1; /* R_XTENSA_32. */
aca88567
NC		 9903 default:
9904 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
9905 elf_header.e_machine);
9906 abort ();
9907 }
9908}
9909
9910/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9911 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
9912
9913static bfd_boolean
9914is_32bit_pcrel_reloc (unsigned int reloc_type)
9915{
9916 switch (elf_header.e_machine)
9917 {
41e92641
NC		 9918 case EM_386:
9919 case EM_486:
3e0873ac 9920 return reloc_type == 2; /* R_386_PC32. */
aca88567 9921 case EM_68K:
3e0873ac 9922 return reloc_type == 4; /* R_68K_PC32. */
cfb8c092
NC		 9923 case EM_ADAPTEVA_EPIPHANY:
9924 return reloc_type == 6;
aca88567
NC		 9925 case EM_ALPHA:
9926 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 9927 case EM_ARM:
3e0873ac 9928 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 9929 case EM_MICROBLAZE:
9930 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
aca88567 9931 case EM_PARISC:
85acf597 9932 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 9933 case EM_PPC:
9934 return reloc_type == 26; /* R_PPC_REL32. */
9935 case EM_PPC64:
3e0873ac 9936 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 9937 case EM_S390_OLD:
9938 case EM_S390:
3e0873ac 9939 return reloc_type == 5; /* R_390_PC32. */
aca88567 9940 case EM_SH:
3e0873ac 9941 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 9942 case EM_SPARC32PLUS:
9943 case EM_SPARCV9:
9944 case EM_SPARC:
3e0873ac 9945 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 9946 case EM_SPU:
9947 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 9948 case EM_TILEGX:
9949 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
9950 case EM_TILEPRO:
9951 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
aca88567 9952 case EM_X86_64:
8a9036a4 9953 case EM_L1OM:
7a9068fe 9954 case EM_K1OM:
3e0873ac 9955 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 9956 case EM_XTENSA_OLD:
9957 case EM_XTENSA:
9958 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 9959 default:
9960 /* Do not abort or issue an error message here. Not all targets use
9961 pc-relative 32-bit relocs in their DWARF debug information and we
9962 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 9963 more helpful warning message will be generated by apply_relocations
9964 anyway, so just return. */
aca88567
NC		 9965 return FALSE;
9966 }
9967}
9968
9969/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9970 a 64-bit absolute RELA relocation used in DWARF debug sections. */
9971
9972static bfd_boolean
9973is_64bit_abs_reloc (unsigned int reloc_type)
9974{
9975 switch (elf_header.e_machine)
9976 {
9977 case EM_ALPHA:
9978 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 9979 case EM_IA_64:
9980 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 9981 case EM_PARISC:
9982 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 9983 case EM_PPC64:
9984 return reloc_type == 38; /* R_PPC64_ADDR64. */
9985 case EM_SPARC32PLUS:
9986 case EM_SPARCV9:
9987 case EM_SPARC:
9988 return reloc_type == 54; /* R_SPARC_UA64. */
9989 case EM_X86_64:
8a9036a4 9990 case EM_L1OM:
7a9068fe 9991 case EM_K1OM:
aca88567 9992 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 9993 case EM_S390_OLD:
9994 case EM_S390:
aa137e4d
NC		 9995 return reloc_type == 22; /* R_S390_64. */
9996 case EM_TILEGX:
9997 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 9998 case EM_MIPS:
aa137e4d 9999 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 10000 default:
10001 return FALSE;
10002 }
10003}
10004
85acf597
RH		 10005/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10006 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10007
10008static bfd_boolean
10009is_64bit_pcrel_reloc (unsigned int reloc_type)
10010{
10011 switch (elf_header.e_machine)
10012 {
10013 case EM_ALPHA:
aa137e4d 10014 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 10015 case EM_IA_64:
aa137e4d 10016 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 10017 case EM_PARISC:
aa137e4d 10018 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 10019 case EM_PPC64:
aa137e4d 10020 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 10021 case EM_SPARC32PLUS:
10022 case EM_SPARCV9:
10023 case EM_SPARC:
aa137e4d 10024 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 10025 case EM_X86_64:
8a9036a4 10026 case EM_L1OM:
7a9068fe 10027 case EM_K1OM:
aa137e4d 10028 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 10029 case EM_S390_OLD:
10030 case EM_S390:
aa137e4d
NC		 10031 return reloc_type == 23; /* R_S390_PC64. */
10032 case EM_TILEGX:
10033 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 10034 default:
10035 return FALSE;
10036 }
10037}
10038
4dc3c23d
AM		 10039/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10040 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10041
10042static bfd_boolean
10043is_24bit_abs_reloc (unsigned int reloc_type)
10044{
10045 switch (elf_header.e_machine)
10046 {
10047 case EM_CYGNUS_MN10200:
10048 case EM_MN10200:
10049 return reloc_type == 4; /* R_MN10200_24. */
10050 default:
10051 return FALSE;
10052 }
10053}
10054
aca88567
NC		 10055/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10056 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10057
10058static bfd_boolean
10059is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 10060{
10061 switch (elf_header.e_machine)
10062 {
aca88567
NC		 10063 case EM_AVR_OLD:
10064 case EM_AVR:
10065 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 10066 case EM_ADAPTEVA_EPIPHANY:
10067 return reloc_type == 5;
41e92641
NC		 10068 case EM_CYGNUS_D10V:
10069 case EM_D10V:
10070 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 10071 case EM_H8S:
10072 case EM_H8_300:
10073 case EM_H8_300H:
aca88567
NC		 10074 return reloc_type == R_H8_DIR16;
10075 case EM_IP2K_OLD:
10076 case EM_IP2K:
10077 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 10078 case EM_M32C_OLD:
f4236fe4
DD		 10079 case EM_M32C:
10080 return reloc_type == 1; /* R_M32C_16 */
aca88567
NC		 10081 case EM_MSP430_OLD:
10082 case EM_MSP430:
10083 return reloc_type == 5; /* R_MSP430_16_BYTE. */
3e0873ac
NC		 10084 case EM_ALTERA_NIOS2:
10085 case EM_NIOS32:
10086 return reloc_type == 9; /* R_NIOS_16. */
40b36596
JM		 10087 case EM_TI_C6000:
10088 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 10089 case EM_XC16X:
10090 case EM_C166:
10091 return reloc_type == 2; /* R_XC16C_ABS_16. */
0a22ae8e
NC		 10092 case EM_CYGNUS_MN10300:
10093 case EM_MN10300:
10094 return reloc_type == 2; /* R_MN10300_16. */
f6c1a2d5
NC		 10095 case EM_XGATE:
10096 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 10097 default:
aca88567 10098 return FALSE;
4b78141a
NC		 10099 }
10100}
10101
2a7b2e88
JK		 10102/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10103 relocation entries (possibly formerly used for SHT_GROUP sections). */
10104
10105static bfd_boolean
10106is_none_reloc (unsigned int reloc_type)
10107{
10108 switch (elf_header.e_machine)
10109 {
cb8f3167
NC		 10110 case EM_68K: /* R_68K_NONE. */
10111 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 10112 case EM_SPARC32PLUS:
10113 case EM_SPARCV9:
cb8f3167
NC		 10114 case EM_SPARC: /* R_SPARC_NONE. */
10115 case EM_MIPS: /* R_MIPS_NONE. */
10116 case EM_PARISC: /* R_PARISC_NONE. */
10117 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 10118 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 10119 case EM_PPC: /* R_PPC_NONE. */
10120 case EM_PPC64: /* R_PPC64_NONE. */
10121 case EM_ARM: /* R_ARM_NONE. */
10122 case EM_IA_64: /* R_IA64_NONE. */
10123 case EM_SH: /* R_SH_NONE. */
2a7b2e88 10124 case EM_S390_OLD:
cb8f3167
NC		 10125 case EM_S390: /* R_390_NONE. */
10126 case EM_CRIS: /* R_CRIS_NONE. */
10127 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 10128 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 10129 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 10130 case EM_MN10300: /* R_MN10300_NONE. */
5506d11a 10131 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 10132 case EM_M32R: /* R_M32R_NONE. */
40b36596 10133 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 10134 case EM_TILEGX: /* R_TILEGX_NONE. */
10135 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 10136 case EM_XC16X:
10137 case EM_C166: /* R_XC16X_NONE. */
cb8f3167 10138 return reloc_type == 0;
58332dda
JK		 10139 case EM_XTENSA_OLD:
10140 case EM_XTENSA:
4dc3c23d
AM		 10141 return (reloc_type == 0 /* R_XTENSA_NONE. */
10142 || reloc_type == 17 /* R_XTENSA_DIFF8. */
10143 || reloc_type == 18 /* R_XTENSA_DIFF16. */
10144 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
2a7b2e88
JK		 10145 }
10146 return FALSE;
10147}
10148
cf13d699
NC		 10149/* Apply relocations to a section.
10150 Note: So far support has been added only for those relocations
10151 which can be found in debug sections.
10152 FIXME: Add support for more relocations ? */
1b315056 10153
cf13d699
NC		 10154static void
10155apply_relocations (void * file,
10156 Elf_Internal_Shdr * section,
10157 unsigned char * start)
1b315056 10158{
cf13d699
NC		 10159 Elf_Internal_Shdr * relsec;
10160 unsigned char * end = start + section->sh_size;
cb8f3167 10161
cf13d699
NC		 10162 if (elf_header.e_type != ET_REL)
10163 return;
1b315056 10164
cf13d699 10165 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 10166 for (relsec = section_headers;
10167 relsec < section_headers + elf_header.e_shnum;
10168 ++relsec)
252b5132 10169 {
41e92641
NC		 10170 bfd_boolean is_rela;
10171 unsigned long num_relocs;
2cf0635d
NC		 10172 Elf_Internal_Rela * relocs;
10173 Elf_Internal_Rela * rp;
10174 Elf_Internal_Shdr * symsec;
10175 Elf_Internal_Sym * symtab;
ba5cdace 10176 unsigned long num_syms;
2cf0635d 10177 Elf_Internal_Sym * sym;
252b5132 10178
41e92641 10179 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 10180 || relsec->sh_info >= elf_header.e_shnum
10181 || section_headers + relsec->sh_info != section
c256ffe7 10182 || relsec->sh_size == 0
4fbb74a6 10183 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 10184 continue;
428409d5 10185
41e92641
NC		 10186 is_rela = relsec->sh_type == SHT_RELA;
10187
10188 if (is_rela)
10189 {
3f5e193b
NC		 10190 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10191 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10192 return;
10193 }
10194 else
10195 {
3f5e193b
NC		 10196 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10197 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10198 return;
10199 }
10200
10201 /* SH uses RELA but uses in place value instead of the addend field. */
10202 if (elf_header.e_machine == EM_SH)
10203 is_rela = FALSE;
428409d5 10204
4fbb74a6 10205 symsec = section_headers + relsec->sh_link;
ba5cdace 10206 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 10207
41e92641 10208 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 10209 {
41e92641
NC		 10210 bfd_vma addend;
10211 unsigned int reloc_type;
10212 unsigned int reloc_size;
91d6fa6a 10213 unsigned char * rloc;
ba5cdace 10214 unsigned long sym_index;
4b78141a 10215
aca88567 10216 reloc_type = get_reloc_type (rp->r_info);
41e92641 10217
98fb390a 10218 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 10219 continue;
98fb390a
NC		 10220 else if (is_none_reloc (reloc_type))
10221 continue;
10222 else if (is_32bit_abs_reloc (reloc_type)
10223 || is_32bit_pcrel_reloc (reloc_type))
aca88567 10224 reloc_size = 4;
85acf597
RH		 10225 else if (is_64bit_abs_reloc (reloc_type)
10226 || is_64bit_pcrel_reloc (reloc_type))
aca88567 10227 reloc_size = 8;
4dc3c23d
AM		 10228 else if (is_24bit_abs_reloc (reloc_type))
10229 reloc_size = 3;
aca88567
NC		 10230 else if (is_16bit_abs_reloc (reloc_type))
10231 reloc_size = 2;
10232 else
4b78141a 10233 {
41e92641 10234 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
aca88567 10235 reloc_type, SECTION_NAME (section));
4b78141a
NC		 10236 continue;
10237 }
103f02d3 10238
91d6fa6a
NC		 10239 rloc = start + rp->r_offset;
10240 if ((rloc + reloc_size) > end)
700dd8b7
L		 10241 {
10242 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10243 (unsigned long) rp->r_offset,
10244 SECTION_NAME (section));
10245 continue;
10246 }
103f02d3 10247
ba5cdace
NC		 10248 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
10249 if (sym_index >= num_syms)
10250 {
10251 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10252 sym_index, SECTION_NAME (section));
10253 continue;
10254 }
10255 sym = symtab + sym_index;
41e92641
NC		 10256
10257 /* If the reloc has a symbol associated with it,
55f25fc3
L		 10258 make sure that it is of an appropriate type.
10259
10260 Relocations against symbols without type can happen.
10261 Gcc -feliminate-dwarf2-dups may generate symbols
10262 without type for debug info.
10263
10264 Icc generates relocations against function symbols
10265 instead of local labels.
10266
10267 Relocations against object symbols can happen, eg when
10268 referencing a global array. For an example of this see
10269 the _clz.o binary in libgcc.a. */
aca88567 10270 if (sym != symtab
55f25fc3 10271 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 10272 {
41e92641 10273 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 10274 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 10275 (long int)(rp - relocs),
41e92641 10276 SECTION_NAME (relsec));
aca88567 10277 continue;
5b18a4bc 10278 }
252b5132 10279
4dc3c23d
AM		 10280 addend = 0;
10281 if (is_rela)
10282 addend += rp->r_addend;
c47320c3
AM		 10283 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10284 partial_inplace. */
4dc3c23d
AM		 10285 if (!is_rela
10286 || (elf_header.e_machine == EM_XTENSA
10287 && reloc_type == 1)
10288 || ((elf_header.e_machine == EM_PJ
10289 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 10290 && reloc_type == 1)
10291 || ((elf_header.e_machine == EM_D30V
10292 || elf_header.e_machine == EM_CYGNUS_D30V)
10293 && reloc_type == 12))
91d6fa6a 10294 addend += byte_get (rloc, reloc_size);
cb8f3167 10295
85acf597
RH		 10296 if (is_32bit_pcrel_reloc (reloc_type)
10297 || is_64bit_pcrel_reloc (reloc_type))
10298 {
10299 /* On HPPA, all pc-relative relocations are biased by 8. */
10300 if (elf_header.e_machine == EM_PARISC)
10301 addend -= 8;
91d6fa6a 10302 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 10303 reloc_size);
10304 }
41e92641 10305 else
91d6fa6a 10306 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 10307 }
252b5132 10308
5b18a4bc 10309 free (symtab);
41e92641 10310 free (relocs);
5b18a4bc
NC		 10311 break;
10312 }
5b18a4bc 10313}
103f02d3 10314
cf13d699
NC		 10315#ifdef SUPPORT_DISASSEMBLY
10316static int
10317disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10318{
10319 printf (_("\nAssembly dump of section %s\n"),
10320 SECTION_NAME (section));
10321
10322 /* XXX -- to be done --- XXX */
10323
10324 return 1;
10325}
10326#endif
10327
10328/* Reads in the contents of SECTION from FILE, returning a pointer
10329 to a malloc'ed buffer or NULL if something went wrong. */
10330
10331static char *
10332get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10333{
10334 bfd_size_type num_bytes;
10335
10336 num_bytes = section->sh_size;
10337
10338 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
10339 {
10340 printf (_("\nSection '%s' has no data to dump.\n"),
10341 SECTION_NAME (section));
10342 return NULL;
10343 }
10344
3f5e193b
NC		 10345 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
10346 _("section contents"));
cf13d699
NC		 10347}
10348
dd24e3da 10349
cf13d699
NC		 10350static void
10351dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
10352{
10353 Elf_Internal_Shdr * relsec;
10354 bfd_size_type num_bytes;
cf13d699
NC		 10355 char * data;
10356 char * end;
10357 char * start;
10358 char * name = SECTION_NAME (section);
10359 bfd_boolean some_strings_shown;
10360
10361 start = get_section_contents (section, file);
10362 if (start == NULL)
10363 return;
10364
10365 printf (_("\nString dump of section '%s':\n"), name);
10366
10367 /* If the section being dumped has relocations against it the user might
10368 be expecting these relocations to have been applied. Check for this
10369 case and issue a warning message in order to avoid confusion.
10370 FIXME: Maybe we ought to have an option that dumps a section with
10371 relocs applied ? */
10372 for (relsec = section_headers;
10373 relsec < section_headers + elf_header.e_shnum;
10374 ++relsec)
10375 {
10376 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10377 || relsec->sh_info >= elf_header.e_shnum
10378 || section_headers + relsec->sh_info != section
10379 || relsec->sh_size == 0
10380 || relsec->sh_link >= elf_header.e_shnum)
10381 continue;
10382
10383 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10384 break;
10385 }
10386
10387 num_bytes = section->sh_size;
cf13d699
NC		 10388 data = start;
10389 end = start + num_bytes;
10390 some_strings_shown = FALSE;
10391
10392 while (data < end)
10393 {
10394 while (!ISPRINT (* data))
10395 if (++ data >= end)
10396 break;
10397
10398 if (data < end)
10399 {
10400#ifndef __MSVCRT__
c975cc98
NC		 10401 /* PR 11128: Use two separate invocations in order to work
10402 around bugs in the Solaris 8 implementation of printf. */
10403 printf (" [%6tx] ", data - start);
10404 printf ("%s\n", data);
cf13d699
NC		 10405#else
10406 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
10407#endif
10408 data += strlen (data);
10409 some_strings_shown = TRUE;
10410 }
10411 }
10412
10413 if (! some_strings_shown)
10414 printf (_(" No strings found in this section."));
10415
10416 free (start);
10417
10418 putchar ('\n');
10419}
10420
10421static void
10422dump_section_as_bytes (Elf_Internal_Shdr * section,
10423 FILE * file,
10424 bfd_boolean relocate)
10425{
10426 Elf_Internal_Shdr * relsec;
10427 bfd_size_type bytes;
10428 bfd_vma addr;
10429 unsigned char * data;
10430 unsigned char * start;
10431
10432 start = (unsigned char *) get_section_contents (section, file);
10433 if (start == NULL)
10434 return;
10435
10436 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
10437
10438 if (relocate)
10439 {
10440 apply_relocations (file, section, start);
10441 }
10442 else
10443 {
10444 /* If the section being dumped has relocations against it the user might
10445 be expecting these relocations to have been applied. Check for this
10446 case and issue a warning message in order to avoid confusion.
10447 FIXME: Maybe we ought to have an option that dumps a section with
10448 relocs applied ? */
10449 for (relsec = section_headers;
10450 relsec < section_headers + elf_header.e_shnum;
10451 ++relsec)
10452 {
10453 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10454 || relsec->sh_info >= elf_header.e_shnum
10455 || section_headers + relsec->sh_info != section
10456 || relsec->sh_size == 0
10457 || relsec->sh_link >= elf_header.e_shnum)
10458 continue;
10459
10460 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10461 break;
10462 }
10463 }
10464
10465 addr = section->sh_addr;
10466 bytes = section->sh_size;
10467 data = start;
10468
10469 while (bytes)
10470 {
10471 int j;
10472 int k;
10473 int lbytes;
10474
10475 lbytes = (bytes > 16 ? 16 : bytes);
10476
10477 printf (" 0x%8.8lx ", (unsigned long) addr);
10478
10479 for (j = 0; j < 16; j++)
10480 {
10481 if (j < lbytes)
10482 printf ("%2.2x", data[j]);
10483 else
10484 printf (" ");
10485
10486 if ((j & 3) == 3)
10487 printf (" ");
10488 }
10489
10490 for (j = 0; j < lbytes; j++)
10491 {
10492 k = data[j];
10493 if (k >= ' ' && k < 0x7f)
10494 printf ("%c", k);
10495 else
10496 printf (".");
10497 }
10498
10499 putchar ('\n');
10500
10501 data += lbytes;
10502 addr += lbytes;
10503 bytes -= lbytes;
10504 }
10505
10506 free (start);
10507
10508 putchar ('\n');
10509}
10510
4a114e3e 10511/* Uncompresses a section that was compressed using zlib, in place. */
cf13d699
NC		 10512
10513static int
d3dbc530
AM		 10514uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10515 dwarf_size_type *size ATTRIBUTE_UNUSED)
cf13d699
NC		 10516{
10517#ifndef HAVE_ZLIB_H
cf13d699
NC		 10518 return FALSE;
10519#else
10520 dwarf_size_type compressed_size = *size;
10521 unsigned char * compressed_buffer = *buffer;
10522 dwarf_size_type uncompressed_size;
10523 unsigned char * uncompressed_buffer;
10524 z_stream strm;
10525 int rc;
10526 dwarf_size_type header_size = 12;
10527
10528 /* Read the zlib header. In this case, it should be "ZLIB" followed
10529 by the uncompressed section size, 8 bytes in big-endian order. */
10530 if (compressed_size < header_size
10531 || ! streq ((char *) compressed_buffer, "ZLIB"))
10532 return 0;
10533
10534 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10535 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10536 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10537 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10538 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10539 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10540 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10541 uncompressed_size += compressed_buffer[11];
10542
10543 /* It is possible the section consists of several compressed
10544 buffers concatenated together, so we uncompress in a loop. */
10545 strm.zalloc = NULL;
10546 strm.zfree = NULL;
10547 strm.opaque = NULL;
10548 strm.avail_in = compressed_size - header_size;
10549 strm.next_in = (Bytef *) compressed_buffer + header_size;
10550 strm.avail_out = uncompressed_size;
3f5e193b 10551 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
cf13d699
NC		 10552
10553 rc = inflateInit (& strm);
10554 while (strm.avail_in > 0)
10555 {
10556 if (rc != Z_OK)
10557 goto fail;
10558 strm.next_out = ((Bytef *) uncompressed_buffer
10559 + (uncompressed_size - strm.avail_out));
10560 rc = inflate (&strm, Z_FINISH);
10561 if (rc != Z_STREAM_END)
10562 goto fail;
10563 rc = inflateReset (& strm);
10564 }
10565 rc = inflateEnd (& strm);
10566 if (rc != Z_OK
10567 || strm.avail_out != 0)
10568 goto fail;
10569
10570 free (compressed_buffer);
10571 *buffer = uncompressed_buffer;
10572 *size = uncompressed_size;
10573 return 1;
10574
10575 fail:
10576 free (uncompressed_buffer);
4a114e3e
L		 10577 /* Indicate decompression failure. */
10578 *buffer = NULL;
cf13d699
NC		 10579 return 0;
10580#endif /* HAVE_ZLIB_H */
10581}
10582
d966045b
DJ		 10583static int
10584load_specific_debug_section (enum dwarf_section_display_enum debug,
2cf0635d 10585 Elf_Internal_Shdr * sec, void * file)
1007acb3 10586{
2cf0635d 10587 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 10588 char buf [64];
1007acb3 10589
19e6b90e
L		 10590 /* If it is already loaded, do nothing. */
10591 if (section->start != NULL)
10592 return 1;
1007acb3 10593
19e6b90e
L		 10594 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
10595 section->address = sec->sh_addr;
3f5e193b
NC		 10596 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
10597 sec->sh_offset, 1,
10598 sec->sh_size, buf);
59245841
NC		 10599 if (section->start == NULL)
10600 section->size = 0;
10601 else
10602 {
10603 section->size = sec->sh_size;
10604 if (uncompress_section_contents (&section->start, &section->size))
10605 sec->sh_size = section->size;
10606 }
4a114e3e 10607
1b315056
CS		 10608 if (section->start == NULL)
10609 return 0;
10610
19e6b90e 10611 if (debug_displays [debug].relocate)
3f5e193b 10612 apply_relocations ((FILE *) file, sec, section->start);
1007acb3 10613
1b315056 10614 return 1;
1007acb3
L		 10615}
10616
d966045b 10617int
2cf0635d 10618load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 10619{
2cf0635d
NC		 10620 struct dwarf_section * section = &debug_displays [debug].section;
10621 Elf_Internal_Shdr * sec;
d966045b
DJ		 10622
10623 /* Locate the debug section. */
10624 sec = find_section (section->uncompressed_name);
10625 if (sec != NULL)
10626 section->name = section->uncompressed_name;
10627 else
10628 {
10629 sec = find_section (section->compressed_name);
10630 if (sec != NULL)
10631 section->name = section->compressed_name;
10632 }
10633 if (sec == NULL)
10634 return 0;
10635
3f5e193b 10636 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 10637}
10638
19e6b90e
L		 10639void
10640free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 10641{
2cf0635d 10642 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 10643
19e6b90e
L		 10644 if (section->start == NULL)
10645 return;
1007acb3 10646
19e6b90e
L		 10647 free ((char *) section->start);
10648 section->start = NULL;
10649 section->address = 0;
10650 section->size = 0;
1007acb3
L		 10651}
10652
1007acb3 10653static int
2cf0635d 10654display_debug_section (Elf_Internal_Shdr * section, FILE * file)
1007acb3 10655{
2cf0635d 10656 char * name = SECTION_NAME (section);
19e6b90e
L		 10657 bfd_size_type length;
10658 int result = 1;
3f5e193b 10659 int i;
1007acb3 10660
19e6b90e
L		 10661 length = section->sh_size;
10662 if (length == 0)
1007acb3 10663 {
19e6b90e
L		 10664 printf (_("\nSection '%s' has no debugging data.\n"), name);
10665 return 0;
1007acb3 10666 }
5dff79d8
NC		 10667 if (section->sh_type == SHT_NOBITS)
10668 {
10669 /* There is no point in dumping the contents of a debugging section
10670 which has the NOBITS type - the bits in the file will be random.
10671 This can happen when a file containing a .eh_frame section is
10672 stripped with the --only-keep-debug command line option. */
10673 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
10674 return 0;
10675 }
1007acb3 10676
0112cd26 10677 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 10678 name = ".debug_info";
1007acb3 10679
19e6b90e
L		 10680 /* See if we know how to display the contents of this section. */
10681 for (i = 0; i < max; i++)
1b315056
CS		 10682 if (streq (debug_displays[i].section.uncompressed_name, name)
10683 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 10684 {
2cf0635d 10685 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 10686 int secondary = (section != find_section (name));
10687
10688 if (secondary)
3f5e193b 10689 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 10690
2b6f5997 10691 if (streq (sec->uncompressed_name, name))
d966045b
DJ		 10692 sec->name = sec->uncompressed_name;
10693 else
10694 sec->name = sec->compressed_name;
3f5e193b
NC		 10695 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
10696 section, file))
19e6b90e
L		 10697 {
10698 result &= debug_displays[i].display (sec, file);
1007acb3 10699
d966045b 10700 if (secondary || (i != info && i != abbrev))
3f5e193b 10701 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 10702 }
1007acb3 10703
19e6b90e
L		 10704 break;
10705 }
1007acb3 10706
19e6b90e 10707 if (i == max)
1007acb3 10708 {
19e6b90e
L		 10709 printf (_("Unrecognized debug section: %s\n"), name);
10710 result = 0;
1007acb3
L		 10711 }
10712
19e6b90e 10713 return result;
5b18a4bc 10714}
103f02d3 10715
aef1f6d0
DJ		 10716/* Set DUMP_SECTS for all sections where dumps were requested
10717 based on section name. */
10718
10719static void
10720initialise_dumps_byname (void)
10721{
2cf0635d 10722 struct dump_list_entry * cur;
aef1f6d0
DJ		 10723
10724 for (cur = dump_sects_byname; cur; cur = cur->next)
10725 {
10726 unsigned int i;
10727 int any;
10728
10729 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
10730 if (streq (SECTION_NAME (section_headers + i), cur->name))
10731 {
09c11c86 10732 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 10733 any = 1;
10734 }
10735
10736 if (!any)
10737 warn (_("Section '%s' was not dumped because it does not exist!\n"),
10738 cur->name);
10739 }
10740}
10741
5b18a4bc 10742static void
2cf0635d 10743process_section_contents (FILE * file)
5b18a4bc 10744{
2cf0635d 10745 Elf_Internal_Shdr * section;
19e6b90e 10746 unsigned int i;
103f02d3 10747
19e6b90e
L		 10748 if (! do_dump)
10749 return;
103f02d3 10750
aef1f6d0
DJ		 10751 initialise_dumps_byname ();
10752
19e6b90e
L		 10753 for (i = 0, section = section_headers;
10754 i < elf_header.e_shnum && i < num_dump_sects;
10755 i++, section++)
10756 {
10757#ifdef SUPPORT_DISASSEMBLY
10758 if (dump_sects[i] & DISASS_DUMP)
10759 disassemble_section (section, file);
10760#endif
10761 if (dump_sects[i] & HEX_DUMP)
cf13d699 10762 dump_section_as_bytes (section, file, FALSE);
103f02d3 10763
cf13d699
NC		 10764 if (dump_sects[i] & RELOC_DUMP)
10765 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 10766
10767 if (dump_sects[i] & STRING_DUMP)
10768 dump_section_as_strings (section, file);
cf13d699
NC		 10769
10770 if (dump_sects[i] & DEBUG_DUMP)
10771 display_debug_section (section, file);
5b18a4bc 10772 }
103f02d3 10773
19e6b90e
L		 10774 /* Check to see if the user requested a
10775 dump of a section that does not exist. */
10776 while (i++ < num_dump_sects)
10777 if (dump_sects[i])
10778 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 10779}
103f02d3 10780
5b18a4bc 10781static void
19e6b90e 10782process_mips_fpe_exception (int mask)
5b18a4bc 10783{
19e6b90e
L		 10784 if (mask)
10785 {
10786 int first = 1;
10787 if (mask & OEX_FPU_INEX)
10788 fputs ("INEX", stdout), first = 0;
10789 if (mask & OEX_FPU_UFLO)
10790 printf ("%sUFLO", first ? "" : "|"), first = 0;
10791 if (mask & OEX_FPU_OFLO)
10792 printf ("%sOFLO", first ? "" : "|"), first = 0;
10793 if (mask & OEX_FPU_DIV0)
10794 printf ("%sDIV0", first ? "" : "|"), first = 0;
10795 if (mask & OEX_FPU_INVAL)
10796 printf ("%sINVAL", first ? "" : "|");
10797 }
5b18a4bc 10798 else
19e6b90e 10799 fputs ("0", stdout);
5b18a4bc 10800}
103f02d3 10801
11c1ff18
PB		 10802/* ARM EABI attributes section. */
10803typedef struct
10804{
10805 int tag;
2cf0635d 10806 const char * name;
11c1ff18
PB		 10807 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
10808 int type;
2cf0635d 10809 const char ** table;
11c1ff18
PB		 10810} arm_attr_public_tag;
10811
2cf0635d 10812static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 10813 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
9e3c6df6 10814 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
2cf0635d
NC		 10815static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
10816static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 10817 {"No", "Thumb-1", "Thumb-2"};
75375b3e 10818static const char * arm_attr_tag_FP_arch[] =
62f3b8c8 10819 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
2cf0635d 10820static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 10821static const char * arm_attr_tag_Advanced_SIMD_arch[] =
cd21e546 10822 {"No", "NEONv1", "NEONv1 with Fused-MAC"};
2cf0635d 10823static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 10824 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
10825 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 10826static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 10827 {"V6", "SB", "TLS", "Unused"};
2cf0635d 10828static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 10829 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 10830static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 10831 {"Absolute", "PC-relative", "None"};
2cf0635d 10832static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 10833 {"None", "direct", "GOT-indirect"};
2cf0635d 10834static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 10835 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 10836static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
10837static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 10838 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 10839static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
10840static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
10841static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 10842 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 10843static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 10844 {"Unused", "small", "int", "forced to int"};
2cf0635d 10845static const char * arm_attr_tag_ABI_HardFP_use[] =
75375b3e 10846 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
2cf0635d 10847static const char * arm_attr_tag_ABI_VFP_args[] =
11c1ff18 10848 {"AAPCS", "VFP registers", "custom"};
2cf0635d 10849static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 10850 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 10851static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 10852 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10853 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 10854static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 10855 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10856 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 10857static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 10858static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 10859 {"Not Allowed", "Allowed"};
2cf0635d 10860static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 10861 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 10862static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 10863 {"Not Allowed", "Allowed"};
10864static const char * arm_attr_tag_DIV_use[] =
dd24e3da 10865 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 10866 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 10867static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
10868static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 10869 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 10870 "TrustZone and Virtualization Extensions"};
dd24e3da 10871static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 10872 {"Not Allowed", "Allowed"};
11c1ff18
PB		 10873
10874#define LOOKUP(id, name) \
10875 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 10876static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 10877{
10878 {4, "CPU_raw_name", 1, NULL},
10879 {5, "CPU_name", 1, NULL},
10880 LOOKUP(6, CPU_arch),
10881 {7, "CPU_arch_profile", 0, NULL},
10882 LOOKUP(8, ARM_ISA_use),
10883 LOOKUP(9, THUMB_ISA_use),
75375b3e 10884 LOOKUP(10, FP_arch),
11c1ff18 10885 LOOKUP(11, WMMX_arch),
f5f53991
AS		 10886 LOOKUP(12, Advanced_SIMD_arch),
10887 LOOKUP(13, PCS_config),
11c1ff18
PB		 10888 LOOKUP(14, ABI_PCS_R9_use),
10889 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 10890 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 10891 LOOKUP(17, ABI_PCS_GOT_use),
10892 LOOKUP(18, ABI_PCS_wchar_t),
10893 LOOKUP(19, ABI_FP_rounding),
10894 LOOKUP(20, ABI_FP_denormal),
10895 LOOKUP(21, ABI_FP_exceptions),
10896 LOOKUP(22, ABI_FP_user_exceptions),
10897 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 10898 {24, "ABI_align_needed", 0, NULL},
10899 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 10900 LOOKUP(26, ABI_enum_size),
10901 LOOKUP(27, ABI_HardFP_use),
10902 LOOKUP(28, ABI_VFP_args),
10903 LOOKUP(29, ABI_WMMX_args),
10904 LOOKUP(30, ABI_optimization_goals),
10905 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 10906 {32, "compatibility", 0, NULL},
f5f53991 10907 LOOKUP(34, CPU_unaligned_access),
75375b3e 10908 LOOKUP(36, FP_HP_extension),
8e79c3df 10909 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 10910 LOOKUP(42, MPextension_use),
10911 LOOKUP(44, DIV_use),
f5f53991
AS		 10912 {64, "nodefaults", 0, NULL},
10913 {65, "also_compatible_with", 0, NULL},
10914 LOOKUP(66, T2EE_use),
10915 {67, "conformance", 1, NULL},
10916 LOOKUP(68, Virtualization_use),
cd21e546 10917 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 10918};
10919#undef LOOKUP
10920
11c1ff18 10921static unsigned char *
2cf0635d 10922display_arm_attribute (unsigned char * p)
11c1ff18
PB		 10923{
10924 int tag;
10925 unsigned int len;
10926 int val;
2cf0635d 10927 arm_attr_public_tag * attr;
11c1ff18
PB		 10928 unsigned i;
10929 int type;
10930
10931 tag = read_uleb128 (p, &len);
10932 p += len;
10933 attr = NULL;
2cf0635d 10934 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 10935 {
10936 if (arm_attr_public_tags[i].tag == tag)
10937 {
10938 attr = &arm_attr_public_tags[i];
10939 break;
10940 }
10941 }
10942
10943 if (attr)
10944 {
10945 printf (" Tag_%s: ", attr->name);
10946 switch (attr->type)
10947 {
10948 case 0:
10949 switch (tag)
10950 {
10951 case 7: /* Tag_CPU_arch_profile. */
10952 val = read_uleb128 (p, &len);
10953 p += len;
10954 switch (val)
10955 {
2b692964
NC		 10956 case 0: printf (_("None\n")); break;
10957 case 'A': printf (_("Application\n")); break;
10958 case 'R': printf (_("Realtime\n")); break;
10959 case 'M': printf (_("Microcontroller\n")); break;
10960 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 10961 default: printf ("??? (%d)\n", val); break;
10962 }
10963 break;
10964
75375b3e
MGD		 10965 case 24: /* Tag_align_needed. */
10966 val = read_uleb128 (p, &len);
10967 p += len;
10968 switch (val)
10969 {
2b692964
NC		 10970 case 0: printf (_("None\n")); break;
10971 case 1: printf (_("8-byte\n")); break;
10972 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 10973 case 3: printf ("??? 3\n"); break;
10974 default:
10975 if (val <= 12)
dd24e3da 10976 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 10977 1 << val);
10978 else
10979 printf ("??? (%d)\n", val);
10980 break;
10981 }
10982 break;
10983
10984 case 25: /* Tag_align_preserved. */
10985 val = read_uleb128 (p, &len);
10986 p += len;
10987 switch (val)
10988 {
2b692964
NC		 10989 case 0: printf (_("None\n")); break;
10990 case 1: printf (_("8-byte, except leaf SP\n")); break;
10991 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 10992 case 3: printf ("??? 3\n"); break;
10993 default:
10994 if (val <= 12)
dd24e3da 10995 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 10996 1 << val);
10997 else
10998 printf ("??? (%d)\n", val);
10999 break;
11000 }
11001 break;
11002
11c1ff18
PB		 11003 case 32: /* Tag_compatibility. */
11004 val = read_uleb128 (p, &len);
11005 p += len;
2b692964 11006 printf (_("flag = %d, vendor = %s\n"), val, p);
2cf0635d 11007 p += strlen ((char *) p) + 1;
11c1ff18
PB		 11008 break;
11009
f5f53991
AS		 11010 case 64: /* Tag_nodefaults. */
11011 p++;
2b692964 11012 printf (_("True\n"));
f5f53991
AS		 11013 break;
11014
11015 case 65: /* Tag_also_compatible_with. */
11016 val = read_uleb128 (p, &len);
11017 p += len;
11018 if (val == 6 /* Tag_CPU_arch. */)
11019 {
11020 val = read_uleb128 (p, &len);
11021 p += len;
2cf0635d 11022 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 11023 printf ("??? (%d)\n", val);
11024 else
11025 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
11026 }
11027 else
11028 printf ("???\n");
11029 while (*(p++) != '\0' /* NUL terminator. */);
11030 break;
11031
11c1ff18 11032 default:
2cf0635d 11033 abort ();
11c1ff18
PB		 11034 }
11035 return p;
11036
11037 case 1:
11038 case 2:
11039 type = attr->type;
11040 break;
11041
11042 default:
11043 assert (attr->type & 0x80);
11044 val = read_uleb128 (p, &len);
11045 p += len;
11046 type = attr->type & 0x7f;
11047 if (val >= type)
11048 printf ("??? (%d)\n", val);
11049 else
11050 printf ("%s\n", attr->table[val]);
11051 return p;
11052 }
11053 }
11054 else
11055 {
11056 if (tag & 1)
11057 type = 1; /* String. */
11058 else
11059 type = 2; /* uleb128. */
11060 printf (" Tag_unknown_%d: ", tag);
11061 }
11062
11063 if (type == 1)
11064 {
11065 printf ("\"%s\"\n", p);
2cf0635d 11066 p += strlen ((char *) p) + 1;
11c1ff18
PB		 11067 }
11068 else
11069 {
11070 val = read_uleb128 (p, &len);
11071 p += len;
11072 printf ("%d (0x%x)\n", val, val);
11073 }
11074
11075 return p;
11076}
11077
104d59d1 11078static unsigned char *
60bca95a
NC		 11079display_gnu_attribute (unsigned char * p,
11080 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
104d59d1
JM		 11081{
11082 int tag;
11083 unsigned int len;
11084 int val;
11085 int type;
11086
11087 tag = read_uleb128 (p, &len);
11088 p += len;
11089
11090 /* Tag_compatibility is the only generic GNU attribute defined at
11091 present. */
11092 if (tag == 32)
11093 {
11094 val = read_uleb128 (p, &len);
11095 p += len;
2b692964 11096 printf (_("flag = %d, vendor = %s\n"), val, p);
60bca95a 11097 p += strlen ((char *) p) + 1;
104d59d1
JM		 11098 return p;
11099 }
11100
11101 if ((tag & 2) == 0 && display_proc_gnu_attribute)
11102 return display_proc_gnu_attribute (p, tag);
11103
11104 if (tag & 1)
11105 type = 1; /* String. */
11106 else
11107 type = 2; /* uleb128. */
11108 printf (" Tag_unknown_%d: ", tag);
11109
11110 if (type == 1)
11111 {
11112 printf ("\"%s\"\n", p);
60bca95a 11113 p += strlen ((char *) p) + 1;
104d59d1
JM		 11114 }
11115 else
11116 {
11117 val = read_uleb128 (p, &len);
11118 p += len;
11119 printf ("%d (0x%x)\n", val, val);
11120 }
11121
11122 return p;
11123}
11124
34c8bcba 11125static unsigned char *
2cf0635d 11126display_power_gnu_attribute (unsigned char * p, int tag)
34c8bcba
JM		 11127{
11128 int type;
11129 unsigned int len;
11130 int val;
11131
11132 if (tag == Tag_GNU_Power_ABI_FP)
11133 {
11134 val = read_uleb128 (p, &len);
11135 p += len;
11136 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 11137
34c8bcba
JM		 11138 switch (val)
11139 {
11140 case 0:
2b692964 11141 printf (_("Hard or soft float\n"));
34c8bcba
JM		 11142 break;
11143 case 1:
2b692964 11144 printf (_("Hard float\n"));
34c8bcba
JM		 11145 break;
11146 case 2:
2b692964 11147 printf (_("Soft float\n"));
34c8bcba 11148 break;
3c7b9897 11149 case 3:
2b692964 11150 printf (_("Single-precision hard float\n"));
3c7b9897 11151 break;
34c8bcba
JM		 11152 default:
11153 printf ("??? (%d)\n", val);
11154 break;
11155 }
11156 return p;
11157 }
11158
c6e65352
DJ		 11159 if (tag == Tag_GNU_Power_ABI_Vector)
11160 {
11161 val = read_uleb128 (p, &len);
11162 p += len;
11163 printf (" Tag_GNU_Power_ABI_Vector: ");
11164 switch (val)
11165 {
11166 case 0:
2b692964 11167 printf (_("Any\n"));
c6e65352
DJ		 11168 break;
11169 case 1:
2b692964 11170 printf (_("Generic\n"));
c6e65352
DJ		 11171 break;
11172 case 2:
11173 printf ("AltiVec\n");
11174 break;
11175 case 3:
11176 printf ("SPE\n");
11177 break;
11178 default:
11179 printf ("??? (%d)\n", val);
11180 break;
11181 }
11182 return p;
11183 }
11184
f82e0623
NF		 11185 if (tag == Tag_GNU_Power_ABI_Struct_Return)
11186 {
11187 val = read_uleb128 (p, &len);
11188 p += len;
11189 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11190 switch (val)
11191 {
11192 case 0:
2b692964 11193 printf (_("Any\n"));
f82e0623
NF		 11194 break;
11195 case 1:
11196 printf ("r3/r4\n");
11197 break;
11198 case 2:
2b692964 11199 printf (_("Memory\n"));
f82e0623
NF		 11200 break;
11201 default:
11202 printf ("??? (%d)\n", val);
11203 break;
11204 }
11205 return p;
11206 }
11207
34c8bcba
JM		 11208 if (tag & 1)
11209 type = 1; /* String. */
11210 else
11211 type = 2; /* uleb128. */
11212 printf (" Tag_unknown_%d: ", tag);
11213
11214 if (type == 1)
11215 {
11216 printf ("\"%s\"\n", p);
60bca95a 11217 p += strlen ((char *) p) + 1;
34c8bcba
JM		 11218 }
11219 else
11220 {
11221 val = read_uleb128 (p, &len);
11222 p += len;
11223 printf ("%d (0x%x)\n", val, val);
11224 }
11225
11226 return p;
11227}
11228
9e8c70f9
DM		 11229static void
11230display_sparc_hwcaps (int mask)
11231{
11232 if (mask)
11233 {
11234 int first = 1;
11235 if (mask & ELF_SPARC_HWCAP_MUL32)
11236 fputs ("mul32", stdout), first = 0;
11237 if (mask & ELF_SPARC_HWCAP_DIV32)
11238 printf ("%sdiv32", first ? "" : "|"), first = 0;
11239 if (mask & ELF_SPARC_HWCAP_FSMULD)
11240 printf ("%sfsmuld", first ? "" : "|"), first = 0;
11241 if (mask & ELF_SPARC_HWCAP_V8PLUS)
11242 printf ("%sv8plus", first ? "" : "|"), first = 0;
11243 if (mask & ELF_SPARC_HWCAP_POPC)
11244 printf ("%spopc", first ? "" : "|"), first = 0;
11245 if (mask & ELF_SPARC_HWCAP_VIS)
11246 printf ("%svis", first ? "" : "|"), first = 0;
11247 if (mask & ELF_SPARC_HWCAP_VIS2)
11248 printf ("%svis2", first ? "" : "|"), first = 0;
11249 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
11250 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
11251 if (mask & ELF_SPARC_HWCAP_FMAF)
11252 printf ("%sfmaf", first ? "" : "|"), first = 0;
11253 if (mask & ELF_SPARC_HWCAP_VIS3)
11254 printf ("%svis3", first ? "" : "|"), first = 0;
11255 if (mask & ELF_SPARC_HWCAP_HPC)
11256 printf ("%shpc", first ? "" : "|"), first = 0;
11257 if (mask & ELF_SPARC_HWCAP_RANDOM)
11258 printf ("%srandom", first ? "" : "|"), first = 0;
11259 if (mask & ELF_SPARC_HWCAP_TRANS)
11260 printf ("%strans", first ? "" : "|"), first = 0;
11261 if (mask & ELF_SPARC_HWCAP_FJFMAU)
11262 printf ("%sfjfmau", first ? "" : "|"), first = 0;
11263 if (mask & ELF_SPARC_HWCAP_IMA)
11264 printf ("%sima", first ? "" : "|"), first = 0;
11265 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
11266 printf ("%scspare", first ? "" : "|"), first = 0;
11267 }
11268 else
11269 fputc('0', stdout);
11270 fputc('\n', stdout);
11271}
11272
11273static unsigned char *
11274display_sparc_gnu_attribute (unsigned char * p, int tag)
11275{
11276 int type;
11277 unsigned int len;
11278 int val;
11279
11280 if (tag == Tag_GNU_Sparc_HWCAPS)
11281 {
11282 val = read_uleb128 (p, &len);
11283 p += len;
11284 printf (" Tag_GNU_Sparc_HWCAPS: ");
11285
11286 display_sparc_hwcaps (val);
11287 return p;
11288 }
11289
11290 if (tag & 1)
11291 type = 1; /* String. */
11292 else
11293 type = 2; /* uleb128. */
11294 printf (" Tag_unknown_%d: ", tag);
11295
11296 if (type == 1)
11297 {
11298 printf ("\"%s\"\n", p);
11299 p += strlen ((char *) p) + 1;
11300 }
11301 else
11302 {
11303 val = read_uleb128 (p, &len);
11304 p += len;
11305 printf ("%d (0x%x)\n", val, val);
11306 }
11307
11308 return p;
11309}
11310
2cf19d5c 11311static unsigned char *
2cf0635d 11312display_mips_gnu_attribute (unsigned char * p, int tag)
2cf19d5c
JM		 11313{
11314 int type;
11315 unsigned int len;
11316 int val;
11317
11318 if (tag == Tag_GNU_MIPS_ABI_FP)
11319 {
11320 val = read_uleb128 (p, &len);
11321 p += len;
11322 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 11323
2cf19d5c
JM		 11324 switch (val)
11325 {
11326 case 0:
2b692964 11327 printf (_("Hard or soft float\n"));
2cf19d5c
JM		 11328 break;
11329 case 1:
2b692964 11330 printf (_("Hard float (double precision)\n"));
2cf19d5c
JM		 11331 break;
11332 case 2:
2b692964 11333 printf (_("Hard float (single precision)\n"));
2cf19d5c
JM		 11334 break;
11335 case 3:
2b692964 11336 printf (_("Soft float\n"));
2cf19d5c 11337 break;
42554f6a 11338 case 4:
9eeefea8 11339 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
42554f6a 11340 break;
2cf19d5c
JM		 11341 default:
11342 printf ("??? (%d)\n", val);
11343 break;
11344 }
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);
60bca95a 11357 p += strlen ((char *) p) + 1;
2cf19d5c
JM		 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
59e6276b
JM		 11369static unsigned char *
11370display_tic6x_attribute (unsigned char * p)
11371{
11372 int tag;
11373 unsigned int len;
11374 int val;
11375
11376 tag = read_uleb128 (p, &len);
11377 p += len;
11378
11379 switch (tag)
11380 {
75fa6dc1 11381 case Tag_ISA:
59e6276b
JM		 11382 val = read_uleb128 (p, &len);
11383 p += len;
75fa6dc1 11384 printf (" Tag_ISA: ");
59e6276b
JM		 11385
11386 switch (val)
11387 {
75fa6dc1 11388 case C6XABI_Tag_ISA_none:
59e6276b
JM		 11389 printf (_("None\n"));
11390 break;
75fa6dc1 11391 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 11392 printf ("C62x\n");
11393 break;
75fa6dc1 11394 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 11395 printf ("C67x\n");
11396 break;
75fa6dc1 11397 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 11398 printf ("C67x+\n");
11399 break;
75fa6dc1 11400 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 11401 printf ("C64x\n");
11402 break;
75fa6dc1 11403 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 11404 printf ("C64x+\n");
11405 break;
75fa6dc1 11406 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 11407 printf ("C674x\n");
11408 break;
11409 default:
11410 printf ("??? (%d)\n", val);
11411 break;
11412 }
11413 return p;
11414
87779176
JM		 11415 case Tag_ABI_wchar_t:
11416 val = read_uleb128 (p, &len);
11417 p += len;
11418 printf (" Tag_ABI_wchar_t: ");
11419 switch (val)
11420 {
11421 case 0:
11422 printf (_("Not used\n"));
11423 break;
11424 case 1:
11425 printf (_("2 bytes\n"));
11426 break;
11427 case 2:
11428 printf (_("4 bytes\n"));
11429 break;
11430 default:
11431 printf ("??? (%d)\n", val);
11432 break;
11433 }
11434 return p;
11435
11436 case Tag_ABI_stack_align_needed:
11437 val = read_uleb128 (p, &len);
11438 p += len;
11439 printf (" Tag_ABI_stack_align_needed: ");
11440 switch (val)
11441 {
11442 case 0:
11443 printf (_("8-byte\n"));
11444 break;
11445 case 1:
11446 printf (_("16-byte\n"));
11447 break;
11448 default:
11449 printf ("??? (%d)\n", val);
11450 break;
11451 }
11452 return p;
11453
11454 case Tag_ABI_stack_align_preserved:
11455 val = read_uleb128 (p, &len);
11456 p += len;
11457 printf (" Tag_ABI_stack_align_preserved: ");
11458 switch (val)
11459 {
11460 case 0:
11461 printf (_("8-byte\n"));
11462 break;
11463 case 1:
11464 printf (_("16-byte\n"));
11465 break;
11466 default:
11467 printf ("??? (%d)\n", val);
11468 break;
11469 }
11470 return p;
11471
b5593623
JM		 11472 case Tag_ABI_DSBT:
11473 val = read_uleb128 (p, &len);
11474 p += len;
11475 printf (" Tag_ABI_DSBT: ");
11476 switch (val)
11477 {
11478 case 0:
11479 printf (_("DSBT addressing not used\n"));
11480 break;
11481 case 1:
11482 printf (_("DSBT addressing used\n"));
11483 break;
11484 default:
11485 printf ("??? (%d)\n", val);
11486 break;
11487 }
11488 return p;
11489
87779176
JM		 11490 case Tag_ABI_PID:
11491 val = read_uleb128 (p, &len);
11492 p += len;
11493 printf (" Tag_ABI_PID: ");
11494 switch (val)
11495 {
11496 case 0:
11497 printf (_("Data addressing position-dependent\n"));
11498 break;
11499 case 1:
11500 printf (_("Data addressing position-independent, GOT near DP\n"));
11501 break;
11502 case 2:
11503 printf (_("Data addressing position-independent, GOT far from DP\n"));
11504 break;
11505 default:
11506 printf ("??? (%d)\n", val);
11507 break;
11508 }
11509 return p;
11510
11511 case Tag_ABI_PIC:
11512 val = read_uleb128 (p, &len);
11513 p += len;
11514 printf (" Tag_ABI_PIC: ");
11515 switch (val)
11516 {
11517 case 0:
11518 printf (_("Code addressing position-dependent\n"));
11519 break;
11520 case 1:
11521 printf (_("Code addressing position-independent\n"));
11522 break;
11523 default:
11524 printf ("??? (%d)\n", val);
11525 break;
11526 }
11527 return p;
11528
11529 case Tag_ABI_array_object_alignment:
11530 val = read_uleb128 (p, &len);
11531 p += len;
11532 printf (" Tag_ABI_array_object_alignment: ");
11533 switch (val)
11534 {
11535 case 0:
11536 printf (_("8-byte\n"));
11537 break;
11538 case 1:
11539 printf (_("4-byte\n"));
11540 break;
11541 case 2:
11542 printf (_("16-byte\n"));
11543 break;
11544 default:
11545 printf ("??? (%d)\n", val);
11546 break;
11547 }
11548 return p;
11549
11550 case Tag_ABI_array_object_align_expected:
11551 val = read_uleb128 (p, &len);
11552 p += len;
11553 printf (" Tag_ABI_array_object_align_expected: ");
11554 switch (val)
11555 {
11556 case 0:
11557 printf (_("8-byte\n"));
11558 break;
11559 case 1:
11560 printf (_("4-byte\n"));
11561 break;
11562 case 2:
11563 printf (_("16-byte\n"));
11564 break;
11565 default:
11566 printf ("??? (%d)\n", val);
11567 break;
11568 }
11569 return p;
11570
3cbd1c06 11571 case Tag_ABI_compatibility:
59e6276b
JM		 11572 val = read_uleb128 (p, &len);
11573 p += len;
3cbd1c06 11574 printf (" Tag_ABI_compatibility: ");
59e6276b
JM		 11575 printf (_("flag = %d, vendor = %s\n"), val, p);
11576 p += strlen ((char *) p) + 1;
11577 return p;
87779176
JM		 11578
11579 case Tag_ABI_conformance:
11580 printf (" Tag_ABI_conformance: ");
11581 printf ("\"%s\"\n", p);
11582 p += strlen ((char *) p) + 1;
11583 return p;
59e6276b
JM		 11584 }
11585
11586 printf (" Tag_unknown_%d: ", tag);
11587
87779176
JM		 11588 if (tag & 1)
11589 {
11590 printf ("\"%s\"\n", p);
11591 p += strlen ((char *) p) + 1;
11592 }
11593 else
11594 {
11595 val = read_uleb128 (p, &len);
11596 p += len;
11597 printf ("%d (0x%x)\n", val, val);
11598 }
59e6276b
JM		 11599
11600 return p;
11601}
11602
11c1ff18 11603static int
60bca95a
NC		 11604process_attributes (FILE * file,
11605 const char * public_name,
104d59d1 11606 unsigned int proc_type,
60bca95a
NC		 11607 unsigned char * (* display_pub_attribute) (unsigned char *),
11608 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11c1ff18 11609{
2cf0635d
NC		 11610 Elf_Internal_Shdr * sect;
11611 unsigned char * contents;
11612 unsigned char * p;
11613 unsigned char * end;
11c1ff18
PB		 11614 bfd_vma section_len;
11615 bfd_vma len;
11616 unsigned i;
11617
11618 /* Find the section header so that we get the size. */
11619 for (i = 0, sect = section_headers;
11620 i < elf_header.e_shnum;
11621 i++, sect++)
11622 {
104d59d1 11623 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 11624 continue;
11625
3f5e193b
NC		 11626 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
11627 sect->sh_size, _("attributes"));
60bca95a 11628 if (contents == NULL)
11c1ff18 11629 continue;
60bca95a 11630
11c1ff18
PB		 11631 p = contents;
11632 if (*p == 'A')
11633 {
11634 len = sect->sh_size - 1;
11635 p++;
60bca95a 11636
11c1ff18
PB		 11637 while (len > 0)
11638 {
11639 int namelen;
11640 bfd_boolean public_section;
104d59d1 11641 bfd_boolean gnu_section;
11c1ff18
PB		 11642
11643 section_len = byte_get (p, 4);
11644 p += 4;
60bca95a 11645
11c1ff18
PB		 11646 if (section_len > len)
11647 {
11648 printf (_("ERROR: Bad section length (%d > %d)\n"),
60bca95a 11649 (int) section_len, (int) len);
11c1ff18
PB		 11650 section_len = len;
11651 }
60bca95a 11652
11c1ff18 11653 len -= section_len;
2b692964 11654 printf (_("Attribute Section: %s\n"), p);
60bca95a
NC		 11655
11656 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 11657 public_section = TRUE;
11658 else
11659 public_section = FALSE;
60bca95a
NC		 11660
11661 if (streq ((char *) p, "gnu"))
104d59d1
JM		 11662 gnu_section = TRUE;
11663 else
11664 gnu_section = FALSE;
60bca95a
NC		 11665
11666 namelen = strlen ((char *) p) + 1;
11c1ff18
PB		 11667 p += namelen;
11668 section_len -= namelen + 4;
60bca95a 11669
11c1ff18
PB		 11670 while (section_len > 0)
11671 {
11672 int tag = *(p++);
11673 int val;
11674 bfd_vma size;
60bca95a 11675
11c1ff18
PB		 11676 size = byte_get (p, 4);
11677 if (size > section_len)
11678 {
11679 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
60bca95a 11680 (int) size, (int) section_len);
11c1ff18
PB		 11681 size = section_len;
11682 }
60bca95a 11683
11c1ff18
PB		 11684 section_len -= size;
11685 end = p + size - 1;
11686 p += 4;
60bca95a 11687
11c1ff18
PB		 11688 switch (tag)
11689 {
11690 case 1:
2b692964 11691 printf (_("File Attributes\n"));
11c1ff18
PB		 11692 break;
11693 case 2:
2b692964 11694 printf (_("Section Attributes:"));
11c1ff18
PB		 11695 goto do_numlist;
11696 case 3:
2b692964 11697 printf (_("Symbol Attributes:"));
11c1ff18
PB		 11698 do_numlist:
11699 for (;;)
11700 {
91d6fa6a 11701 unsigned int j;
60bca95a 11702
91d6fa6a
NC		 11703 val = read_uleb128 (p, &j);
11704 p += j;
11c1ff18
PB		 11705 if (val == 0)
11706 break;
11707 printf (" %d", val);
11708 }
11709 printf ("\n");
11710 break;
11711 default:
2b692964 11712 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 11713 public_section = FALSE;
11714 break;
11715 }
60bca95a 11716
11c1ff18
PB		 11717 if (public_section)
11718 {
11719 while (p < end)
104d59d1
JM		 11720 p = display_pub_attribute (p);
11721 }
11722 else if (gnu_section)
11723 {
11724 while (p < end)
11725 p = display_gnu_attribute (p,
11726 display_proc_gnu_attribute);
11c1ff18
PB		 11727 }
11728 else
11729 {
11730 /* ??? Do something sensible, like dump hex. */
2b692964 11731 printf (_(" Unknown section contexts\n"));
11c1ff18
PB		 11732 p = end;
11733 }
11734 }
11735 }
11736 }
11737 else
60bca95a 11738 printf (_("Unknown format '%c'\n"), *p);
d70c5fc7 11739
60bca95a 11740 free (contents);
11c1ff18
PB		 11741 }
11742 return 1;
11743}
11744
104d59d1 11745static int
2cf0635d 11746process_arm_specific (FILE * file)
104d59d1
JM		 11747{
11748 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
11749 display_arm_attribute, NULL);
11750}
11751
34c8bcba 11752static int
2cf0635d 11753process_power_specific (FILE * file)
34c8bcba
JM		 11754{
11755 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11756 display_power_gnu_attribute);
11757}
11758
9e8c70f9
DM		 11759static int
11760process_sparc_specific (FILE * file)
11761{
11762 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11763 display_sparc_gnu_attribute);
11764}
11765
59e6276b
JM		 11766static int
11767process_tic6x_specific (FILE * file)
11768{
11769 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
11770 display_tic6x_attribute, NULL);
11771}
11772
ccb4c951
RS		 11773/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
11774 Print the Address, Access and Initial fields of an entry at VMA ADDR
11775 and return the VMA of the next entry. */
11776
11777static bfd_vma
2cf0635d 11778print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
ccb4c951
RS		 11779{
11780 printf (" ");
11781 print_vma (addr, LONG_HEX);
11782 printf (" ");
11783 if (addr < pltgot + 0xfff0)
11784 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
11785 else
11786 printf ("%10s", "");
11787 printf (" ");
11788 if (data == NULL)
2b692964 11789 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 11790 else
11791 {
11792 bfd_vma entry;
11793
11794 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11795 print_vma (entry, LONG_HEX);
11796 }
11797 return addr + (is_32bit_elf ? 4 : 8);
11798}
11799
861fb55a
DJ		 11800/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
11801 PLTGOT. Print the Address and Initial fields of an entry at VMA
11802 ADDR and return the VMA of the next entry. */
11803
11804static bfd_vma
2cf0635d 11805print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 11806{
11807 printf (" ");
11808 print_vma (addr, LONG_HEX);
11809 printf (" ");
11810 if (data == NULL)
2b692964 11811 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 11812 else
11813 {
11814 bfd_vma entry;
11815
11816 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11817 print_vma (entry, LONG_HEX);
11818 }
11819 return addr + (is_32bit_elf ? 4 : 8);
11820}
11821
19e6b90e 11822static int
2cf0635d 11823process_mips_specific (FILE * file)
5b18a4bc 11824{
2cf0635d 11825 Elf_Internal_Dyn * entry;
19e6b90e
L		 11826 size_t liblist_offset = 0;
11827 size_t liblistno = 0;
11828 size_t conflictsno = 0;
11829 size_t options_offset = 0;
11830 size_t conflicts_offset = 0;
861fb55a
DJ		 11831 size_t pltrelsz = 0;
11832 size_t pltrel = 0;
ccb4c951 11833 bfd_vma pltgot = 0;
861fb55a
DJ		 11834 bfd_vma mips_pltgot = 0;
11835 bfd_vma jmprel = 0;
ccb4c951
RS		 11836 bfd_vma local_gotno = 0;
11837 bfd_vma gotsym = 0;
11838 bfd_vma symtabno = 0;
103f02d3 11839
2cf19d5c
JM		 11840 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11841 display_mips_gnu_attribute);
11842
19e6b90e
L		 11843 /* We have a lot of special sections. Thanks SGI! */
11844 if (dynamic_section == NULL)
11845 /* No information available. */
11846 return 0;
252b5132 11847
b2d38a17 11848 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
252b5132
RH		 11849 switch (entry->d_tag)
11850 {
11851 case DT_MIPS_LIBLIST:
d93f0186
NC		 11852 liblist_offset
11853 = offset_from_vma (file, entry->d_un.d_val,
11854 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 11855 break;
11856 case DT_MIPS_LIBLISTNO:
11857 liblistno = entry->d_un.d_val;
11858 break;
11859 case DT_MIPS_OPTIONS:
d93f0186 11860 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 11861 break;
11862 case DT_MIPS_CONFLICT:
d93f0186
NC		 11863 conflicts_offset
11864 = offset_from_vma (file, entry->d_un.d_val,
11865 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 11866 break;
11867 case DT_MIPS_CONFLICTNO:
11868 conflictsno = entry->d_un.d_val;
11869 break;
ccb4c951 11870 case DT_PLTGOT:
861fb55a
DJ		 11871 pltgot = entry->d_un.d_ptr;
11872 break;
ccb4c951
RS		 11873 case DT_MIPS_LOCAL_GOTNO:
11874 local_gotno = entry->d_un.d_val;
11875 break;
11876 case DT_MIPS_GOTSYM:
11877 gotsym = entry->d_un.d_val;
11878 break;
11879 case DT_MIPS_SYMTABNO:
11880 symtabno = entry->d_un.d_val;
11881 break;
861fb55a
DJ		 11882 case DT_MIPS_PLTGOT:
11883 mips_pltgot = entry->d_un.d_ptr;
11884 break;
11885 case DT_PLTREL:
11886 pltrel = entry->d_un.d_val;
11887 break;
11888 case DT_PLTRELSZ:
11889 pltrelsz = entry->d_un.d_val;
11890 break;
11891 case DT_JMPREL:
11892 jmprel = entry->d_un.d_ptr;
11893 break;
252b5132
RH		 11894 default:
11895 break;
11896 }
11897
11898 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
11899 {
2cf0635d 11900 Elf32_External_Lib * elib;
252b5132
RH		 11901 size_t cnt;
11902
3f5e193b
NC		 11903 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
11904 liblistno,
11905 sizeof (Elf32_External_Lib),
9cf03b7e 11906 _("liblist section data"));
a6e9f9df 11907 if (elib)
252b5132 11908 {
2b692964 11909 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 11910 (unsigned long) liblistno);
2b692964 11911 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 11912 stdout);
11913
11914 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 11915 {
a6e9f9df 11916 Elf32_Lib liblist;
91d6fa6a 11917 time_t atime;
a6e9f9df 11918 char timebuf[20];
2cf0635d 11919 struct tm * tmp;
a6e9f9df
AM		 11920
11921 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 11922 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 11923 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
11924 liblist.l_version = BYTE_GET (elib[cnt].l_version);
11925 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
11926
91d6fa6a 11927 tmp = gmtime (&atime);
e9e44622
JJ		 11928 snprintf (timebuf, sizeof (timebuf),
11929 "%04u-%02u-%02uT%02u:%02u:%02u",
11930 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
11931 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 11932
31104126 11933 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 11934 if (VALID_DYNAMIC_NAME (liblist.l_name))
11935 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
11936 else
2b692964 11937 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 11938 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
11939 liblist.l_version);
a6e9f9df
AM		 11940
11941 if (liblist.l_flags == 0)
2b692964 11942 puts (_(" NONE"));
a6e9f9df
AM		 11943 else
11944 {
11945 static const struct
252b5132 11946 {
2cf0635d 11947 const char * name;
a6e9f9df 11948 int bit;
252b5132 11949 }
a6e9f9df
AM		 11950 l_flags_vals[] =
11951 {
11952 { " EXACT_MATCH", LL_EXACT_MATCH },
11953 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
11954 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
11955 { " EXPORTS", LL_EXPORTS },
11956 { " DELAY_LOAD", LL_DELAY_LOAD },
11957 { " DELTA", LL_DELTA }
11958 };
11959 int flags = liblist.l_flags;
11960 size_t fcnt;
11961
60bca95a 11962 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 11963 if ((flags & l_flags_vals[fcnt].bit) != 0)
11964 {
11965 fputs (l_flags_vals[fcnt].name, stdout);
11966 flags ^= l_flags_vals[fcnt].bit;
11967 }
11968 if (flags != 0)
11969 printf (" %#x", (unsigned int) flags);
252b5132 11970
a6e9f9df
AM		 11971 puts ("");
11972 }
252b5132 11973 }
252b5132 11974
a6e9f9df
AM		 11975 free (elib);
11976 }
252b5132
RH		 11977 }
11978
11979 if (options_offset != 0)
11980 {
2cf0635d
NC		 11981 Elf_External_Options * eopt;
11982 Elf_Internal_Shdr * sect = section_headers;
11983 Elf_Internal_Options * iopt;
11984 Elf_Internal_Options * option;
252b5132
RH		 11985 size_t offset;
11986 int cnt;
11987
11988 /* Find the section header so that we get the size. */
11989 while (sect->sh_type != SHT_MIPS_OPTIONS)
b34976b6 11990 ++sect;
252b5132 11991
3f5e193b
NC		 11992 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
11993 sect->sh_size, _("options"));
a6e9f9df 11994 if (eopt)
252b5132 11995 {
3f5e193b
NC		 11996 iopt = (Elf_Internal_Options *)
11997 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 11998 if (iopt == NULL)
11999 {
591a748a 12000 error (_("Out of memory\n"));
a6e9f9df
AM		 12001 return 0;
12002 }
76da6bbe 12003
a6e9f9df
AM		 12004 offset = cnt = 0;
12005 option = iopt;
252b5132 12006
a6e9f9df
AM		 12007 while (offset < sect->sh_size)
12008 {
2cf0635d 12009 Elf_External_Options * eoption;
252b5132 12010
a6e9f9df 12011 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 12012
a6e9f9df
AM		 12013 option->kind = BYTE_GET (eoption->kind);
12014 option->size = BYTE_GET (eoption->size);
12015 option->section = BYTE_GET (eoption->section);
12016 option->info = BYTE_GET (eoption->info);
76da6bbe 12017
a6e9f9df 12018 offset += option->size;
252b5132 12019
a6e9f9df
AM		 12020 ++option;
12021 ++cnt;
12022 }
252b5132 12023
a6e9f9df
AM		 12024 printf (_("\nSection '%s' contains %d entries:\n"),
12025 SECTION_NAME (sect), cnt);
76da6bbe 12026
a6e9f9df 12027 option = iopt;
252b5132 12028
a6e9f9df 12029 while (cnt-- > 0)
252b5132 12030 {
a6e9f9df
AM		 12031 size_t len;
12032
12033 switch (option->kind)
252b5132 12034 {
a6e9f9df
AM		 12035 case ODK_NULL:
12036 /* This shouldn't happen. */
12037 printf (" NULL %d %lx", option->section, option->info);
12038 break;
12039 case ODK_REGINFO:
12040 printf (" REGINFO ");
12041 if (elf_header.e_machine == EM_MIPS)
12042 {
12043 /* 32bit form. */
2cf0635d 12044 Elf32_External_RegInfo * ereg;
b34976b6 12045 Elf32_RegInfo reginfo;
a6e9f9df
AM		 12046
12047 ereg = (Elf32_External_RegInfo *) (option + 1);
12048 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12049 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12050 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12051 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12052 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12053 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
12054
12055 printf ("GPR %08lx GP 0x%lx\n",
12056 reginfo.ri_gprmask,
12057 (unsigned long) reginfo.ri_gp_value);
12058 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12059 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12060 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12061 }
12062 else
12063 {
12064 /* 64 bit form. */
2cf0635d 12065 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 12066 Elf64_Internal_RegInfo reginfo;
12067
12068 ereg = (Elf64_External_RegInfo *) (option + 1);
12069 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12070 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12071 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12072 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12073 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 12074 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 12075
12076 printf ("GPR %08lx GP 0x",
12077 reginfo.ri_gprmask);
12078 printf_vma (reginfo.ri_gp_value);
12079 printf ("\n");
12080
12081 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12082 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12083 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12084 }
12085 ++option;
12086 continue;
12087 case ODK_EXCEPTIONS:
12088 fputs (" EXCEPTIONS fpe_min(", stdout);
12089 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
12090 fputs (") fpe_max(", stdout);
12091 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
12092 fputs (")", stdout);
12093
12094 if (option->info & OEX_PAGE0)
12095 fputs (" PAGE0", stdout);
12096 if (option->info & OEX_SMM)
12097 fputs (" SMM", stdout);
12098 if (option->info & OEX_FPDBUG)
12099 fputs (" FPDBUG", stdout);
12100 if (option->info & OEX_DISMISS)
12101 fputs (" DISMISS", stdout);
12102 break;
12103 case ODK_PAD:
12104 fputs (" PAD ", stdout);
12105 if (option->info & OPAD_PREFIX)
12106 fputs (" PREFIX", stdout);
12107 if (option->info & OPAD_POSTFIX)
12108 fputs (" POSTFIX", stdout);
12109 if (option->info & OPAD_SYMBOL)
12110 fputs (" SYMBOL", stdout);
12111 break;
12112 case ODK_HWPATCH:
12113 fputs (" HWPATCH ", stdout);
12114 if (option->info & OHW_R4KEOP)
12115 fputs (" R4KEOP", stdout);
12116 if (option->info & OHW_R8KPFETCH)
12117 fputs (" R8KPFETCH", stdout);
12118 if (option->info & OHW_R5KEOP)
12119 fputs (" R5KEOP", stdout);
12120 if (option->info & OHW_R5KCVTL)
12121 fputs (" R5KCVTL", stdout);
12122 break;
12123 case ODK_FILL:
12124 fputs (" FILL ", stdout);
12125 /* XXX Print content of info word? */
12126 break;
12127 case ODK_TAGS:
12128 fputs (" TAGS ", stdout);
12129 /* XXX Print content of info word? */
12130 break;
12131 case ODK_HWAND:
12132 fputs (" HWAND ", stdout);
12133 if (option->info & OHWA0_R4KEOP_CHECKED)
12134 fputs (" R4KEOP_CHECKED", stdout);
12135 if (option->info & OHWA0_R4KEOP_CLEAN)
12136 fputs (" R4KEOP_CLEAN", stdout);
12137 break;
12138 case ODK_HWOR:
12139 fputs (" HWOR ", stdout);
12140 if (option->info & OHWA0_R4KEOP_CHECKED)
12141 fputs (" R4KEOP_CHECKED", stdout);
12142 if (option->info & OHWA0_R4KEOP_CLEAN)
12143 fputs (" R4KEOP_CLEAN", stdout);
12144 break;
12145 case ODK_GP_GROUP:
12146 printf (" GP_GROUP %#06lx self-contained %#06lx",
12147 option->info & OGP_GROUP,
12148 (option->info & OGP_SELF) >> 16);
12149 break;
12150 case ODK_IDENT:
12151 printf (" IDENT %#06lx self-contained %#06lx",
12152 option->info & OGP_GROUP,
12153 (option->info & OGP_SELF) >> 16);
12154 break;
12155 default:
12156 /* This shouldn't happen. */
12157 printf (" %3d ??? %d %lx",
12158 option->kind, option->section, option->info);
12159 break;
252b5132 12160 }
a6e9f9df 12161
2cf0635d 12162 len = sizeof (* eopt);
a6e9f9df
AM		 12163 while (len < option->size)
12164 if (((char *) option)[len] >= ' '
12165 && ((char *) option)[len] < 0x7f)
12166 printf ("%c", ((char *) option)[len++]);
12167 else
12168 printf ("\\%03o", ((char *) option)[len++]);
12169
12170 fputs ("\n", stdout);
252b5132 12171 ++option;
252b5132
RH		 12172 }
12173
a6e9f9df 12174 free (eopt);
252b5132 12175 }
252b5132
RH		 12176 }
12177
12178 if (conflicts_offset != 0 && conflictsno != 0)
12179 {
2cf0635d 12180 Elf32_Conflict * iconf;
252b5132
RH		 12181 size_t cnt;
12182
12183 if (dynamic_symbols == NULL)
12184 {
591a748a 12185 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 12186 return 0;
12187 }
12188
3f5e193b 12189 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 12190 if (iconf == NULL)
12191 {
591a748a 12192 error (_("Out of memory\n"));
252b5132
RH		 12193 return 0;
12194 }
12195
9ea033b2 12196 if (is_32bit_elf)
252b5132 12197 {
2cf0635d 12198 Elf32_External_Conflict * econf32;
a6e9f9df 12199
3f5e193b
NC		 12200 econf32 = (Elf32_External_Conflict *)
12201 get_data (NULL, file, conflicts_offset, conflictsno,
12202 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 12203 if (!econf32)
12204 return 0;
252b5132
RH		 12205
12206 for (cnt = 0; cnt < conflictsno; ++cnt)
12207 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 12208
12209 free (econf32);
252b5132
RH		 12210 }
12211 else
12212 {
2cf0635d 12213 Elf64_External_Conflict * econf64;
a6e9f9df 12214
3f5e193b
NC		 12215 econf64 = (Elf64_External_Conflict *)
12216 get_data (NULL, file, conflicts_offset, conflictsno,
12217 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 12218 if (!econf64)
12219 return 0;
252b5132
RH		 12220
12221 for (cnt = 0; cnt < conflictsno; ++cnt)
12222 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 12223
12224 free (econf64);
252b5132
RH		 12225 }
12226
c7e7ca54
NC		 12227 printf (_("\nSection '.conflict' contains %lu entries:\n"),
12228 (unsigned long) conflictsno);
252b5132
RH		 12229 puts (_(" Num: Index Value Name"));
12230
12231 for (cnt = 0; cnt < conflictsno; ++cnt)
12232 {
2cf0635d 12233 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
252b5132 12234
b34976b6 12235 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
f7a99963 12236 print_vma (psym->st_value, FULL_HEX);
31104126 12237 putchar (' ');
d79b3d50
NC		 12238 if (VALID_DYNAMIC_NAME (psym->st_name))
12239 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
12240 else
2b692964 12241 printf (_("<corrupt: %14ld>"), psym->st_name);
31104126 12242 putchar ('\n');
252b5132
RH		 12243 }
12244
252b5132
RH		 12245 free (iconf);
12246 }
12247
ccb4c951
RS		 12248 if (pltgot != 0 && local_gotno != 0)
12249 {
91d6fa6a 12250 bfd_vma ent, local_end, global_end;
bbeee7ea 12251 size_t i, offset;
2cf0635d 12252 unsigned char * data;
bbeee7ea 12253 int addr_size;
ccb4c951 12254
91d6fa6a 12255 ent = pltgot;
ccb4c951
RS		 12256 addr_size = (is_32bit_elf ? 4 : 8);
12257 local_end = pltgot + local_gotno * addr_size;
12258 global_end = local_end + (symtabno - gotsym) * addr_size;
12259
12260 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 12261 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 12262 global_end - pltgot, 1,
12263 _("Global Offset Table data"));
59245841
NC		 12264 if (data == NULL)
12265 return 0;
12266
ccb4c951
RS		 12267 printf (_("\nPrimary GOT:\n"));
12268 printf (_(" Canonical gp value: "));
12269 print_vma (pltgot + 0x7ff0, LONG_HEX);
12270 printf ("\n\n");
12271
12272 printf (_(" Reserved entries:\n"));
12273 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 12274 addr_size * 2, _("Address"), _("Access"),
12275 addr_size * 2, _("Initial"));
91d6fa6a 12276 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 12277 printf (_(" Lazy resolver\n"));
ccb4c951 12278 if (data
91d6fa6a 12279 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 12280 >> (addr_size * 8 - 1)) != 0)
12281 {
91d6fa6a 12282 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 12283 printf (_(" Module pointer (GNU extension)\n"));
ccb4c951
RS		 12284 }
12285 printf ("\n");
12286
91d6fa6a 12287 if (ent < local_end)
ccb4c951
RS		 12288 {
12289 printf (_(" Local entries:\n"));
cc5914eb 12290 printf (" %*s %10s %*s\n",
2b692964
NC		 12291 addr_size * 2, _("Address"), _("Access"),
12292 addr_size * 2, _("Initial"));
91d6fa6a 12293 while (ent < local_end)
ccb4c951 12294 {
91d6fa6a 12295 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 12296 printf ("\n");
12297 }
12298 printf ("\n");
12299 }
12300
12301 if (gotsym < symtabno)
12302 {
12303 int sym_width;
12304
12305 printf (_(" Global entries:\n"));
cc5914eb 12306 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 12307 addr_size * 2, _("Address"),
12308 _("Access"),
2b692964 12309 addr_size * 2, _("Initial"),
9cf03b7e
NC		 12310 addr_size * 2, _("Sym.Val."),
12311 _("Type"),
12312 /* Note for translators: "Ndx" = abbreviated form of "Index". */
12313 _("Ndx"), _("Name"));
12314
ccb4c951
RS		 12315 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
12316 for (i = gotsym; i < symtabno; i++)
12317 {
2cf0635d 12318 Elf_Internal_Sym * psym;
ccb4c951
RS		 12319
12320 psym = dynamic_symbols + i;
91d6fa6a 12321 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 12322 printf (" ");
12323 print_vma (psym->st_value, LONG_HEX);
12324 printf (" %-7s %3s ",
12325 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12326 get_symbol_index_type (psym->st_shndx));
12327 if (VALID_DYNAMIC_NAME (psym->st_name))
12328 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12329 else
2b692964 12330 printf (_("<corrupt: %14ld>"), psym->st_name);
ccb4c951
RS		 12331 printf ("\n");
12332 }
12333 printf ("\n");
12334 }
12335
12336 if (data)
12337 free (data);
12338 }
12339
861fb55a
DJ		 12340 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
12341 {
91d6fa6a 12342 bfd_vma ent, end;
861fb55a
DJ		 12343 size_t offset, rel_offset;
12344 unsigned long count, i;
2cf0635d 12345 unsigned char * data;
861fb55a 12346 int addr_size, sym_width;
2cf0635d 12347 Elf_Internal_Rela * rels;
861fb55a
DJ		 12348
12349 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
12350 if (pltrel == DT_RELA)
12351 {
12352 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
12353 return 0;
12354 }
12355 else
12356 {
12357 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
12358 return 0;
12359 }
12360
91d6fa6a 12361 ent = mips_pltgot;
861fb55a
DJ		 12362 addr_size = (is_32bit_elf ? 4 : 8);
12363 end = mips_pltgot + (2 + count) * addr_size;
12364
12365 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 12366 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 12367 1, _("Procedure Linkage Table data"));
59245841
NC		 12368 if (data == NULL)
12369 return 0;
12370
9cf03b7e 12371 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 12372 printf (_(" Reserved entries:\n"));
12373 printf (_(" %*s %*s Purpose\n"),
2b692964 12374 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 12375 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 12376 printf (_(" PLT lazy resolver\n"));
91d6fa6a 12377 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 12378 printf (_(" Module pointer\n"));
861fb55a
DJ		 12379 printf ("\n");
12380
12381 printf (_(" Entries:\n"));
cc5914eb 12382 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 12383 addr_size * 2, _("Address"),
12384 addr_size * 2, _("Initial"),
12385 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 12386 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
12387 for (i = 0; i < count; i++)
12388 {
2cf0635d 12389 Elf_Internal_Sym * psym;
861fb55a
DJ		 12390
12391 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
91d6fa6a 12392 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a
DJ		 12393 printf (" ");
12394 print_vma (psym->st_value, LONG_HEX);
12395 printf (" %-7s %3s ",
12396 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12397 get_symbol_index_type (psym->st_shndx));
12398 if (VALID_DYNAMIC_NAME (psym->st_name))
12399 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12400 else
2b692964 12401 printf (_("<corrupt: %14ld>"), psym->st_name);
861fb55a
DJ		 12402 printf ("\n");
12403 }
12404 printf ("\n");
12405
12406 if (data)
12407 free (data);
12408 free (rels);
12409 }
12410
252b5132
RH		 12411 return 1;
12412}
12413
047b2264 12414static int
2cf0635d 12415process_gnu_liblist (FILE * file)
047b2264 12416{
2cf0635d
NC		 12417 Elf_Internal_Shdr * section;
12418 Elf_Internal_Shdr * string_sec;
12419 Elf32_External_Lib * elib;
12420 char * strtab;
c256ffe7 12421 size_t strtab_size;
047b2264
JJ		 12422 size_t cnt;
12423 unsigned i;
12424
12425 if (! do_arch)
12426 return 0;
12427
12428 for (i = 0, section = section_headers;
12429 i < elf_header.e_shnum;
b34976b6 12430 i++, section++)
047b2264
JJ		 12431 {
12432 switch (section->sh_type)
12433 {
12434 case SHT_GNU_LIBLIST:
4fbb74a6 12435 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 12436 break;
12437
3f5e193b
NC		 12438 elib = (Elf32_External_Lib *)
12439 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 12440 _("liblist section data"));
047b2264
JJ		 12441
12442 if (elib == NULL)
12443 break;
4fbb74a6 12444 string_sec = section_headers + section->sh_link;
047b2264 12445
3f5e193b
NC		 12446 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
12447 string_sec->sh_size,
12448 _("liblist string table"));
047b2264
JJ		 12449 if (strtab == NULL
12450 || section->sh_entsize != sizeof (Elf32_External_Lib))
12451 {
12452 free (elib);
2842702f 12453 free (strtab);
047b2264
JJ		 12454 break;
12455 }
59245841 12456 strtab_size = string_sec->sh_size;
047b2264
JJ		 12457
12458 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12459 SECTION_NAME (section),
0af1713e 12460 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 12461
2b692964 12462 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 12463
12464 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
12465 ++cnt)
12466 {
12467 Elf32_Lib liblist;
91d6fa6a 12468 time_t atime;
047b2264 12469 char timebuf[20];
2cf0635d 12470 struct tm * tmp;
047b2264
JJ		 12471
12472 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 12473 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 12474 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12475 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12476 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12477
91d6fa6a 12478 tmp = gmtime (&atime);
e9e44622
JJ		 12479 snprintf (timebuf, sizeof (timebuf),
12480 "%04u-%02u-%02uT%02u:%02u:%02u",
12481 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12482 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 12483
12484 printf ("%3lu: ", (unsigned long) cnt);
12485 if (do_wide)
c256ffe7 12486 printf ("%-20s", liblist.l_name < strtab_size
2b692964 12487 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 12488 else
c256ffe7 12489 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 12490 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 12491 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
12492 liblist.l_version, liblist.l_flags);
12493 }
12494
12495 free (elib);
2842702f 12496 free (strtab);
047b2264
JJ		 12497 }
12498 }
12499
12500 return 1;
12501}
12502
9437c45b 12503static const char *
d3ba0551 12504get_note_type (unsigned e_type)
779fe533
NC		 12505{
12506 static char buff[64];
103f02d3 12507
1ec5cd37
NC		 12508 if (elf_header.e_type == ET_CORE)
12509 switch (e_type)
12510 {
57346661 12511 case NT_AUXV:
1ec5cd37 12512 return _("NT_AUXV (auxiliary vector)");
57346661 12513 case NT_PRSTATUS:
1ec5cd37 12514 return _("NT_PRSTATUS (prstatus structure)");
57346661 12515 case NT_FPREGSET:
1ec5cd37 12516 return _("NT_FPREGSET (floating point registers)");
57346661 12517 case NT_PRPSINFO:
1ec5cd37 12518 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 12519 case NT_TASKSTRUCT:
1ec5cd37 12520 return _("NT_TASKSTRUCT (task structure)");
57346661 12521 case NT_PRXFPREG:
1ec5cd37 12522 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 12523 case NT_PPC_VMX:
12524 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 12525 case NT_PPC_VSX:
12526 return _("NT_PPC_VSX (ppc VSX registers)");
4339cae0
L		 12527 case NT_X86_XSTATE:
12528 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 12529 case NT_S390_HIGH_GPRS:
12530 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 12531 case NT_S390_TIMER:
12532 return _("NT_S390_TIMER (s390 timer register)");
12533 case NT_S390_TODCMP:
12534 return _("NT_S390_TODCMP (s390 TOD comparator register)");
12535 case NT_S390_TODPREG:
12536 return _("NT_S390_TODPREG (s390 TOD programmable register)");
12537 case NT_S390_CTRS:
12538 return _("NT_S390_CTRS (s390 control registers)");
12539 case NT_S390_PREFIX:
12540 return _("NT_S390_PREFIX (s390 prefix register)");
faa9a424
UW		 12541 case NT_ARM_VFP:
12542 return _("NT_ARM_VFP (arm VFP registers)");
57346661 12543 case NT_PSTATUS:
1ec5cd37 12544 return _("NT_PSTATUS (pstatus structure)");
57346661 12545 case NT_FPREGS:
1ec5cd37 12546 return _("NT_FPREGS (floating point registers)");
57346661 12547 case NT_PSINFO:
1ec5cd37 12548 return _("NT_PSINFO (psinfo structure)");
57346661 12549 case NT_LWPSTATUS:
1ec5cd37 12550 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 12551 case NT_LWPSINFO:
1ec5cd37 12552 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 12553 case NT_WIN32PSTATUS:
1ec5cd37
NC		 12554 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
12555 default:
12556 break;
12557 }
12558 else
12559 switch (e_type)
12560 {
12561 case NT_VERSION:
12562 return _("NT_VERSION (version)");
12563 case NT_ARCH:
12564 return _("NT_ARCH (architecture)");
12565 default:
12566 break;
12567 }
12568
e9e44622 12569 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 12570 return buff;
779fe533
NC		 12571}
12572
1118d252
RM		 12573static const char *
12574get_gnu_elf_note_type (unsigned e_type)
12575{
12576 static char buff[64];
12577
12578 switch (e_type)
12579 {
12580 case NT_GNU_ABI_TAG:
12581 return _("NT_GNU_ABI_TAG (ABI version tag)");
12582 case NT_GNU_HWCAP:
12583 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
12584 case NT_GNU_BUILD_ID:
12585 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 12586 case NT_GNU_GOLD_VERSION:
12587 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 12588 default:
12589 break;
12590 }
12591
12592 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12593 return buff;
12594}
12595
664f90a3
TT		 12596static int
12597print_gnu_note (Elf_Internal_Note *pnote)
12598{
12599 switch (pnote->type)
12600 {
12601 case NT_GNU_BUILD_ID:
12602 {
12603 unsigned long i;
12604
12605 printf (_(" Build ID: "));
12606 for (i = 0; i < pnote->descsz; ++i)
12607 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 12608 printf ("\n");
664f90a3
TT		 12609 }
12610 break;
12611
12612 case NT_GNU_ABI_TAG:
12613 {
12614 unsigned long os, major, minor, subminor;
12615 const char *osname;
12616
12617 os = byte_get ((unsigned char *) pnote->descdata, 4);
12618 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
12619 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
12620 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
12621
12622 switch (os)
12623 {
12624 case GNU_ABI_TAG_LINUX:
12625 osname = "Linux";
12626 break;
12627 case GNU_ABI_TAG_HURD:
12628 osname = "Hurd";
12629 break;
12630 case GNU_ABI_TAG_SOLARIS:
12631 osname = "Solaris";
12632 break;
12633 case GNU_ABI_TAG_FREEBSD:
12634 osname = "FreeBSD";
12635 break;
12636 case GNU_ABI_TAG_NETBSD:
12637 osname = "NetBSD";
12638 break;
12639 default:
12640 osname = "Unknown";
12641 break;
12642 }
12643
12644 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
12645 major, minor, subminor);
12646 }
12647 break;
12648 }
12649
12650 return 1;
12651}
12652
9437c45b 12653static const char *
d3ba0551 12654get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 12655{
12656 static char buff[64];
12657
b4db1224 12658 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 12659 {
12660 /* NetBSD core "procinfo" structure. */
12661 return _("NetBSD procinfo structure");
12662 }
12663
12664 /* As of Jan 2002 there are no other machine-independent notes
12665 defined for NetBSD core files. If the note type is less
12666 than the start of the machine-dependent note types, we don't
12667 understand it. */
12668
b4db1224 12669 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 12670 {
e9e44622 12671 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 12672 return buff;
12673 }
12674
12675 switch (elf_header.e_machine)
12676 {
12677 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
12678 and PT_GETFPREGS == mach+2. */
12679
12680 case EM_OLD_ALPHA:
12681 case EM_ALPHA:
12682 case EM_SPARC:
12683 case EM_SPARC32PLUS:
12684 case EM_SPARCV9:
12685 switch (e_type)
12686 {
2b692964 12687 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 12688 return _("PT_GETREGS (reg structure)");
2b692964 12689 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 12690 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 12691 default:
12692 break;
12693 }
12694 break;
12695
12696 /* On all other arch's, PT_GETREGS == mach+1 and
12697 PT_GETFPREGS == mach+3. */
12698 default:
12699 switch (e_type)
12700 {
2b692964 12701 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 12702 return _("PT_GETREGS (reg structure)");
2b692964 12703 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 12704 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 12705 default:
12706 break;
12707 }
12708 }
12709
9cf03b7e 12710 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 12711 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 12712 return buff;
12713}
12714
70616151
TT		 12715static const char *
12716get_stapsdt_note_type (unsigned e_type)
12717{
12718 static char buff[64];
12719
12720 switch (e_type)
12721 {
12722 case NT_STAPSDT:
12723 return _("NT_STAPSDT (SystemTap probe descriptors)");
12724
12725 default:
12726 break;
12727 }
12728
12729 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12730 return buff;
12731}
12732
c6a9fc58
TT		 12733static int
12734print_stapsdt_note (Elf_Internal_Note *pnote)
12735{
12736 int addr_size = is_32bit_elf ? 4 : 8;
12737 char *data = pnote->descdata;
12738 char *data_end = pnote->descdata + pnote->descsz;
12739 bfd_vma pc, base_addr, semaphore;
12740 char *provider, *probe, *arg_fmt;
12741
12742 pc = byte_get ((unsigned char *) data, addr_size);
12743 data += addr_size;
12744 base_addr = byte_get ((unsigned char *) data, addr_size);
12745 data += addr_size;
12746 semaphore = byte_get ((unsigned char *) data, addr_size);
12747 data += addr_size;
12748
12749 provider = data;
12750 data += strlen (data) + 1;
12751 probe = data;
12752 data += strlen (data) + 1;
12753 arg_fmt = data;
12754 data += strlen (data) + 1;
12755
12756 printf (_(" Provider: %s\n"), provider);
12757 printf (_(" Name: %s\n"), probe);
12758 printf (_(" Location: "));
12759 print_vma (pc, FULL_HEX);
12760 printf (_(", Base: "));
12761 print_vma (base_addr, FULL_HEX);
12762 printf (_(", Semaphore: "));
12763 print_vma (semaphore, FULL_HEX);
9cf03b7e 12764 printf ("\n");
c6a9fc58
TT		 12765 printf (_(" Arguments: %s\n"), arg_fmt);
12766
12767 return data == data_end;
12768}
12769
00e98fc7
TG		 12770static const char *
12771get_ia64_vms_note_type (unsigned e_type)
12772{
12773 static char buff[64];
12774
12775 switch (e_type)
12776 {
12777 case NT_VMS_MHD:
12778 return _("NT_VMS_MHD (module header)");
12779 case NT_VMS_LNM:
12780 return _("NT_VMS_LNM (language name)");
12781 case NT_VMS_SRC:
12782 return _("NT_VMS_SRC (source files)");
12783 case NT_VMS_TITLE:
9cf03b7e 12784 return "NT_VMS_TITLE";
00e98fc7
TG		 12785 case NT_VMS_EIDC:
12786 return _("NT_VMS_EIDC (consistency check)");
12787 case NT_VMS_FPMODE:
12788 return _("NT_VMS_FPMODE (FP mode)");
12789 case NT_VMS_LINKTIME:
9cf03b7e 12790 return "NT_VMS_LINKTIME";
00e98fc7
TG		 12791 case NT_VMS_IMGNAM:
12792 return _("NT_VMS_IMGNAM (image name)");
12793 case NT_VMS_IMGID:
12794 return _("NT_VMS_IMGID (image id)");
12795 case NT_VMS_LINKID:
12796 return _("NT_VMS_LINKID (link id)");
12797 case NT_VMS_IMGBID:
12798 return _("NT_VMS_IMGBID (build id)");
12799 case NT_VMS_GSTNAM:
12800 return _("NT_VMS_GSTNAM (sym table name)");
12801 case NT_VMS_ORIG_DYN:
9cf03b7e 12802 return "NT_VMS_ORIG_DYN";
00e98fc7 12803 case NT_VMS_PATCHTIME:
9cf03b7e 12804 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 12805 default:
12806 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12807 return buff;
12808 }
12809}
12810
12811static int
12812print_ia64_vms_note (Elf_Internal_Note * pnote)
12813{
12814 switch (pnote->type)
12815 {
12816 case NT_VMS_MHD:
12817 if (pnote->descsz > 36)
12818 {
12819 size_t l = strlen (pnote->descdata + 34);
12820 printf (_(" Creation date : %.17s\n"), pnote->descdata);
12821 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
12822 printf (_(" Module name : %s\n"), pnote->descdata + 34);
12823 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
12824 }
12825 else
12826 printf (_(" Invalid size\n"));
12827 break;
12828 case NT_VMS_LNM:
12829 printf (_(" Language: %s\n"), pnote->descdata);
12830 break;
12831#ifdef BFD64
12832 case NT_VMS_FPMODE:
9cf03b7e 12833 printf (_(" Floating Point mode: "));
4a5cb34f 12834 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 12835 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
12836 break;
12837 case NT_VMS_LINKTIME:
12838 printf (_(" Link time: "));
12839 print_vms_time
12840 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
12841 printf ("\n");
12842 break;
12843 case NT_VMS_PATCHTIME:
12844 printf (_(" Patch time: "));
12845 print_vms_time
12846 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
12847 printf ("\n");
12848 break;
12849 case NT_VMS_ORIG_DYN:
12850 printf (_(" Major id: %u, minor id: %u\n"),
12851 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
12852 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 12853 printf (_(" Last modified : "));
00e98fc7
TG		 12854 print_vms_time
12855 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 12856 printf (_("\n Link flags : "));
4a5cb34f 12857 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 12858 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
12859 printf (_(" Header flags: 0x%08x\n"),
12860 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
12861 printf (_(" Image id : %s\n"), pnote->descdata + 32);
12862 break;
12863#endif
12864 case NT_VMS_IMGNAM:
12865 printf (_(" Image name: %s\n"), pnote->descdata);
12866 break;
12867 case NT_VMS_GSTNAM:
12868 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
12869 break;
12870 case NT_VMS_IMGID:
12871 printf (_(" Image id: %s\n"), pnote->descdata);
12872 break;
12873 case NT_VMS_LINKID:
12874 printf (_(" Linker id: %s\n"), pnote->descdata);
12875 break;
12876 default:
12877 break;
12878 }
12879 return 1;
12880}
12881
6d118b09
NC		 12882/* Note that by the ELF standard, the name field is already null byte
12883 terminated, and namesz includes the terminating null byte.
12884 I.E. the value of namesz for the name "FSF" is 4.
12885
e3c8793a 12886 If the value of namesz is zero, there is no name present. */
779fe533 12887static int
2cf0635d 12888process_note (Elf_Internal_Note * pnote)
779fe533 12889{
2cf0635d
NC		 12890 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
12891 const char * nt;
9437c45b
JT		 12892
12893 if (pnote->namesz == 0)
1ec5cd37
NC		 12894 /* If there is no note name, then use the default set of
12895 note type strings. */
12896 nt = get_note_type (pnote->type);
12897
1118d252
RM		 12898 else if (const_strneq (pnote->namedata, "GNU"))
12899 /* GNU-specific object file notes. */
12900 nt = get_gnu_elf_note_type (pnote->type);
12901
0112cd26 12902 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 12903 /* NetBSD-specific core file notes. */
12904 nt = get_netbsd_elfcore_note_type (pnote->type);
12905
b15fa79e
AM		 12906 else if (strneq (pnote->namedata, "SPU/", 4))
12907 {
12908 /* SPU-specific core file notes. */
12909 nt = pnote->namedata + 4;
12910 name = "SPU";
12911 }
12912
00e98fc7
TG		 12913 else if (const_strneq (pnote->namedata, "IPF/VMS"))
12914 /* VMS/ia64-specific file notes. */
12915 nt = get_ia64_vms_note_type (pnote->type);
12916
70616151
TT		 12917 else if (const_strneq (pnote->namedata, "stapsdt"))
12918 nt = get_stapsdt_note_type (pnote->type);
12919
9437c45b 12920 else
1ec5cd37
NC		 12921 /* Don't recognize this note name; just use the default set of
12922 note type strings. */
00e98fc7 12923 nt = get_note_type (pnote->type);
9437c45b 12924
2aee03ae 12925 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 12926
12927 if (const_strneq (pnote->namedata, "IPF/VMS"))
12928 return print_ia64_vms_note (pnote);
664f90a3
TT		 12929 else if (const_strneq (pnote->namedata, "GNU"))
12930 return print_gnu_note (pnote);
c6a9fc58
TT		 12931 else if (const_strneq (pnote->namedata, "stapsdt"))
12932 return print_stapsdt_note (pnote);
00e98fc7
TG		 12933 else
12934 return 1;
779fe533
NC		 12935}
12936
6d118b09 12937
779fe533 12938static int
2cf0635d 12939process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 12940{
2cf0635d
NC		 12941 Elf_External_Note * pnotes;
12942 Elf_External_Note * external;
b34976b6 12943 int res = 1;
103f02d3 12944
779fe533
NC		 12945 if (length <= 0)
12946 return 0;
103f02d3 12947
3f5e193b
NC		 12948 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
12949 _("notes"));
dd24e3da 12950 if (pnotes == NULL)
a6e9f9df 12951 return 0;
779fe533 12952
103f02d3 12953 external = pnotes;
103f02d3 12954
305c7206 12955 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 12956 (unsigned long) offset, (unsigned long) length);
2aee03ae 12957 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 12958
2cf0635d 12959 while (external < (Elf_External_Note *) ((char *) pnotes + length))
779fe533 12960 {
2cf0635d 12961 Elf_External_Note * next;
b34976b6 12962 Elf_Internal_Note inote;
2cf0635d 12963 char * temp = NULL;
6d118b09 12964
00e98fc7
TG		 12965 if (!is_ia64_vms ())
12966 {
12967 inote.type = BYTE_GET (external->type);
12968 inote.namesz = BYTE_GET (external->namesz);
12969 inote.namedata = external->name;
12970 inote.descsz = BYTE_GET (external->descsz);
12971 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
12972 inote.descpos = offset + (inote.descdata - (char *) pnotes);
12973
12974 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
12975 }
12976 else
12977 {
12978 Elf64_External_VMS_Note *vms_external;
12979
12980 vms_external = (Elf64_External_VMS_Note *)external;
12981 inote.type = BYTE_GET (vms_external->type);
12982 inote.namesz = BYTE_GET (vms_external->namesz);
12983 inote.namedata = vms_external->name;
12984 inote.descsz = BYTE_GET (vms_external->descsz);
12985 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
12986 inote.descpos = offset + (inote.descdata - (char *) pnotes);
12987
12988 next = (Elf_External_Note *)
12989 (inote.descdata + align_power (inote.descsz, 3));
12990 }
3e55a963 12991
dd24e3da
NC		 12992 if ( ((char *) next > ((char *) pnotes) + length)
12993 || ((char *) next < (char *) pnotes))
3e55a963 12994 {
0fd3a477 12995 warn (_("corrupt note found at offset %lx into core notes\n"),
0af1713e 12996 (unsigned long) ((char *) external - (char *) pnotes));
0fd3a477 12997 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
3e55a963
NC		 12998 inote.type, inote.namesz, inote.descsz);
12999 break;
13000 }
13001
13002 external = next;
6d118b09 13003
dd24e3da 13004 /* Prevent out-of-bounds indexing. */
8b971f9f 13005 if (inote.namedata + inote.namesz > (char *) pnotes + length
dd24e3da
NC		 13006 || inote.namedata + inote.namesz < inote.namedata)
13007 {
13008 warn (_("corrupt note found at offset %lx into core notes\n"),
13009 (unsigned long) ((char *) external - (char *) pnotes));
13010 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
13011 inote.type, inote.namesz, inote.descsz);
13012 break;
13013 }
13014
6d118b09
NC		 13015 /* Verify that name is null terminated. It appears that at least
13016 one version of Linux (RedHat 6.0) generates corefiles that don't
13017 comply with the ELF spec by failing to include the null byte in
13018 namesz. */
8b971f9f 13019 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 13020 {
3f5e193b 13021 temp = (char *) malloc (inote.namesz + 1);
76da6bbe 13022
6d118b09
NC		 13023 if (temp == NULL)
13024 {
13025 error (_("Out of memory\n"));
13026 res = 0;
13027 break;
13028 }
76da6bbe 13029
6d118b09
NC		 13030 strncpy (temp, inote.namedata, inote.namesz);
13031 temp[inote.namesz] = 0;
76da6bbe 13032
6d118b09
NC		 13033 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
13034 inote.namedata = temp;
13035 }
13036
13037 res &= process_note (& inote);
103f02d3 13038
6d118b09
NC		 13039 if (temp != NULL)
13040 {
13041 free (temp);
13042 temp = NULL;
13043 }
779fe533
NC		 13044 }
13045
13046 free (pnotes);
103f02d3 13047
779fe533
NC		 13048 return res;
13049}
13050
13051static int
2cf0635d 13052process_corefile_note_segments (FILE * file)
779fe533 13053{
2cf0635d 13054 Elf_Internal_Phdr * segment;
b34976b6
AM		 13055 unsigned int i;
13056 int res = 1;
103f02d3 13057
d93f0186 13058 if (! get_program_headers (file))
779fe533 13059 return 0;
103f02d3 13060
779fe533
NC		 13061 for (i = 0, segment = program_headers;
13062 i < elf_header.e_phnum;
b34976b6 13063 i++, segment++)
779fe533
NC		 13064 {
13065 if (segment->p_type == PT_NOTE)
103f02d3 13066 res &= process_corefile_note_segment (file,
30800947
NC		 13067 (bfd_vma) segment->p_offset,
13068 (bfd_vma) segment->p_filesz);
779fe533 13069 }
103f02d3 13070
779fe533
NC		 13071 return res;
13072}
13073
13074static int
2cf0635d 13075process_note_sections (FILE * file)
1ec5cd37 13076{
2cf0635d 13077 Elf_Internal_Shdr * section;
1ec5cd37
NC		 13078 unsigned long i;
13079 int res = 1;
13080
13081 for (i = 0, section = section_headers;
fa1908fd 13082 i < elf_header.e_shnum && section != NULL;
1ec5cd37
NC		 13083 i++, section++)
13084 if (section->sh_type == SHT_NOTE)
13085 res &= process_corefile_note_segment (file,
13086 (bfd_vma) section->sh_offset,
13087 (bfd_vma) section->sh_size);
13088
13089 return res;
13090}
13091
13092static int
2cf0635d 13093process_notes (FILE * file)
779fe533
NC		 13094{
13095 /* If we have not been asked to display the notes then do nothing. */
13096 if (! do_notes)
13097 return 1;
103f02d3 13098
779fe533 13099 if (elf_header.e_type != ET_CORE)
1ec5cd37 13100 return process_note_sections (file);
103f02d3 13101
779fe533 13102 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 13103 if (elf_header.e_phnum > 0)
13104 return process_corefile_note_segments (file);
779fe533 13105
1ec5cd37
NC		 13106 printf (_("No note segments present in the core file.\n"));
13107 return 1;
779fe533
NC		 13108}
13109
252b5132 13110static int
2cf0635d 13111process_arch_specific (FILE * file)
252b5132 13112{
a952a375
NC		 13113 if (! do_arch)
13114 return 1;
13115
252b5132
RH		 13116 switch (elf_header.e_machine)
13117 {
11c1ff18
PB		 13118 case EM_ARM:
13119 return process_arm_specific (file);
252b5132 13120 case EM_MIPS:
4fe85591 13121 case EM_MIPS_RS3_LE:
252b5132
RH		 13122 return process_mips_specific (file);
13123 break;
34c8bcba
JM		 13124 case EM_PPC:
13125 return process_power_specific (file);
13126 break;
9e8c70f9
DM		 13127 case EM_SPARC:
13128 case EM_SPARC32PLUS:
13129 case EM_SPARCV9:
13130 return process_sparc_specific (file);
13131 break;
59e6276b
JM		 13132 case EM_TI_C6000:
13133 return process_tic6x_specific (file);
13134 break;
252b5132
RH		 13135 default:
13136 break;
13137 }
13138 return 1;
13139}
13140
13141static int
2cf0635d 13142get_file_header (FILE * file)
252b5132 13143{
9ea033b2
NC		 13144 /* Read in the identity array. */
13145 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 13146 return 0;
13147
9ea033b2 13148 /* Determine how to read the rest of the header. */
b34976b6 13149 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 13150 {
13151 default: /* fall through */
13152 case ELFDATANONE: /* fall through */
adab8cdc
AO		 13153 case ELFDATA2LSB:
13154 byte_get = byte_get_little_endian;
13155 byte_put = byte_put_little_endian;
13156 break;
13157 case ELFDATA2MSB:
13158 byte_get = byte_get_big_endian;
13159 byte_put = byte_put_big_endian;
13160 break;
9ea033b2
NC		 13161 }
13162
13163 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 13164 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 13165
13166 /* Read in the rest of the header. */
13167 if (is_32bit_elf)
13168 {
13169 Elf32_External_Ehdr ehdr32;
252b5132 13170
9ea033b2
NC		 13171 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
13172 return 0;
103f02d3 13173
9ea033b2
NC		 13174 elf_header.e_type = BYTE_GET (ehdr32.e_type);
13175 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
13176 elf_header.e_version = BYTE_GET (ehdr32.e_version);
13177 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
13178 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
13179 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
13180 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
13181 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
13182 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
13183 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
13184 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
13185 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
13186 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
13187 }
252b5132 13188 else
9ea033b2
NC		 13189 {
13190 Elf64_External_Ehdr ehdr64;
a952a375
NC		 13191
13192 /* If we have been compiled with sizeof (bfd_vma) == 4, then
13193 we will not be able to cope with the 64bit data found in
13194 64 ELF files. Detect this now and abort before we start
50c2245b 13195 overwriting things. */
a952a375
NC		 13196 if (sizeof (bfd_vma) < 8)
13197 {
e3c8793a
NC		 13198 error (_("This instance of readelf has been built without support for a\n\
1319964 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 13200 return 0;
13201 }
103f02d3 13202
9ea033b2
NC		 13203 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
13204 return 0;
103f02d3 13205
9ea033b2
NC		 13206 elf_header.e_type = BYTE_GET (ehdr64.e_type);
13207 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
13208 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 13209 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
13210 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
13211 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 13212 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
13213 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
13214 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
13215 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
13216 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
13217 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
13218 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
13219 }
252b5132 13220
7ece0d85
JJ		 13221 if (elf_header.e_shoff)
13222 {
13223 /* There may be some extensions in the first section header. Don't
13224 bomb if we can't read it. */
13225 if (is_32bit_elf)
13226 get_32bit_section_headers (file, 1);
13227 else
13228 get_64bit_section_headers (file, 1);
13229 }
560f3c1c 13230
252b5132
RH		 13231 return 1;
13232}
13233
fb52b2f4
NC		 13234/* Process one ELF object file according to the command line options.
13235 This file may actually be stored in an archive. The file is
13236 positioned at the start of the ELF object. */
13237
ff78d6d6 13238static int
2cf0635d 13239process_object (char * file_name, FILE * file)
252b5132 13240{
252b5132
RH		 13241 unsigned int i;
13242
252b5132
RH		 13243 if (! get_file_header (file))
13244 {
13245 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 13246 return 1;
252b5132
RH		 13247 }
13248
13249 /* Initialise per file variables. */
60bca95a 13250 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 13251 version_info[i] = 0;
13252
60bca95a 13253 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 13254 dynamic_info[i] = 0;
5115b233 13255 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 13256
13257 /* Process the file. */
13258 if (show_name)
13259 printf (_("\nFile: %s\n"), file_name);
13260
18bd398b
NC		 13261 /* Initialise the dump_sects array from the cmdline_dump_sects array.
13262 Note we do this even if cmdline_dump_sects is empty because we
13263 must make sure that the dump_sets array is zeroed out before each
13264 object file is processed. */
13265 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 13266 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 13267
13268 if (num_cmdline_dump_sects > 0)
13269 {
13270 if (num_dump_sects == 0)
13271 /* A sneaky way of allocating the dump_sects array. */
09c11c86 13272 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 13273
13274 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 13275 memcpy (dump_sects, cmdline_dump_sects,
13276 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 13277 }
d70c5fc7 13278
252b5132 13279 if (! process_file_header ())
fb52b2f4 13280 return 1;
252b5132 13281
d1f5c6e3 13282 if (! process_section_headers (file))
2f62977e 13283 {
d1f5c6e3
L		 13284 /* Without loaded section headers we cannot process lots of
13285 things. */
2f62977e 13286 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 13287
2f62977e 13288 if (! do_using_dynamic)
2c610e4b 13289 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 13290 }
252b5132 13291
d1f5c6e3
L		 13292 if (! process_section_groups (file))
13293 {
13294 /* Without loaded section groups we cannot process unwind. */
13295 do_unwind = 0;
13296 }
13297
2f62977e 13298 if (process_program_headers (file))
b2d38a17 13299 process_dynamic_section (file);
252b5132
RH		 13300
13301 process_relocs (file);
13302
4d6ed7c8
NC		 13303 process_unwind (file);
13304
252b5132
RH		 13305 process_symbol_table (file);
13306
13307 process_syminfo (file);
13308
13309 process_version_sections (file);
13310
13311 process_section_contents (file);
f5842774 13312
1ec5cd37 13313 process_notes (file);
103f02d3 13314
047b2264
JJ		 13315 process_gnu_liblist (file);
13316
252b5132
RH		 13317 process_arch_specific (file);
13318
d93f0186
NC		 13319 if (program_headers)
13320 {
13321 free (program_headers);
13322 program_headers = NULL;
13323 }
13324
252b5132
RH		 13325 if (section_headers)
13326 {
13327 free (section_headers);
13328 section_headers = NULL;
13329 }
13330
13331 if (string_table)
13332 {
13333 free (string_table);
13334 string_table = NULL;
d40ac9bd 13335 string_table_length = 0;
252b5132
RH		 13336 }
13337
13338 if (dynamic_strings)
13339 {
13340 free (dynamic_strings);
13341 dynamic_strings = NULL;
d79b3d50 13342 dynamic_strings_length = 0;
252b5132
RH		 13343 }
13344
13345 if (dynamic_symbols)
13346 {
13347 free (dynamic_symbols);
13348 dynamic_symbols = NULL;
19936277 13349 num_dynamic_syms = 0;
252b5132
RH		 13350 }
13351
13352 if (dynamic_syminfo)
13353 {
13354 free (dynamic_syminfo);
13355 dynamic_syminfo = NULL;
13356 }
ff78d6d6 13357
293c573e
MR		 13358 if (dynamic_section)
13359 {
13360 free (dynamic_section);
13361 dynamic_section = NULL;
13362 }
13363
e4b17d5c
L		 13364 if (section_headers_groups)
13365 {
13366 free (section_headers_groups);
13367 section_headers_groups = NULL;
13368 }
13369
13370 if (section_groups)
13371 {
2cf0635d
NC		 13372 struct group_list * g;
13373 struct group_list * next;
e4b17d5c
L		 13374
13375 for (i = 0; i < group_count; i++)
13376 {
13377 for (g = section_groups [i].root; g != NULL; g = next)
13378 {
13379 next = g->next;
13380 free (g);
13381 }
13382 }
13383
13384 free (section_groups);
13385 section_groups = NULL;
13386 }
13387
19e6b90e 13388 free_debug_memory ();
18bd398b 13389
ff78d6d6 13390 return 0;
252b5132
RH		 13391}
13392
2cf0635d
NC		 13393/* Process an ELF archive.
13394 On entry the file is positioned just after the ARMAG string. */
13395
13396static int
13397process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
13398{
13399 struct archive_info arch;
13400 struct archive_info nested_arch;
13401 size_t got;
2cf0635d
NC		 13402 int ret;
13403
13404 show_name = 1;
13405
13406 /* The ARCH structure is used to hold information about this archive. */
13407 arch.file_name = NULL;
13408 arch.file = NULL;
13409 arch.index_array = NULL;
13410 arch.sym_table = NULL;
13411 arch.longnames = NULL;
13412
13413 /* The NESTED_ARCH structure is used as a single-item cache of information
13414 about a nested archive (when members of a thin archive reside within
13415 another regular archive file). */
13416 nested_arch.file_name = NULL;
13417 nested_arch.file = NULL;
13418 nested_arch.index_array = NULL;
13419 nested_arch.sym_table = NULL;
13420 nested_arch.longnames = NULL;
13421
13422 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
13423 {
13424 ret = 1;
13425 goto out;
4145f1d5 13426 }
fb52b2f4 13427
4145f1d5
NC		 13428 if (do_archive_index)
13429 {
2cf0635d 13430 if (arch.sym_table == NULL)
4145f1d5
NC		 13431 error (_("%s: unable to dump the index as none was found\n"), file_name);
13432 else
13433 {
2cf0635d 13434 unsigned int i, l;
4145f1d5
NC		 13435 unsigned long current_pos;
13436
13437 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
2cf0635d 13438 file_name, arch.index_num, arch.sym_size);
4145f1d5
NC		 13439 current_pos = ftell (file);
13440
2cf0635d 13441 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 13442 {
2cf0635d
NC		 13443 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
13444 {
13445 char * member_name;
4145f1d5 13446
2cf0635d
NC		 13447 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
13448
13449 if (member_name != NULL)
13450 {
13451 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
13452
13453 if (qualified_name != NULL)
13454 {
13455 printf (_("Binary %s contains:\n"), qualified_name);
13456 free (qualified_name);
13457 }
4145f1d5
NC		 13458 }
13459 }
2cf0635d
NC		 13460
13461 if (l >= arch.sym_size)
4145f1d5
NC		 13462 {
13463 error (_("%s: end of the symbol table reached before the end of the index\n"),
13464 file_name);
cb8f3167 13465 break;
4145f1d5 13466 }
2cf0635d
NC		 13467 printf ("\t%s\n", arch.sym_table + l);
13468 l += strlen (arch.sym_table + l) + 1;
4145f1d5
NC		 13469 }
13470
2cf0635d
NC		 13471 if (l & 01)
13472 ++l;
13473 if (l < arch.sym_size)
4145f1d5
NC		 13474 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
13475 file_name);
13476
4145f1d5
NC		 13477 if (fseek (file, current_pos, SEEK_SET) != 0)
13478 {
13479 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 13480 ret = 1;
13481 goto out;
4145f1d5 13482 }
fb52b2f4 13483 }
4145f1d5
NC		 13484
13485 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
13486 && !do_segments && !do_header && !do_dump && !do_version
13487 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 13488 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 13489 {
13490 ret = 0; /* Archive index only. */
13491 goto out;
13492 }
fb52b2f4
NC		 13493 }
13494
d989285c 13495 ret = 0;
fb52b2f4
NC		 13496
13497 while (1)
13498 {
2cf0635d
NC		 13499 char * name;
13500 size_t namelen;
13501 char * qualified_name;
13502
13503 /* Read the next archive header. */
13504 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
13505 {
13506 error (_("%s: failed to seek to next archive header\n"), file_name);
13507 return 1;
13508 }
13509 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
13510 if (got != sizeof arch.arhdr)
13511 {
13512 if (got == 0)
13513 break;
13514 error (_("%s: failed to read archive header\n"), file_name);
13515 ret = 1;
13516 break;
13517 }
13518 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
13519 {
13520 error (_("%s: did not find a valid archive header\n"), arch.file_name);
13521 ret = 1;
13522 break;
13523 }
13524
13525 arch.next_arhdr_offset += sizeof arch.arhdr;
13526
13527 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
13528 if (archive_file_size & 01)
13529 ++archive_file_size;
13530
13531 name = get_archive_member_name (&arch, &nested_arch);
13532 if (name == NULL)
fb52b2f4 13533 {
0fd3a477 13534 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 13535 ret = 1;
13536 break;
fb52b2f4 13537 }
2cf0635d 13538 namelen = strlen (name);
fb52b2f4 13539
2cf0635d
NC		 13540 qualified_name = make_qualified_name (&arch, &nested_arch, name);
13541 if (qualified_name == NULL)
fb52b2f4 13542 {
2cf0635d 13543 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 13544 ret = 1;
13545 break;
fb52b2f4
NC		 13546 }
13547
2cf0635d
NC		 13548 if (is_thin_archive && arch.nested_member_origin == 0)
13549 {
13550 /* This is a proxy for an external member of a thin archive. */
13551 FILE * member_file;
13552 char * member_file_name = adjust_relative_path (file_name, name, namelen);
13553 if (member_file_name == NULL)
13554 {
13555 ret = 1;
13556 break;
13557 }
13558
13559 member_file = fopen (member_file_name, "rb");
13560 if (member_file == NULL)
13561 {
13562 error (_("Input file '%s' is not readable.\n"), member_file_name);
13563 free (member_file_name);
13564 ret = 1;
13565 break;
13566 }
13567
13568 archive_file_offset = arch.nested_member_origin;
13569
13570 ret |= process_object (qualified_name, member_file);
13571
13572 fclose (member_file);
13573 free (member_file_name);
13574 }
13575 else if (is_thin_archive)
13576 {
13577 /* This is a proxy for a member of a nested archive. */
13578 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
13579
13580 /* The nested archive file will have been opened and setup by
13581 get_archive_member_name. */
13582 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
13583 {
13584 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
13585 ret = 1;
13586 break;
13587 }
13588
13589 ret |= process_object (qualified_name, nested_arch.file);
13590 }
13591 else
13592 {
13593 archive_file_offset = arch.next_arhdr_offset;
13594 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 13595
2cf0635d
NC		 13596 ret |= process_object (qualified_name, file);
13597 }
fb52b2f4 13598
2b52916e
L		 13599 if (dump_sects != NULL)
13600 {
13601 free (dump_sects);
13602 dump_sects = NULL;
13603 num_dump_sects = 0;
13604 }
13605
2cf0635d 13606 free (qualified_name);
fb52b2f4
NC		 13607 }
13608
4145f1d5 13609 out:
2cf0635d
NC		 13610 if (nested_arch.file != NULL)
13611 fclose (nested_arch.file);
13612 release_archive (&nested_arch);
13613 release_archive (&arch);
fb52b2f4 13614
d989285c 13615 return ret;
fb52b2f4
NC		 13616}
13617
13618static int
2cf0635d 13619process_file (char * file_name)
fb52b2f4 13620{
2cf0635d 13621 FILE * file;
fb52b2f4
NC		 13622 struct stat statbuf;
13623 char armag[SARMAG];
13624 int ret;
13625
13626 if (stat (file_name, &statbuf) < 0)
13627 {
f24ddbdd
NC		 13628 if (errno == ENOENT)
13629 error (_("'%s': No such file\n"), file_name);
13630 else
13631 error (_("Could not locate '%s'. System error message: %s\n"),
13632 file_name, strerror (errno));
13633 return 1;
13634 }
13635
13636 if (! S_ISREG (statbuf.st_mode))
13637 {
13638 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 13639 return 1;
13640 }
13641
13642 file = fopen (file_name, "rb");
13643 if (file == NULL)
13644 {
f24ddbdd 13645 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 13646 return 1;
13647 }
13648
13649 if (fread (armag, SARMAG, 1, file) != 1)
13650 {
4145f1d5 13651 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 13652 fclose (file);
13653 return 1;
13654 }
13655
13656 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 13657 ret = process_archive (file_name, file, FALSE);
13658 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
13659 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 13660 else
13661 {
4145f1d5
NC		 13662 if (do_archive_index)
13663 error (_("File %s is not an archive so its index cannot be displayed.\n"),
13664 file_name);
13665
fb52b2f4
NC		 13666 rewind (file);
13667 archive_file_size = archive_file_offset = 0;
13668 ret = process_object (file_name, file);
13669 }
13670
13671 fclose (file);
13672
13673 return ret;
13674}
13675
252b5132
RH		 13676#ifdef SUPPORT_DISASSEMBLY
13677/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 13678 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 13679 symbols. */
252b5132
RH		 13680
13681void
2cf0635d 13682print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 13683{
13684 fprintf (outfile,"0x%8.8x", addr);
13685}
13686
e3c8793a 13687/* Needed by the i386 disassembler. */
252b5132
RH		 13688void
13689db_task_printsym (unsigned int addr)
13690{
13691 print_address (addr, stderr);
13692}
13693#endif
13694
13695int
2cf0635d 13696main (int argc, char ** argv)
252b5132 13697{
ff78d6d6
L		 13698 int err;
13699
252b5132
RH		 13700#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
13701 setlocale (LC_MESSAGES, "");
3882b010
L		 13702#endif
13703#if defined (HAVE_SETLOCALE)
13704 setlocale (LC_CTYPE, "");
252b5132
RH		 13705#endif
13706 bindtextdomain (PACKAGE, LOCALEDIR);
13707 textdomain (PACKAGE);
13708
869b9d07
MM		 13709 expandargv (&argc, &argv);
13710
252b5132
RH		 13711 parse_args (argc, argv);
13712
18bd398b 13713 if (num_dump_sects > 0)
59f14fc0 13714 {
18bd398b 13715 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 13716 cmdline_dump_sects = (dump_type *)
13717 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 13718 if (cmdline_dump_sects == NULL)
591a748a 13719 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 13720 else
13721 {
09c11c86
NC		 13722 memcpy (cmdline_dump_sects, dump_sects,
13723 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 13724 num_cmdline_dump_sects = num_dump_sects;
13725 }
13726 }
13727
18bd398b
NC		 13728 if (optind < (argc - 1))
13729 show_name = 1;
13730
ff78d6d6 13731 err = 0;
252b5132 13732 while (optind < argc)
18bd398b 13733 err |= process_file (argv[optind++]);
252b5132
RH		 13734
13735 if (dump_sects != NULL)
13736 free (dump_sects);
59f14fc0
AS		 13737 if (cmdline_dump_sects != NULL)
13738 free (cmdline_dump_sects);
252b5132 13739
ff78d6d6 13740 return err;
252b5132 13741}
A mirror of the official binutils-gdb repository