]> 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
* po/eo.po: New Esperanto translation.
[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,
7a88bc9c 3 2008, 2009, 2010, 2011
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
1b315056 45#include "config.h"
3db64b00 46#include "sysdep.h"
252b5132
RH		 47#include <assert.h>
48#include <sys/stat.h>
252b5132 49#include <time.h>
1b315056
CS		 50#ifdef HAVE_ZLIB_H
51#include <zlib.h>
52#endif
252b5132 53
a952a375 54#if __GNUC__ >= 2
19936277 55/* Define BFD64 here, even if our default architecture is 32 bit ELF
a952a375 56 as this will allow us to read in and parse 64bit and 32bit ELF files.
b34976b6 57 Only do this if we believe that the compiler can support a 64 bit
a952a375 58 data type. For now we only rely on GCC being able to do this. */
19936277 59#define BFD64
a952a375
NC		 60#endif
61
3db64b00
AM		 62#include "bfd.h"
63#include "bucomm.h"
3284fe0c 64#include "elfcomm.h"
19e6b90e 65#include "dwarf.h"
252b5132
RH		 66
67#include "elf/common.h"
68#include "elf/external.h"
69#include "elf/internal.h"
252b5132 70
4b78141a
NC		 71
72/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
73 we can obtain the H8 reloc numbers. We need these for the
74 get_reloc_size() function. We include h8.h again after defining
75 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
76
77#include "elf/h8.h"
78#undef _ELF_H8_H
79
80/* Undo the effects of #including reloc-macros.h. */
81
82#undef START_RELOC_NUMBERS
83#undef RELOC_NUMBER
84#undef FAKE_RELOC
85#undef EMPTY_RELOC
86#undef END_RELOC_NUMBERS
87#undef _RELOC_MACROS_H
88
252b5132
RH		 89/* The following headers use the elf/reloc-macros.h file to
90 automatically generate relocation recognition functions
91 such as elf_mips_reloc_type() */
92
93#define RELOC_MACROS_GEN_FUNC
94
252b5132 95#include "elf/alpha.h"
3b16e843 96#include "elf/arc.h"
252b5132 97#include "elf/arm.h"
3b16e843 98#include "elf/avr.h"
1d65ded4 99#include "elf/bfin.h"
60bca95a 100#include "elf/cr16.h"
3b16e843 101#include "elf/cris.h"
1c0d3aa6 102#include "elf/crx.h"
252b5132
RH		 103#include "elf/d10v.h"
104#include "elf/d30v.h"
d172d4ba 105#include "elf/dlx.h"
252b5132 106#include "elf/fr30.h"
5c70f934 107#include "elf/frv.h"
3b16e843
NC		 108#include "elf/h8.h"
109#include "elf/hppa.h"
110#include "elf/i386.h"
35b1837e 111#include "elf/i370.h"
3b16e843
NC		 112#include "elf/i860.h"
113#include "elf/i960.h"
114#include "elf/ia64.h"
1e4cf259 115#include "elf/ip2k.h"
84e94c90 116#include "elf/lm32.h"
1c0d3aa6 117#include "elf/iq2000.h"
49f58d10 118#include "elf/m32c.h"
3b16e843
NC		 119#include "elf/m32r.h"
120#include "elf/m68k.h"
75751cd9 121#include "elf/m68hc11.h"
252b5132 122#include "elf/mcore.h"
15ab5209 123#include "elf/mep.h"
7ba29e2a 124#include "elf/microblaze.h"
3b16e843 125#include "elf/mips.h"
3c3bdf30 126#include "elf/mmix.h"
3b16e843
NC		 127#include "elf/mn10200.h"
128#include "elf/mn10300.h"
5506d11a 129#include "elf/moxie.h"
4970f871 130#include "elf/mt.h"
2469cfa2 131#include "elf/msp430.h"
3b16e843 132#include "elf/or32.h"
7d466069 133#include "elf/pj.h"
3b16e843 134#include "elf/ppc.h"
c833c019 135#include "elf/ppc64.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"
3b16e843 143#include "elf/v850.h"
179d3252 144#include "elf/vax.h"
3b16e843 145#include "elf/x86-64.h"
c29aca4a 146#include "elf/xc16x.h"
93fbbb04 147#include "elf/xstormy16.h"
88da6820 148#include "elf/xtensa.h"
252b5132 149
252b5132 150#include "getopt.h"
566b0d53 151#include "libiberty.h"
09c11c86 152#include "safe-ctype.h"
2cf0635d 153#include "filenames.h"
252b5132 154
2cf0635d 155char * program_name = "readelf";
85b1c36d
BE		 156static long archive_file_offset;
157static unsigned long archive_file_size;
158static unsigned long dynamic_addr;
159static bfd_size_type dynamic_size;
160static unsigned int dynamic_nent;
2cf0635d 161static char * dynamic_strings;
85b1c36d 162static unsigned long dynamic_strings_length;
2cf0635d 163static char * string_table;
85b1c36d
BE		 164static unsigned long string_table_length;
165static unsigned long num_dynamic_syms;
2cf0635d
NC		 166static Elf_Internal_Sym * dynamic_symbols;
167static Elf_Internal_Syminfo * dynamic_syminfo;
85b1c36d
BE		 168static unsigned long dynamic_syminfo_offset;
169static unsigned int dynamic_syminfo_nent;
f8eae8b2 170static char program_interpreter[PATH_MAX];
bb8a0291 171static bfd_vma dynamic_info[DT_ENCODING];
fdc90cb4 172static bfd_vma dynamic_info_DT_GNU_HASH;
85b1c36d
BE		 173static bfd_vma version_info[16];
174static Elf_Internal_Ehdr elf_header;
2cf0635d
NC		 175static Elf_Internal_Shdr * section_headers;
176static Elf_Internal_Phdr * program_headers;
177static Elf_Internal_Dyn * dynamic_section;
178static Elf_Internal_Shdr * symtab_shndx_hdr;
85b1c36d
BE		 179static int show_name;
180static int do_dynamic;
181static int do_syms;
2c610e4b 182static int do_dyn_syms;
85b1c36d
BE		 183static int do_reloc;
184static int do_sections;
185static int do_section_groups;
5477e8a0 186static int do_section_details;
85b1c36d
BE		 187static int do_segments;
188static int do_unwind;
189static int do_using_dynamic;
190static int do_header;
191static int do_dump;
192static int do_version;
85b1c36d
BE		 193static int do_histogram;
194static int do_debugging;
85b1c36d
BE		 195static int do_arch;
196static int do_notes;
4145f1d5 197static int do_archive_index;
85b1c36d 198static int is_32bit_elf;
252b5132 199
e4b17d5c
L		 200struct group_list
201{
2cf0635d 202 struct group_list * next;
e4b17d5c
L		 203 unsigned int section_index;
204};
205
206struct group
207{
2cf0635d 208 struct group_list * root;
e4b17d5c
L		 209 unsigned int group_index;
210};
211
85b1c36d 212static size_t group_count;
2cf0635d
NC		 213static struct group * section_groups;
214static struct group ** section_headers_groups;
e4b17d5c 215
09c11c86
NC		 216
217/* Flag bits indicating particular types of dump. */
218#define HEX_DUMP (1 << 0) /* The -x command line switch. */
219#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
220#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
221#define STRING_DUMP (1 << 3) /* The -p command line switch. */
cf13d699 222#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
09c11c86
NC		 223
224typedef unsigned char dump_type;
225
226/* A linked list of the section names for which dumps were requested. */
aef1f6d0
DJ		 227struct dump_list_entry
228{
2cf0635d 229 char * name;
09c11c86 230 dump_type type;
2cf0635d 231 struct dump_list_entry * next;
aef1f6d0 232};
2cf0635d 233static struct dump_list_entry * dump_sects_byname;
aef1f6d0 234
09c11c86
NC		 235/* A dynamic array of flags indicating for which sections a dump
236 has been requested via command line switches. */
237static dump_type * cmdline_dump_sects = NULL;
238static unsigned int num_cmdline_dump_sects = 0;
18bd398b
NC		 239
240/* A dynamic array of flags indicating for which sections a dump of
241 some kind has been requested. It is reset on a per-object file
aef1f6d0
DJ		 242 basis and then initialised from the cmdline_dump_sects array,
243 the results of interpreting the -w switch, and the
244 dump_sects_byname list. */
09c11c86
NC		 245static dump_type * dump_sects = NULL;
246static unsigned int num_dump_sects = 0;
252b5132 247
252b5132 248
c256ffe7 249/* How to print a vma value. */
843dd992
NC		 250typedef enum print_mode
251{
252 HEX,
253 DEC,
254 DEC_5,
255 UNSIGNED,
256 PREFIX_HEX,
257 FULL_HEX,
258 LONG_HEX
259}
260print_mode;
261
9c19a809
NC		 262#define UNKNOWN -1
263
2b692964
NC		 264#define SECTION_NAME(X) \
265 ((X) == NULL ? _("<none>") \
266 : string_table == NULL ? _("<no-name>") \
267 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
0b49d371 268 : string_table + (X)->sh_name))
252b5132 269
ee42cf8c 270#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
252b5132 271
9ad5cbcf
AM		 272#define GET_ELF_SYMBOLS(file, section) \
273 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
274 : get_64bit_elf_symbols (file, section))
9ea033b2 275
d79b3d50
NC		 276#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
277/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
278 already been called and verified that the string exists. */
279#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
18bd398b 280
61865e30
NC		 281#define REMOVE_ARCH_BITS(ADDR) \
282 do \
283 { \
284 if (elf_header.e_machine == EM_ARM) \
285 (ADDR) &= ~1; \
286 } \
287 while (0)
d79b3d50 288\f
c256ffe7 289static void *
2cf0635d
NC		 290get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
291 const char * reason)
a6e9f9df 292{
2cf0635d 293 void * mvar;
a6e9f9df 294
c256ffe7 295 if (size == 0 || nmemb == 0)
a6e9f9df
AM		 296 return NULL;
297
fb52b2f4 298 if (fseek (file, archive_file_offset + offset, SEEK_SET))
a6e9f9df 299 {
0fd3a477 300 error (_("Unable to seek to 0x%lx for %s\n"),
0af1713e 301 (unsigned long) archive_file_offset + offset, reason);
a6e9f9df
AM		 302 return NULL;
303 }
304
305 mvar = var;
306 if (mvar == NULL)
307 {
c256ffe7
JJ		 308 /* Check for overflow. */
309 if (nmemb < (~(size_t) 0 - 1) / size)
310 /* + 1 so that we can '\0' terminate invalid string table sections. */
311 mvar = malloc (size * nmemb + 1);
a6e9f9df
AM		 312
313 if (mvar == NULL)
314 {
0fd3a477
JW		 315 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
316 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM		 317 return NULL;
318 }
c256ffe7
JJ		 319
320 ((char *) mvar)[size * nmemb] = '\0';
a6e9f9df
AM		 321 }
322
c256ffe7 323 if (fread (mvar, size, nmemb, file) != nmemb)
a6e9f9df 324 {
0fd3a477
JW		 325 error (_("Unable to read in 0x%lx bytes of %s\n"),
326 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM		 327 if (mvar != var)
328 free (mvar);
329 return NULL;
330 }
331
332 return mvar;
333}
334
14a91970 335/* Print a VMA value. */
cb8f3167 336
66543521 337static int
14a91970 338print_vma (bfd_vma vma, print_mode mode)
66543521 339{
66543521
AM		 340 int nc = 0;
341
14a91970 342 switch (mode)
66543521 343 {
14a91970
AM		 344 case FULL_HEX:
345 nc = printf ("0x");
346 /* Drop through. */
66543521 347
14a91970 348 case LONG_HEX:
f7a99963 349#ifdef BFD64
14a91970 350 if (is_32bit_elf)
437c2fb7 351 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
f7a99963 352#endif
14a91970
AM		 353 printf_vma (vma);
354 return nc + 16;
b19aac67 355
14a91970
AM		 356 case DEC_5:
357 if (vma <= 99999)
358 return printf ("%5" BFD_VMA_FMT "d", vma);
359 /* Drop through. */
66543521 360
14a91970
AM		 361 case PREFIX_HEX:
362 nc = printf ("0x");
363 /* Drop through. */
66543521 364
14a91970
AM		 365 case HEX:
366 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 367
14a91970
AM		 368 case DEC:
369 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 370
14a91970
AM		 371 case UNSIGNED:
372 return printf ("%" BFD_VMA_FMT "u", vma);
f7a99963 373 }
66543521 374 return 0;
f7a99963
NC		 375}
376
171191ba 377/* Display a symbol on stdout. Handles the display of non-printing characters.
31104126 378
171191ba
NC		 379 If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
380 truncating as necessary. If WIDTH is negative then format the string to be
381 exactly - WIDTH characters, truncating or padding as necessary.
382
383 Returns the number of emitted characters. */
384
385static unsigned int
7a88bc9c 386print_symbol (int width, const char *symbol)
31104126 387{
7a88bc9c 388 const char *c;
171191ba
NC		 389 bfd_boolean extra_padding = FALSE;
390 unsigned int num_printed = 0;
961c521f 391
31104126 392 if (do_wide)
961c521f 393 {
7a88bc9c
AS		 394 /* Set the width to a very large value. This simplifies the
395 code below. */
961c521f
NC		 396 width = INT_MAX;
397 }
31104126 398 else if (width < 0)
961c521f 399 {
961c521f
NC		 400 /* Keep the width positive. This also helps. */
401 width = - width;
171191ba 402 extra_padding = TRUE;
961c521f
NC		 403 }
404
405 while (width)
406 {
407 int len;
408
409 c = symbol;
410
411 /* Look for non-printing symbols inside the symbol's name.
412 This test is triggered in particular by the names generated
413 by the assembler for local labels. */
7a88bc9c 414 while (ISPRINT (*c))
961c521f
NC		 415 c++;
416
417 len = c - symbol;
418
419 if (len)
420 {
421 if (len > width)
422 len = width;
cb8f3167 423
171191ba 424 printf ("%.*s", len, symbol);
961c521f
NC		 425
426 width -= len;
171191ba 427 num_printed += len;
961c521f
NC		 428 }
429
7a88bc9c 430 if (*c == 0 || width == 0)
961c521f
NC		 431 break;
432
433 /* Now display the non-printing character, if
434 there is room left in which to dipslay it. */
7a88bc9c 435 if ((unsigned char) *c < 32)
961c521f
NC		 436 {
437 if (width < 2)
438 break;
439
440 printf ("^%c", *c + 0x40);
441
442 width -= 2;
171191ba 443 num_printed += 2;
961c521f
NC		 444 }
445 else
446 {
447 if (width < 6)
448 break;
cb8f3167 449
7a88bc9c 450 printf ("<0x%.2x>", (unsigned char) *c);
961c521f
NC		 451
452 width -= 6;
171191ba 453 num_printed += 6;
961c521f
NC		 454 }
455
456 symbol = c + 1;
457 }
171191ba
NC		 458
459 if (extra_padding && width > 0)
460 {
461 /* Fill in the remaining spaces. */
462 printf ("%-*s", width, " ");
463 num_printed += 2;
464 }
465
466 return num_printed;
31104126
NC		 467}
468
89fac5e3
RS		 469/* Return a pointer to section NAME, or NULL if no such section exists. */
470
471static Elf_Internal_Shdr *
2cf0635d 472find_section (const char * name)
89fac5e3
RS		 473{
474 unsigned int i;
475
476 for (i = 0; i < elf_header.e_shnum; i++)
477 if (streq (SECTION_NAME (section_headers + i), name))
478 return section_headers + i;
479
480 return NULL;
481}
482
0b6ae522
DJ		 483/* Return a pointer to a section containing ADDR, or NULL if no such
484 section exists. */
485
486static Elf_Internal_Shdr *
487find_section_by_address (bfd_vma addr)
488{
489 unsigned int i;
490
491 for (i = 0; i < elf_header.e_shnum; i++)
492 {
493 Elf_Internal_Shdr *sec = section_headers + i;
494 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
495 return sec;
496 }
497
498 return NULL;
499}
500
501/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
502 bytes read. */
503
504static unsigned long
505read_uleb128 (unsigned char *data, unsigned int *length_return)
506{
507 return read_leb128 (data, length_return, 0);
508}
509
28f997cf
TG		 510/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
511 This OS has so many departures from the ELF standard that we test it at
512 many places. */
513
514static inline int
515is_ia64_vms (void)
516{
517 return elf_header.e_machine == EM_IA_64
518 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
519}
520
bcedfee6 521/* Guess the relocation size commonly used by the specific machines. */
252b5132 522
252b5132 523static int
2dc4cec1 524guess_is_rela (unsigned int e_machine)
252b5132 525{
9c19a809 526 switch (e_machine)
252b5132
RH		 527 {
528 /* Targets that use REL relocations. */
252b5132
RH		 529 case EM_386:
530 case EM_486:
63fcb9e9 531 case EM_960:
e9f53129 532 case EM_ARM:
2b0337b0 533 case EM_D10V:
252b5132 534 case EM_CYGNUS_D10V:
e9f53129 535 case EM_DLX:
252b5132 536 case EM_MIPS:
4fe85591 537 case EM_MIPS_RS3_LE:
e9f53129
AM		 538 case EM_CYGNUS_M32R:
539 case EM_OPENRISC:
540 case EM_OR32:
1c0d3aa6 541 case EM_SCORE:
9c19a809 542 return FALSE;
103f02d3 543
252b5132
RH		 544 /* Targets that use RELA relocations. */
545 case EM_68K:
e9f53129
AM		 546 case EM_860:
547 case EM_ALPHA:
548 case EM_ALTERA_NIOS2:
549 case EM_AVR:
550 case EM_AVR_OLD:
551 case EM_BLACKFIN:
60bca95a 552 case EM_CR16:
6c03b1ed 553 case EM_CR16_OLD:
e9f53129
AM		 554 case EM_CRIS:
555 case EM_CRX:
2b0337b0 556 case EM_D30V:
252b5132 557 case EM_CYGNUS_D30V:
2b0337b0 558 case EM_FR30:
252b5132 559 case EM_CYGNUS_FR30:
5c70f934 560 case EM_CYGNUS_FRV:
e9f53129
AM		 561 case EM_H8S:
562 case EM_H8_300:
563 case EM_H8_300H:
800eeca4 564 case EM_IA_64:
1e4cf259
NC		 565 case EM_IP2K:
566 case EM_IP2K_OLD:
3b36097d 567 case EM_IQ2000:
84e94c90 568 case EM_LATTICEMICO32:
ff7eeb89 569 case EM_M32C_OLD:
49f58d10 570 case EM_M32C:
e9f53129
AM		 571 case EM_M32R:
572 case EM_MCORE:
15ab5209 573 case EM_CYGNUS_MEP:
e9f53129
AM		 574 case EM_MMIX:
575 case EM_MN10200:
576 case EM_CYGNUS_MN10200:
577 case EM_MN10300:
578 case EM_CYGNUS_MN10300:
5506d11a 579 case EM_MOXIE:
e9f53129
AM		 580 case EM_MSP430:
581 case EM_MSP430_OLD:
d031aafb 582 case EM_MT:
64fd6348 583 case EM_NIOS32:
e9f53129
AM		 584 case EM_PPC64:
585 case EM_PPC:
c7927a3c 586 case EM_RX:
e9f53129
AM		 587 case EM_S390:
588 case EM_S390_OLD:
589 case EM_SH:
590 case EM_SPARC:
591 case EM_SPARC32PLUS:
592 case EM_SPARCV9:
593 case EM_SPU:
40b36596 594 case EM_TI_C6000:
e9f53129
AM		 595 case EM_V850:
596 case EM_CYGNUS_V850:
597 case EM_VAX:
598 case EM_X86_64:
8a9036a4 599 case EM_L1OM:
e9f53129
AM		 600 case EM_XSTORMY16:
601 case EM_XTENSA:
602 case EM_XTENSA_OLD:
7ba29e2a
NC		 603 case EM_MICROBLAZE:
604 case EM_MICROBLAZE_OLD:
9c19a809 605 return TRUE;
103f02d3 606
e9f53129
AM		 607 case EM_68HC05:
608 case EM_68HC08:
609 case EM_68HC11:
610 case EM_68HC16:
611 case EM_FX66:
612 case EM_ME16:
d1133906 613 case EM_MMA:
d1133906
NC		 614 case EM_NCPU:
615 case EM_NDR1:
e9f53129 616 case EM_PCP:
d1133906 617 case EM_ST100:
e9f53129 618 case EM_ST19:
d1133906 619 case EM_ST7:
e9f53129
AM		 620 case EM_ST9PLUS:
621 case EM_STARCORE:
d1133906 622 case EM_SVX:
e9f53129 623 case EM_TINYJ:
9c19a809
NC		 624 default:
625 warn (_("Don't know about relocations on this machine architecture\n"));
626 return FALSE;
627 }
628}
252b5132 629
9c19a809 630static int
2cf0635d 631slurp_rela_relocs (FILE * file,
d3ba0551
AM		 632 unsigned long rel_offset,
633 unsigned long rel_size,
2cf0635d
NC		 634 Elf_Internal_Rela ** relasp,
635 unsigned long * nrelasp)
9c19a809 636{
2cf0635d 637 Elf_Internal_Rela * relas;
4d6ed7c8
NC		 638 unsigned long nrelas;
639 unsigned int i;
252b5132 640
4d6ed7c8
NC		 641 if (is_32bit_elf)
642 {
2cf0635d 643 Elf32_External_Rela * erelas;
103f02d3 644
3f5e193b
NC		 645 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
646 rel_size, _("relocs"));
a6e9f9df
AM		 647 if (!erelas)
648 return 0;
252b5132 649
4d6ed7c8 650 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 651
3f5e193b
NC		 652 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
653 sizeof (Elf_Internal_Rela));
103f02d3 654
4d6ed7c8
NC		 655 if (relas == NULL)
656 {
c256ffe7 657 free (erelas);
591a748a 658 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 659 return 0;
660 }
103f02d3 661
4d6ed7c8
NC		 662 for (i = 0; i < nrelas; i++)
663 {
664 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
665 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 666 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 667 }
103f02d3 668
4d6ed7c8
NC		 669 free (erelas);
670 }
671 else
672 {
2cf0635d 673 Elf64_External_Rela * erelas;
103f02d3 674
3f5e193b
NC		 675 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
676 rel_size, _("relocs"));
a6e9f9df
AM		 677 if (!erelas)
678 return 0;
4d6ed7c8
NC		 679
680 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 681
3f5e193b
NC		 682 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
683 sizeof (Elf_Internal_Rela));
103f02d3 684
4d6ed7c8
NC		 685 if (relas == NULL)
686 {
c256ffe7 687 free (erelas);
591a748a 688 error (_("out of memory parsing relocs\n"));
4d6ed7c8 689 return 0;
9c19a809 690 }
4d6ed7c8
NC		 691
692 for (i = 0; i < nrelas; i++)
9c19a809 693 {
66543521
AM		 694 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
695 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 696 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 697
698 /* The #ifdef BFD64 below is to prevent a compile time
699 warning. We know that if we do not have a 64 bit data
700 type that we will never execute this code anyway. */
701#ifdef BFD64
702 if (elf_header.e_machine == EM_MIPS
703 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
704 {
705 /* In little-endian objects, r_info isn't really a
706 64-bit little-endian value: it has a 32-bit
707 little-endian symbol index followed by four
708 individual byte fields. Reorder INFO
709 accordingly. */
91d6fa6a
NC		 710 bfd_vma inf = relas[i].r_info;
711 inf = (((inf & 0xffffffff) << 32)
712 | ((inf >> 56) & 0xff)
713 | ((inf >> 40) & 0xff00)
714 | ((inf >> 24) & 0xff0000)
715 | ((inf >> 8) & 0xff000000));
716 relas[i].r_info = inf;
861fb55a
DJ		 717 }
718#endif /* BFD64 */
4d6ed7c8 719 }
103f02d3 720
4d6ed7c8
NC		 721 free (erelas);
722 }
723 *relasp = relas;
724 *nrelasp = nrelas;
725 return 1;
726}
103f02d3 727
4d6ed7c8 728static int
2cf0635d 729slurp_rel_relocs (FILE * file,
d3ba0551
AM		 730 unsigned long rel_offset,
731 unsigned long rel_size,
2cf0635d
NC		 732 Elf_Internal_Rela ** relsp,
733 unsigned long * nrelsp)
4d6ed7c8 734{
2cf0635d 735 Elf_Internal_Rela * rels;
4d6ed7c8
NC		 736 unsigned long nrels;
737 unsigned int i;
103f02d3 738
4d6ed7c8
NC		 739 if (is_32bit_elf)
740 {
2cf0635d 741 Elf32_External_Rel * erels;
103f02d3 742
3f5e193b
NC		 743 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
744 rel_size, _("relocs"));
a6e9f9df
AM		 745 if (!erels)
746 return 0;
103f02d3 747
4d6ed7c8 748 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 749
3f5e193b 750 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 751
4d6ed7c8
NC		 752 if (rels == NULL)
753 {
c256ffe7 754 free (erels);
591a748a 755 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 756 return 0;
757 }
758
759 for (i = 0; i < nrels; i++)
760 {
761 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
762 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 763 rels[i].r_addend = 0;
9ea033b2 764 }
4d6ed7c8
NC		 765
766 free (erels);
9c19a809
NC		 767 }
768 else
769 {
2cf0635d 770 Elf64_External_Rel * erels;
9ea033b2 771
3f5e193b
NC		 772 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
773 rel_size, _("relocs"));
a6e9f9df
AM		 774 if (!erels)
775 return 0;
103f02d3 776
4d6ed7c8 777 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 778
3f5e193b 779 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 780
4d6ed7c8 781 if (rels == NULL)
9c19a809 782 {
c256ffe7 783 free (erels);
591a748a 784 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 785 return 0;
786 }
103f02d3 787
4d6ed7c8
NC		 788 for (i = 0; i < nrels; i++)
789 {
66543521
AM		 790 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
791 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 792 rels[i].r_addend = 0;
861fb55a
DJ		 793
794 /* The #ifdef BFD64 below is to prevent a compile time
795 warning. We know that if we do not have a 64 bit data
796 type that we will never execute this code anyway. */
797#ifdef BFD64
798 if (elf_header.e_machine == EM_MIPS
799 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
800 {
801 /* In little-endian objects, r_info isn't really a
802 64-bit little-endian value: it has a 32-bit
803 little-endian symbol index followed by four
804 individual byte fields. Reorder INFO
805 accordingly. */
91d6fa6a
NC		 806 bfd_vma inf = rels[i].r_info;
807 inf = (((inf & 0xffffffff) << 32)
808 | ((inf >> 56) & 0xff)
809 | ((inf >> 40) & 0xff00)
810 | ((inf >> 24) & 0xff0000)
811 | ((inf >> 8) & 0xff000000));
812 rels[i].r_info = inf;
861fb55a
DJ		 813 }
814#endif /* BFD64 */
4d6ed7c8 815 }
103f02d3 816
4d6ed7c8
NC		 817 free (erels);
818 }
819 *relsp = rels;
820 *nrelsp = nrels;
821 return 1;
822}
103f02d3 823
aca88567
NC		 824/* Returns the reloc type extracted from the reloc info field. */
825
826static unsigned int
827get_reloc_type (bfd_vma reloc_info)
828{
829 if (is_32bit_elf)
830 return ELF32_R_TYPE (reloc_info);
831
832 switch (elf_header.e_machine)
833 {
834 case EM_MIPS:
835 /* Note: We assume that reloc_info has already been adjusted for us. */
836 return ELF64_MIPS_R_TYPE (reloc_info);
837
838 case EM_SPARCV9:
839 return ELF64_R_TYPE_ID (reloc_info);
840
841 default:
842 return ELF64_R_TYPE (reloc_info);
843 }
844}
845
846/* Return the symbol index extracted from the reloc info field. */
847
848static bfd_vma
849get_reloc_symindex (bfd_vma reloc_info)
850{
851 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
852}
853
d3ba0551
AM		 854/* Display the contents of the relocation data found at the specified
855 offset. */
ee42cf8c 856
41e92641 857static void
2cf0635d 858dump_relocations (FILE * file,
d3ba0551
AM		 859 unsigned long rel_offset,
860 unsigned long rel_size,
2cf0635d 861 Elf_Internal_Sym * symtab,
d3ba0551 862 unsigned long nsyms,
2cf0635d 863 char * strtab,
d79b3d50 864 unsigned long strtablen,
d3ba0551 865 int is_rela)
4d6ed7c8 866{
b34976b6 867 unsigned int i;
2cf0635d 868 Elf_Internal_Rela * rels;
103f02d3 869
4d6ed7c8
NC		 870 if (is_rela == UNKNOWN)
871 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 872
4d6ed7c8
NC		 873 if (is_rela)
874 {
c8286bd1 875 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 876 return;
4d6ed7c8
NC		 877 }
878 else
879 {
880 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 881 return;
252b5132
RH		 882 }
883
410f7a12
L		 884 if (is_32bit_elf)
885 {
886 if (is_rela)
2c71103e
NC		 887 {
888 if (do_wide)
889 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
890 else
891 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
892 }
410f7a12 893 else
2c71103e
NC		 894 {
895 if (do_wide)
896 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
897 else
898 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
899 }
410f7a12 900 }
252b5132 901 else
410f7a12
L		 902 {
903 if (is_rela)
2c71103e
NC		 904 {
905 if (do_wide)
8beeaeb7 906 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 907 else
908 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
909 }
410f7a12 910 else
2c71103e
NC		 911 {
912 if (do_wide)
8beeaeb7 913 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 914 else
915 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
916 }
410f7a12 917 }
252b5132
RH		 918
919 for (i = 0; i < rel_size; i++)
920 {
2cf0635d 921 const char * rtype;
b34976b6 922 bfd_vma offset;
91d6fa6a 923 bfd_vma inf;
b34976b6
AM		 924 bfd_vma symtab_index;
925 bfd_vma type;
103f02d3 926
b34976b6 927 offset = rels[i].r_offset;
91d6fa6a 928 inf = rels[i].r_info;
103f02d3 929
91d6fa6a
NC		 930 type = get_reloc_type (inf);
931 symtab_index = get_reloc_symindex (inf);
252b5132 932
410f7a12
L		 933 if (is_32bit_elf)
934 {
39dbeff8
AM		 935 printf ("%8.8lx %8.8lx ",
936 (unsigned long) offset & 0xffffffff,
91d6fa6a 937 (unsigned long) inf & 0xffffffff);
410f7a12
L		 938 }
939 else
940 {
39dbeff8
AM		 941#if BFD_HOST_64BIT_LONG
942 printf (do_wide
943 ? "%16.16lx %16.16lx "
944 : "%12.12lx %12.12lx ",
91d6fa6a 945 offset, inf);
39dbeff8 946#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 947#ifndef __MSVCRT__
39dbeff8
AM		 948 printf (do_wide
949 ? "%16.16llx %16.16llx "
950 : "%12.12llx %12.12llx ",
91d6fa6a 951 offset, inf);
6e3d6dc1
NC		 952#else
953 printf (do_wide
954 ? "%16.16I64x %16.16I64x "
955 : "%12.12I64x %12.12I64x ",
91d6fa6a 956 offset, inf);
6e3d6dc1 957#endif
39dbeff8 958#else
2c71103e
NC		 959 printf (do_wide
960 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
961 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 962 _bfd_int64_high (offset),
963 _bfd_int64_low (offset),
91d6fa6a
NC		 964 _bfd_int64_high (inf),
965 _bfd_int64_low (inf));
9ea033b2 966#endif
410f7a12 967 }
103f02d3 968
252b5132
RH		 969 switch (elf_header.e_machine)
970 {
971 default:
972 rtype = NULL;
973 break;
974
2b0337b0 975 case EM_M32R:
252b5132 976 case EM_CYGNUS_M32R:
9ea033b2 977 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 978 break;
979
980 case EM_386:
981 case EM_486:
9ea033b2 982 rtype = elf_i386_reloc_type (type);
252b5132
RH		 983 break;
984
ba2685cc
AM		 985 case EM_68HC11:
986 case EM_68HC12:
987 rtype = elf_m68hc11_reloc_type (type);
988 break;
75751cd9 989
252b5132 990 case EM_68K:
9ea033b2 991 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 992 break;
993
63fcb9e9 994 case EM_960:
9ea033b2 995 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 996 break;
997
adde6300 998 case EM_AVR:
2b0337b0 999 case EM_AVR_OLD:
adde6300
AM		 1000 rtype = elf_avr_reloc_type (type);
1001 break;
1002
9ea033b2
NC		 1003 case EM_OLD_SPARCV9:
1004 case EM_SPARC32PLUS:
1005 case EM_SPARCV9:
252b5132 1006 case EM_SPARC:
9ea033b2 1007 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1008 break;
1009
e9f53129
AM		 1010 case EM_SPU:
1011 rtype = elf_spu_reloc_type (type);
1012 break;
1013
2b0337b0 1014 case EM_V850:
252b5132 1015 case EM_CYGNUS_V850:
9ea033b2 1016 rtype = v850_reloc_type (type);
252b5132
RH		 1017 break;
1018
2b0337b0 1019 case EM_D10V:
252b5132 1020 case EM_CYGNUS_D10V:
9ea033b2 1021 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1022 break;
1023
2b0337b0 1024 case EM_D30V:
252b5132 1025 case EM_CYGNUS_D30V:
9ea033b2 1026 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1027 break;
1028
d172d4ba
NC		 1029 case EM_DLX:
1030 rtype = elf_dlx_reloc_type (type);
1031 break;
1032
252b5132 1033 case EM_SH:
9ea033b2 1034 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1035 break;
1036
2b0337b0 1037 case EM_MN10300:
252b5132 1038 case EM_CYGNUS_MN10300:
9ea033b2 1039 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1040 break;
1041
2b0337b0 1042 case EM_MN10200:
252b5132 1043 case EM_CYGNUS_MN10200:
9ea033b2 1044 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1045 break;
1046
2b0337b0 1047 case EM_FR30:
252b5132 1048 case EM_CYGNUS_FR30:
9ea033b2 1049 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1050 break;
1051
ba2685cc
AM		 1052 case EM_CYGNUS_FRV:
1053 rtype = elf_frv_reloc_type (type);
1054 break;
5c70f934 1055
252b5132 1056 case EM_MCORE:
9ea033b2 1057 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1058 break;
1059
3c3bdf30
NC		 1060 case EM_MMIX:
1061 rtype = elf_mmix_reloc_type (type);
1062 break;
1063
5506d11a
AM		 1064 case EM_MOXIE:
1065 rtype = elf_moxie_reloc_type (type);
1066 break;
1067
2469cfa2
NC		 1068 case EM_MSP430:
1069 case EM_MSP430_OLD:
1070 rtype = elf_msp430_reloc_type (type);
1071 break;
1072
252b5132 1073 case EM_PPC:
9ea033b2 1074 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1075 break;
1076
c833c019
AM		 1077 case EM_PPC64:
1078 rtype = elf_ppc64_reloc_type (type);
1079 break;
1080
252b5132 1081 case EM_MIPS:
4fe85591 1082 case EM_MIPS_RS3_LE:
9ea033b2 1083 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1084 break;
1085
1086 case EM_ALPHA:
9ea033b2 1087 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1088 break;
1089
1090 case EM_ARM:
9ea033b2 1091 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1092 break;
1093
584da044 1094 case EM_ARC:
9ea033b2 1095 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1096 break;
1097
1098 case EM_PARISC:
69e617ca 1099 rtype = elf_hppa_reloc_type (type);
252b5132 1100 break;
7d466069 1101
b8720f9d
JL		 1102 case EM_H8_300:
1103 case EM_H8_300H:
1104 case EM_H8S:
1105 rtype = elf_h8_reloc_type (type);
1106 break;
1107
3b16e843
NC		 1108 case EM_OPENRISC:
1109 case EM_OR32:
1110 rtype = elf_or32_reloc_type (type);
1111 break;
1112
7d466069 1113 case EM_PJ:
2b0337b0 1114 case EM_PJ_OLD:
7d466069
ILT		 1115 rtype = elf_pj_reloc_type (type);
1116 break;
800eeca4
JW		 1117 case EM_IA_64:
1118 rtype = elf_ia64_reloc_type (type);
1119 break;
1b61cf92
HPN		 1120
1121 case EM_CRIS:
1122 rtype = elf_cris_reloc_type (type);
1123 break;
535c37ff
JE		 1124
1125 case EM_860:
1126 rtype = elf_i860_reloc_type (type);
1127 break;
bcedfee6
NC		 1128
1129 case EM_X86_64:
8a9036a4 1130 case EM_L1OM:
bcedfee6
NC		 1131 rtype = elf_x86_64_reloc_type (type);
1132 break;
a85d7ed0 1133
35b1837e
AM		 1134 case EM_S370:
1135 rtype = i370_reloc_type (type);
1136 break;
1137
53c7db4b
KH		 1138 case EM_S390_OLD:
1139 case EM_S390:
1140 rtype = elf_s390_reloc_type (type);
1141 break;
93fbbb04 1142
1c0d3aa6
NC		 1143 case EM_SCORE:
1144 rtype = elf_score_reloc_type (type);
1145 break;
1146
93fbbb04
GK		 1147 case EM_XSTORMY16:
1148 rtype = elf_xstormy16_reloc_type (type);
1149 break;
179d3252 1150
1fe1f39c
NC		 1151 case EM_CRX:
1152 rtype = elf_crx_reloc_type (type);
1153 break;
1154
179d3252
JT		 1155 case EM_VAX:
1156 rtype = elf_vax_reloc_type (type);
1157 break;
1e4cf259
NC		 1158
1159 case EM_IP2K:
1160 case EM_IP2K_OLD:
1161 rtype = elf_ip2k_reloc_type (type);
1162 break;
3b36097d
SC		 1163
1164 case EM_IQ2000:
1165 rtype = elf_iq2000_reloc_type (type);
1166 break;
88da6820
NC		 1167
1168 case EM_XTENSA_OLD:
1169 case EM_XTENSA:
1170 rtype = elf_xtensa_reloc_type (type);
1171 break;
a34e3ecb 1172
84e94c90
NC		 1173 case EM_LATTICEMICO32:
1174 rtype = elf_lm32_reloc_type (type);
1175 break;
1176
ff7eeb89 1177 case EM_M32C_OLD:
49f58d10
JB		 1178 case EM_M32C:
1179 rtype = elf_m32c_reloc_type (type);
1180 break;
1181
d031aafb
NS		 1182 case EM_MT:
1183 rtype = elf_mt_reloc_type (type);
a34e3ecb 1184 break;
1d65ded4
CM		 1185
1186 case EM_BLACKFIN:
1187 rtype = elf_bfin_reloc_type (type);
1188 break;
15ab5209
DB		 1189
1190 case EM_CYGNUS_MEP:
1191 rtype = elf_mep_reloc_type (type);
1192 break;
60bca95a
NC		 1193
1194 case EM_CR16:
6c03b1ed 1195 case EM_CR16_OLD:
60bca95a
NC		 1196 rtype = elf_cr16_reloc_type (type);
1197 break;
dd24e3da 1198
7ba29e2a
NC		 1199 case EM_MICROBLAZE:
1200 case EM_MICROBLAZE_OLD:
1201 rtype = elf_microblaze_reloc_type (type);
1202 break;
c7927a3c
NC		 1203
1204 case EM_RX:
1205 rtype = elf_rx_reloc_type (type);
1206 break;
c29aca4a
NC		 1207
1208 case EM_XC16X:
1209 case EM_C166:
1210 rtype = elf_xc16x_reloc_type (type);
1211 break;
40b36596
JM		 1212
1213 case EM_TI_C6000:
1214 rtype = elf_tic6x_reloc_type (type);
1215 break;
252b5132
RH		 1216 }
1217
1218 if (rtype == NULL)
39dbeff8 1219 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1220 else
8beeaeb7 1221 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1222
7ace3541 1223 if (elf_header.e_machine == EM_ALPHA
157c2599 1224 && rtype != NULL
7ace3541
RH		 1225 && streq (rtype, "R_ALPHA_LITUSE")
1226 && is_rela)
1227 {
1228 switch (rels[i].r_addend)
1229 {
1230 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1231 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1232 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1233 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1234 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1235 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1236 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1237 default: rtype = NULL;
1238 }
1239 if (rtype)
1240 printf (" (%s)", rtype);
1241 else
1242 {
1243 putchar (' ');
1244 printf (_("<unknown addend: %lx>"),
1245 (unsigned long) rels[i].r_addend);
1246 }
1247 }
1248 else if (symtab_index)
252b5132 1249 {
af3fc3bc 1250 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1251 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1252 else
19936277 1253 {
2cf0635d 1254 Elf_Internal_Sym * psym;
19936277 1255
af3fc3bc 1256 psym = symtab + symtab_index;
103f02d3 1257
af3fc3bc 1258 printf (" ");
171191ba 1259
d8045f23
NC		 1260 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1261 {
1262 const char * name;
1263 unsigned int len;
1264 unsigned int width = is_32bit_elf ? 8 : 14;
1265
1266 /* Relocations against GNU_IFUNC symbols do not use the value
1267 of the symbol as the address to relocate against. Instead
1268 they invoke the function named by the symbol and use its
1269 result as the address for relocation.
1270
1271 To indicate this to the user, do not display the value of
1272 the symbol in the "Symbols's Value" field. Instead show
1273 its name followed by () as a hint that the symbol is
1274 invoked. */
1275
1276 if (strtab == NULL
1277 || psym->st_name == 0
1278 || psym->st_name >= strtablen)
1279 name = "??";
1280 else
1281 name = strtab + psym->st_name;
1282
1283 len = print_symbol (width, name);
1284 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1285 }
1286 else
1287 {
1288 print_vma (psym->st_value, LONG_HEX);
171191ba 1289
d8045f23
NC		 1290 printf (is_32bit_elf ? " " : " ");
1291 }
103f02d3 1292
af3fc3bc 1293 if (psym->st_name == 0)
f1ef08cb 1294 {
2cf0635d 1295 const char * sec_name = "<null>";
f1ef08cb
AM		 1296 char name_buf[40];
1297
1298 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1299 {
4fbb74a6
AM		 1300 if (psym->st_shndx < elf_header.e_shnum)
1301 sec_name
1302 = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1303 else if (psym->st_shndx == SHN_ABS)
1304 sec_name = "ABS";
1305 else if (psym->st_shndx == SHN_COMMON)
1306 sec_name = "COMMON";
172553c7
TS		 1307 else if (elf_header.e_machine == EM_MIPS
1308 && psym->st_shndx == SHN_MIPS_SCOMMON)
1309 sec_name = "SCOMMON";
1310 else if (elf_header.e_machine == EM_MIPS
1311 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1312 sec_name = "SUNDEF";
8a9036a4
L		 1313 else if ((elf_header.e_machine == EM_X86_64
1314 || elf_header.e_machine == EM_L1OM)
3b22753a
L		 1315 && psym->st_shndx == SHN_X86_64_LCOMMON)
1316 sec_name = "LARGE_COMMON";
9ce701e2
L		 1317 else if (elf_header.e_machine == EM_IA_64
1318 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1319 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1320 sec_name = "ANSI_COM";
28f997cf 1321 else if (is_ia64_vms ()
148b93f2
NC		 1322 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1323 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1324 else
1325 {
1326 sprintf (name_buf, "<section 0x%x>",
1327 (unsigned int) psym->st_shndx);
1328 sec_name = name_buf;
1329 }
1330 }
1331 print_symbol (22, sec_name);
1332 }
af3fc3bc 1333 else if (strtab == NULL)
d79b3d50 1334 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1335 else if (psym->st_name >= strtablen)
d79b3d50 1336 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1337 else
2c71103e 1338 print_symbol (22, strtab + psym->st_name);
103f02d3 1339
af3fc3bc 1340 if (is_rela)
171191ba 1341 {
598aaa76 1342 bfd_signed_vma off = rels[i].r_addend;
171191ba 1343
91d6fa6a 1344 if (off < 0)
598aaa76 1345 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1346 else
598aaa76 1347 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1348 }
19936277 1349 }
252b5132 1350 }
1b228002 1351 else if (is_rela)
f7a99963 1352 {
18bd398b
NC		 1353 printf ("%*c", is_32bit_elf ?
1354 (do_wide ? 34 : 28) : (do_wide ? 26 : 20), ' ');
c8286bd1 1355 print_vma (rels[i].r_addend, LONG_HEX);
f7a99963 1356 }
252b5132 1357
157c2599
NC		 1358 if (elf_header.e_machine == EM_SPARCV9
1359 && rtype != NULL
1360 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1361 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1362
252b5132 1363 putchar ('\n');
2c71103e 1364
aca88567 1365#ifdef BFD64
53c7db4b 1366 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1367 {
91d6fa6a
NC		 1368 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1369 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1370 const char * rtype2 = elf_mips_reloc_type (type2);
1371 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1372
2c71103e
NC		 1373 printf (" Type2: ");
1374
1375 if (rtype2 == NULL)
39dbeff8
AM		 1376 printf (_("unrecognized: %-7lx"),
1377 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1378 else
1379 printf ("%-17.17s", rtype2);
1380
18bd398b 1381 printf ("\n Type3: ");
2c71103e
NC		 1382
1383 if (rtype3 == NULL)
39dbeff8
AM		 1384 printf (_("unrecognized: %-7lx"),
1385 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1386 else
1387 printf ("%-17.17s", rtype3);
1388
53c7db4b 1389 putchar ('\n');
2c71103e 1390 }
aca88567 1391#endif /* BFD64 */
252b5132
RH		 1392 }
1393
c8286bd1 1394 free (rels);
252b5132
RH		 1395}
1396
1397static const char *
d3ba0551 1398get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1399{
1400 switch (type)
1401 {
1402 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1403 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1404 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1405 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1406 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1407 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1408 case DT_MIPS_MSYM: return "MIPS_MSYM";
1409 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1410 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1411 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1412 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1413 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1414 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1415 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1416 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1417 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1418 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1419 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1420 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1421 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1422 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1423 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1424 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1425 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1426 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1427 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1428 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1429 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1430 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1431 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1432 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1433 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1434 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1435 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1436 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1437 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1438 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1439 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1440 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1441 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1442 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1443 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1444 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1445 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1446 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1447 default:
1448 return NULL;
1449 }
1450}
1451
9a097730 1452static const char *
d3ba0551 1453get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1454{
1455 switch (type)
1456 {
1457 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1458 default:
1459 return NULL;
1460 }
103f02d3
UD		 1461}
1462
7490d522
AM		 1463static const char *
1464get_ppc_dynamic_type (unsigned long type)
1465{
1466 switch (type)
1467 {
a7f2871e
AM		 1468 case DT_PPC_GOT: return "PPC_GOT";
1469 case DT_PPC_TLSOPT: return "PPC_TLSOPT";
7490d522
AM		 1470 default:
1471 return NULL;
1472 }
1473}
1474
f1cb7e17 1475static const char *
d3ba0551 1476get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1477{
1478 switch (type)
1479 {
a7f2871e
AM		 1480 case DT_PPC64_GLINK: return "PPC64_GLINK";
1481 case DT_PPC64_OPD: return "PPC64_OPD";
1482 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1483 case DT_PPC64_TLSOPT: return "PPC64_TLSOPT";
f1cb7e17
AM		 1484 default:
1485 return NULL;
1486 }
1487}
1488
103f02d3 1489static const char *
d3ba0551 1490get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1491{
1492 switch (type)
1493 {
1494 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1495 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1496 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1497 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1498 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1499 case DT_HP_PREINIT: return "HP_PREINIT";
1500 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1501 case DT_HP_NEEDED: return "HP_NEEDED";
1502 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1503 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1504 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1505 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1506 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1507 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1508 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1509 case DT_HP_FILTERED: return "HP_FILTERED";
1510 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1511 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1512 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1513 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1514 case DT_PLT: return "PLT";
1515 case DT_PLT_SIZE: return "PLT_SIZE";
1516 case DT_DLT: return "DLT";
1517 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1518 default:
1519 return NULL;
1520 }
1521}
9a097730 1522
ecc51f48 1523static const char *
d3ba0551 1524get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1525{
1526 switch (type)
1527 {
148b93f2
NC		 1528 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1529 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1530 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1531 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1532 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1533 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1534 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1535 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1536 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1537 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1538 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1539 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1540 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1541 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1542 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1543 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1544 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1545 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1546 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1547 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1548 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1549 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1550 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1551 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1552 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1553 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1554 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1555 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1556 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1557 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1558 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1559 default:
1560 return NULL;
1561 }
1562}
1563
fabcb361
RH		 1564static const char *
1565get_alpha_dynamic_type (unsigned long type)
1566{
1567 switch (type)
1568 {
1569 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1570 default:
1571 return NULL;
1572 }
1573}
1574
1c0d3aa6
NC		 1575static const char *
1576get_score_dynamic_type (unsigned long type)
1577{
1578 switch (type)
1579 {
1580 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1581 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1582 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1583 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1584 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1585 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1586 default:
1587 return NULL;
1588 }
1589}
1590
40b36596
JM		 1591static const char *
1592get_tic6x_dynamic_type (unsigned long type)
1593{
1594 switch (type)
1595 {
1596 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1597 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1598 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1599 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1600 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1601 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1602 default:
1603 return NULL;
1604 }
1605}
1c0d3aa6 1606
252b5132 1607static const char *
d3ba0551 1608get_dynamic_type (unsigned long type)
252b5132 1609{
e9e44622 1610 static char buff[64];
252b5132
RH		 1611
1612 switch (type)
1613 {
1614 case DT_NULL: return "NULL";
1615 case DT_NEEDED: return "NEEDED";
1616 case DT_PLTRELSZ: return "PLTRELSZ";
1617 case DT_PLTGOT: return "PLTGOT";
1618 case DT_HASH: return "HASH";
1619 case DT_STRTAB: return "STRTAB";
1620 case DT_SYMTAB: return "SYMTAB";
1621 case DT_RELA: return "RELA";
1622 case DT_RELASZ: return "RELASZ";
1623 case DT_RELAENT: return "RELAENT";
1624 case DT_STRSZ: return "STRSZ";
1625 case DT_SYMENT: return "SYMENT";
1626 case DT_INIT: return "INIT";
1627 case DT_FINI: return "FINI";
1628 case DT_SONAME: return "SONAME";
1629 case DT_RPATH: return "RPATH";
1630 case DT_SYMBOLIC: return "SYMBOLIC";
1631 case DT_REL: return "REL";
1632 case DT_RELSZ: return "RELSZ";
1633 case DT_RELENT: return "RELENT";
1634 case DT_PLTREL: return "PLTREL";
1635 case DT_DEBUG: return "DEBUG";
1636 case DT_TEXTREL: return "TEXTREL";
1637 case DT_JMPREL: return "JMPREL";
1638 case DT_BIND_NOW: return "BIND_NOW";
1639 case DT_INIT_ARRAY: return "INIT_ARRAY";
1640 case DT_FINI_ARRAY: return "FINI_ARRAY";
1641 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1642 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1643 case DT_RUNPATH: return "RUNPATH";
1644 case DT_FLAGS: return "FLAGS";
2d0e6f43 1645
d1133906
NC		 1646 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1647 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1648
05107a46 1649 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1650 case DT_PLTPADSZ: return "PLTPADSZ";
1651 case DT_MOVEENT: return "MOVEENT";
1652 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1653 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1654 case DT_POSFLAG_1: return "POSFLAG_1";
1655 case DT_SYMINSZ: return "SYMINSZ";
1656 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1657
252b5132 1658 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1659 case DT_CONFIG: return "CONFIG";
1660 case DT_DEPAUDIT: return "DEPAUDIT";
1661 case DT_AUDIT: return "AUDIT";
1662 case DT_PLTPAD: return "PLTPAD";
1663 case DT_MOVETAB: return "MOVETAB";
252b5132 1664 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1665
252b5132 1666 case DT_VERSYM: return "VERSYM";
103f02d3 1667
67a4f2b7
AO		 1668 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1669 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1670 case DT_RELACOUNT: return "RELACOUNT";
1671 case DT_RELCOUNT: return "RELCOUNT";
1672 case DT_FLAGS_1: return "FLAGS_1";
1673 case DT_VERDEF: return "VERDEF";
1674 case DT_VERDEFNUM: return "VERDEFNUM";
1675 case DT_VERNEED: return "VERNEED";
1676 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1677
019148e4 1678 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1679 case DT_USED: return "USED";
1680 case DT_FILTER: return "FILTER";
103f02d3 1681
047b2264
JJ		 1682 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1683 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1684 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1685 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1686 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1687 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1688
252b5132
RH		 1689 default:
1690 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1691 {
2cf0635d 1692 const char * result;
103f02d3 1693
252b5132
RH		 1694 switch (elf_header.e_machine)
1695 {
1696 case EM_MIPS:
4fe85591 1697 case EM_MIPS_RS3_LE:
252b5132
RH		 1698 result = get_mips_dynamic_type (type);
1699 break;
9a097730
RH		 1700 case EM_SPARCV9:
1701 result = get_sparc64_dynamic_type (type);
1702 break;
7490d522
AM		 1703 case EM_PPC:
1704 result = get_ppc_dynamic_type (type);
1705 break;
f1cb7e17
AM		 1706 case EM_PPC64:
1707 result = get_ppc64_dynamic_type (type);
1708 break;
ecc51f48
NC		 1709 case EM_IA_64:
1710 result = get_ia64_dynamic_type (type);
1711 break;
fabcb361
RH		 1712 case EM_ALPHA:
1713 result = get_alpha_dynamic_type (type);
1714 break;
1c0d3aa6
NC		 1715 case EM_SCORE:
1716 result = get_score_dynamic_type (type);
1717 break;
40b36596
JM		 1718 case EM_TI_C6000:
1719 result = get_tic6x_dynamic_type (type);
1720 break;
252b5132
RH		 1721 default:
1722 result = NULL;
1723 break;
1724 }
1725
1726 if (result != NULL)
1727 return result;
1728
e9e44622 1729 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 1730 }
eec8f817
DA		 1731 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1732 || (elf_header.e_machine == EM_PARISC
1733 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 1734 {
2cf0635d 1735 const char * result;
103f02d3
UD		 1736
1737 switch (elf_header.e_machine)
1738 {
1739 case EM_PARISC:
1740 result = get_parisc_dynamic_type (type);
1741 break;
148b93f2
NC		 1742 case EM_IA_64:
1743 result = get_ia64_dynamic_type (type);
1744 break;
103f02d3
UD		 1745 default:
1746 result = NULL;
1747 break;
1748 }
1749
1750 if (result != NULL)
1751 return result;
1752
e9e44622
JJ		 1753 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1754 type);
103f02d3 1755 }
252b5132 1756 else
e9e44622 1757 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 1758
252b5132
RH		 1759 return buff;
1760 }
1761}
1762
1763static char *
d3ba0551 1764get_file_type (unsigned e_type)
252b5132 1765{
b34976b6 1766 static char buff[32];
252b5132
RH		 1767
1768 switch (e_type)
1769 {
1770 case ET_NONE: return _("NONE (None)");
1771 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 1772 case ET_EXEC: return _("EXEC (Executable file)");
1773 case ET_DYN: return _("DYN (Shared object file)");
1774 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 1775
1776 default:
1777 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 1778 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 1779 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 1780 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 1781 else
e9e44622 1782 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 1783 return buff;
1784 }
1785}
1786
1787static char *
d3ba0551 1788get_machine_name (unsigned e_machine)
252b5132 1789{
b34976b6 1790 static char buff[64]; /* XXX */
252b5132
RH		 1791
1792 switch (e_machine)
1793 {
c45021f2
NC		 1794 case EM_NONE: return _("None");
1795 case EM_M32: return "WE32100";
1796 case EM_SPARC: return "Sparc";
e9f53129 1797 case EM_SPU: return "SPU";
c45021f2
NC		 1798 case EM_386: return "Intel 80386";
1799 case EM_68K: return "MC68000";
1800 case EM_88K: return "MC88000";
1801 case EM_486: return "Intel 80486";
1802 case EM_860: return "Intel 80860";
1803 case EM_MIPS: return "MIPS R3000";
1804 case EM_S370: return "IBM System/370";
7036c0e1 1805 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 1806 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 1807 case EM_PARISC: return "HPPA";
252b5132 1808 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 1809 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 1810 case EM_960: return "Intel 90860";
1811 case EM_PPC: return "PowerPC";
285d1771 1812 case EM_PPC64: return "PowerPC64";
c45021f2
NC		 1813 case EM_V800: return "NEC V800";
1814 case EM_FR20: return "Fujitsu FR20";
1815 case EM_RH32: return "TRW RH32";
b34976b6 1816 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 1817 case EM_ARM: return "ARM";
1818 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 1819 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 1820 case EM_SPARCV9: return "Sparc v9";
1821 case EM_TRICORE: return "Siemens Tricore";
584da044 1822 case EM_ARC: return "ARC";
c2dcd04e
NC		 1823 case EM_H8_300: return "Renesas H8/300";
1824 case EM_H8_300H: return "Renesas H8/300H";
1825 case EM_H8S: return "Renesas H8S";
1826 case EM_H8_500: return "Renesas H8/500";
30800947 1827 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 1828 case EM_MIPS_X: return "Stanford MIPS-X";
1829 case EM_COLDFIRE: return "Motorola Coldfire";
1830 case EM_68HC12: return "Motorola M68HC12";
c45021f2 1831 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 1832 case EM_CYGNUS_D10V:
1833 case EM_D10V: return "d10v";
1834 case EM_CYGNUS_D30V:
b34976b6 1835 case EM_D30V: return "d30v";
2b0337b0 1836 case EM_CYGNUS_M32R:
26597c86 1837 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 1838 case EM_CYGNUS_V850:
8f7e76d0 1839 case EM_V850: return "Renesas v850";
2b0337b0
AO		 1840 case EM_CYGNUS_MN10300:
1841 case EM_MN10300: return "mn10300";
1842 case EM_CYGNUS_MN10200:
1843 case EM_MN10200: return "mn10200";
5506d11a 1844 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 1845 case EM_CYGNUS_FR30:
1846 case EM_FR30: return "Fujitsu FR30";
b34976b6 1847 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 1848 case EM_PJ_OLD:
b34976b6 1849 case EM_PJ: return "picoJava";
7036c0e1
AJ		 1850 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1851 case EM_PCP: return "Siemens PCP";
1852 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1853 case EM_NDR1: return "Denso NDR1 microprocesspr";
1854 case EM_STARCORE: return "Motorola Star*Core processor";
1855 case EM_ME16: return "Toyota ME16 processor";
1856 case EM_ST100: return "STMicroelectronics ST100 processor";
1857 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 1858 case EM_PDSP: return "Sony DSP processor";
1859 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
1860 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 1861 case EM_FX66: return "Siemens FX66 microcontroller";
1862 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1863 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1864 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1865 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1866 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1867 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1868 case EM_SVX: return "Silicon Graphics SVx";
1869 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1870 case EM_VAX: return "Digital VAX";
2b0337b0 1871 case EM_AVR_OLD:
b34976b6 1872 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 1873 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 1874 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1875 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1876 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 1877 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 1878 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 1879 case EM_PRISM: return "Vitesse Prism";
bcedfee6 1880 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 1881 case EM_L1OM: return "Intel L1OM";
b7498e0e 1882 case EM_S390_OLD:
b34976b6 1883 case EM_S390: return "IBM S/390";
1c0d3aa6 1884 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 1885 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
3b16e843
NC		 1886 case EM_OPENRISC:
1887 case EM_OR32: return "OpenRISC";
11636f9e 1888 case EM_ARC_A5: return "ARC International ARCompact processor";
1fe1f39c 1889 case EM_CRX: return "National Semiconductor CRX microprocessor";
d172d4ba 1890 case EM_DLX: return "OpenDLX";
1e4cf259 1891 case EM_IP2K_OLD:
b34976b6 1892 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 1893 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 1894 case EM_XTENSA_OLD:
1895 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 1896 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
1897 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
1898 case EM_NS32K: return "National Semiconductor 32000 series";
1899 case EM_TPC: return "Tenor Network TPC processor";
1900 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
1901 case EM_MAX: return "MAX Processor";
1902 case EM_CR: return "National Semiconductor CompactRISC";
1903 case EM_F2MC16: return "Fujitsu F2MC16";
1904 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 1905 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 1906 case EM_M32C_OLD:
49f58d10 1907 case EM_M32C: return "Renesas M32c";
d031aafb 1908 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 1909 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 1910 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
1911 case EM_SEP: return "Sharp embedded microprocessor";
1912 case EM_ARCA: return "Arca RISC microprocessor";
1913 case EM_UNICORE: return "Unicore";
1914 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
1915 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 1916 case EM_NIOS32: return "Altera Nios";
1917 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 1918 case EM_C166:
d70c5fc7 1919 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 1920 case EM_M16C: return "Renesas M16C series microprocessors";
1921 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
1922 case EM_CE: return "Freescale Communication Engine RISC core";
1923 case EM_TSK3000: return "Altium TSK3000 core";
1924 case EM_RS08: return "Freescale RS08 embedded processor";
1925 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
1926 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
1927 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
1928 case EM_SE_C17: return "Seiko Epson C17 family";
1929 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
1930 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
1931 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
1932 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
1933 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
1934 case EM_R32C: return "Renesas R32C series microprocessors";
1935 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
1936 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
1937 case EM_8051: return "Intel 8051 and variants";
1938 case EM_STXP7X: return "STMicroelectronics STxP7x family";
1939 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
1940 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
1941 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
1942 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
1943 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
1944 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 1945 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 1946 case EM_CR16:
6c03b1ed 1947 case EM_CR16_OLD: return "National Semiconductor's CR16";
7ba29e2a
NC		 1948 case EM_MICROBLAZE: return "Xilinx MicroBlaze";
1949 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
c7927a3c 1950 case EM_RX: return "Renesas RX";
11636f9e
JM		 1951 case EM_METAG: return "Imagination Technologies META processor architecture";
1952 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
1953 case EM_ECOG16: return "Cyan Technology eCOG16 family";
1954 case EM_ETPU: return "Freescale Extended Time Processing Unit";
1955 case EM_SLE9X: return "Infineon Technologies SLE9X core";
1956 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
1957 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
1958 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
1959 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
1960 case EM_CUDA: return "NVIDIA CUDA architecture";
252b5132 1961 default:
35d9dd2f 1962 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 1963 return buff;
1964 }
1965}
1966
f3485b74 1967static void
d3ba0551 1968decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 1969{
1970 unsigned eabi;
1971 int unknown = 0;
1972
1973 eabi = EF_ARM_EABI_VERSION (e_flags);
1974 e_flags &= ~ EF_ARM_EABIMASK;
1975
1976 /* Handle "generic" ARM flags. */
1977 if (e_flags & EF_ARM_RELEXEC)
1978 {
1979 strcat (buf, ", relocatable executable");
1980 e_flags &= ~ EF_ARM_RELEXEC;
1981 }
76da6bbe 1982
f3485b74
NC		 1983 if (e_flags & EF_ARM_HASENTRY)
1984 {
1985 strcat (buf, ", has entry point");
1986 e_flags &= ~ EF_ARM_HASENTRY;
1987 }
76da6bbe 1988
f3485b74
NC		 1989 /* Now handle EABI specific flags. */
1990 switch (eabi)
1991 {
1992 default:
2c71103e 1993 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 1994 if (e_flags)
1995 unknown = 1;
1996 break;
1997
1998 case EF_ARM_EABI_VER1:
a5bcd848 1999 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2000 while (e_flags)
2001 {
2002 unsigned flag;
76da6bbe 2003
f3485b74
NC		 2004 /* Process flags one bit at a time. */
2005 flag = e_flags & - e_flags;
2006 e_flags &= ~ flag;
76da6bbe 2007
f3485b74
NC		 2008 switch (flag)
2009 {
a5bcd848 2010 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2011 strcat (buf, ", sorted symbol tables");
2012 break;
76da6bbe 2013
f3485b74
NC		 2014 default:
2015 unknown = 1;
2016 break;
2017 }
2018 }
2019 break;
76da6bbe 2020
a5bcd848
PB		 2021 case EF_ARM_EABI_VER2:
2022 strcat (buf, ", Version2 EABI");
2023 while (e_flags)
2024 {
2025 unsigned flag;
2026
2027 /* Process flags one bit at a time. */
2028 flag = e_flags & - e_flags;
2029 e_flags &= ~ flag;
2030
2031 switch (flag)
2032 {
2033 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2034 strcat (buf, ", sorted symbol tables");
2035 break;
2036
2037 case EF_ARM_DYNSYMSUSESEGIDX:
2038 strcat (buf, ", dynamic symbols use segment index");
2039 break;
2040
2041 case EF_ARM_MAPSYMSFIRST:
2042 strcat (buf, ", mapping symbols precede others");
2043 break;
2044
2045 default:
2046 unknown = 1;
2047 break;
2048 }
2049 }
2050 break;
2051
d507cf36
PB		 2052 case EF_ARM_EABI_VER3:
2053 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2054 break;
2055
2056 case EF_ARM_EABI_VER4:
2057 strcat (buf, ", Version4 EABI");
3a4a14e9
PB		 2058 goto eabi;
2059
2060 case EF_ARM_EABI_VER5:
2061 strcat (buf, ", Version5 EABI");
2062 eabi:
d507cf36
PB		 2063 while (e_flags)
2064 {
2065 unsigned flag;
2066
2067 /* Process flags one bit at a time. */
2068 flag = e_flags & - e_flags;
2069 e_flags &= ~ flag;
2070
2071 switch (flag)
2072 {
2073 case EF_ARM_BE8:
2074 strcat (buf, ", BE8");
2075 break;
2076
2077 case EF_ARM_LE8:
2078 strcat (buf, ", LE8");
2079 break;
2080
2081 default:
2082 unknown = 1;
2083 break;
2084 }
2085 }
2086 break;
2087
f3485b74 2088 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2089 strcat (buf, ", GNU EABI");
f3485b74
NC		 2090 while (e_flags)
2091 {
2092 unsigned flag;
76da6bbe 2093
f3485b74
NC		 2094 /* Process flags one bit at a time. */
2095 flag = e_flags & - e_flags;
2096 e_flags &= ~ flag;
76da6bbe 2097
f3485b74
NC		 2098 switch (flag)
2099 {
a5bcd848 2100 case EF_ARM_INTERWORK:
f3485b74
NC		 2101 strcat (buf, ", interworking enabled");
2102 break;
76da6bbe 2103
a5bcd848 2104 case EF_ARM_APCS_26:
f3485b74
NC		 2105 strcat (buf, ", uses APCS/26");
2106 break;
76da6bbe 2107
a5bcd848 2108 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2109 strcat (buf, ", uses APCS/float");
2110 break;
76da6bbe 2111
a5bcd848 2112 case EF_ARM_PIC:
f3485b74
NC		 2113 strcat (buf, ", position independent");
2114 break;
76da6bbe 2115
a5bcd848 2116 case EF_ARM_ALIGN8:
f3485b74
NC		 2117 strcat (buf, ", 8 bit structure alignment");
2118 break;
76da6bbe 2119
a5bcd848 2120 case EF_ARM_NEW_ABI:
f3485b74
NC		 2121 strcat (buf, ", uses new ABI");
2122 break;
76da6bbe 2123
a5bcd848 2124 case EF_ARM_OLD_ABI:
f3485b74
NC		 2125 strcat (buf, ", uses old ABI");
2126 break;
76da6bbe 2127
a5bcd848 2128 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2129 strcat (buf, ", software FP");
2130 break;
76da6bbe 2131
90e01f86
ILT		 2132 case EF_ARM_VFP_FLOAT:
2133 strcat (buf, ", VFP");
2134 break;
2135
fde78edd
NC		 2136 case EF_ARM_MAVERICK_FLOAT:
2137 strcat (buf, ", Maverick FP");
2138 break;
2139
f3485b74
NC		 2140 default:
2141 unknown = 1;
2142 break;
2143 }
2144 }
2145 }
f3485b74
NC		 2146
2147 if (unknown)
2b692964 2148 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2149}
2150
252b5132 2151static char *
d3ba0551 2152get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2153{
b34976b6 2154 static char buf[1024];
252b5132
RH		 2155
2156 buf[0] = '\0';
76da6bbe 2157
252b5132
RH		 2158 if (e_flags)
2159 {
2160 switch (e_machine)
2161 {
2162 default:
2163 break;
2164
f3485b74
NC		 2165 case EM_ARM:
2166 decode_ARM_machine_flags (e_flags, buf);
2167 break;
76da6bbe 2168
781303ce
MF		 2169 case EM_BLACKFIN:
2170 if (e_flags & EF_BFIN_PIC)
2171 strcat (buf, ", PIC");
2172
2173 if (e_flags & EF_BFIN_FDPIC)
2174 strcat (buf, ", FDPIC");
2175
2176 if (e_flags & EF_BFIN_CODE_IN_L1)
2177 strcat (buf, ", code in L1");
2178
2179 if (e_flags & EF_BFIN_DATA_IN_L1)
2180 strcat (buf, ", data in L1");
2181
2182 break;
2183
ec2dfb42
AO		 2184 case EM_CYGNUS_FRV:
2185 switch (e_flags & EF_FRV_CPU_MASK)
2186 {
2187 case EF_FRV_CPU_GENERIC:
2188 break;
2189
2190 default:
2191 strcat (buf, ", fr???");
2192 break;
57346661 2193
ec2dfb42
AO		 2194 case EF_FRV_CPU_FR300:
2195 strcat (buf, ", fr300");
2196 break;
2197
2198 case EF_FRV_CPU_FR400:
2199 strcat (buf, ", fr400");
2200 break;
2201 case EF_FRV_CPU_FR405:
2202 strcat (buf, ", fr405");
2203 break;
2204
2205 case EF_FRV_CPU_FR450:
2206 strcat (buf, ", fr450");
2207 break;
2208
2209 case EF_FRV_CPU_FR500:
2210 strcat (buf, ", fr500");
2211 break;
2212 case EF_FRV_CPU_FR550:
2213 strcat (buf, ", fr550");
2214 break;
2215
2216 case EF_FRV_CPU_SIMPLE:
2217 strcat (buf, ", simple");
2218 break;
2219 case EF_FRV_CPU_TOMCAT:
2220 strcat (buf, ", tomcat");
2221 break;
2222 }
1c877e87 2223 break;
ec2dfb42 2224
53c7db4b 2225 case EM_68K:
425c6cb0 2226 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2227 strcat (buf, ", m68000");
425c6cb0 2228 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2229 strcat (buf, ", cpu32");
2230 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2231 strcat (buf, ", fido_a");
425c6cb0 2232 else
266abb8f 2233 {
2cf0635d
NC		 2234 char const * isa = _("unknown");
2235 char const * mac = _("unknown mac");
2236 char const * additional = NULL;
0112cd26 2237
c694fd50 2238 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2239 {
c694fd50 2240 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2241 isa = "A";
2242 additional = ", nodiv";
2243 break;
c694fd50 2244 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2245 isa = "A";
2246 break;
c694fd50 2247 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2248 isa = "A+";
2249 break;
c694fd50 2250 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2251 isa = "B";
2252 additional = ", nousp";
2253 break;
c694fd50 2254 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2255 isa = "B";
2256 break;
f608cd77
NS		 2257 case EF_M68K_CF_ISA_C:
2258 isa = "C";
2259 break;
2260 case EF_M68K_CF_ISA_C_NODIV:
2261 isa = "C";
2262 additional = ", nodiv";
2263 break;
266abb8f
NS		 2264 }
2265 strcat (buf, ", cf, isa ");
2266 strcat (buf, isa);
0b2e31dc
NS		 2267 if (additional)
2268 strcat (buf, additional);
c694fd50 2269 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2270 strcat (buf, ", float");
c694fd50 2271 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2272 {
2273 case 0:
2274 mac = NULL;
2275 break;
c694fd50 2276 case EF_M68K_CF_MAC:
266abb8f
NS		 2277 mac = "mac";
2278 break;
c694fd50 2279 case EF_M68K_CF_EMAC:
266abb8f
NS		 2280 mac = "emac";
2281 break;
f608cd77
NS		 2282 case EF_M68K_CF_EMAC_B:
2283 mac = "emac_b";
2284 break;
266abb8f
NS		 2285 }
2286 if (mac)
2287 {
2288 strcat (buf, ", ");
2289 strcat (buf, mac);
2290 }
266abb8f 2291 }
53c7db4b 2292 break;
33c63f9d 2293
252b5132
RH		 2294 case EM_PPC:
2295 if (e_flags & EF_PPC_EMB)
2296 strcat (buf, ", emb");
2297
2298 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2299 strcat (buf, _(", relocatable"));
252b5132
RH		 2300
2301 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 2302 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 2303 break;
2304
2b0337b0 2305 case EM_V850:
252b5132
RH		 2306 case EM_CYGNUS_V850:
2307 switch (e_flags & EF_V850_ARCH)
2308 {
1cd986c5
NC		 2309 case E_V850E2V3_ARCH:
2310 strcat (buf, ", v850e2v3");
2311 break;
2312 case E_V850E2_ARCH:
2313 strcat (buf, ", v850e2");
2314 break;
2315 case E_V850E1_ARCH:
2316 strcat (buf, ", v850e1");
8ad30312 2317 break;
252b5132
RH		 2318 case E_V850E_ARCH:
2319 strcat (buf, ", v850e");
2320 break;
252b5132
RH		 2321 case E_V850_ARCH:
2322 strcat (buf, ", v850");
2323 break;
2324 default:
2b692964 2325 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 2326 break;
2327 }
2328 break;
2329
2b0337b0 2330 case EM_M32R:
252b5132
RH		 2331 case EM_CYGNUS_M32R:
2332 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2333 strcat (buf, ", m32r");
252b5132
RH		 2334 break;
2335
2336 case EM_MIPS:
4fe85591 2337 case EM_MIPS_RS3_LE:
252b5132
RH		 2338 if (e_flags & EF_MIPS_NOREORDER)
2339 strcat (buf, ", noreorder");
2340
2341 if (e_flags & EF_MIPS_PIC)
2342 strcat (buf, ", pic");
2343
2344 if (e_flags & EF_MIPS_CPIC)
2345 strcat (buf, ", cpic");
2346
d1bdd336
TS		 2347 if (e_flags & EF_MIPS_UCODE)
2348 strcat (buf, ", ugen_reserved");
2349
252b5132
RH		 2350 if (e_flags & EF_MIPS_ABI2)
2351 strcat (buf, ", abi2");
2352
43521d43
TS		 2353 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2354 strcat (buf, ", odk first");
2355
a5d22d2a
TS		 2356 if (e_flags & EF_MIPS_32BITMODE)
2357 strcat (buf, ", 32bitmode");
2358
156c2f8b
NC		 2359 switch ((e_flags & EF_MIPS_MACH))
2360 {
2361 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2362 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2363 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 2364 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 2365 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2366 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2367 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2368 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 2369 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 2370 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 2371 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2372 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 2373 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 2374 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 2375 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
52b6b6b9 2376 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 2377 case 0:
2378 /* We simply ignore the field in this case to avoid confusion:
2379 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2380 extension. */
2381 break;
2b692964 2382 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 2383 }
43521d43
TS		 2384
2385 switch ((e_flags & EF_MIPS_ABI))
2386 {
2387 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2388 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2389 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2390 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2391 case 0:
2392 /* We simply ignore the field in this case to avoid confusion:
2393 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2394 This means it is likely to be an o32 file, but not for
2395 sure. */
2396 break;
2b692964 2397 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 2398 }
2399
2400 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2401 strcat (buf, ", mdmx");
2402
2403 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2404 strcat (buf, ", mips16");
2405
2406 switch ((e_flags & EF_MIPS_ARCH))
2407 {
2408 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2409 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2410 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2411 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2412 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2413 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 2414 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
43521d43 2415 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 2416 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2b692964 2417 default: strcat (buf, _(", unknown ISA")); break;
43521d43
TS		 2418 }
2419
8e45593f
NC		 2420 if (e_flags & EF_SH_PIC)
2421 strcat (buf, ", pic");
2422
2423 if (e_flags & EF_SH_FDPIC)
2424 strcat (buf, ", fdpic");
252b5132 2425 break;
351b4b40 2426
ccde1100
AO		 2427 case EM_SH:
2428 switch ((e_flags & EF_SH_MACH_MASK))
2429 {
2430 case EF_SH1: strcat (buf, ", sh1"); break;
2431 case EF_SH2: strcat (buf, ", sh2"); break;
2432 case EF_SH3: strcat (buf, ", sh3"); break;
2433 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2434 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2435 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2436 case EF_SH3E: strcat (buf, ", sh3e"); break;
2437 case EF_SH4: strcat (buf, ", sh4"); break;
2438 case EF_SH5: strcat (buf, ", sh5"); break;
2439 case EF_SH2E: strcat (buf, ", sh2e"); break;
2440 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 2441 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 2442 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2443 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 2444 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 2445 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2446 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2447 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2448 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2449 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2450 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 2451 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 2452 }
2453
2454 break;
57346661 2455
351b4b40
RH		 2456 case EM_SPARCV9:
2457 if (e_flags & EF_SPARC_32PLUS)
2458 strcat (buf, ", v8+");
2459
2460 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 2461 strcat (buf, ", ultrasparcI");
2462
2463 if (e_flags & EF_SPARC_SUN_US3)
2464 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 2465
2466 if (e_flags & EF_SPARC_HAL_R1)
2467 strcat (buf, ", halr1");
2468
2469 if (e_flags & EF_SPARC_LEDATA)
2470 strcat (buf, ", ledata");
2471
2472 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2473 strcat (buf, ", tso");
2474
2475 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2476 strcat (buf, ", pso");
2477
2478 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2479 strcat (buf, ", rmo");
2480 break;
7d466069 2481
103f02d3
UD		 2482 case EM_PARISC:
2483 switch (e_flags & EF_PARISC_ARCH)
2484 {
2485 case EFA_PARISC_1_0:
2486 strcpy (buf, ", PA-RISC 1.0");
2487 break;
2488 case EFA_PARISC_1_1:
2489 strcpy (buf, ", PA-RISC 1.1");
2490 break;
2491 case EFA_PARISC_2_0:
2492 strcpy (buf, ", PA-RISC 2.0");
2493 break;
2494 default:
2495 break;
2496 }
2497 if (e_flags & EF_PARISC_TRAPNIL)
2498 strcat (buf, ", trapnil");
2499 if (e_flags & EF_PARISC_EXT)
2500 strcat (buf, ", ext");
2501 if (e_flags & EF_PARISC_LSB)
2502 strcat (buf, ", lsb");
2503 if (e_flags & EF_PARISC_WIDE)
2504 strcat (buf, ", wide");
2505 if (e_flags & EF_PARISC_NO_KABP)
2506 strcat (buf, ", no kabp");
2507 if (e_flags & EF_PARISC_LAZYSWAP)
2508 strcat (buf, ", lazyswap");
30800947 2509 break;
76da6bbe 2510
7d466069 2511 case EM_PJ:
2b0337b0 2512 case EM_PJ_OLD:
7d466069
ILT		 2513 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2514 strcat (buf, ", new calling convention");
2515
2516 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2517 strcat (buf, ", gnu calling convention");
2518 break;
4d6ed7c8
NC		 2519
2520 case EM_IA_64:
2521 if ((e_flags & EF_IA_64_ABI64))
2522 strcat (buf, ", 64-bit");
2523 else
2524 strcat (buf, ", 32-bit");
2525 if ((e_flags & EF_IA_64_REDUCEDFP))
2526 strcat (buf, ", reduced fp model");
2527 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2528 strcat (buf, ", no function descriptors, constant gp");
2529 else if ((e_flags & EF_IA_64_CONS_GP))
2530 strcat (buf, ", constant gp");
2531 if ((e_flags & EF_IA_64_ABSOLUTE))
2532 strcat (buf, ", absolute");
28f997cf
TG		 2533 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2534 {
2535 if ((e_flags & EF_IA_64_VMS_LINKAGES))
2536 strcat (buf, ", vms_linkages");
2537 switch ((e_flags & EF_IA_64_VMS_COMCOD))
2538 {
2539 case EF_IA_64_VMS_COMCOD_SUCCESS:
2540 break;
2541 case EF_IA_64_VMS_COMCOD_WARNING:
2542 strcat (buf, ", warning");
2543 break;
2544 case EF_IA_64_VMS_COMCOD_ERROR:
2545 strcat (buf, ", error");
2546 break;
2547 case EF_IA_64_VMS_COMCOD_ABORT:
2548 strcat (buf, ", abort");
2549 break;
2550 default:
2551 abort ();
2552 }
2553 }
4d6ed7c8 2554 break;
179d3252
JT		 2555
2556 case EM_VAX:
2557 if ((e_flags & EF_VAX_NONPIC))
2558 strcat (buf, ", non-PIC");
2559 if ((e_flags & EF_VAX_DFLOAT))
2560 strcat (buf, ", D-Float");
2561 if ((e_flags & EF_VAX_GFLOAT))
2562 strcat (buf, ", G-Float");
2563 break;
c7927a3c
NC		 2564
2565 case EM_RX:
2566 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2567 strcat (buf, ", 64-bit doubles");
2568 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 2569 strcat (buf, ", dsp");
55786da2
AK		 2570
2571 case EM_S390:
2572 if (e_flags & EF_S390_HIGH_GPRS)
2573 strcat (buf, ", highgprs");
40b36596
JM		 2574
2575 case EM_TI_C6000:
2576 if ((e_flags & EF_C6000_REL))
2577 strcat (buf, ", relocatable module");
252b5132
RH		 2578 }
2579 }
2580
2581 return buf;
2582}
2583
252b5132 2584static const char *
d3ba0551
AM		 2585get_osabi_name (unsigned int osabi)
2586{
2587 static char buff[32];
2588
2589 switch (osabi)
2590 {
2591 case ELFOSABI_NONE: return "UNIX - System V";
2592 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2593 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
2594 case ELFOSABI_LINUX: return "UNIX - Linux";
2595 case ELFOSABI_HURD: return "GNU/Hurd";
2596 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2597 case ELFOSABI_AIX: return "UNIX - AIX";
2598 case ELFOSABI_IRIX: return "UNIX - IRIX";
2599 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2600 case ELFOSABI_TRU64: return "UNIX - TRU64";
2601 case ELFOSABI_MODESTO: return "Novell - Modesto";
2602 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2603 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2604 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 2605 case ELFOSABI_AROS: return "AROS";
11636f9e 2606 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 2607 default:
40b36596
JM		 2608 if (osabi >= 64)
2609 switch (elf_header.e_machine)
2610 {
2611 case EM_ARM:
2612 switch (osabi)
2613 {
2614 case ELFOSABI_ARM: return "ARM";
2615 default:
2616 break;
2617 }
2618 break;
2619
2620 case EM_MSP430:
2621 case EM_MSP430_OLD:
2622 switch (osabi)
2623 {
2624 case ELFOSABI_STANDALONE: return _("Standalone App");
2625 default:
2626 break;
2627 }
2628 break;
2629
2630 case EM_TI_C6000:
2631 switch (osabi)
2632 {
2633 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
2634 case ELFOSABI_C6000_LINUX: return "Linux C6000";
2635 default:
2636 break;
2637 }
2638 break;
2639
2640 default:
2641 break;
2642 }
e9e44622 2643 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 2644 return buff;
2645 }
2646}
2647
b294bdf8
MM		 2648static const char *
2649get_arm_segment_type (unsigned long type)
2650{
2651 switch (type)
2652 {
2653 case PT_ARM_EXIDX:
2654 return "EXIDX";
2655 default:
2656 break;
2657 }
2658
2659 return NULL;
2660}
2661
d3ba0551
AM		 2662static const char *
2663get_mips_segment_type (unsigned long type)
252b5132
RH		 2664{
2665 switch (type)
2666 {
2667 case PT_MIPS_REGINFO:
2668 return "REGINFO";
2669 case PT_MIPS_RTPROC:
2670 return "RTPROC";
2671 case PT_MIPS_OPTIONS:
2672 return "OPTIONS";
2673 default:
2674 break;
2675 }
2676
2677 return NULL;
2678}
2679
103f02d3 2680static const char *
d3ba0551 2681get_parisc_segment_type (unsigned long type)
103f02d3
UD		 2682{
2683 switch (type)
2684 {
2685 case PT_HP_TLS: return "HP_TLS";
2686 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2687 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2688 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2689 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2690 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2691 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2692 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2693 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2694 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2695 case PT_HP_PARALLEL: return "HP_PARALLEL";
2696 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 2697 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
2698 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
2699 case PT_HP_STACK: return "HP_STACK";
2700 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 2701 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2702 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 2703 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 2704 default:
2705 break;
2706 }
2707
2708 return NULL;
2709}
2710
4d6ed7c8 2711static const char *
d3ba0551 2712get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 2713{
2714 switch (type)
2715 {
2716 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2717 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 2718 case PT_HP_TLS: return "HP_TLS";
2719 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2720 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2721 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 2722 default:
2723 break;
2724 }
2725
2726 return NULL;
2727}
2728
40b36596
JM		 2729static const char *
2730get_tic6x_segment_type (unsigned long type)
2731{
2732 switch (type)
2733 {
2734 case PT_C6000_PHATTR: return "C6000_PHATTR";
2735 default:
2736 break;
2737 }
2738
2739 return NULL;
2740}
2741
252b5132 2742static const char *
d3ba0551 2743get_segment_type (unsigned long p_type)
252b5132 2744{
b34976b6 2745 static char buff[32];
252b5132
RH		 2746
2747 switch (p_type)
2748 {
b34976b6
AM		 2749 case PT_NULL: return "NULL";
2750 case PT_LOAD: return "LOAD";
252b5132 2751 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 2752 case PT_INTERP: return "INTERP";
2753 case PT_NOTE: return "NOTE";
2754 case PT_SHLIB: return "SHLIB";
2755 case PT_PHDR: return "PHDR";
13ae64f3 2756 case PT_TLS: return "TLS";
252b5132 2757
65765700
JJ		 2758 case PT_GNU_EH_FRAME:
2759 return "GNU_EH_FRAME";
2b05f1b7 2760 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 2761 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 2762
252b5132
RH		 2763 default:
2764 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2765 {
2cf0635d 2766 const char * result;
103f02d3 2767
252b5132
RH		 2768 switch (elf_header.e_machine)
2769 {
b294bdf8
MM		 2770 case EM_ARM:
2771 result = get_arm_segment_type (p_type);
2772 break;
252b5132 2773 case EM_MIPS:
4fe85591 2774 case EM_MIPS_RS3_LE:
252b5132
RH		 2775 result = get_mips_segment_type (p_type);
2776 break;
103f02d3
UD		 2777 case EM_PARISC:
2778 result = get_parisc_segment_type (p_type);
2779 break;
4d6ed7c8
NC		 2780 case EM_IA_64:
2781 result = get_ia64_segment_type (p_type);
2782 break;
40b36596
JM		 2783 case EM_TI_C6000:
2784 result = get_tic6x_segment_type (p_type);
2785 break;
252b5132
RH		 2786 default:
2787 result = NULL;
2788 break;
2789 }
103f02d3 2790
252b5132
RH		 2791 if (result != NULL)
2792 return result;
103f02d3 2793
252b5132
RH		 2794 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2795 }
2796 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 2797 {
2cf0635d 2798 const char * result;
103f02d3
UD		 2799
2800 switch (elf_header.e_machine)
2801 {
2802 case EM_PARISC:
2803 result = get_parisc_segment_type (p_type);
2804 break;
00428cca
AM		 2805 case EM_IA_64:
2806 result = get_ia64_segment_type (p_type);
2807 break;
103f02d3
UD		 2808 default:
2809 result = NULL;
2810 break;
2811 }
2812
2813 if (result != NULL)
2814 return result;
2815
2816 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2817 }
252b5132 2818 else
e9e44622 2819 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 2820
2821 return buff;
2822 }
2823}
2824
2825static const char *
d3ba0551 2826get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 2827{
2828 switch (sh_type)
2829 {
b34976b6
AM		 2830 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
2831 case SHT_MIPS_MSYM: return "MIPS_MSYM";
2832 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
2833 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
2834 case SHT_MIPS_UCODE: return "MIPS_UCODE";
2835 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
2836 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
2837 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
2838 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
2839 case SHT_MIPS_RELD: return "MIPS_RELD";
2840 case SHT_MIPS_IFACE: return "MIPS_IFACE";
2841 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
2842 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
2843 case SHT_MIPS_SHDR: return "MIPS_SHDR";
2844 case SHT_MIPS_FDESC: return "MIPS_FDESC";
2845 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
2846 case SHT_MIPS_DENSE: return "MIPS_DENSE";
2847 case SHT_MIPS_PDESC: return "MIPS_PDESC";
2848 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
2849 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
2850 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
2851 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
2852 case SHT_MIPS_LINE: return "MIPS_LINE";
2853 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
2854 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
2855 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
2856 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
2857 case SHT_MIPS_DWARF: return "MIPS_DWARF";
2858 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
2859 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
2860 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
2861 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
2862 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
2863 case SHT_MIPS_XLATE: return "MIPS_XLATE";
2864 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
2865 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
2866 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
2867 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132
RH		 2868 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2869 default:
2870 break;
2871 }
2872 return NULL;
2873}
2874
103f02d3 2875static const char *
d3ba0551 2876get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 2877{
2878 switch (sh_type)
2879 {
2880 case SHT_PARISC_EXT: return "PARISC_EXT";
2881 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
2882 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 2883 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
2884 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
2885 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 2886 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 2887 default:
2888 break;
2889 }
2890 return NULL;
2891}
2892
4d6ed7c8 2893static const char *
d3ba0551 2894get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 2895{
18bd398b 2896 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 2897 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
2898 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 2899
4d6ed7c8
NC		 2900 switch (sh_type)
2901 {
148b93f2
NC		 2902 case SHT_IA_64_EXT: return "IA_64_EXT";
2903 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
2904 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
2905 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
2906 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
2907 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
2908 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
2909 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
2910 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
2911 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 2912 default:
2913 break;
2914 }
2915 return NULL;
2916}
2917
d2b2c203
DJ		 2918static const char *
2919get_x86_64_section_type_name (unsigned int sh_type)
2920{
2921 switch (sh_type)
2922 {
2923 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
2924 default:
2925 break;
2926 }
2927 return NULL;
2928}
2929
40a18ebd
NC		 2930static const char *
2931get_arm_section_type_name (unsigned int sh_type)
2932{
2933 switch (sh_type)
2934 {
7f6fed87
NC		 2935 case SHT_ARM_EXIDX: return "ARM_EXIDX";
2936 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
2937 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
2938 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
2939 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 2940 default:
2941 break;
2942 }
2943 return NULL;
2944}
2945
40b36596
JM		 2946static const char *
2947get_tic6x_section_type_name (unsigned int sh_type)
2948{
2949 switch (sh_type)
2950 {
2951 case SHT_C6000_UNWIND:
2952 return "C6000_UNWIND";
2953 case SHT_C6000_PREEMPTMAP:
2954 return "C6000_PREEMPTMAP";
2955 case SHT_C6000_ATTRIBUTES:
2956 return "C6000_ATTRIBUTES";
2957 case SHT_TI_ICODE:
2958 return "TI_ICODE";
2959 case SHT_TI_XREF:
2960 return "TI_XREF";
2961 case SHT_TI_HANDLER:
2962 return "TI_HANDLER";
2963 case SHT_TI_INITINFO:
2964 return "TI_INITINFO";
2965 case SHT_TI_PHATTRS:
2966 return "TI_PHATTRS";
2967 default:
2968 break;
2969 }
2970 return NULL;
2971}
2972
252b5132 2973static const char *
d3ba0551 2974get_section_type_name (unsigned int sh_type)
252b5132 2975{
b34976b6 2976 static char buff[32];
252b5132
RH		 2977
2978 switch (sh_type)
2979 {
2980 case SHT_NULL: return "NULL";
2981 case SHT_PROGBITS: return "PROGBITS";
2982 case SHT_SYMTAB: return "SYMTAB";
2983 case SHT_STRTAB: return "STRTAB";
2984 case SHT_RELA: return "RELA";
2985 case SHT_HASH: return "HASH";
2986 case SHT_DYNAMIC: return "DYNAMIC";
2987 case SHT_NOTE: return "NOTE";
2988 case SHT_NOBITS: return "NOBITS";
2989 case SHT_REL: return "REL";
2990 case SHT_SHLIB: return "SHLIB";
2991 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 2992 case SHT_INIT_ARRAY: return "INIT_ARRAY";
2993 case SHT_FINI_ARRAY: return "FINI_ARRAY";
2994 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 2995 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 2996 case SHT_GROUP: return "GROUP";
2997 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 2998 case SHT_GNU_verdef: return "VERDEF";
2999 case SHT_GNU_verneed: return "VERNEED";
3000 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3001 case 0x6ffffff0: return "VERSYM";
3002 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3003 case 0x7ffffffd: return "AUXILIARY";
3004 case 0x7fffffff: return "FILTER";
047b2264 3005 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3006
3007 default:
3008 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3009 {
2cf0635d 3010 const char * result;
252b5132
RH		 3011
3012 switch (elf_header.e_machine)
3013 {
3014 case EM_MIPS:
4fe85591 3015 case EM_MIPS_RS3_LE:
252b5132
RH		 3016 result = get_mips_section_type_name (sh_type);
3017 break;
103f02d3
UD		 3018 case EM_PARISC:
3019 result = get_parisc_section_type_name (sh_type);
3020 break;
4d6ed7c8
NC		 3021 case EM_IA_64:
3022 result = get_ia64_section_type_name (sh_type);
3023 break;
d2b2c203 3024 case EM_X86_64:
8a9036a4 3025 case EM_L1OM:
d2b2c203
DJ		 3026 result = get_x86_64_section_type_name (sh_type);
3027 break;
40a18ebd
NC		 3028 case EM_ARM:
3029 result = get_arm_section_type_name (sh_type);
3030 break;
40b36596
JM		 3031 case EM_TI_C6000:
3032 result = get_tic6x_section_type_name (sh_type);
3033 break;
252b5132
RH		 3034 default:
3035 result = NULL;
3036 break;
3037 }
3038
3039 if (result != NULL)
3040 return result;
3041
c91d0dfb 3042 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3043 }
3044 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3045 {
2cf0635d 3046 const char * result;
148b93f2
NC		 3047
3048 switch (elf_header.e_machine)
3049 {
3050 case EM_IA_64:
3051 result = get_ia64_section_type_name (sh_type);
3052 break;
3053 default:
3054 result = NULL;
3055 break;
3056 }
3057
3058 if (result != NULL)
3059 return result;
3060
3061 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3062 }
252b5132 3063 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
c91d0dfb 3064 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
252b5132 3065 else
e9e44622 3066 snprintf (buff, sizeof (buff), _("<unknown>: %x"), sh_type);
103f02d3 3067
252b5132
RH		 3068 return buff;
3069 }
3070}
3071
2979dc34 3072#define OPTION_DEBUG_DUMP 512
2c610e4b 3073#define OPTION_DYN_SYMS 513
2979dc34 3074
85b1c36d 3075static struct option options[] =
252b5132 3076{
b34976b6 3077 {"all", no_argument, 0, 'a'},
252b5132
RH		 3078 {"file-header", no_argument, 0, 'h'},
3079 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3080 {"headers", no_argument, 0, 'e'},
3081 {"histogram", no_argument, 0, 'I'},
3082 {"segments", no_argument, 0, 'l'},
3083 {"sections", no_argument, 0, 'S'},
252b5132 3084 {"section-headers", no_argument, 0, 'S'},
f5842774 3085 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3086 {"section-details", no_argument, 0, 't'},
595cf52e 3087 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3088 {"symbols", no_argument, 0, 's'},
3089 {"syms", no_argument, 0, 's'},
2c610e4b 3090 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3091 {"relocs", no_argument, 0, 'r'},
3092 {"notes", no_argument, 0, 'n'},
3093 {"dynamic", no_argument, 0, 'd'},
a952a375 3094 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3095 {"version-info", no_argument, 0, 'V'},
3096 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3097 {"unwind", no_argument, 0, 'u'},
4145f1d5 3098 {"archive-index", no_argument, 0, 'c'},
b34976b6 3099 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3100 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3101 {"string-dump", required_argument, 0, 'p'},
252b5132
RH		 3102#ifdef SUPPORT_DISASSEMBLY
3103 {"instruction-dump", required_argument, 0, 'i'},
3104#endif
cf13d699 3105 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3106
b34976b6
AM		 3107 {"version", no_argument, 0, 'v'},
3108 {"wide", no_argument, 0, 'W'},
3109 {"help", no_argument, 0, 'H'},
3110 {0, no_argument, 0, 0}
252b5132
RH		 3111};
3112
3113static void
2cf0635d 3114usage (FILE * stream)
252b5132 3115{
92f01d61
JM		 3116 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3117 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3118 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3119 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3120 -h --file-header Display the ELF file header\n\
3121 -l --program-headers Display the program headers\n\
3122 --segments An alias for --program-headers\n\
3123 -S --section-headers Display the sections' header\n\
3124 --sections An alias for --section-headers\n\
f5842774 3125 -g --section-groups Display the section groups\n\
5477e8a0 3126 -t --section-details Display the section details\n\
8b53311e
NC		 3127 -e --headers Equivalent to: -h -l -S\n\
3128 -s --syms Display the symbol table\n\
3f08eb35 3129 --symbols An alias for --syms\n\
2c610e4b 3130 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3131 -n --notes Display the core notes (if present)\n\
3132 -r --relocs Display the relocations (if present)\n\
3133 -u --unwind Display the unwind info (if present)\n\
b2d38a17 3134 -d --dynamic Display the dynamic section (if present)\n\
8b53311e
NC		 3135 -V --version-info Display the version sections (if present)\n\
3136 -A --arch-specific Display architecture specific information (if any).\n\
4145f1d5 3137 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 3138 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 3139 -x --hex-dump=<number|name>\n\
3140 Dump the contents of section <number|name> as bytes\n\
3141 -p --string-dump=<number|name>\n\
3142 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 3143 -R --relocated-dump=<number|name>\n\
3144 Dump the contents of section <number|name> as relocated bytes\n\
f9f0e732 3145 -w[lLiaprmfFsoRt] or\n\
1ed06042 3146 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 3147 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
5bbdf3d5 3148 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges]\n\
8b53311e 3149 Display the contents of DWARF2 debug sections\n"));
252b5132 3150#ifdef SUPPORT_DISASSEMBLY
92f01d61 3151 fprintf (stream, _("\
09c11c86
NC		 3152 -i --instruction-dump=<number|name>\n\
3153 Disassemble the contents of section <number|name>\n"));
252b5132 3154#endif
92f01d61 3155 fprintf (stream, _("\
8b53311e
NC		 3156 -I --histogram Display histogram of bucket list lengths\n\
3157 -W --wide Allow output width to exceed 80 characters\n\
07012eee 3158 @<file> Read options from <file>\n\
8b53311e
NC		 3159 -H --help Display this information\n\
3160 -v --version Display the version number of readelf\n"));
1118d252 3161
92f01d61
JM		 3162 if (REPORT_BUGS_TO[0] && stream == stdout)
3163 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 3164
92f01d61 3165 exit (stream == stdout ? 0 : 1);
252b5132
RH		 3166}
3167
18bd398b
NC		 3168/* Record the fact that the user wants the contents of section number
3169 SECTION to be displayed using the method(s) encoded as flags bits
3170 in TYPE. Note, TYPE can be zero if we are creating the array for
3171 the first time. */
3172
252b5132 3173static void
09c11c86 3174request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 3175{
3176 if (section >= num_dump_sects)
3177 {
2cf0635d 3178 dump_type * new_dump_sects;
252b5132 3179
3f5e193b
NC		 3180 new_dump_sects = (dump_type *) calloc (section + 1,
3181 sizeof (* dump_sects));
252b5132
RH		 3182
3183 if (new_dump_sects == NULL)
591a748a 3184 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 3185 else
3186 {
3187 /* Copy current flag settings. */
09c11c86 3188 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 3189
3190 free (dump_sects);
3191
3192 dump_sects = new_dump_sects;
3193 num_dump_sects = section + 1;
3194 }
3195 }
3196
3197 if (dump_sects)
b34976b6 3198 dump_sects[section] |= type;
252b5132
RH		 3199
3200 return;
3201}
3202
aef1f6d0
DJ		 3203/* Request a dump by section name. */
3204
3205static void
2cf0635d 3206request_dump_byname (const char * section, dump_type type)
aef1f6d0 3207{
2cf0635d 3208 struct dump_list_entry * new_request;
aef1f6d0 3209
3f5e193b
NC		 3210 new_request = (struct dump_list_entry *)
3211 malloc (sizeof (struct dump_list_entry));
aef1f6d0 3212 if (!new_request)
591a748a 3213 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3214
3215 new_request->name = strdup (section);
3216 if (!new_request->name)
591a748a 3217 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3218
3219 new_request->type = type;
3220
3221 new_request->next = dump_sects_byname;
3222 dump_sects_byname = new_request;
3223}
3224
cf13d699
NC		 3225static inline void
3226request_dump (dump_type type)
3227{
3228 int section;
3229 char * cp;
3230
3231 do_dump++;
3232 section = strtoul (optarg, & cp, 0);
3233
3234 if (! *cp && section >= 0)
3235 request_dump_bynumber (section, type);
3236 else
3237 request_dump_byname (optarg, type);
3238}
3239
3240
252b5132 3241static void
2cf0635d 3242parse_args (int argc, char ** argv)
252b5132
RH		 3243{
3244 int c;
3245
3246 if (argc < 2)
92f01d61 3247 usage (stderr);
252b5132
RH		 3248
3249 while ((c = getopt_long
cf13d699 3250 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
252b5132 3251 {
252b5132
RH		 3252 switch (c)
3253 {
3254 case 0:
3255 /* Long options. */
3256 break;
3257 case 'H':
92f01d61 3258 usage (stdout);
252b5132
RH		 3259 break;
3260
3261 case 'a':
b34976b6
AM		 3262 do_syms++;
3263 do_reloc++;
3264 do_unwind++;
3265 do_dynamic++;
3266 do_header++;
3267 do_sections++;
f5842774 3268 do_section_groups++;
b34976b6
AM		 3269 do_segments++;
3270 do_version++;
3271 do_histogram++;
3272 do_arch++;
3273 do_notes++;
252b5132 3274 break;
f5842774
L		 3275 case 'g':
3276 do_section_groups++;
3277 break;
5477e8a0 3278 case 't':
595cf52e 3279 case 'N':
5477e8a0
L		 3280 do_sections++;
3281 do_section_details++;
595cf52e 3282 break;
252b5132 3283 case 'e':
b34976b6
AM		 3284 do_header++;
3285 do_sections++;
3286 do_segments++;
252b5132 3287 break;
a952a375 3288 case 'A':
b34976b6 3289 do_arch++;
a952a375 3290 break;
252b5132 3291 case 'D':
b34976b6 3292 do_using_dynamic++;
252b5132
RH		 3293 break;
3294 case 'r':
b34976b6 3295 do_reloc++;
252b5132 3296 break;
4d6ed7c8 3297 case 'u':
b34976b6 3298 do_unwind++;
4d6ed7c8 3299 break;
252b5132 3300 case 'h':
b34976b6 3301 do_header++;
252b5132
RH		 3302 break;
3303 case 'l':
b34976b6 3304 do_segments++;
252b5132
RH		 3305 break;
3306 case 's':
b34976b6 3307 do_syms++;
252b5132
RH		 3308 break;
3309 case 'S':
b34976b6 3310 do_sections++;
252b5132
RH		 3311 break;
3312 case 'd':
b34976b6 3313 do_dynamic++;
252b5132 3314 break;
a952a375 3315 case 'I':
b34976b6 3316 do_histogram++;
a952a375 3317 break;
779fe533 3318 case 'n':
b34976b6 3319 do_notes++;
779fe533 3320 break;
4145f1d5
NC		 3321 case 'c':
3322 do_archive_index++;
3323 break;
252b5132 3324 case 'x':
cf13d699 3325 request_dump (HEX_DUMP);
aef1f6d0 3326 break;
09c11c86 3327 case 'p':
cf13d699
NC		 3328 request_dump (STRING_DUMP);
3329 break;
3330 case 'R':
3331 request_dump (RELOC_DUMP);
09c11c86 3332 break;
252b5132 3333 case 'w':
b34976b6 3334 do_dump++;
252b5132 3335 if (optarg == 0)
613ff48b
CC		 3336 {
3337 do_debugging = 1;
3338 dwarf_select_sections_all ();
3339 }
252b5132
RH		 3340 else
3341 {
3342 do_debugging = 0;
4cb93e3b 3343 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 3344 }
3345 break;
2979dc34 3346 case OPTION_DEBUG_DUMP:
b34976b6 3347 do_dump++;
2979dc34
JJ		 3348 if (optarg == 0)
3349 do_debugging = 1;
3350 else
3351 {
2979dc34 3352 do_debugging = 0;
4cb93e3b 3353 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 3354 }
3355 break;
2c610e4b
L		 3356 case OPTION_DYN_SYMS:
3357 do_dyn_syms++;
3358 break;
252b5132
RH		 3359#ifdef SUPPORT_DISASSEMBLY
3360 case 'i':
cf13d699
NC		 3361 request_dump (DISASS_DUMP);
3362 break;
252b5132
RH		 3363#endif
3364 case 'v':
3365 print_version (program_name);
3366 break;
3367 case 'V':
b34976b6 3368 do_version++;
252b5132 3369 break;
d974e256 3370 case 'W':
b34976b6 3371 do_wide++;
d974e256 3372 break;
252b5132 3373 default:
252b5132
RH		 3374 /* xgettext:c-format */
3375 error (_("Invalid option '-%c'\n"), c);
3376 /* Drop through. */
3377 case '?':
92f01d61 3378 usage (stderr);
252b5132
RH		 3379 }
3380 }
3381
4d6ed7c8 3382 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 3383 && !do_segments && !do_header && !do_dump && !do_version
f5842774 3384 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 3385 && !do_section_groups && !do_archive_index
3386 && !do_dyn_syms)
92f01d61 3387 usage (stderr);
252b5132
RH		 3388 else if (argc < 3)
3389 {
3390 warn (_("Nothing to do.\n"));
92f01d61 3391 usage (stderr);
252b5132
RH		 3392 }
3393}
3394
3395static const char *
d3ba0551 3396get_elf_class (unsigned int elf_class)
252b5132 3397{
b34976b6 3398 static char buff[32];
103f02d3 3399
252b5132
RH		 3400 switch (elf_class)
3401 {
3402 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 3403 case ELFCLASS32: return "ELF32";
3404 case ELFCLASS64: return "ELF64";
ab5e7794 3405 default:
e9e44622 3406 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 3407 return buff;
252b5132
RH		 3408 }
3409}
3410
3411static const char *
d3ba0551 3412get_data_encoding (unsigned int encoding)
252b5132 3413{
b34976b6 3414 static char buff[32];
103f02d3 3415
252b5132
RH		 3416 switch (encoding)
3417 {
3418 case ELFDATANONE: return _("none");
33c63f9d
CM		 3419 case ELFDATA2LSB: return _("2's complement, little endian");
3420 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 3421 default:
e9e44622 3422 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 3423 return buff;
252b5132
RH		 3424 }
3425}
3426
252b5132 3427/* Decode the data held in 'elf_header'. */
ee42cf8c 3428
252b5132 3429static int
d3ba0551 3430process_file_header (void)
252b5132 3431{
b34976b6
AM		 3432 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3433 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3434 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3435 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 3436 {
3437 error
3438 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3439 return 0;
3440 }
3441
2dc4cec1
L		 3442 init_dwarf_regnames (elf_header.e_machine);
3443
252b5132
RH		 3444 if (do_header)
3445 {
3446 int i;
3447
3448 printf (_("ELF Header:\n"));
3449 printf (_(" Magic: "));
b34976b6
AM		 3450 for (i = 0; i < EI_NIDENT; i++)
3451 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 3452 printf ("\n");
3453 printf (_(" Class: %s\n"),
b34976b6 3454 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 3455 printf (_(" Data: %s\n"),
b34976b6 3456 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 3457 printf (_(" Version: %d %s\n"),
b34976b6
AM		 3458 elf_header.e_ident[EI_VERSION],
3459 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 3460 ? "(current)"
b34976b6 3461 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 3462 ? _("<unknown: %lx>")
789be9f7 3463 : "")));
252b5132 3464 printf (_(" OS/ABI: %s\n"),
b34976b6 3465 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 3466 printf (_(" ABI Version: %d\n"),
b34976b6 3467 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 3468 printf (_(" Type: %s\n"),
3469 get_file_type (elf_header.e_type));
3470 printf (_(" Machine: %s\n"),
3471 get_machine_name (elf_header.e_machine));
3472 printf (_(" Version: 0x%lx\n"),
3473 (unsigned long) elf_header.e_version);
76da6bbe 3474
f7a99963
NC		 3475 printf (_(" Entry point address: "));
3476 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3477 printf (_("\n Start of program headers: "));
3478 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3479 printf (_(" (bytes into file)\n Start of section headers: "));
3480 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3481 printf (_(" (bytes into file)\n"));
76da6bbe 3482
252b5132
RH		 3483 printf (_(" Flags: 0x%lx%s\n"),
3484 (unsigned long) elf_header.e_flags,
3485 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3486 printf (_(" Size of this header: %ld (bytes)\n"),
3487 (long) elf_header.e_ehsize);
3488 printf (_(" Size of program headers: %ld (bytes)\n"),
3489 (long) elf_header.e_phentsize);
2046a35d 3490 printf (_(" Number of program headers: %ld"),
252b5132 3491 (long) elf_header.e_phnum);
2046a35d
AM		 3492 if (section_headers != NULL
3493 && elf_header.e_phnum == PN_XNUM
3494 && section_headers[0].sh_info != 0)
cc5914eb 3495 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 3496 putc ('\n', stdout);
252b5132
RH		 3497 printf (_(" Size of section headers: %ld (bytes)\n"),
3498 (long) elf_header.e_shentsize);
560f3c1c 3499 printf (_(" Number of section headers: %ld"),
252b5132 3500 (long) elf_header.e_shnum);
4fbb74a6 3501 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 3502 printf (" (%ld)", (long) section_headers[0].sh_size);
3503 putc ('\n', stdout);
3504 printf (_(" Section header string table index: %ld"),
252b5132 3505 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 3506 if (section_headers != NULL
3507 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 3508 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 3509 else if (elf_header.e_shstrndx != SHN_UNDEF
3510 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 3511 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 3512 putc ('\n', stdout);
3513 }
3514
3515 if (section_headers != NULL)
3516 {
2046a35d
AM		 3517 if (elf_header.e_phnum == PN_XNUM
3518 && section_headers[0].sh_info != 0)
3519 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 3520 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 3521 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 3522 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 3523 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 3524 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 3525 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 3526 free (section_headers);
3527 section_headers = NULL;
252b5132 3528 }
103f02d3 3529
9ea033b2
NC		 3530 return 1;
3531}
3532
252b5132 3533
9ea033b2 3534static int
91d6fa6a 3535get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3536{
2cf0635d
NC		 3537 Elf32_External_Phdr * phdrs;
3538 Elf32_External_Phdr * external;
3539 Elf_Internal_Phdr * internal;
b34976b6 3540 unsigned int i;
103f02d3 3541
3f5e193b
NC		 3542 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3543 elf_header.e_phentsize,
3544 elf_header.e_phnum,
3545 _("program headers"));
a6e9f9df
AM		 3546 if (!phdrs)
3547 return 0;
9ea033b2 3548
91d6fa6a 3549 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3550 i < elf_header.e_phnum;
b34976b6 3551 i++, internal++, external++)
252b5132 3552 {
9ea033b2
NC		 3553 internal->p_type = BYTE_GET (external->p_type);
3554 internal->p_offset = BYTE_GET (external->p_offset);
3555 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3556 internal->p_paddr = BYTE_GET (external->p_paddr);
3557 internal->p_filesz = BYTE_GET (external->p_filesz);
3558 internal->p_memsz = BYTE_GET (external->p_memsz);
3559 internal->p_flags = BYTE_GET (external->p_flags);
3560 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 3561 }
3562
9ea033b2
NC		 3563 free (phdrs);
3564
252b5132
RH		 3565 return 1;
3566}
3567
9ea033b2 3568static int
91d6fa6a 3569get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3570{
2cf0635d
NC		 3571 Elf64_External_Phdr * phdrs;
3572 Elf64_External_Phdr * external;
3573 Elf_Internal_Phdr * internal;
b34976b6 3574 unsigned int i;
103f02d3 3575
3f5e193b
NC		 3576 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3577 elf_header.e_phentsize,
3578 elf_header.e_phnum,
3579 _("program headers"));
a6e9f9df
AM		 3580 if (!phdrs)
3581 return 0;
9ea033b2 3582
91d6fa6a 3583 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3584 i < elf_header.e_phnum;
b34976b6 3585 i++, internal++, external++)
9ea033b2
NC		 3586 {
3587 internal->p_type = BYTE_GET (external->p_type);
3588 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 3589 internal->p_offset = BYTE_GET (external->p_offset);
3590 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3591 internal->p_paddr = BYTE_GET (external->p_paddr);
3592 internal->p_filesz = BYTE_GET (external->p_filesz);
3593 internal->p_memsz = BYTE_GET (external->p_memsz);
3594 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 3595 }
3596
3597 free (phdrs);
3598
3599 return 1;
3600}
252b5132 3601
d93f0186
NC		 3602/* Returns 1 if the program headers were read into `program_headers'. */
3603
3604static int
2cf0635d 3605get_program_headers (FILE * file)
d93f0186 3606{
2cf0635d 3607 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 3608
3609 /* Check cache of prior read. */
3610 if (program_headers != NULL)
3611 return 1;
3612
3f5e193b
NC		 3613 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3614 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 3615
3616 if (phdrs == NULL)
3617 {
3618 error (_("Out of memory\n"));
3619 return 0;
3620 }
3621
3622 if (is_32bit_elf
3623 ? get_32bit_program_headers (file, phdrs)
3624 : get_64bit_program_headers (file, phdrs))
3625 {
3626 program_headers = phdrs;
3627 return 1;
3628 }
3629
3630 free (phdrs);
3631 return 0;
3632}
3633
2f62977e
NC		 3634/* Returns 1 if the program headers were loaded. */
3635
252b5132 3636static int
2cf0635d 3637process_program_headers (FILE * file)
252b5132 3638{
2cf0635d 3639 Elf_Internal_Phdr * segment;
b34976b6 3640 unsigned int i;
252b5132
RH		 3641
3642 if (elf_header.e_phnum == 0)
3643 {
82f2dbf7
NC		 3644 /* PR binutils/12467. */
3645 if (elf_header.e_phoff != 0)
3646 warn (_("possibly corrupt ELF header - it has a non-zero program"
3647 " header offset, but no program headers"));
3648 else if (do_segments)
252b5132 3649 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 3650 return 0;
252b5132
RH		 3651 }
3652
3653 if (do_segments && !do_header)
3654 {
f7a99963
NC		 3655 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3656 printf (_("Entry point "));
3657 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3658 printf (_("\nThere are %d program headers, starting at offset "),
3659 elf_header.e_phnum);
3660 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3661 printf ("\n");
252b5132
RH		 3662 }
3663
d93f0186 3664 if (! get_program_headers (file))
252b5132 3665 return 0;
103f02d3 3666
252b5132
RH		 3667 if (do_segments)
3668 {
3a1a2036
NC		 3669 if (elf_header.e_phnum > 1)
3670 printf (_("\nProgram Headers:\n"));
3671 else
3672 printf (_("\nProgram Headers:\n"));
76da6bbe 3673
f7a99963
NC		 3674 if (is_32bit_elf)
3675 printf
3676 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 3677 else if (do_wide)
3678 printf
3679 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 3680 else
3681 {
3682 printf
3683 (_(" Type Offset VirtAddr PhysAddr\n"));
3684 printf
3685 (_(" FileSiz MemSiz Flags Align\n"));
3686 }
252b5132
RH		 3687 }
3688
252b5132 3689 dynamic_addr = 0;
1b228002 3690 dynamic_size = 0;
252b5132
RH		 3691
3692 for (i = 0, segment = program_headers;
3693 i < elf_header.e_phnum;
b34976b6 3694 i++, segment++)
252b5132
RH		 3695 {
3696 if (do_segments)
3697 {
103f02d3 3698 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 3699
3700 if (is_32bit_elf)
3701 {
3702 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3703 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3704 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3705 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3706 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3707 printf ("%c%c%c ",
3708 (segment->p_flags & PF_R ? 'R' : ' '),
3709 (segment->p_flags & PF_W ? 'W' : ' '),
3710 (segment->p_flags & PF_X ? 'E' : ' '));
3711 printf ("%#lx", (unsigned long) segment->p_align);
3712 }
d974e256
JJ		 3713 else if (do_wide)
3714 {
3715 if ((unsigned long) segment->p_offset == segment->p_offset)
3716 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3717 else
3718 {
3719 print_vma (segment->p_offset, FULL_HEX);
3720 putchar (' ');
3721 }
3722
3723 print_vma (segment->p_vaddr, FULL_HEX);
3724 putchar (' ');
3725 print_vma (segment->p_paddr, FULL_HEX);
3726 putchar (' ');
3727
3728 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3729 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3730 else
3731 {
3732 print_vma (segment->p_filesz, FULL_HEX);
3733 putchar (' ');
3734 }
3735
3736 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3737 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3738 else
3739 {
3740 print_vma (segment->p_offset, FULL_HEX);
3741 }
3742
3743 printf (" %c%c%c ",
3744 (segment->p_flags & PF_R ? 'R' : ' '),
3745 (segment->p_flags & PF_W ? 'W' : ' '),
3746 (segment->p_flags & PF_X ? 'E' : ' '));
3747
3748 if ((unsigned long) segment->p_align == segment->p_align)
3749 printf ("%#lx", (unsigned long) segment->p_align);
3750 else
3751 {
3752 print_vma (segment->p_align, PREFIX_HEX);
3753 }
3754 }
f7a99963
NC		 3755 else
3756 {
3757 print_vma (segment->p_offset, FULL_HEX);
3758 putchar (' ');
3759 print_vma (segment->p_vaddr, FULL_HEX);
3760 putchar (' ');
3761 print_vma (segment->p_paddr, FULL_HEX);
3762 printf ("\n ");
3763 print_vma (segment->p_filesz, FULL_HEX);
3764 putchar (' ');
3765 print_vma (segment->p_memsz, FULL_HEX);
3766 printf (" %c%c%c ",
3767 (segment->p_flags & PF_R ? 'R' : ' '),
3768 (segment->p_flags & PF_W ? 'W' : ' '),
3769 (segment->p_flags & PF_X ? 'E' : ' '));
3770 print_vma (segment->p_align, HEX);
3771 }
252b5132
RH		 3772 }
3773
3774 switch (segment->p_type)
3775 {
252b5132
RH		 3776 case PT_DYNAMIC:
3777 if (dynamic_addr)
3778 error (_("more than one dynamic segment\n"));
3779
20737c13
AM		 3780 /* By default, assume that the .dynamic section is the first
3781 section in the DYNAMIC segment. */
3782 dynamic_addr = segment->p_offset;
3783 dynamic_size = segment->p_filesz;
3784
b2d38a17
NC		 3785 /* Try to locate the .dynamic section. If there is
3786 a section header table, we can easily locate it. */
3787 if (section_headers != NULL)
3788 {
2cf0635d 3789 Elf_Internal_Shdr * sec;
b2d38a17 3790
89fac5e3
RS		 3791 sec = find_section (".dynamic");
3792 if (sec == NULL || sec->sh_size == 0)
b2d38a17 3793 {
28f997cf
TG		 3794 /* A corresponding .dynamic section is expected, but on
3795 IA-64/OpenVMS it is OK for it to be missing. */
3796 if (!is_ia64_vms ())
3797 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 3798 break;
3799 }
3800
42bb2e33 3801 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 3802 {
3803 dynamic_size = 0;
3804 break;
3805 }
42bb2e33 3806
b2d38a17
NC		 3807 dynamic_addr = sec->sh_offset;
3808 dynamic_size = sec->sh_size;
3809
3810 if (dynamic_addr < segment->p_offset
3811 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 3812 warn (_("the .dynamic section is not contained"
3813 " within the dynamic segment\n"));
b2d38a17 3814 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 3815 warn (_("the .dynamic section is not the first section"
3816 " in the dynamic segment.\n"));
b2d38a17 3817 }
252b5132
RH		 3818 break;
3819
3820 case PT_INTERP:
fb52b2f4
NC		 3821 if (fseek (file, archive_file_offset + (long) segment->p_offset,
3822 SEEK_SET))
252b5132
RH		 3823 error (_("Unable to find program interpreter name\n"));
3824 else
3825 {
f8eae8b2
L		 3826 char fmt [32];
3827 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
3828
3829 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 3830 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 3831
252b5132 3832 program_interpreter[0] = 0;
7bd7b3ef
AM		 3833 if (fscanf (file, fmt, program_interpreter) <= 0)
3834 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 3835
3836 if (do_segments)
3837 printf (_("\n [Requesting program interpreter: %s]"),
3838 program_interpreter);
3839 }
3840 break;
3841 }
3842
3843 if (do_segments)
3844 putc ('\n', stdout);
3845 }
3846
c256ffe7 3847 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 3848 {
3849 printf (_("\n Section to Segment mapping:\n"));
3850 printf (_(" Segment Sections...\n"));
3851
252b5132
RH		 3852 for (i = 0; i < elf_header.e_phnum; i++)
3853 {
9ad5cbcf 3854 unsigned int j;
2cf0635d 3855 Elf_Internal_Shdr * section;
252b5132
RH		 3856
3857 segment = program_headers + i;
b391a3e3 3858 section = section_headers + 1;
252b5132
RH		 3859
3860 printf (" %2.2d ", i);
3861
b34976b6 3862 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 3863 {
f4638467
AM		 3864 if (!ELF_TBSS_SPECIAL (section, segment)
3865 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
252b5132
RH		 3866 printf ("%s ", SECTION_NAME (section));
3867 }
3868
3869 putc ('\n',stdout);
3870 }
3871 }
3872
252b5132
RH		 3873 return 1;
3874}
3875
3876
d93f0186
NC		 3877/* Find the file offset corresponding to VMA by using the program headers. */
3878
3879static long
2cf0635d 3880offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 3881{
2cf0635d 3882 Elf_Internal_Phdr * seg;
d93f0186
NC		 3883
3884 if (! get_program_headers (file))
3885 {
3886 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3887 return (long) vma;
3888 }
3889
3890 for (seg = program_headers;
3891 seg < program_headers + elf_header.e_phnum;
3892 ++seg)
3893 {
3894 if (seg->p_type != PT_LOAD)
3895 continue;
3896
3897 if (vma >= (seg->p_vaddr & -seg->p_align)
3898 && vma + size <= seg->p_vaddr + seg->p_filesz)
3899 return vma - seg->p_vaddr + seg->p_offset;
3900 }
3901
3902 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 3903 (unsigned long) vma);
d93f0186
NC		 3904 return (long) vma;
3905}
3906
3907
252b5132 3908static int
2cf0635d 3909get_32bit_section_headers (FILE * file, unsigned int num)
252b5132 3910{
2cf0635d
NC		 3911 Elf32_External_Shdr * shdrs;
3912 Elf_Internal_Shdr * internal;
b34976b6 3913 unsigned int i;
252b5132 3914
3f5e193b
NC		 3915 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
3916 elf_header.e_shentsize, num,
3917 _("section headers"));
a6e9f9df
AM		 3918 if (!shdrs)
3919 return 0;
252b5132 3920
3f5e193b
NC		 3921 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
3922 sizeof (Elf_Internal_Shdr));
252b5132
RH		 3923
3924 if (section_headers == NULL)
3925 {
3926 error (_("Out of memory\n"));
3927 return 0;
3928 }
3929
3930 for (i = 0, internal = section_headers;
560f3c1c 3931 i < num;
b34976b6 3932 i++, internal++)
252b5132
RH		 3933 {
3934 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3935 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3936 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3937 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3938 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3939 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3940 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3941 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3942 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3943 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3944 }
3945
3946 free (shdrs);
3947
3948 return 1;
3949}
3950
9ea033b2 3951static int
2cf0635d 3952get_64bit_section_headers (FILE * file, unsigned int num)
9ea033b2 3953{
2cf0635d
NC		 3954 Elf64_External_Shdr * shdrs;
3955 Elf_Internal_Shdr * internal;
b34976b6 3956 unsigned int i;
9ea033b2 3957
3f5e193b
NC		 3958 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
3959 elf_header.e_shentsize, num,
3960 _("section headers"));
a6e9f9df
AM		 3961 if (!shdrs)
3962 return 0;
9ea033b2 3963
3f5e193b
NC		 3964 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
3965 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 3966
3967 if (section_headers == NULL)
3968 {
3969 error (_("Out of memory\n"));
3970 return 0;
3971 }
3972
3973 for (i = 0, internal = section_headers;
560f3c1c 3974 i < num;
b34976b6 3975 i++, internal++)
9ea033b2
NC		 3976 {
3977 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3978 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 3979 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3980 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3981 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3982 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 3983 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3984 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3985 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3986 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3987 }
3988
3989 free (shdrs);
3990
3991 return 1;
3992}
3993
252b5132 3994static Elf_Internal_Sym *
2cf0635d 3995get_32bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
252b5132 3996{
9ad5cbcf 3997 unsigned long number;
dd24e3da 3998 Elf32_External_Sym * esyms = NULL;
2cf0635d 3999 Elf_External_Sym_Shndx * shndx;
dd24e3da 4000 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4001 Elf_Internal_Sym * psym;
b34976b6 4002 unsigned int j;
252b5132 4003
dd24e3da
NC		 4004 /* Run some sanity checks first. */
4005 if (section->sh_entsize == 0)
4006 {
4007 error (_("sh_entsize is zero\n"));
4008 return NULL;
4009 }
4010
4011 number = section->sh_size / section->sh_entsize;
4012
4013 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4014 {
4015 error (_("Invalid sh_entsize\n"));
4016 return NULL;
4017 }
4018
3f5e193b
NC		 4019 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4020 section->sh_size, _("symbols"));
dd24e3da 4021 if (esyms == NULL)
a6e9f9df 4022 return NULL;
252b5132 4023
9ad5cbcf
AM		 4024 shndx = NULL;
4025 if (symtab_shndx_hdr != NULL
4026 && (symtab_shndx_hdr->sh_link
4fbb74a6 4027 == (unsigned long) (section - section_headers)))
9ad5cbcf 4028 {
3f5e193b
NC		 4029 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4030 symtab_shndx_hdr->sh_offset,
4031 1, symtab_shndx_hdr->sh_size,
4032 _("symtab shndx"));
dd24e3da
NC		 4033 if (shndx == NULL)
4034 goto exit_point;
9ad5cbcf
AM		 4035 }
4036
3f5e193b 4037 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 4038
4039 if (isyms == NULL)
4040 {
4041 error (_("Out of memory\n"));
dd24e3da 4042 goto exit_point;
252b5132
RH		 4043 }
4044
dd24e3da 4045 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 4046 {
4047 psym->st_name = BYTE_GET (esyms[j].st_name);
4048 psym->st_value = BYTE_GET (esyms[j].st_value);
4049 psym->st_size = BYTE_GET (esyms[j].st_size);
4050 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4051 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4052 psym->st_shndx
4053 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4054 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4055 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 4056 psym->st_info = BYTE_GET (esyms[j].st_info);
4057 psym->st_other = BYTE_GET (esyms[j].st_other);
4058 }
4059
dd24e3da 4060 exit_point:
9ad5cbcf
AM		 4061 if (shndx)
4062 free (shndx);
dd24e3da
NC		 4063 if (esyms)
4064 free (esyms);
252b5132
RH		 4065
4066 return isyms;
4067}
4068
9ea033b2 4069static Elf_Internal_Sym *
2cf0635d 4070get_64bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
9ea033b2 4071{
9ad5cbcf 4072 unsigned long number;
2cf0635d
NC		 4073 Elf64_External_Sym * esyms;
4074 Elf_External_Sym_Shndx * shndx;
4075 Elf_Internal_Sym * isyms;
4076 Elf_Internal_Sym * psym;
b34976b6 4077 unsigned int j;
9ea033b2 4078
dd24e3da
NC		 4079 /* Run some sanity checks first. */
4080 if (section->sh_entsize == 0)
4081 {
4082 error (_("sh_entsize is zero\n"));
4083 return NULL;
4084 }
4085
4086 number = section->sh_size / section->sh_entsize;
4087
4088 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4089 {
4090 error (_("Invalid sh_entsize\n"));
4091 return NULL;
4092 }
4093
3f5e193b
NC		 4094 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4095 section->sh_size, _("symbols"));
a6e9f9df
AM		 4096 if (!esyms)
4097 return NULL;
9ea033b2 4098
9ad5cbcf
AM		 4099 shndx = NULL;
4100 if (symtab_shndx_hdr != NULL
4101 && (symtab_shndx_hdr->sh_link
4fbb74a6 4102 == (unsigned long) (section - section_headers)))
9ad5cbcf 4103 {
3f5e193b
NC		 4104 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4105 symtab_shndx_hdr->sh_offset,
4106 1, symtab_shndx_hdr->sh_size,
4107 _("symtab shndx"));
9ad5cbcf
AM		 4108 if (!shndx)
4109 {
4110 free (esyms);
4111 return NULL;
4112 }
4113 }
4114
3f5e193b 4115 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 4116
4117 if (isyms == NULL)
4118 {
4119 error (_("Out of memory\n"));
9ad5cbcf
AM		 4120 if (shndx)
4121 free (shndx);
9ea033b2 4122 free (esyms);
9ea033b2
NC		 4123 return NULL;
4124 }
4125
4126 for (j = 0, psym = isyms;
4127 j < number;
b34976b6 4128 j++, psym++)
9ea033b2
NC		 4129 {
4130 psym->st_name = BYTE_GET (esyms[j].st_name);
4131 psym->st_info = BYTE_GET (esyms[j].st_info);
4132 psym->st_other = BYTE_GET (esyms[j].st_other);
4133 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4134 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4135 psym->st_shndx
4136 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4137 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4138 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
66543521
AM		 4139 psym->st_value = BYTE_GET (esyms[j].st_value);
4140 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 4141 }
4142
9ad5cbcf
AM		 4143 if (shndx)
4144 free (shndx);
9ea033b2
NC		 4145 free (esyms);
4146
4147 return isyms;
4148}
4149
d1133906 4150static const char *
d3ba0551 4151get_elf_section_flags (bfd_vma sh_flags)
d1133906 4152{
5477e8a0 4153 static char buff[1024];
2cf0635d 4154 char * p = buff;
8d5ff12c 4155 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 4156 int sindex;
4157 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 4158 bfd_vma os_flags = 0;
4159 bfd_vma proc_flags = 0;
4160 bfd_vma unknown_flags = 0;
148b93f2 4161 static const struct
5477e8a0 4162 {
2cf0635d 4163 const char * str;
5477e8a0
L		 4164 int len;
4165 }
4166 flags [] =
4167 {
cfcac11d
NC		 4168 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4169 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4170 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4171 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4172 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4173 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4174 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4175 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4176 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4177 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4178 /* IA-64 specific. */
4179 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4180 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4181 /* IA-64 OpenVMS specific. */
4182 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4183 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4184 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4185 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4186 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4187 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 4188 /* Generic. */
cfcac11d 4189 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 4190 /* SPARC specific. */
cfcac11d 4191 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5477e8a0
L		 4192 };
4193
4194 if (do_section_details)
4195 {
8d5ff12c
L		 4196 sprintf (buff, "[%*.*lx]: ",
4197 field_size, field_size, (unsigned long) sh_flags);
4198 p += field_size + 4;
5477e8a0 4199 }
76da6bbe 4200
d1133906
NC		 4201 while (sh_flags)
4202 {
4203 bfd_vma flag;
4204
4205 flag = sh_flags & - sh_flags;
4206 sh_flags &= ~ flag;
76da6bbe 4207
5477e8a0 4208 if (do_section_details)
d1133906 4209 {
5477e8a0
L		 4210 switch (flag)
4211 {
91d6fa6a
NC		 4212 case SHF_WRITE: sindex = 0; break;
4213 case SHF_ALLOC: sindex = 1; break;
4214 case SHF_EXECINSTR: sindex = 2; break;
4215 case SHF_MERGE: sindex = 3; break;
4216 case SHF_STRINGS: sindex = 4; break;
4217 case SHF_INFO_LINK: sindex = 5; break;
4218 case SHF_LINK_ORDER: sindex = 6; break;
4219 case SHF_OS_NONCONFORMING: sindex = 7; break;
4220 case SHF_GROUP: sindex = 8; break;
4221 case SHF_TLS: sindex = 9; break;
18ae9cc1 4222 case SHF_EXCLUDE: sindex = 18; break;
76da6bbe 4223
5477e8a0 4224 default:
91d6fa6a 4225 sindex = -1;
cfcac11d 4226 switch (elf_header.e_machine)
148b93f2 4227 {
cfcac11d 4228 case EM_IA_64:
148b93f2 4229 if (flag == SHF_IA_64_SHORT)
91d6fa6a 4230 sindex = 10;
148b93f2 4231 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 4232 sindex = 11;
148b93f2
NC		 4233#ifdef BFD64
4234 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4235 switch (flag)
4236 {
91d6fa6a
NC		 4237 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4238 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4239 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4240 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4241 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4242 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 4243 default: break;
4244 }
4245#endif
cfcac11d
NC		 4246 break;
4247
caa83f8b
NC		 4248 case EM_386:
4249 case EM_486:
4250 case EM_X86_64:
7f502d6c 4251 case EM_L1OM:
cfcac11d
NC		 4252 case EM_OLD_SPARCV9:
4253 case EM_SPARC32PLUS:
4254 case EM_SPARCV9:
4255 case EM_SPARC:
18ae9cc1 4256 if (flag == SHF_ORDERED)
91d6fa6a 4257 sindex = 19;
cfcac11d
NC		 4258 break;
4259 default:
4260 break;
148b93f2 4261 }
5477e8a0
L		 4262 }
4263
91d6fa6a 4264 if (sindex != -1)
5477e8a0 4265 {
8d5ff12c
L		 4266 if (p != buff + field_size + 4)
4267 {
4268 if (size < (10 + 2))
4269 abort ();
4270 size -= 2;
4271 *p++ = ',';
4272 *p++ = ' ';
4273 }
4274
91d6fa6a
NC		 4275 size -= flags [sindex].len;
4276 p = stpcpy (p, flags [sindex].str);
5477e8a0 4277 }
3b22753a 4278 else if (flag & SHF_MASKOS)
8d5ff12c 4279 os_flags |= flag;
d1133906 4280 else if (flag & SHF_MASKPROC)
8d5ff12c 4281 proc_flags |= flag;
d1133906 4282 else
8d5ff12c 4283 unknown_flags |= flag;
5477e8a0
L		 4284 }
4285 else
4286 {
4287 switch (flag)
4288 {
4289 case SHF_WRITE: *p = 'W'; break;
4290 case SHF_ALLOC: *p = 'A'; break;
4291 case SHF_EXECINSTR: *p = 'X'; break;
4292 case SHF_MERGE: *p = 'M'; break;
4293 case SHF_STRINGS: *p = 'S'; break;
4294 case SHF_INFO_LINK: *p = 'I'; break;
4295 case SHF_LINK_ORDER: *p = 'L'; break;
4296 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4297 case SHF_GROUP: *p = 'G'; break;
4298 case SHF_TLS: *p = 'T'; break;
18ae9cc1 4299 case SHF_EXCLUDE: *p = 'E'; break;
5477e8a0
L		 4300
4301 default:
8a9036a4
L		 4302 if ((elf_header.e_machine == EM_X86_64
4303 || elf_header.e_machine == EM_L1OM)
5477e8a0
L		 4304 && flag == SHF_X86_64_LARGE)
4305 *p = 'l';
4306 else if (flag & SHF_MASKOS)
4307 {
4308 *p = 'o';
4309 sh_flags &= ~ SHF_MASKOS;
4310 }
4311 else if (flag & SHF_MASKPROC)
4312 {
4313 *p = 'p';
4314 sh_flags &= ~ SHF_MASKPROC;
4315 }
4316 else
4317 *p = 'x';
4318 break;
4319 }
4320 p++;
d1133906
NC		 4321 }
4322 }
76da6bbe 4323
8d5ff12c
L		 4324 if (do_section_details)
4325 {
4326 if (os_flags)
4327 {
4328 size -= 5 + field_size;
4329 if (p != buff + field_size + 4)
4330 {
4331 if (size < (2 + 1))
4332 abort ();
4333 size -= 2;
4334 *p++ = ',';
4335 *p++ = ' ';
4336 }
4337 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4338 (unsigned long) os_flags);
4339 p += 5 + field_size;
4340 }
4341 if (proc_flags)
4342 {
4343 size -= 7 + field_size;
4344 if (p != buff + field_size + 4)
4345 {
4346 if (size < (2 + 1))
4347 abort ();
4348 size -= 2;
4349 *p++ = ',';
4350 *p++ = ' ';
4351 }
4352 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4353 (unsigned long) proc_flags);
4354 p += 7 + field_size;
4355 }
4356 if (unknown_flags)
4357 {
4358 size -= 10 + field_size;
4359 if (p != buff + field_size + 4)
4360 {
4361 if (size < (2 + 1))
4362 abort ();
4363 size -= 2;
4364 *p++ = ',';
4365 *p++ = ' ';
4366 }
2b692964 4367 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 4368 (unsigned long) unknown_flags);
4369 p += 10 + field_size;
4370 }
4371 }
4372
e9e44622 4373 *p = '\0';
d1133906
NC		 4374 return buff;
4375}
4376
252b5132 4377static int
2cf0635d 4378process_section_headers (FILE * file)
252b5132 4379{
2cf0635d 4380 Elf_Internal_Shdr * section;
b34976b6 4381 unsigned int i;
252b5132
RH		 4382
4383 section_headers = NULL;
4384
4385 if (elf_header.e_shnum == 0)
4386 {
82f2dbf7
NC		 4387 /* PR binutils/12467. */
4388 if (elf_header.e_shoff != 0)
4389 warn (_("possibly corrupt ELF file header - it has a non-zero"
4390 " section header offset, but no section headers\n"));
4391 else if (do_sections)
252b5132
RH		 4392 printf (_("\nThere are no sections in this file.\n"));
4393
4394 return 1;
4395 }
4396
4397 if (do_sections && !do_header)
9ea033b2 4398 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 4399 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4400
9ea033b2
NC		 4401 if (is_32bit_elf)
4402 {
560f3c1c 4403 if (! get_32bit_section_headers (file, elf_header.e_shnum))
9ea033b2
NC		 4404 return 0;
4405 }
560f3c1c 4406 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
252b5132
RH		 4407 return 0;
4408
4409 /* Read in the string table, so that we have names to display. */
0b49d371 4410 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 4411 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 4412 {
4fbb74a6 4413 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 4414
c256ffe7
JJ		 4415 if (section->sh_size != 0)
4416 {
3f5e193b
NC		 4417 string_table = (char *) get_data (NULL, file, section->sh_offset,
4418 1, section->sh_size,
4419 _("string table"));
0de14b54 4420
c256ffe7
JJ		 4421 string_table_length = string_table != NULL ? section->sh_size : 0;
4422 }
252b5132
RH		 4423 }
4424
4425 /* Scan the sections for the dynamic symbol table
e3c8793a 4426 and dynamic string table and debug sections. */
252b5132
RH		 4427 dynamic_symbols = NULL;
4428 dynamic_strings = NULL;
4429 dynamic_syminfo = NULL;
f1ef08cb 4430 symtab_shndx_hdr = NULL;
103f02d3 4431
89fac5e3
RS		 4432 eh_addr_size = is_32bit_elf ? 4 : 8;
4433 switch (elf_header.e_machine)
4434 {
4435 case EM_MIPS:
4436 case EM_MIPS_RS3_LE:
4437 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4438 FDE addresses. However, the ABI also has a semi-official ILP32
4439 variant for which the normal FDE address size rules apply.
4440
4441 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4442 section, where XX is the size of longs in bits. Unfortunately,
4443 earlier compilers provided no way of distinguishing ILP32 objects
4444 from LP64 objects, so if there's any doubt, we should assume that
4445 the official LP64 form is being used. */
4446 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4447 && find_section (".gcc_compiled_long32") == NULL)
4448 eh_addr_size = 8;
4449 break;
0f56a26a
DD		 4450
4451 case EM_H8_300:
4452 case EM_H8_300H:
4453 switch (elf_header.e_flags & EF_H8_MACH)
4454 {
4455 case E_H8_MACH_H8300:
4456 case E_H8_MACH_H8300HN:
4457 case E_H8_MACH_H8300SN:
4458 case E_H8_MACH_H8300SXN:
4459 eh_addr_size = 2;
4460 break;
4461 case E_H8_MACH_H8300H:
4462 case E_H8_MACH_H8300S:
4463 case E_H8_MACH_H8300SX:
4464 eh_addr_size = 4;
4465 break;
4466 }
f4236fe4
DD		 4467 break;
4468
ff7eeb89 4469 case EM_M32C_OLD:
f4236fe4
DD		 4470 case EM_M32C:
4471 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4472 {
4473 case EF_M32C_CPU_M16C:
4474 eh_addr_size = 2;
4475 break;
4476 }
4477 break;
89fac5e3
RS		 4478 }
4479
08d8fa11
JJ		 4480#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4481 do \
4482 { \
4483 size_t expected_entsize \
4484 = is_32bit_elf ? size32 : size64; \
4485 if (section->sh_entsize != expected_entsize) \
4486 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4487 i, (unsigned long int) section->sh_entsize, \
4488 (unsigned long int) expected_entsize); \
4489 section->sh_entsize = expected_entsize; \
4490 } \
4491 while (0)
4492#define CHECK_ENTSIZE(section, i, type) \
4493 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4494 sizeof (Elf64_External_##type))
4495
252b5132
RH		 4496 for (i = 0, section = section_headers;
4497 i < elf_header.e_shnum;
b34976b6 4498 i++, section++)
252b5132 4499 {
2cf0635d 4500 char * name = SECTION_NAME (section);
252b5132
RH		 4501
4502 if (section->sh_type == SHT_DYNSYM)
4503 {
4504 if (dynamic_symbols != NULL)
4505 {
4506 error (_("File contains multiple dynamic symbol tables\n"));
4507 continue;
4508 }
4509
08d8fa11 4510 CHECK_ENTSIZE (section, i, Sym);
19936277 4511 num_dynamic_syms = section->sh_size / section->sh_entsize;
9ad5cbcf 4512 dynamic_symbols = GET_ELF_SYMBOLS (file, section);
252b5132
RH		 4513 }
4514 else if (section->sh_type == SHT_STRTAB
18bd398b 4515 && streq (name, ".dynstr"))
252b5132
RH		 4516 {
4517 if (dynamic_strings != NULL)
4518 {
4519 error (_("File contains multiple dynamic string tables\n"));
4520 continue;
4521 }
4522
3f5e193b
NC		 4523 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4524 1, section->sh_size,
4525 _("dynamic strings"));
d79b3d50 4526 dynamic_strings_length = section->sh_size;
252b5132 4527 }
9ad5cbcf
AM		 4528 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4529 {
4530 if (symtab_shndx_hdr != NULL)
4531 {
4532 error (_("File contains multiple symtab shndx tables\n"));
4533 continue;
4534 }
4535 symtab_shndx_hdr = section;
4536 }
08d8fa11
JJ		 4537 else if (section->sh_type == SHT_SYMTAB)
4538 CHECK_ENTSIZE (section, i, Sym);
4539 else if (section->sh_type == SHT_GROUP)
4540 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4541 else if (section->sh_type == SHT_REL)
4542 CHECK_ENTSIZE (section, i, Rel);
4543 else if (section->sh_type == SHT_RELA)
4544 CHECK_ENTSIZE (section, i, Rela);
252b5132 4545 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 4546 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 4547 || do_debug_aranges || do_debug_frames || do_debug_macinfo
a262ae96 4548 || do_debug_str || do_debug_loc || do_debug_ranges)
1b315056
CS		 4549 && (const_strneq (name, ".debug_")
4550 || const_strneq (name, ".zdebug_")))
252b5132 4551 {
1b315056
CS		 4552 if (name[1] == 'z')
4553 name += sizeof (".zdebug_") - 1;
4554 else
4555 name += sizeof (".debug_") - 1;
252b5132
RH		 4556
4557 if (do_debugging
18bd398b 4558 || (do_debug_info && streq (name, "info"))
2b6f5997 4559 || (do_debug_info && streq (name, "types"))
18bd398b 4560 || (do_debug_abbrevs && streq (name, "abbrev"))
4cb93e3b 4561 || (do_debug_lines && streq (name, "line"))
18bd398b 4562 || (do_debug_pubnames && streq (name, "pubnames"))
f9f0e732 4563 || (do_debug_pubtypes && streq (name, "pubtypes"))
18bd398b
NC		 4564 || (do_debug_aranges && streq (name, "aranges"))
4565 || (do_debug_ranges && streq (name, "ranges"))
4566 || (do_debug_frames && streq (name, "frame"))
4567 || (do_debug_macinfo && streq (name, "macinfo"))
4568 || (do_debug_str && streq (name, "str"))
4569 || (do_debug_loc && streq (name, "loc"))
252b5132 4570 )
09c11c86 4571 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 4572 }
a262ae96 4573 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 4574 else if ((do_debugging || do_debug_info)
0112cd26 4575 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 4576 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 4577 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 4578 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 4579 else if (do_gdb_index && streq (name, ".gdb_index"))
4580 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 4581 /* Trace sections for Itanium VMS. */
4582 else if ((do_debugging || do_trace_info || do_trace_abbrevs
4583 || do_trace_aranges)
4584 && const_strneq (name, ".trace_"))
4585 {
4586 name += sizeof (".trace_") - 1;
4587
4588 if (do_debugging
4589 || (do_trace_info && streq (name, "info"))
4590 || (do_trace_abbrevs && streq (name, "abbrev"))
4591 || (do_trace_aranges && streq (name, "aranges"))
4592 )
4593 request_dump_bynumber (i, DEBUG_DUMP);
4594 }
4595
252b5132
RH		 4596 }
4597
4598 if (! do_sections)
4599 return 1;
4600
3a1a2036
NC		 4601 if (elf_header.e_shnum > 1)
4602 printf (_("\nSection Headers:\n"));
4603 else
4604 printf (_("\nSection Header:\n"));
76da6bbe 4605
f7a99963 4606 if (is_32bit_elf)
595cf52e 4607 {
5477e8a0 4608 if (do_section_details)
595cf52e
L		 4609 {
4610 printf (_(" [Nr] Name\n"));
5477e8a0 4611 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 4612 }
4613 else
4614 printf
4615 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4616 }
d974e256 4617 else if (do_wide)
595cf52e 4618 {
5477e8a0 4619 if (do_section_details)
595cf52e
L		 4620 {
4621 printf (_(" [Nr] Name\n"));
5477e8a0 4622 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 4623 }
4624 else
4625 printf
4626 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4627 }
f7a99963
NC		 4628 else
4629 {
5477e8a0 4630 if (do_section_details)
595cf52e
L		 4631 {
4632 printf (_(" [Nr] Name\n"));
5477e8a0
L		 4633 printf (_(" Type Address Offset Link\n"));
4634 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 4635 }
4636 else
4637 {
4638 printf (_(" [Nr] Name Type Address Offset\n"));
4639 printf (_(" Size EntSize Flags Link Info Align\n"));
4640 }
f7a99963 4641 }
252b5132 4642
5477e8a0
L		 4643 if (do_section_details)
4644 printf (_(" Flags\n"));
4645
252b5132
RH		 4646 for (i = 0, section = section_headers;
4647 i < elf_header.e_shnum;
b34976b6 4648 i++, section++)
252b5132 4649 {
5477e8a0 4650 if (do_section_details)
595cf52e
L		 4651 {
4652 printf (" [%2u] %s\n",
4fbb74a6 4653 i,
595cf52e
L		 4654 SECTION_NAME (section));
4655 if (is_32bit_elf || do_wide)
4656 printf (" %-15.15s ",
4657 get_section_type_name (section->sh_type));
4658 }
4659 else
b9eb56c1
NC		 4660 printf ((do_wide ? " [%2u] %-17s %-15s "
4661 : " [%2u] %-17.17s %-15.15s "),
4fbb74a6 4662 i,
595cf52e
L		 4663 SECTION_NAME (section),
4664 get_section_type_name (section->sh_type));
252b5132 4665
f7a99963
NC		 4666 if (is_32bit_elf)
4667 {
cfcac11d
NC		 4668 const char * link_too_big = NULL;
4669
f7a99963 4670 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 4671
f7a99963
NC		 4672 printf ( " %6.6lx %6.6lx %2.2lx",
4673 (unsigned long) section->sh_offset,
4674 (unsigned long) section->sh_size,
4675 (unsigned long) section->sh_entsize);
d1133906 4676
5477e8a0
L		 4677 if (do_section_details)
4678 fputs (" ", stdout);
4679 else
4680 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 4681
cfcac11d
NC		 4682 if (section->sh_link >= elf_header.e_shnum)
4683 {
4684 link_too_big = "";
4685 /* The sh_link value is out of range. Normally this indicates
caa83f8b 4686 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 4687 switch (elf_header.e_machine)
4688 {
caa83f8b
NC		 4689 case EM_386:
4690 case EM_486:
4691 case EM_X86_64:
7f502d6c 4692 case EM_L1OM:
cfcac11d
NC		 4693 case EM_OLD_SPARCV9:
4694 case EM_SPARC32PLUS:
4695 case EM_SPARCV9:
4696 case EM_SPARC:
4697 if (section->sh_link == (SHN_BEFORE & 0xffff))
4698 link_too_big = "BEFORE";
4699 else if (section->sh_link == (SHN_AFTER & 0xffff))
4700 link_too_big = "AFTER";
4701 break;
4702 default:
4703 break;
4704 }
4705 }
4706
4707 if (do_section_details)
4708 {
4709 if (link_too_big != NULL && * link_too_big)
4710 printf ("<%s> ", link_too_big);
4711 else
4712 printf ("%2u ", section->sh_link);
4713 printf ("%3u %2lu\n", section->sh_info,
4714 (unsigned long) section->sh_addralign);
4715 }
4716 else
4717 printf ("%2u %3u %2lu\n",
4718 section->sh_link,
4719 section->sh_info,
4720 (unsigned long) section->sh_addralign);
4721
4722 if (link_too_big && ! * link_too_big)
4723 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4724 i, section->sh_link);
f7a99963 4725 }
d974e256
JJ		 4726 else if (do_wide)
4727 {
4728 print_vma (section->sh_addr, LONG_HEX);
4729
4730 if ((long) section->sh_offset == section->sh_offset)
4731 printf (" %6.6lx", (unsigned long) section->sh_offset);
4732 else
4733 {
4734 putchar (' ');
4735 print_vma (section->sh_offset, LONG_HEX);
4736 }
4737
4738 if ((unsigned long) section->sh_size == section->sh_size)
4739 printf (" %6.6lx", (unsigned long) section->sh_size);
4740 else
4741 {
4742 putchar (' ');
4743 print_vma (section->sh_size, LONG_HEX);
4744 }
4745
4746 if ((unsigned long) section->sh_entsize == section->sh_entsize)
4747 printf (" %2.2lx", (unsigned long) section->sh_entsize);
4748 else
4749 {
4750 putchar (' ');
4751 print_vma (section->sh_entsize, LONG_HEX);
4752 }
4753
5477e8a0
L		 4754 if (do_section_details)
4755 fputs (" ", stdout);
4756 else
4757 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 4758
72de5009 4759 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 4760
4761 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 4762 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 4763 else
4764 {
4765 print_vma (section->sh_addralign, DEC);
4766 putchar ('\n');
4767 }
4768 }
5477e8a0 4769 else if (do_section_details)
595cf52e 4770 {
5477e8a0 4771 printf (" %-15.15s ",
595cf52e 4772 get_section_type_name (section->sh_type));
595cf52e
L		 4773 print_vma (section->sh_addr, LONG_HEX);
4774 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 4775 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 4776 else
4777 {
4778 printf (" ");
4779 print_vma (section->sh_offset, LONG_HEX);
4780 }
72de5009 4781 printf (" %u\n ", section->sh_link);
595cf52e 4782 print_vma (section->sh_size, LONG_HEX);
5477e8a0 4783 putchar (' ');
595cf52e
L		 4784 print_vma (section->sh_entsize, LONG_HEX);
4785
72de5009
AM		 4786 printf (" %-16u %lu\n",
4787 section->sh_info,
595cf52e
L		 4788 (unsigned long) section->sh_addralign);
4789 }
f7a99963
NC		 4790 else
4791 {
4792 putchar (' ');
4793 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 4794 if ((long) section->sh_offset == section->sh_offset)
4795 printf (" %8.8lx", (unsigned long) section->sh_offset);
4796 else
4797 {
4798 printf (" ");
4799 print_vma (section->sh_offset, LONG_HEX);
4800 }
f7a99963
NC		 4801 printf ("\n ");
4802 print_vma (section->sh_size, LONG_HEX);
4803 printf (" ");
4804 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 4805
d1133906 4806 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 4807
72de5009
AM		 4808 printf (" %2u %3u %lu\n",
4809 section->sh_link,
4810 section->sh_info,
f7a99963
NC		 4811 (unsigned long) section->sh_addralign);
4812 }
5477e8a0
L		 4813
4814 if (do_section_details)
4815 printf (" %s\n", get_elf_section_flags (section->sh_flags));
252b5132
RH		 4816 }
4817
5477e8a0 4818 if (!do_section_details)
3dbcc61d
NC		 4819 {
4820 if (elf_header.e_machine == EM_X86_64
4821 || elf_header.e_machine == EM_L1OM)
4822 printf (_("Key to Flags:\n\
4823 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
4824 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4825 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4826 else
4827 printf (_("Key to Flags:\n\
e3c8793a 4828 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 4829 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 4830 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3dbcc61d 4831 }
d1133906 4832
252b5132
RH		 4833 return 1;
4834}
4835
f5842774
L		 4836static const char *
4837get_group_flags (unsigned int flags)
4838{
4839 static char buff[32];
4840 switch (flags)
4841 {
220453ec
AM		 4842 case 0:
4843 return "";
4844
f5842774 4845 case GRP_COMDAT:
220453ec 4846 return "COMDAT ";
f5842774
L		 4847
4848 default:
220453ec 4849 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 4850 break;
4851 }
4852 return buff;
4853}
4854
4855static int
2cf0635d 4856process_section_groups (FILE * file)
f5842774 4857{
2cf0635d 4858 Elf_Internal_Shdr * section;
f5842774 4859 unsigned int i;
2cf0635d
NC		 4860 struct group * group;
4861 Elf_Internal_Shdr * symtab_sec;
4862 Elf_Internal_Shdr * strtab_sec;
4863 Elf_Internal_Sym * symtab;
4864 char * strtab;
c256ffe7 4865 size_t strtab_size;
d1f5c6e3
L		 4866
4867 /* Don't process section groups unless needed. */
4868 if (!do_unwind && !do_section_groups)
4869 return 1;
f5842774
L		 4870
4871 if (elf_header.e_shnum == 0)
4872 {
4873 if (do_section_groups)
82f2dbf7 4874 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 4875
4876 return 1;
4877 }
4878
4879 if (section_headers == NULL)
4880 {
4881 error (_("Section headers are not available!\n"));
4882 abort ();
4883 }
4884
3f5e193b
NC		 4885 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
4886 sizeof (struct group *));
e4b17d5c
L		 4887
4888 if (section_headers_groups == NULL)
4889 {
4890 error (_("Out of memory\n"));
4891 return 0;
4892 }
4893
f5842774 4894 /* Scan the sections for the group section. */
d1f5c6e3 4895 group_count = 0;
f5842774
L		 4896 for (i = 0, section = section_headers;
4897 i < elf_header.e_shnum;
4898 i++, section++)
e4b17d5c
L		 4899 if (section->sh_type == SHT_GROUP)
4900 group_count++;
4901
d1f5c6e3
L		 4902 if (group_count == 0)
4903 {
4904 if (do_section_groups)
4905 printf (_("\nThere are no section groups in this file.\n"));
4906
4907 return 1;
4908 }
4909
3f5e193b 4910 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 4911
4912 if (section_groups == NULL)
4913 {
4914 error (_("Out of memory\n"));
4915 return 0;
4916 }
4917
d1f5c6e3
L		 4918 symtab_sec = NULL;
4919 strtab_sec = NULL;
4920 symtab = NULL;
4921 strtab = NULL;
c256ffe7 4922 strtab_size = 0;
e4b17d5c
L		 4923 for (i = 0, section = section_headers, group = section_groups;
4924 i < elf_header.e_shnum;
4925 i++, section++)
f5842774
L		 4926 {
4927 if (section->sh_type == SHT_GROUP)
4928 {
2cf0635d
NC		 4929 char * name = SECTION_NAME (section);
4930 char * group_name;
4931 unsigned char * start;
4932 unsigned char * indices;
f5842774 4933 unsigned int entry, j, size;
2cf0635d
NC		 4934 Elf_Internal_Shdr * sec;
4935 Elf_Internal_Sym * sym;
f5842774
L		 4936
4937 /* Get the symbol table. */
4fbb74a6
AM		 4938 if (section->sh_link >= elf_header.e_shnum
4939 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 4940 != SHT_SYMTAB))
f5842774
L		 4941 {
4942 error (_("Bad sh_link in group section `%s'\n"), name);
4943 continue;
4944 }
d1f5c6e3
L		 4945
4946 if (symtab_sec != sec)
4947 {
4948 symtab_sec = sec;
4949 if (symtab)
4950 free (symtab);
4951 symtab = GET_ELF_SYMBOLS (file, symtab_sec);
4952 }
f5842774 4953
dd24e3da
NC		 4954 if (symtab == NULL)
4955 {
4956 error (_("Corrupt header in group section `%s'\n"), name);
4957 continue;
4958 }
4959
f5842774
L		 4960 sym = symtab + section->sh_info;
4961
4962 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4963 {
4fbb74a6
AM		 4964 if (sym->st_shndx == 0
4965 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 4966 {
4967 error (_("Bad sh_info in group section `%s'\n"), name);
4968 continue;
4969 }
ba2685cc 4970
4fbb74a6 4971 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 4972 strtab_sec = NULL;
4973 if (strtab)
4974 free (strtab);
f5842774 4975 strtab = NULL;
c256ffe7 4976 strtab_size = 0;
f5842774
L		 4977 }
4978 else
4979 {
4980 /* Get the string table. */
4fbb74a6 4981 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 4982 {
4983 strtab_sec = NULL;
4984 if (strtab)
4985 free (strtab);
4986 strtab = NULL;
4987 strtab_size = 0;
4988 }
4989 else if (strtab_sec
4fbb74a6 4990 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 4991 {
4992 strtab_sec = sec;
4993 if (strtab)
4994 free (strtab);
3f5e193b
NC		 4995 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
4996 1, strtab_sec->sh_size,
4997 _("string table"));
c256ffe7 4998 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 4999 }
c256ffe7 5000 group_name = sym->st_name < strtab_size
2b692964 5001 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 5002 }
5003
3f5e193b
NC		 5004 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5005 1, section->sh_size,
5006 _("section data"));
f5842774
L		 5007
5008 indices = start;
5009 size = (section->sh_size / section->sh_entsize) - 1;
5010 entry = byte_get (indices, 4);
5011 indices += 4;
e4b17d5c
L		 5012
5013 if (do_section_groups)
5014 {
2b692964 5015 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 5016 get_group_flags (entry), i, name, group_name, size);
ba2685cc 5017
e4b17d5c
L		 5018 printf (_(" [Index] Name\n"));
5019 }
5020
5021 group->group_index = i;
5022
f5842774
L		 5023 for (j = 0; j < size; j++)
5024 {
2cf0635d 5025 struct group_list * g;
e4b17d5c 5026
f5842774
L		 5027 entry = byte_get (indices, 4);
5028 indices += 4;
5029
4fbb74a6 5030 if (entry >= elf_header.e_shnum)
391cb864
L		 5031 {
5032 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5033 entry, i, elf_header.e_shnum - 1);
5034 continue;
5035 }
391cb864 5036
4fbb74a6 5037 if (section_headers_groups [entry] != NULL)
e4b17d5c 5038 {
d1f5c6e3
L		 5039 if (entry)
5040 {
391cb864
L		 5041 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5042 entry, i,
4fbb74a6 5043 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5044 continue;
5045 }
5046 else
5047 {
5048 /* Intel C/C++ compiler may put section 0 in a
5049 section group. We just warn it the first time
5050 and ignore it afterwards. */
5051 static int warned = 0;
5052 if (!warned)
5053 {
5054 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 5055 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5056 warned++;
5057 }
5058 }
e4b17d5c
L		 5059 }
5060
4fbb74a6 5061 section_headers_groups [entry] = group;
e4b17d5c
L		 5062
5063 if (do_section_groups)
5064 {
4fbb74a6 5065 sec = section_headers + entry;
c256ffe7 5066 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
ba2685cc
AM		 5067 }
5068
3f5e193b 5069 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 5070 g->section_index = entry;
5071 g->next = group->root;
5072 group->root = g;
f5842774
L		 5073 }
5074
f5842774
L		 5075 if (start)
5076 free (start);
e4b17d5c
L		 5077
5078 group++;
f5842774
L		 5079 }
5080 }
5081
d1f5c6e3
L		 5082 if (symtab)
5083 free (symtab);
5084 if (strtab)
5085 free (strtab);
f5842774
L		 5086 return 1;
5087}
5088
28f997cf
TG		 5089/* Data used to display dynamic fixups. */
5090
5091struct ia64_vms_dynfixup
5092{
5093 bfd_vma needed_ident; /* Library ident number. */
5094 bfd_vma needed; /* Index in the dstrtab of the library name. */
5095 bfd_vma fixup_needed; /* Index of the library. */
5096 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5097 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5098};
5099
5100/* Data used to display dynamic relocations. */
5101
5102struct ia64_vms_dynimgrela
5103{
5104 bfd_vma img_rela_cnt; /* Number of relocations. */
5105 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5106};
5107
5108/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5109 library). */
5110
5111static void
5112dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5113 const char *strtab, unsigned int strtab_sz)
5114{
5115 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5116 long i;
5117 const char *lib_name;
5118
5119 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5120 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5121 _("dynamic section image fixups"));
5122 if (!imfs)
5123 return;
5124
5125 if (fixup->needed < strtab_sz)
5126 lib_name = strtab + fixup->needed;
5127 else
5128 {
5129 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 5130 (unsigned long) fixup->needed);
28f997cf
TG		 5131 lib_name = "???";
5132 }
5133 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5134 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5135 printf
5136 (_("Seg Offset Type SymVec DataType\n"));
5137
5138 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5139 {
5140 unsigned int type;
5141 const char *rtype;
5142
5143 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5144 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5145 type = BYTE_GET (imfs [i].type);
5146 rtype = elf_ia64_reloc_type (type);
5147 if (rtype == NULL)
5148 printf (" 0x%08x ", type);
5149 else
5150 printf (" %-32s ", rtype);
5151 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5152 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5153 }
5154
5155 free (imfs);
5156}
5157
5158/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5159
5160static void
5161dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5162{
5163 Elf64_External_VMS_IMAGE_RELA *imrs;
5164 long i;
5165
5166 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5167 1, imgrela->img_rela_cnt * sizeof (*imrs),
5168 _("dynamic section image relas"));
5169 if (!imrs)
5170 return;
5171
5172 printf (_("\nImage relocs\n"));
5173 printf
5174 (_("Seg Offset Type Addend Seg Sym Off\n"));
5175
5176 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5177 {
5178 unsigned int type;
5179 const char *rtype;
5180
5181 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5182 printf ("%08" BFD_VMA_FMT "x ",
5183 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5184 type = BYTE_GET (imrs [i].type);
5185 rtype = elf_ia64_reloc_type (type);
5186 if (rtype == NULL)
5187 printf ("0x%08x ", type);
5188 else
5189 printf ("%-31s ", rtype);
5190 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5191 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5192 printf ("%08" BFD_VMA_FMT "x\n",
5193 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5194 }
5195
5196 free (imrs);
5197}
5198
5199/* Display IA-64 OpenVMS dynamic relocations and fixups. */
5200
5201static int
5202process_ia64_vms_dynamic_relocs (FILE *file)
5203{
5204 struct ia64_vms_dynfixup fixup;
5205 struct ia64_vms_dynimgrela imgrela;
5206 Elf_Internal_Dyn *entry;
5207 int res = 0;
5208 bfd_vma strtab_off = 0;
5209 bfd_vma strtab_sz = 0;
5210 char *strtab = NULL;
5211
5212 memset (&fixup, 0, sizeof (fixup));
5213 memset (&imgrela, 0, sizeof (imgrela));
5214
5215 /* Note: the order of the entries is specified by the OpenVMS specs. */
5216 for (entry = dynamic_section;
5217 entry < dynamic_section + dynamic_nent;
5218 entry++)
5219 {
5220 switch (entry->d_tag)
5221 {
5222 case DT_IA_64_VMS_STRTAB_OFFSET:
5223 strtab_off = entry->d_un.d_val;
5224 break;
5225 case DT_STRSZ:
5226 strtab_sz = entry->d_un.d_val;
5227 if (strtab == NULL)
5228 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5229 1, strtab_sz, _("dynamic string section"));
5230 break;
5231
5232 case DT_IA_64_VMS_NEEDED_IDENT:
5233 fixup.needed_ident = entry->d_un.d_val;
5234 break;
5235 case DT_NEEDED:
5236 fixup.needed = entry->d_un.d_val;
5237 break;
5238 case DT_IA_64_VMS_FIXUP_NEEDED:
5239 fixup.fixup_needed = entry->d_un.d_val;
5240 break;
5241 case DT_IA_64_VMS_FIXUP_RELA_CNT:
5242 fixup.fixup_rela_cnt = entry->d_un.d_val;
5243 break;
5244 case DT_IA_64_VMS_FIXUP_RELA_OFF:
5245 fixup.fixup_rela_off = entry->d_un.d_val;
5246 res++;
5247 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5248 break;
5249
5250 case DT_IA_64_VMS_IMG_RELA_CNT:
5251 imgrela.img_rela_cnt = entry->d_un.d_val;
5252 break;
5253 case DT_IA_64_VMS_IMG_RELA_OFF:
5254 imgrela.img_rela_off = entry->d_un.d_val;
5255 res++;
5256 dump_ia64_vms_dynamic_relocs (file, &imgrela);
5257 break;
5258
5259 default:
5260 break;
5261 }
5262 }
5263
5264 if (strtab != NULL)
5265 free (strtab);
5266
5267 return res;
5268}
5269
85b1c36d 5270static struct
566b0d53 5271{
2cf0635d 5272 const char * name;
566b0d53
L		 5273 int reloc;
5274 int size;
5275 int rela;
5276} dynamic_relocations [] =
5277{
5278 { "REL", DT_REL, DT_RELSZ, FALSE },
5279 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5280 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5281};
5282
252b5132 5283/* Process the reloc section. */
18bd398b 5284
252b5132 5285static int
2cf0635d 5286process_relocs (FILE * file)
252b5132 5287{
b34976b6
AM		 5288 unsigned long rel_size;
5289 unsigned long rel_offset;
252b5132
RH		 5290
5291
5292 if (!do_reloc)
5293 return 1;
5294
5295 if (do_using_dynamic)
5296 {
566b0d53 5297 int is_rela;
2cf0635d 5298 const char * name;
566b0d53
L		 5299 int has_dynamic_reloc;
5300 unsigned int i;
0de14b54 5301
566b0d53 5302 has_dynamic_reloc = 0;
252b5132 5303
566b0d53 5304 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 5305 {
566b0d53
L		 5306 is_rela = dynamic_relocations [i].rela;
5307 name = dynamic_relocations [i].name;
5308 rel_size = dynamic_info [dynamic_relocations [i].size];
5309 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 5310
566b0d53
L		 5311 has_dynamic_reloc |= rel_size;
5312
5313 if (is_rela == UNKNOWN)
aa903cfb 5314 {
566b0d53
L		 5315 if (dynamic_relocations [i].reloc == DT_JMPREL)
5316 switch (dynamic_info[DT_PLTREL])
5317 {
5318 case DT_REL:
5319 is_rela = FALSE;
5320 break;
5321 case DT_RELA:
5322 is_rela = TRUE;
5323 break;
5324 }
aa903cfb 5325 }
252b5132 5326
566b0d53
L		 5327 if (rel_size)
5328 {
5329 printf
5330 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5331 name, rel_offset, rel_size);
252b5132 5332
d93f0186
NC		 5333 dump_relocations (file,
5334 offset_from_vma (file, rel_offset, rel_size),
5335 rel_size,
566b0d53 5336 dynamic_symbols, num_dynamic_syms,
d79b3d50 5337 dynamic_strings, dynamic_strings_length, is_rela);
566b0d53 5338 }
252b5132 5339 }
566b0d53 5340
28f997cf
TG		 5341 if (is_ia64_vms ())
5342 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5343
566b0d53 5344 if (! has_dynamic_reloc)
252b5132
RH		 5345 printf (_("\nThere are no dynamic relocations in this file.\n"));
5346 }
5347 else
5348 {
2cf0635d 5349 Elf_Internal_Shdr * section;
b34976b6
AM		 5350 unsigned long i;
5351 int found = 0;
252b5132
RH		 5352
5353 for (i = 0, section = section_headers;
5354 i < elf_header.e_shnum;
b34976b6 5355 i++, section++)
252b5132
RH		 5356 {
5357 if ( section->sh_type != SHT_RELA
5358 && section->sh_type != SHT_REL)
5359 continue;
5360
5361 rel_offset = section->sh_offset;
5362 rel_size = section->sh_size;
5363
5364 if (rel_size)
5365 {
2cf0635d 5366 Elf_Internal_Shdr * strsec;
b34976b6 5367 int is_rela;
103f02d3 5368
252b5132
RH		 5369 printf (_("\nRelocation section "));
5370
5371 if (string_table == NULL)
19936277 5372 printf ("%d", section->sh_name);
252b5132 5373 else
3a1a2036 5374 printf (_("'%s'"), SECTION_NAME (section));
252b5132
RH		 5375
5376 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5377 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5378
d79b3d50
NC		 5379 is_rela = section->sh_type == SHT_RELA;
5380
4fbb74a6
AM		 5381 if (section->sh_link != 0
5382 && section->sh_link < elf_header.e_shnum)
af3fc3bc 5383 {
2cf0635d
NC		 5384 Elf_Internal_Shdr * symsec;
5385 Elf_Internal_Sym * symtab;
d79b3d50 5386 unsigned long nsyms;
c256ffe7 5387 unsigned long strtablen = 0;
2cf0635d 5388 char * strtab = NULL;
57346661 5389
4fbb74a6 5390 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 5391 if (symsec->sh_type != SHT_SYMTAB
5392 && symsec->sh_type != SHT_DYNSYM)
5393 continue;
5394
af3fc3bc 5395 nsyms = symsec->sh_size / symsec->sh_entsize;
9ad5cbcf 5396 symtab = GET_ELF_SYMBOLS (file, symsec);
252b5132 5397
af3fc3bc
AM		 5398 if (symtab == NULL)
5399 continue;
252b5132 5400
4fbb74a6
AM		 5401 if (symsec->sh_link != 0
5402 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 5403 {
4fbb74a6 5404 strsec = section_headers + symsec->sh_link;
103f02d3 5405
3f5e193b
NC		 5406 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5407 1, strsec->sh_size,
5408 _("string table"));
c256ffe7
JJ		 5409 strtablen = strtab == NULL ? 0 : strsec->sh_size;
5410 }
252b5132 5411
d79b3d50
NC		 5412 dump_relocations (file, rel_offset, rel_size,
5413 symtab, nsyms, strtab, strtablen, is_rela);
5414 if (strtab)
5415 free (strtab);
5416 free (symtab);
5417 }
5418 else
5419 dump_relocations (file, rel_offset, rel_size,
5420 NULL, 0, NULL, 0, is_rela);
252b5132
RH		 5421
5422 found = 1;
5423 }
5424 }
5425
5426 if (! found)
5427 printf (_("\nThere are no relocations in this file.\n"));
5428 }
5429
5430 return 1;
5431}
5432
57346661
AM		 5433/* Process the unwind section. */
5434
4d6ed7c8
NC		 5435#include "unwind-ia64.h"
5436
5437/* An absolute address consists of a section and an offset. If the
5438 section is NULL, the offset itself is the address, otherwise, the
5439 address equals to LOAD_ADDRESS(section) + offset. */
5440
5441struct absaddr
5442 {
5443 unsigned short section;
5444 bfd_vma offset;
5445 };
5446
1949de15
L		 5447#define ABSADDR(a) \
5448 ((a).section \
5449 ? section_headers [(a).section].sh_addr + (a).offset \
5450 : (a).offset)
5451
3f5e193b
NC		 5452struct ia64_unw_table_entry
5453 {
5454 struct absaddr start;
5455 struct absaddr end;
5456 struct absaddr info;
5457 };
5458
57346661 5459struct ia64_unw_aux_info
4d6ed7c8 5460 {
3f5e193b
NC		 5461
5462 struct ia64_unw_table_entry *table; /* Unwind table. */
b34976b6 5463 unsigned long table_len; /* Length of unwind table. */
2cf0635d 5464 unsigned char * info; /* Unwind info. */
b34976b6
AM		 5465 unsigned long info_size; /* Size of unwind info. */
5466 bfd_vma info_addr; /* starting address of unwind info. */
5467 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 5468 Elf_Internal_Sym * symtab; /* The symbol table. */
b34976b6 5469 unsigned long nsyms; /* Number of symbols. */
2cf0635d 5470 char * strtab; /* The string table. */
b34976b6 5471 unsigned long strtab_size; /* Size of string table. */
4d6ed7c8
NC		 5472 };
5473
4d6ed7c8 5474static void
2cf0635d 5475find_symbol_for_address (Elf_Internal_Sym * symtab,
57346661 5476 unsigned long nsyms,
2cf0635d 5477 const char * strtab,
57346661 5478 unsigned long strtab_size,
d3ba0551 5479 struct absaddr addr,
2cf0635d
NC		 5480 const char ** symname,
5481 bfd_vma * offset)
4d6ed7c8 5482{
d3ba0551 5483 bfd_vma dist = 0x100000;
2cf0635d
NC		 5484 Elf_Internal_Sym * sym;
5485 Elf_Internal_Sym * best = NULL;
4d6ed7c8
NC		 5486 unsigned long i;
5487
0b6ae522
DJ		 5488 REMOVE_ARCH_BITS (addr.offset);
5489
57346661 5490 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4d6ed7c8 5491 {
0b6ae522
DJ		 5492 bfd_vma value = sym->st_value;
5493
5494 REMOVE_ARCH_BITS (value);
5495
4d6ed7c8
NC		 5496 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5497 && sym->st_name != 0
5498 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 5499 && addr.offset >= value
5500 && addr.offset - value < dist)
4d6ed7c8
NC		 5501 {
5502 best = sym;
0b6ae522 5503 dist = addr.offset - value;
4d6ed7c8
NC		 5504 if (!dist)
5505 break;
5506 }
5507 }
5508 if (best)
5509 {
57346661 5510 *symname = (best->st_name >= strtab_size
2b692964 5511 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 5512 *offset = dist;
5513 return;
5514 }
5515 *symname = NULL;
5516 *offset = addr.offset;
5517}
5518
5519static void
2cf0635d 5520dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 5521{
2cf0635d 5522 struct ia64_unw_table_entry * tp;
4d6ed7c8 5523 int in_body;
7036c0e1 5524
4d6ed7c8
NC		 5525 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5526 {
5527 bfd_vma stamp;
5528 bfd_vma offset;
2cf0635d
NC		 5529 const unsigned char * dp;
5530 const unsigned char * head;
5531 const char * procname;
4d6ed7c8 5532
57346661
AM		 5533 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5534 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 5535
5536 fputs ("\n<", stdout);
5537
5538 if (procname)
5539 {
5540 fputs (procname, stdout);
5541
5542 if (offset)
5543 printf ("+%lx", (unsigned long) offset);
5544 }
5545
5546 fputs (">: [", stdout);
5547 print_vma (tp->start.offset, PREFIX_HEX);
5548 fputc ('-', stdout);
5549 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 5550 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 5551 (unsigned long) (tp->info.offset - aux->seg_base));
5552
1949de15 5553 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 5554 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 5555
86f55779 5556 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 5557 (unsigned) UNW_VER (stamp),
5558 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5559 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5560 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 5561 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 5562
5563 if (UNW_VER (stamp) != 1)
5564 {
2b692964 5565 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 5566 continue;
5567 }
5568
5569 in_body = 0;
89fac5e3 5570 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
4d6ed7c8
NC		 5571 dp = unw_decode (dp, in_body, & in_body);
5572 }
5573}
5574
5575static int
2cf0635d
NC		 5576slurp_ia64_unwind_table (FILE * file,
5577 struct ia64_unw_aux_info * aux,
5578 Elf_Internal_Shdr * sec)
4d6ed7c8 5579{
89fac5e3 5580 unsigned long size, nrelas, i;
2cf0635d
NC		 5581 Elf_Internal_Phdr * seg;
5582 struct ia64_unw_table_entry * tep;
5583 Elf_Internal_Shdr * relsec;
5584 Elf_Internal_Rela * rela;
5585 Elf_Internal_Rela * rp;
5586 unsigned char * table;
5587 unsigned char * tp;
5588 Elf_Internal_Sym * sym;
5589 const char * relname;
4d6ed7c8 5590
4d6ed7c8
NC		 5591 /* First, find the starting address of the segment that includes
5592 this section: */
5593
5594 if (elf_header.e_phnum)
5595 {
d93f0186 5596 if (! get_program_headers (file))
4d6ed7c8 5597 return 0;
4d6ed7c8 5598
d93f0186
NC		 5599 for (seg = program_headers;
5600 seg < program_headers + elf_header.e_phnum;
5601 ++seg)
4d6ed7c8
NC		 5602 {
5603 if (seg->p_type != PT_LOAD)
5604 continue;
5605
5606 if (sec->sh_addr >= seg->p_vaddr
5607 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5608 {
5609 aux->seg_base = seg->p_vaddr;
5610 break;
5611 }
5612 }
4d6ed7c8
NC		 5613 }
5614
5615 /* Second, build the unwind table from the contents of the unwind section: */
5616 size = sec->sh_size;
3f5e193b
NC		 5617 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5618 _("unwind table"));
a6e9f9df
AM		 5619 if (!table)
5620 return 0;
4d6ed7c8 5621
3f5e193b
NC		 5622 aux->table = (struct ia64_unw_table_entry *)
5623 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
89fac5e3 5624 tep = aux->table;
c6a0c689 5625 for (tp = table; tp < table + size; ++tep)
4d6ed7c8
NC		 5626 {
5627 tep->start.section = SHN_UNDEF;
5628 tep->end.section = SHN_UNDEF;
5629 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 5630 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5631 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5632 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 5633 tep->start.offset += aux->seg_base;
5634 tep->end.offset += aux->seg_base;
5635 tep->info.offset += aux->seg_base;
5636 }
5637 free (table);
5638
41e92641 5639 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 5640 for (relsec = section_headers;
5641 relsec < section_headers + elf_header.e_shnum;
5642 ++relsec)
5643 {
5644 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 5645 || relsec->sh_info >= elf_header.e_shnum
5646 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 5647 continue;
5648
5649 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5650 & rela, & nrelas))
5651 return 0;
5652
5653 for (rp = rela; rp < rela + nrelas; ++rp)
5654 {
aca88567
NC		 5655 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5656 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 5657
0112cd26 5658 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 5659 {
e5fb9629 5660 warn (_("Skipping unexpected relocation type %s\n"), relname);
4d6ed7c8
NC		 5661 continue;
5662 }
5663
89fac5e3 5664 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 5665
89fac5e3 5666 switch (rp->r_offset/eh_addr_size % 3)
4d6ed7c8
NC		 5667 {
5668 case 0:
5669 aux->table[i].start.section = sym->st_shndx;
e466bc6e 5670 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5671 break;
5672 case 1:
5673 aux->table[i].end.section = sym->st_shndx;
e466bc6e 5674 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5675 break;
5676 case 2:
5677 aux->table[i].info.section = sym->st_shndx;
e466bc6e 5678 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5679 break;
5680 default:
5681 break;
5682 }
5683 }
5684
5685 free (rela);
5686 }
5687
89fac5e3 5688 aux->table_len = size / (3 * eh_addr_size);
4d6ed7c8
NC		 5689 return 1;
5690}
5691
5692static int
2cf0635d 5693ia64_process_unwind (FILE * file)
4d6ed7c8 5694{
2cf0635d
NC		 5695 Elf_Internal_Shdr * sec;
5696 Elf_Internal_Shdr * unwsec = NULL;
5697 Elf_Internal_Shdr * strsec;
89fac5e3 5698 unsigned long i, unwcount = 0, unwstart = 0;
57346661 5699 struct ia64_unw_aux_info aux;
f1467e33 5700
4d6ed7c8
NC		 5701 memset (& aux, 0, sizeof (aux));
5702
4d6ed7c8
NC		 5703 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5704 {
c256ffe7 5705 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 5706 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8
NC		 5707 {
5708 aux.nsyms = sec->sh_size / sec->sh_entsize;
9ad5cbcf 5709 aux.symtab = GET_ELF_SYMBOLS (file, sec);
4d6ed7c8 5710
4fbb74a6 5711 strsec = section_headers + sec->sh_link;
3f5e193b
NC		 5712 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5713 1, strsec->sh_size,
5714 _("string table"));
c256ffe7 5715 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 5716 }
5717 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 5718 unwcount++;
5719 }
5720
5721 if (!unwcount)
5722 printf (_("\nThere are no unwind sections in this file.\n"));
5723
5724 while (unwcount-- > 0)
5725 {
2cf0635d 5726 char * suffix;
579f31ac
JJ		 5727 size_t len, len2;
5728
5729 for (i = unwstart, sec = section_headers + unwstart;
5730 i < elf_header.e_shnum; ++i, ++sec)
5731 if (sec->sh_type == SHT_IA_64_UNWIND)
5732 {
5733 unwsec = sec;
5734 break;
5735 }
5736
5737 unwstart = i + 1;
5738 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
5739
e4b17d5c
L		 5740 if ((unwsec->sh_flags & SHF_GROUP) != 0)
5741 {
5742 /* We need to find which section group it is in. */
2cf0635d 5743 struct group_list * g = section_headers_groups [i]->root;
e4b17d5c
L		 5744
5745 for (; g != NULL; g = g->next)
5746 {
4fbb74a6 5747 sec = section_headers + g->section_index;
18bd398b
NC		 5748
5749 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
57346661 5750 break;
e4b17d5c
L		 5751 }
5752
5753 if (g == NULL)
5754 i = elf_header.e_shnum;
5755 }
18bd398b 5756 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 5757 {
18bd398b 5758 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 5759 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
5760 suffix = SECTION_NAME (unwsec) + len;
5761 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5762 ++i, ++sec)
18bd398b
NC		 5763 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
5764 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 5765 break;
5766 }
5767 else
5768 {
5769 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 5770 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 5771 len = sizeof (ELF_STRING_ia64_unwind) - 1;
5772 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
5773 suffix = "";
18bd398b 5774 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 5775 suffix = SECTION_NAME (unwsec) + len;
5776 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5777 ++i, ++sec)
18bd398b
NC		 5778 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
5779 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 5780 break;
5781 }
5782
5783 if (i == elf_header.e_shnum)
5784 {
5785 printf (_("\nCould not find unwind info section for "));
5786
5787 if (string_table == NULL)
5788 printf ("%d", unwsec->sh_name);
5789 else
3a1a2036 5790 printf (_("'%s'"), SECTION_NAME (unwsec));
579f31ac
JJ		 5791 }
5792 else
4d6ed7c8
NC		 5793 {
5794 aux.info_size = sec->sh_size;
5795 aux.info_addr = sec->sh_addr;
3f5e193b
NC		 5796 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
5797 aux.info_size,
5798 _("unwind info"));
4d6ed7c8 5799
579f31ac 5800 printf (_("\nUnwind section "));
4d6ed7c8 5801
579f31ac
JJ		 5802 if (string_table == NULL)
5803 printf ("%d", unwsec->sh_name);
5804 else
3a1a2036 5805 printf (_("'%s'"), SECTION_NAME (unwsec));
4d6ed7c8 5806
579f31ac 5807 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 5808 (unsigned long) unwsec->sh_offset,
89fac5e3 5809 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 5810
579f31ac 5811 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4d6ed7c8 5812
579f31ac
JJ		 5813 if (aux.table_len > 0)
5814 dump_ia64_unwind (& aux);
5815
5816 if (aux.table)
5817 free ((char *) aux.table);
5818 if (aux.info)
5819 free ((char *) aux.info);
5820 aux.table = NULL;
5821 aux.info = NULL;
5822 }
4d6ed7c8 5823 }
4d6ed7c8 5824
4d6ed7c8
NC		 5825 if (aux.symtab)
5826 free (aux.symtab);
5827 if (aux.strtab)
5828 free ((char *) aux.strtab);
5829
5830 return 1;
5831}
5832
3f5e193b
NC		 5833struct hppa_unw_table_entry
5834 {
5835 struct absaddr start;
5836 struct absaddr end;
5837 unsigned int Cannot_unwind:1; /* 0 */
5838 unsigned int Millicode:1; /* 1 */
5839 unsigned int Millicode_save_sr0:1; /* 2 */
5840 unsigned int Region_description:2; /* 3..4 */
5841 unsigned int reserved1:1; /* 5 */
5842 unsigned int Entry_SR:1; /* 6 */
5843 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
5844 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
5845 unsigned int Args_stored:1; /* 16 */
5846 unsigned int Variable_Frame:1; /* 17 */
5847 unsigned int Separate_Package_Body:1; /* 18 */
5848 unsigned int Frame_Extension_Millicode:1; /* 19 */
5849 unsigned int Stack_Overflow_Check:1; /* 20 */
5850 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
5851 unsigned int Ada_Region:1; /* 22 */
5852 unsigned int cxx_info:1; /* 23 */
5853 unsigned int cxx_try_catch:1; /* 24 */
5854 unsigned int sched_entry_seq:1; /* 25 */
5855 unsigned int reserved2:1; /* 26 */
5856 unsigned int Save_SP:1; /* 27 */
5857 unsigned int Save_RP:1; /* 28 */
5858 unsigned int Save_MRP_in_frame:1; /* 29 */
5859 unsigned int extn_ptr_defined:1; /* 30 */
5860 unsigned int Cleanup_defined:1; /* 31 */
5861
5862 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
5863 unsigned int HP_UX_interrupt_marker:1; /* 1 */
5864 unsigned int Large_frame:1; /* 2 */
5865 unsigned int Pseudo_SP_Set:1; /* 3 */
5866 unsigned int reserved4:1; /* 4 */
5867 unsigned int Total_frame_size:27; /* 5..31 */
5868 };
5869
57346661
AM		 5870struct hppa_unw_aux_info
5871 {
3f5e193b 5872 struct hppa_unw_table_entry *table; /* Unwind table. */
57346661
AM		 5873 unsigned long table_len; /* Length of unwind table. */
5874 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 5875 Elf_Internal_Sym * symtab; /* The symbol table. */
57346661 5876 unsigned long nsyms; /* Number of symbols. */
2cf0635d 5877 char * strtab; /* The string table. */
57346661
AM		 5878 unsigned long strtab_size; /* Size of string table. */
5879 };
5880
5881static void
2cf0635d 5882dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 5883{
2cf0635d 5884 struct hppa_unw_table_entry * tp;
57346661 5885
57346661
AM		 5886 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5887 {
5888 bfd_vma offset;
2cf0635d 5889 const char * procname;
57346661
AM		 5890
5891 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5892 aux->strtab_size, tp->start, &procname,
5893 &offset);
5894
5895 fputs ("\n<", stdout);
5896
5897 if (procname)
5898 {
5899 fputs (procname, stdout);
5900
5901 if (offset)
5902 printf ("+%lx", (unsigned long) offset);
5903 }
5904
5905 fputs (">: [", stdout);
5906 print_vma (tp->start.offset, PREFIX_HEX);
5907 fputc ('-', stdout);
5908 print_vma (tp->end.offset, PREFIX_HEX);
5909 printf ("]\n\t");
5910
18bd398b
NC		 5911#define PF(_m) if (tp->_m) printf (#_m " ");
5912#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 5913 PF(Cannot_unwind);
5914 PF(Millicode);
5915 PF(Millicode_save_sr0);
18bd398b 5916 /* PV(Region_description); */
57346661
AM		 5917 PF(Entry_SR);
5918 PV(Entry_FR);
5919 PV(Entry_GR);
5920 PF(Args_stored);
5921 PF(Variable_Frame);
5922 PF(Separate_Package_Body);
5923 PF(Frame_Extension_Millicode);
5924 PF(Stack_Overflow_Check);
5925 PF(Two_Instruction_SP_Increment);
5926 PF(Ada_Region);
5927 PF(cxx_info);
5928 PF(cxx_try_catch);
5929 PF(sched_entry_seq);
5930 PF(Save_SP);
5931 PF(Save_RP);
5932 PF(Save_MRP_in_frame);
5933 PF(extn_ptr_defined);
5934 PF(Cleanup_defined);
5935 PF(MPE_XL_interrupt_marker);
5936 PF(HP_UX_interrupt_marker);
5937 PF(Large_frame);
5938 PF(Pseudo_SP_Set);
5939 PV(Total_frame_size);
5940#undef PF
5941#undef PV
5942 }
5943
18bd398b 5944 printf ("\n");
57346661
AM		 5945}
5946
5947static int
2cf0635d
NC		 5948slurp_hppa_unwind_table (FILE * file,
5949 struct hppa_unw_aux_info * aux,
5950 Elf_Internal_Shdr * sec)
57346661 5951{
1c0751b2 5952 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 5953 Elf_Internal_Phdr * seg;
5954 struct hppa_unw_table_entry * tep;
5955 Elf_Internal_Shdr * relsec;
5956 Elf_Internal_Rela * rela;
5957 Elf_Internal_Rela * rp;
5958 unsigned char * table;
5959 unsigned char * tp;
5960 Elf_Internal_Sym * sym;
5961 const char * relname;
57346661 5962
57346661
AM		 5963 /* First, find the starting address of the segment that includes
5964 this section. */
5965
5966 if (elf_header.e_phnum)
5967 {
5968 if (! get_program_headers (file))
5969 return 0;
5970
5971 for (seg = program_headers;
5972 seg < program_headers + elf_header.e_phnum;
5973 ++seg)
5974 {
5975 if (seg->p_type != PT_LOAD)
5976 continue;
5977
5978 if (sec->sh_addr >= seg->p_vaddr
5979 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5980 {
5981 aux->seg_base = seg->p_vaddr;
5982 break;
5983 }
5984 }
5985 }
5986
5987 /* Second, build the unwind table from the contents of the unwind
5988 section. */
5989 size = sec->sh_size;
3f5e193b
NC		 5990 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5991 _("unwind table"));
57346661
AM		 5992 if (!table)
5993 return 0;
5994
1c0751b2
DA		 5995 unw_ent_size = 16;
5996 nentries = size / unw_ent_size;
5997 size = unw_ent_size * nentries;
57346661 5998
3f5e193b
NC		 5999 tep = aux->table = (struct hppa_unw_table_entry *)
6000 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 6001
1c0751b2 6002 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 6003 {
6004 unsigned int tmp1, tmp2;
6005
6006 tep->start.section = SHN_UNDEF;
6007 tep->end.section = SHN_UNDEF;
6008
1c0751b2
DA		 6009 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6010 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6011 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6012 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6013
6014 tep->start.offset += aux->seg_base;
6015 tep->end.offset += aux->seg_base;
57346661
AM		 6016
6017 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6018 tep->Millicode = (tmp1 >> 30) & 0x1;
6019 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6020 tep->Region_description = (tmp1 >> 27) & 0x3;
6021 tep->reserved1 = (tmp1 >> 26) & 0x1;
6022 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6023 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6024 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6025 tep->Args_stored = (tmp1 >> 15) & 0x1;
6026 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6027 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6028 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6029 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6030 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6031 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6032 tep->cxx_info = (tmp1 >> 8) & 0x1;
6033 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6034 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6035 tep->reserved2 = (tmp1 >> 5) & 0x1;
6036 tep->Save_SP = (tmp1 >> 4) & 0x1;
6037 tep->Save_RP = (tmp1 >> 3) & 0x1;
6038 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6039 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6040 tep->Cleanup_defined = tmp1 & 0x1;
6041
6042 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6043 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6044 tep->Large_frame = (tmp2 >> 29) & 0x1;
6045 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6046 tep->reserved4 = (tmp2 >> 27) & 0x1;
6047 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 6048 }
6049 free (table);
6050
6051 /* Third, apply any relocations to the unwind table. */
57346661
AM		 6052 for (relsec = section_headers;
6053 relsec < section_headers + elf_header.e_shnum;
6054 ++relsec)
6055 {
6056 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6057 || relsec->sh_info >= elf_header.e_shnum
6058 || section_headers + relsec->sh_info != sec)
57346661
AM		 6059 continue;
6060
6061 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6062 & rela, & nrelas))
6063 return 0;
6064
6065 for (rp = rela; rp < rela + nrelas; ++rp)
6066 {
aca88567
NC		 6067 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6068 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 6069
6070 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 6071 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 6072 {
6073 warn (_("Skipping unexpected relocation type %s\n"), relname);
6074 continue;
6075 }
6076
6077 i = rp->r_offset / unw_ent_size;
6078
89fac5e3 6079 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 6080 {
6081 case 0:
6082 aux->table[i].start.section = sym->st_shndx;
1e456d54 6083 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 6084 break;
6085 case 1:
6086 aux->table[i].end.section = sym->st_shndx;
1e456d54 6087 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 6088 break;
6089 default:
6090 break;
6091 }
6092 }
6093
6094 free (rela);
6095 }
6096
1c0751b2 6097 aux->table_len = nentries;
57346661
AM		 6098
6099 return 1;
6100}
6101
6102static int
2cf0635d 6103hppa_process_unwind (FILE * file)
57346661 6104{
57346661 6105 struct hppa_unw_aux_info aux;
2cf0635d
NC		 6106 Elf_Internal_Shdr * unwsec = NULL;
6107 Elf_Internal_Shdr * strsec;
6108 Elf_Internal_Shdr * sec;
18bd398b 6109 unsigned long i;
57346661
AM		 6110
6111 memset (& aux, 0, sizeof (aux));
6112
c256ffe7
JJ		 6113 if (string_table == NULL)
6114 return 1;
57346661
AM		 6115
6116 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6117 {
c256ffe7 6118 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6119 && sec->sh_link < elf_header.e_shnum)
57346661
AM		 6120 {
6121 aux.nsyms = sec->sh_size / sec->sh_entsize;
6122 aux.symtab = GET_ELF_SYMBOLS (file, sec);
6123
4fbb74a6 6124 strsec = section_headers + sec->sh_link;
3f5e193b
NC		 6125 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6126 1, strsec->sh_size,
6127 _("string table"));
c256ffe7 6128 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 6129 }
18bd398b 6130 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 6131 unwsec = sec;
6132 }
6133
6134 if (!unwsec)
6135 printf (_("\nThere are no unwind sections in this file.\n"));
6136
6137 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6138 {
18bd398b 6139 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 6140 {
57346661
AM		 6141 printf (_("\nUnwind section "));
6142 printf (_("'%s'"), SECTION_NAME (sec));
6143
6144 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6145 (unsigned long) sec->sh_offset,
89fac5e3 6146 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 6147
6148 slurp_hppa_unwind_table (file, &aux, sec);
6149 if (aux.table_len > 0)
6150 dump_hppa_unwind (&aux);
6151
6152 if (aux.table)
6153 free ((char *) aux.table);
6154 aux.table = NULL;
6155 }
6156 }
6157
6158 if (aux.symtab)
6159 free (aux.symtab);
6160 if (aux.strtab)
6161 free ((char *) aux.strtab);
6162
6163 return 1;
6164}
6165
0b6ae522
DJ		 6166struct arm_section
6167{
6168 unsigned char *data;
6169
6170 Elf_Internal_Shdr *sec;
6171 Elf_Internal_Rela *rela;
6172 unsigned long nrelas;
6173 unsigned int rel_type;
6174
6175 Elf_Internal_Rela *next_rela;
6176};
6177
6178struct arm_unw_aux_info
6179{
6180 FILE *file;
6181
6182 Elf_Internal_Sym *symtab; /* The symbol table. */
6183 unsigned long nsyms; /* Number of symbols. */
6184 char *strtab; /* The string table. */
6185 unsigned long strtab_size; /* Size of string table. */
6186};
6187
6188static const char *
6189arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6190 bfd_vma fn, struct absaddr addr)
6191{
6192 const char *procname;
6193 bfd_vma sym_offset;
6194
6195 if (addr.section == SHN_UNDEF)
6196 addr.offset = fn;
6197
6198 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6199 aux->strtab_size, addr, &procname,
6200 &sym_offset);
6201
6202 print_vma (fn, PREFIX_HEX);
6203
6204 if (procname)
6205 {
6206 fputs (" <", stdout);
6207 fputs (procname, stdout);
6208
6209 if (sym_offset)
6210 printf ("+0x%lx", (unsigned long) sym_offset);
6211 fputc ('>', stdout);
6212 }
6213
6214 return procname;
6215}
6216
6217static void
6218arm_free_section (struct arm_section *arm_sec)
6219{
6220 if (arm_sec->data != NULL)
6221 free (arm_sec->data);
6222
6223 if (arm_sec->rela != NULL)
6224 free (arm_sec->rela);
6225}
6226
6227static int
6228arm_section_get_word (struct arm_unw_aux_info *aux,
6229 struct arm_section *arm_sec,
6230 Elf_Internal_Shdr *sec, bfd_vma word_offset,
6231 unsigned int *wordp, struct absaddr *addr)
6232{
6233 Elf_Internal_Rela *rp;
6234 Elf_Internal_Sym *sym;
6235 const char * relname;
6236 unsigned int word;
6237 bfd_boolean wrapped;
6238
6239 addr->section = SHN_UNDEF;
6240 addr->offset = 0;
6241
6242 if (sec != arm_sec->sec)
6243 {
6244 Elf_Internal_Shdr *relsec;
6245
6246 arm_free_section (arm_sec);
6247
6248 arm_sec->sec = sec;
6249 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6250 sec->sh_size, _("unwind data"));
6251
6252 arm_sec->rela = NULL;
6253 arm_sec->nrelas = 0;
6254
6255 for (relsec = section_headers;
6256 relsec < section_headers + elf_header.e_shnum;
6257 ++relsec)
6258 {
6259 if (relsec->sh_info >= elf_header.e_shnum
6260 || section_headers + relsec->sh_info != sec)
6261 continue;
6262
6263 if (relsec->sh_type == SHT_REL)
6264 {
6265 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6266 relsec->sh_size,
6267 & arm_sec->rela, & arm_sec->nrelas))
6268 return 0;
6269 break;
6270 }
6271 else if (relsec->sh_type == SHT_RELA)
6272 {
6273 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6274 relsec->sh_size,
6275 & arm_sec->rela, & arm_sec->nrelas))
6276 return 0;
6277 break;
6278 }
6279 }
6280
6281 arm_sec->next_rela = arm_sec->rela;
6282 }
6283
6284 if (arm_sec->data == NULL)
6285 return 0;
6286
6287 word = byte_get (arm_sec->data + word_offset, 4);
6288
6289 wrapped = FALSE;
6290 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6291 {
6292 bfd_vma prelval, offset;
6293
6294 if (rp->r_offset > word_offset && !wrapped)
6295 {
6296 rp = arm_sec->rela;
6297 wrapped = TRUE;
6298 }
6299 if (rp->r_offset > word_offset)
6300 break;
6301
6302 if (rp->r_offset & 3)
6303 {
6304 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6305 (unsigned long) rp->r_offset);
6306 continue;
6307 }
6308
6309 if (rp->r_offset < word_offset)
6310 continue;
6311
6312 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6313
6314 if (streq (relname, "R_ARM_NONE"))
6315 continue;
6316
6317 if (! streq (relname, "R_ARM_PREL31"))
6318 {
6319 warn (_("Skipping unexpected relocation type %s\n"), relname);
6320 continue;
6321 }
6322
6323 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6324
6325 if (arm_sec->rel_type == SHT_REL)
6326 {
6327 offset = word & 0x7fffffff;
6328 if (offset & 0x40000000)
6329 offset |= ~ (bfd_vma) 0x7fffffff;
6330 }
6331 else
6332 offset = rp->r_addend;
6333
6334 offset += sym->st_value;
6335 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6336
6337 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6338 addr->section = sym->st_shndx;
6339 addr->offset = offset;
6340 break;
6341 }
6342
6343 *wordp = word;
6344 arm_sec->next_rela = rp;
6345
6346 return 1;
6347}
6348
6349static void
6350decode_arm_unwind (struct arm_unw_aux_info *aux,
6351 unsigned int word, unsigned int remaining,
6352 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6353 struct arm_section *data_arm_sec)
6354{
6355 int per_index;
6356 unsigned int more_words;
6357 struct absaddr addr;
6358
6359#define ADVANCE \
6360 if (remaining == 0 && more_words) \
6361 { \
6362 data_offset += 4; \
6363 if (!arm_section_get_word (aux, data_arm_sec, data_sec, \
6364 data_offset, &word, &addr)) \
6365 return; \
6366 remaining = 4; \
6367 more_words--; \
6368 } \
6369
6370#define GET_OP(OP) \
6371 ADVANCE; \
6372 if (remaining) \
6373 { \
6374 remaining--; \
6375 (OP) = word >> 24; \
6376 word <<= 8; \
6377 } \
6378 else \
6379 { \
2b692964 6380 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 6381 return; \
6382 } \
cc5914eb 6383 printf ("0x%02x ", OP)
0b6ae522
DJ		 6384
6385 if (remaining == 0)
6386 {
6387 /* Fetch the first word. */
6388 if (!arm_section_get_word (aux, data_arm_sec, data_sec, data_offset,
6389 &word, &addr))
6390 return;
6391 remaining = 4;
6392 }
6393
6394 if ((word & 0x80000000) == 0)
6395 {
6396 /* Expand prel31 for personality routine. */
6397 bfd_vma fn;
6398 const char *procname;
6399
6400 fn = word;
6401 if (fn & 0x40000000)
6402 fn |= ~ (bfd_vma) 0x7fffffff;
6403 fn = fn + data_sec->sh_addr + data_offset;
6404
6405 printf (_(" Personality routine: "));
6406 procname = arm_print_vma_and_name (aux, fn, addr);
6407 fputc ('\n', stdout);
6408
6409 /* The GCC personality routines use the standard compact
6410 encoding, starting with one byte giving the number of
6411 words. */
6412 if (procname != NULL
6413 && (const_strneq (procname, "__gcc_personality_v0")
6414 || const_strneq (procname, "__gxx_personality_v0")
6415 || const_strneq (procname, "__gcj_personality_v0")
6416 || const_strneq (procname, "__gnu_objc_personality_v0")))
6417 {
6418 remaining = 0;
6419 more_words = 1;
6420 ADVANCE;
6421 if (!remaining)
6422 {
6423 printf (_(" [Truncated data]\n"));
6424 return;
6425 }
6426 more_words = word >> 24;
6427 word <<= 8;
6428 remaining--;
6429 }
6430 else
6431 return;
6432 }
6433 else
6434 {
0b6ae522
DJ		 6435 per_index = (word >> 24) & 0x7f;
6436 if (per_index != 0 && per_index != 1 && per_index != 2)
6437 {
6438 printf (_(" [reserved compact index %d]\n"), per_index);
6439 return;
6440 }
6441
6442 printf (_(" Compact model %d\n"), per_index);
6443 if (per_index == 0)
6444 {
6445 more_words = 0;
6446 word <<= 8;
6447 remaining--;
6448 }
6449 else
6450 {
6451 more_words = (word >> 16) & 0xff;
6452 word <<= 16;
6453 remaining -= 2;
6454 }
6455 }
6456
6457 /* Decode the unwinding instructions. */
6458 while (1)
6459 {
6460 unsigned int op, op2;
6461
6462 ADVANCE;
6463 if (remaining == 0)
6464 break;
6465 remaining--;
6466 op = word >> 24;
6467 word <<= 8;
6468
cc5914eb 6469 printf (" 0x%02x ", op);
0b6ae522
DJ		 6470
6471 if ((op & 0xc0) == 0x00)
6472 {
6473 int offset = ((op & 0x3f) << 2) + 4;
61865e30 6474
cc5914eb 6475 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 6476 }
6477 else if ((op & 0xc0) == 0x40)
6478 {
6479 int offset = ((op & 0x3f) << 2) + 4;
61865e30 6480
cc5914eb 6481 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 6482 }
6483 else if ((op & 0xf0) == 0x80)
6484 {
6485 GET_OP (op2);
6486 if (op == 0x80 && op2 == 0)
6487 printf (_("Refuse to unwind"));
6488 else
6489 {
6490 unsigned int mask = ((op & 0x0f) << 8) | op2;
6491 int first = 1;
6492 int i;
2b692964 6493
0b6ae522
DJ		 6494 printf ("pop {");
6495 for (i = 0; i < 12; i++)
6496 if (mask & (1 << i))
6497 {
6498 if (first)
6499 first = 0;
6500 else
6501 printf (", ");
6502 printf ("r%d", 4 + i);
6503 }
6504 printf ("}");
6505 }
6506 }
6507 else if ((op & 0xf0) == 0x90)
6508 {
6509 if (op == 0x9d || op == 0x9f)
6510 printf (_(" [Reserved]"));
6511 else
cc5914eb 6512 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 6513 }
6514 else if ((op & 0xf0) == 0xa0)
6515 {
6516 int end = 4 + (op & 0x07);
6517 int first = 1;
6518 int i;
61865e30 6519
0b6ae522
DJ		 6520 printf (" pop {");
6521 for (i = 4; i <= end; i++)
6522 {
6523 if (first)
6524 first = 0;
6525 else
6526 printf (", ");
6527 printf ("r%d", i);
6528 }
6529 if (op & 0x08)
6530 {
6531 if (first)
6532 printf (", ");
6533 printf ("r14");
6534 }
6535 printf ("}");
6536 }
6537 else if (op == 0xb0)
6538 printf (_(" finish"));
6539 else if (op == 0xb1)
6540 {
6541 GET_OP (op2);
6542 if (op2 == 0 || (op2 & 0xf0) != 0)
6543 printf (_("[Spare]"));
6544 else
6545 {
6546 unsigned int mask = op2 & 0x0f;
6547 int first = 1;
6548 int i;
61865e30 6549
0b6ae522
DJ		 6550 printf ("pop {");
6551 for (i = 0; i < 12; i++)
6552 if (mask & (1 << i))
6553 {
6554 if (first)
6555 first = 0;
6556 else
6557 printf (", ");
6558 printf ("r%d", i);
6559 }
6560 printf ("}");
6561 }
6562 }
6563 else if (op == 0xb2)
6564 {
b115cf96 6565 unsigned char buf[9];
0b6ae522
DJ		 6566 unsigned int i, len;
6567 unsigned long offset;
61865e30 6568
b115cf96 6569 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 6570 {
6571 GET_OP (buf[i]);
6572 if ((buf[i] & 0x80) == 0)
6573 break;
6574 }
6575 assert (i < sizeof (buf));
6576 offset = read_uleb128 (buf, &len);
6577 assert (len == i + 1);
6578 offset = offset * 4 + 0x204;
cc5914eb 6579 printf ("vsp = vsp + %ld", offset);
0b6ae522 6580 }
61865e30 6581 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 6582 {
61865e30
NC		 6583 unsigned int first, last;
6584
6585 GET_OP (op2);
6586 first = op2 >> 4;
6587 last = op2 & 0x0f;
6588 if (op == 0xc8)
6589 first = first + 16;
6590 printf ("pop {D%d", first);
6591 if (last)
6592 printf ("-D%d", first + last);
6593 printf ("}");
6594 }
6595 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
6596 {
6597 unsigned int count = op & 0x07;
6598
6599 printf ("pop {D8");
6600 if (count)
6601 printf ("-D%d", 8 + count);
6602 printf ("}");
6603 }
6604 else if (op >= 0xc0 && op <= 0xc5)
6605 {
6606 unsigned int count = op & 0x07;
6607
6608 printf (" pop {wR10");
6609 if (count)
6610 printf ("-wR%d", 10 + count);
6611 printf ("}");
6612 }
6613 else if (op == 0xc6)
6614 {
6615 unsigned int first, last;
6616
6617 GET_OP (op2);
6618 first = op2 >> 4;
6619 last = op2 & 0x0f;
6620 printf ("pop {wR%d", first);
6621 if (last)
6622 printf ("-wR%d", first + last);
6623 printf ("}");
6624 }
6625 else if (op == 0xc7)
6626 {
6627 GET_OP (op2);
6628 if (op2 == 0 || (op2 & 0xf0) != 0)
6629 printf (_("[Spare]"));
0b6ae522
DJ		 6630 else
6631 {
61865e30
NC		 6632 unsigned int mask = op2 & 0x0f;
6633 int first = 1;
6634 int i;
6635
6636 printf ("pop {");
6637 for (i = 0; i < 4; i++)
6638 if (mask & (1 << i))
6639 {
6640 if (first)
6641 first = 0;
6642 else
6643 printf (", ");
6644 printf ("wCGR%d", i);
6645 }
6646 printf ("}");
0b6ae522
DJ		 6647 }
6648 }
61865e30
NC		 6649 else
6650 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 6651 printf ("\n");
6652 }
6653
6654 /* Decode the descriptors. Not implemented. */
6655}
6656
6657static void
6658dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
6659{
6660 struct arm_section exidx_arm_sec, extab_arm_sec;
6661 unsigned int i, exidx_len;
6662
6663 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
6664 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
6665 exidx_len = exidx_sec->sh_size / 8;
6666
6667 for (i = 0; i < exidx_len; i++)
6668 {
6669 unsigned int exidx_fn, exidx_entry;
6670 struct absaddr fn_addr, entry_addr;
6671 bfd_vma fn;
6672
6673 fputc ('\n', stdout);
6674
6675 if (!arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6676 8 * i, &exidx_fn, &fn_addr)
6677 || !arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6678 8 * i + 4, &exidx_entry, &entry_addr))
6679 {
6680 arm_free_section (&exidx_arm_sec);
6681 arm_free_section (&extab_arm_sec);
6682 return;
6683 }
6684
6685 fn = exidx_fn & 0x7fffffff;
6686 if (fn & 0x40000000)
6687 fn |= ~ (bfd_vma) 0x7fffffff;
6688 fn = fn + exidx_sec->sh_addr + 8 * i;
6689
6690 arm_print_vma_and_name (aux, fn, entry_addr);
6691 fputs (": ", stdout);
6692
6693 if (exidx_entry == 1)
6694 {
6695 print_vma (exidx_entry, PREFIX_HEX);
6696 fputs (" [cantunwind]\n", stdout);
6697 }
6698 else if (exidx_entry & 0x80000000)
6699 {
6700 print_vma (exidx_entry, PREFIX_HEX);
6701 fputc ('\n', stdout);
6702 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
6703 }
6704 else
6705 {
8f73510c 6706 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 6707 Elf_Internal_Shdr *table_sec;
6708
6709 fputs ("@", stdout);
6710 table = exidx_entry;
6711 if (table & 0x40000000)
6712 table |= ~ (bfd_vma) 0x7fffffff;
6713 table = table + exidx_sec->sh_addr + 8 * i + 4;
6714 print_vma (table, PREFIX_HEX);
6715 printf ("\n");
6716
6717 /* Locate the matching .ARM.extab. */
6718 if (entry_addr.section != SHN_UNDEF
6719 && entry_addr.section < elf_header.e_shnum)
6720 {
6721 table_sec = section_headers + entry_addr.section;
6722 table_offset = entry_addr.offset;
6723 }
6724 else
6725 {
6726 table_sec = find_section_by_address (table);
6727 if (table_sec != NULL)
6728 table_offset = table - table_sec->sh_addr;
6729 }
6730 if (table_sec == NULL)
6731 {
6732 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
6733 (unsigned long) table);
6734 continue;
6735 }
6736 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
6737 &extab_arm_sec);
6738 }
6739 }
6740
6741 printf ("\n");
6742
6743 arm_free_section (&exidx_arm_sec);
6744 arm_free_section (&extab_arm_sec);
6745}
6746
6747static int
6748arm_process_unwind (FILE *file)
6749{
6750 struct arm_unw_aux_info aux;
6751 Elf_Internal_Shdr *unwsec = NULL;
6752 Elf_Internal_Shdr *strsec;
6753 Elf_Internal_Shdr *sec;
6754 unsigned long i;
6755
6756 memset (& aux, 0, sizeof (aux));
6757 aux.file = file;
6758
6759 if (string_table == NULL)
6760 return 1;
6761
6762 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6763 {
6764 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
6765 {
6766 aux.nsyms = sec->sh_size / sec->sh_entsize;
6767 aux.symtab = GET_ELF_SYMBOLS (file, sec);
6768
6769 strsec = section_headers + sec->sh_link;
6770 aux.strtab = get_data (NULL, file, strsec->sh_offset,
6771 1, strsec->sh_size, _("string table"));
6772 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6773 }
6774 else if (sec->sh_type == SHT_ARM_EXIDX)
6775 unwsec = sec;
6776 }
6777
6778 if (!unwsec)
6779 printf (_("\nThere are no unwind sections in this file.\n"));
6780
6781 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6782 {
6783 if (sec->sh_type == SHT_ARM_EXIDX)
6784 {
6785 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
6786 SECTION_NAME (sec),
6787 (unsigned long) sec->sh_offset,
6788 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
6789
6790 dump_arm_unwind (&aux, sec);
6791 }
6792 }
6793
6794 if (aux.symtab)
6795 free (aux.symtab);
6796 if (aux.strtab)
6797 free ((char *) aux.strtab);
6798
6799 return 1;
6800}
6801
57346661 6802static int
2cf0635d 6803process_unwind (FILE * file)
57346661 6804{
2cf0635d
NC		 6805 struct unwind_handler
6806 {
57346661 6807 int machtype;
2cf0635d
NC		 6808 int (* handler)(FILE *);
6809 } handlers[] =
6810 {
0b6ae522 6811 { EM_ARM, arm_process_unwind },
57346661
AM		 6812 { EM_IA_64, ia64_process_unwind },
6813 { EM_PARISC, hppa_process_unwind },
6814 { 0, 0 }
6815 };
6816 int i;
6817
6818 if (!do_unwind)
6819 return 1;
6820
6821 for (i = 0; handlers[i].handler != NULL; i++)
6822 if (elf_header.e_machine == handlers[i].machtype)
18bd398b 6823 return handlers[i].handler (file);
57346661
AM		 6824
6825 printf (_("\nThere are no unwind sections in this file.\n"));
6826 return 1;
6827}
6828
252b5132 6829static void
2cf0635d 6830dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 6831{
6832 switch (entry->d_tag)
6833 {
6834 case DT_MIPS_FLAGS:
6835 if (entry->d_un.d_val == 0)
2b692964 6836 printf (_("NONE\n"));
252b5132
RH		 6837 else
6838 {
6839 static const char * opts[] =
6840 {
6841 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
6842 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
6843 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
6844 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
6845 "RLD_ORDER_SAFE"
6846 };
6847 unsigned int cnt;
6848 int first = 1;
2b692964 6849
60bca95a 6850 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 6851 if (entry->d_un.d_val & (1 << cnt))
6852 {
6853 printf ("%s%s", first ? "" : " ", opts[cnt]);
6854 first = 0;
6855 }
6856 puts ("");
6857 }
6858 break;
103f02d3 6859
252b5132 6860 case DT_MIPS_IVERSION:
d79b3d50 6861 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
2b692964 6862 printf (_("Interface Version: %s\n"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 6863 else
2b692964 6864 printf (_("<corrupt: %ld>\n"), (long) entry->d_un.d_ptr);
252b5132 6865 break;
103f02d3 6866
252b5132
RH		 6867 case DT_MIPS_TIME_STAMP:
6868 {
6869 char timebuf[20];
2cf0635d 6870 struct tm * tmp;
50da7a9c 6871
91d6fa6a
NC		 6872 time_t atime = entry->d_un.d_val;
6873 tmp = gmtime (&atime);
e9e44622
JJ		 6874 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
6875 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
6876 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
2b692964 6877 printf (_("Time Stamp: %s\n"), timebuf);
252b5132
RH		 6878 }
6879 break;
103f02d3 6880
252b5132
RH		 6881 case DT_MIPS_RLD_VERSION:
6882 case DT_MIPS_LOCAL_GOTNO:
6883 case DT_MIPS_CONFLICTNO:
6884 case DT_MIPS_LIBLISTNO:
6885 case DT_MIPS_SYMTABNO:
6886 case DT_MIPS_UNREFEXTNO:
6887 case DT_MIPS_HIPAGENO:
6888 case DT_MIPS_DELTA_CLASS_NO:
6889 case DT_MIPS_DELTA_INSTANCE_NO:
6890 case DT_MIPS_DELTA_RELOC_NO:
6891 case DT_MIPS_DELTA_SYM_NO:
6892 case DT_MIPS_DELTA_CLASSSYM_NO:
6893 case DT_MIPS_COMPACT_SIZE:
6894 printf ("%ld\n", (long) entry->d_un.d_ptr);
6895 break;
103f02d3
UD		 6896
6897 default:
0af1713e 6898 printf ("%#lx\n", (unsigned long) entry->d_un.d_ptr);
103f02d3
UD		 6899 }
6900}
6901
103f02d3 6902static void
2cf0635d 6903dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 6904{
6905 switch (entry->d_tag)
6906 {
6907 case DT_HP_DLD_FLAGS:
6908 {
6909 static struct
6910 {
6911 long int bit;
2cf0635d 6912 const char * str;
5e220199
NC		 6913 }
6914 flags[] =
6915 {
6916 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
6917 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
6918 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
6919 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
6920 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
6921 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
6922 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
6923 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
6924 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
6925 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 6926 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
6927 { DT_HP_GST, "HP_GST" },
6928 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
6929 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
6930 { DT_HP_NODELETE, "HP_NODELETE" },
6931 { DT_HP_GROUP, "HP_GROUP" },
6932 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 6933 };
103f02d3 6934 int first = 1;
5e220199 6935 size_t cnt;
f7a99963 6936 bfd_vma val = entry->d_un.d_val;
103f02d3 6937
60bca95a 6938 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 6939 if (val & flags[cnt].bit)
30800947
NC		 6940 {
6941 if (! first)
6942 putchar (' ');
6943 fputs (flags[cnt].str, stdout);
6944 first = 0;
6945 val ^= flags[cnt].bit;
6946 }
76da6bbe 6947
103f02d3 6948 if (val != 0 || first)
f7a99963
NC		 6949 {
6950 if (! first)
6951 putchar (' ');
6952 print_vma (val, HEX);
6953 }
103f02d3
UD		 6954 }
6955 break;
76da6bbe 6956
252b5132 6957 default:
f7a99963
NC		 6958 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
6959 break;
252b5132 6960 }
35b1837e 6961 putchar ('\n');
252b5132
RH		 6962}
6963
28f997cf
TG		 6964#ifdef BFD64
6965
6966/* VMS vs Unix time offset and factor. */
6967
6968#define VMS_EPOCH_OFFSET 35067168000000000LL
6969#define VMS_GRANULARITY_FACTOR 10000000
6970
6971/* Display a VMS time in a human readable format. */
6972
6973static void
6974print_vms_time (bfd_int64_t vmstime)
6975{
6976 struct tm *tm;
6977 time_t unxtime;
6978
6979 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
6980 tm = gmtime (&unxtime);
6981 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
6982 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
6983 tm->tm_hour, tm->tm_min, tm->tm_sec);
6984}
6985#endif /* BFD64 */
6986
ecc51f48 6987static void
2cf0635d 6988dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 6989{
6990 switch (entry->d_tag)
6991 {
0de14b54 6992 case DT_IA_64_PLT_RESERVE:
bdf4d63a 6993 /* First 3 slots reserved. */
ecc51f48
NC		 6994 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
6995 printf (" -- ");
6996 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 6997 break;
6998
28f997cf
TG		 6999 case DT_IA_64_VMS_LINKTIME:
7000#ifdef BFD64
7001 print_vms_time (entry->d_un.d_val);
7002#endif
7003 break;
7004
7005 case DT_IA_64_VMS_LNKFLAGS:
7006 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7007 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7008 printf (" CALL_DEBUG");
7009 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7010 printf (" NOP0BUFS");
7011 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7012 printf (" P0IMAGE");
7013 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7014 printf (" MKTHREADS");
7015 if (entry->d_un.d_val & VMS_LF_UPCALLS)
7016 printf (" UPCALLS");
7017 if (entry->d_un.d_val & VMS_LF_IMGSTA)
7018 printf (" IMGSTA");
7019 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7020 printf (" INITIALIZE");
7021 if (entry->d_un.d_val & VMS_LF_MAIN)
7022 printf (" MAIN");
7023 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7024 printf (" EXE_INIT");
7025 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7026 printf (" TBK_IN_IMG");
7027 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7028 printf (" DBG_IN_IMG");
7029 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7030 printf (" TBK_IN_DSF");
7031 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7032 printf (" DBG_IN_DSF");
7033 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7034 printf (" SIGNATURES");
7035 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7036 printf (" REL_SEG_OFF");
7037 break;
7038
bdf4d63a
JJ		 7039 default:
7040 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7041 break;
ecc51f48 7042 }
bdf4d63a 7043 putchar ('\n');
ecc51f48
NC		 7044}
7045
252b5132 7046static int
2cf0635d 7047get_32bit_dynamic_section (FILE * file)
252b5132 7048{
2cf0635d
NC		 7049 Elf32_External_Dyn * edyn;
7050 Elf32_External_Dyn * ext;
7051 Elf_Internal_Dyn * entry;
103f02d3 7052
3f5e193b
NC		 7053 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7054 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 7055 if (!edyn)
7056 return 0;
103f02d3 7057
ba2685cc
AM		 7058/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7059 might not have the luxury of section headers. Look for the DT_NULL
7060 terminator to determine the number of entries. */
7061 for (ext = edyn, dynamic_nent = 0;
7062 (char *) ext < (char *) edyn + dynamic_size;
7063 ext++)
7064 {
7065 dynamic_nent++;
7066 if (BYTE_GET (ext->d_tag) == DT_NULL)
7067 break;
7068 }
252b5132 7069
3f5e193b
NC		 7070 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7071 sizeof (* entry));
b2d38a17 7072 if (dynamic_section == NULL)
252b5132 7073 {
9ea033b2
NC		 7074 error (_("Out of memory\n"));
7075 free (edyn);
7076 return 0;
7077 }
252b5132 7078
fb514b26 7079 for (ext = edyn, entry = dynamic_section;
ba2685cc 7080 entry < dynamic_section + dynamic_nent;
fb514b26 7081 ext++, entry++)
9ea033b2 7082 {
fb514b26
AM		 7083 entry->d_tag = BYTE_GET (ext->d_tag);
7084 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 7085 }
7086
9ea033b2
NC		 7087 free (edyn);
7088
7089 return 1;
7090}
7091
7092static int
2cf0635d 7093get_64bit_dynamic_section (FILE * file)
9ea033b2 7094{
2cf0635d
NC		 7095 Elf64_External_Dyn * edyn;
7096 Elf64_External_Dyn * ext;
7097 Elf_Internal_Dyn * entry;
103f02d3 7098
3f5e193b
NC		 7099 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7100 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 7101 if (!edyn)
7102 return 0;
103f02d3 7103
ba2685cc
AM		 7104/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7105 might not have the luxury of section headers. Look for the DT_NULL
7106 terminator to determine the number of entries. */
7107 for (ext = edyn, dynamic_nent = 0;
7108 (char *) ext < (char *) edyn + dynamic_size;
7109 ext++)
7110 {
7111 dynamic_nent++;
66543521 7112 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 7113 break;
7114 }
252b5132 7115
3f5e193b
NC		 7116 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7117 sizeof (* entry));
b2d38a17 7118 if (dynamic_section == NULL)
252b5132
RH		 7119 {
7120 error (_("Out of memory\n"));
7121 free (edyn);
7122 return 0;
7123 }
7124
fb514b26 7125 for (ext = edyn, entry = dynamic_section;
ba2685cc 7126 entry < dynamic_section + dynamic_nent;
fb514b26 7127 ext++, entry++)
252b5132 7128 {
66543521
AM		 7129 entry->d_tag = BYTE_GET (ext->d_tag);
7130 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 7131 }
7132
7133 free (edyn);
7134
9ea033b2
NC		 7135 return 1;
7136}
7137
e9e44622
JJ		 7138static void
7139print_dynamic_flags (bfd_vma flags)
d1133906 7140{
e9e44622 7141 int first = 1;
13ae64f3 7142
d1133906
NC		 7143 while (flags)
7144 {
7145 bfd_vma flag;
7146
7147 flag = flags & - flags;
7148 flags &= ~ flag;
7149
e9e44622
JJ		 7150 if (first)
7151 first = 0;
7152 else
7153 putc (' ', stdout);
13ae64f3 7154
d1133906
NC		 7155 switch (flag)
7156 {
e9e44622
JJ		 7157 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
7158 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
7159 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
7160 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
7161 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 7162 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 7163 }
7164 }
e9e44622 7165 puts ("");
d1133906
NC		 7166}
7167
b2d38a17
NC		 7168/* Parse and display the contents of the dynamic section. */
7169
9ea033b2 7170static int
2cf0635d 7171process_dynamic_section (FILE * file)
9ea033b2 7172{
2cf0635d 7173 Elf_Internal_Dyn * entry;
9ea033b2
NC		 7174
7175 if (dynamic_size == 0)
7176 {
7177 if (do_dynamic)
b2d38a17 7178 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 7179
7180 return 1;
7181 }
7182
7183 if (is_32bit_elf)
7184 {
b2d38a17 7185 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 7186 return 0;
7187 }
b2d38a17 7188 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 7189 return 0;
7190
252b5132
RH		 7191 /* Find the appropriate symbol table. */
7192 if (dynamic_symbols == NULL)
7193 {
86dba8ee
AM		 7194 for (entry = dynamic_section;
7195 entry < dynamic_section + dynamic_nent;
7196 ++entry)
252b5132 7197 {
c8286bd1 7198 Elf_Internal_Shdr section;
252b5132
RH		 7199
7200 if (entry->d_tag != DT_SYMTAB)
7201 continue;
7202
7203 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7204
7205 /* Since we do not know how big the symbol table is,
7206 we default to reading in the entire file (!) and
7207 processing that. This is overkill, I know, but it
e3c8793a 7208 should work. */
d93f0186 7209 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 7210
fb52b2f4
NC		 7211 if (archive_file_offset != 0)
7212 section.sh_size = archive_file_size - section.sh_offset;
7213 else
7214 {
7215 if (fseek (file, 0, SEEK_END))
591a748a 7216 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 7217
7218 section.sh_size = ftell (file) - section.sh_offset;
7219 }
252b5132 7220
9ea033b2 7221 if (is_32bit_elf)
9ad5cbcf 7222 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 7223 else
9ad5cbcf 7224 section.sh_entsize = sizeof (Elf64_External_Sym);
252b5132 7225
9ad5cbcf 7226 num_dynamic_syms = section.sh_size / section.sh_entsize;
19936277 7227 if (num_dynamic_syms < 1)
252b5132
RH		 7228 {
7229 error (_("Unable to determine the number of symbols to load\n"));
7230 continue;
7231 }
7232
9ad5cbcf 7233 dynamic_symbols = GET_ELF_SYMBOLS (file, &section);
252b5132
RH		 7234 }
7235 }
7236
7237 /* Similarly find a string table. */
7238 if (dynamic_strings == NULL)
7239 {
86dba8ee
AM		 7240 for (entry = dynamic_section;
7241 entry < dynamic_section + dynamic_nent;
7242 ++entry)
252b5132
RH		 7243 {
7244 unsigned long offset;
b34976b6 7245 long str_tab_len;
252b5132
RH		 7246
7247 if (entry->d_tag != DT_STRTAB)
7248 continue;
7249
7250 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7251
7252 /* Since we do not know how big the string table is,
7253 we default to reading in the entire file (!) and
7254 processing that. This is overkill, I know, but it
e3c8793a 7255 should work. */
252b5132 7256
d93f0186 7257 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 7258
7259 if (archive_file_offset != 0)
7260 str_tab_len = archive_file_size - offset;
7261 else
7262 {
7263 if (fseek (file, 0, SEEK_END))
7264 error (_("Unable to seek to end of file\n"));
7265 str_tab_len = ftell (file) - offset;
7266 }
252b5132
RH		 7267
7268 if (str_tab_len < 1)
7269 {
7270 error
7271 (_("Unable to determine the length of the dynamic string table\n"));
7272 continue;
7273 }
7274
3f5e193b
NC		 7275 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7276 str_tab_len,
7277 _("dynamic string table"));
d79b3d50 7278 dynamic_strings_length = str_tab_len;
252b5132
RH		 7279 break;
7280 }
7281 }
7282
7283 /* And find the syminfo section if available. */
7284 if (dynamic_syminfo == NULL)
7285 {
3e8bba36 7286 unsigned long syminsz = 0;
252b5132 7287
86dba8ee
AM		 7288 for (entry = dynamic_section;
7289 entry < dynamic_section + dynamic_nent;
7290 ++entry)
252b5132
RH		 7291 {
7292 if (entry->d_tag == DT_SYMINENT)
7293 {
7294 /* Note: these braces are necessary to avoid a syntax
7295 error from the SunOS4 C compiler. */
7296 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7297 }
7298 else if (entry->d_tag == DT_SYMINSZ)
7299 syminsz = entry->d_un.d_val;
7300 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 7301 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7302 syminsz);
252b5132
RH		 7303 }
7304
7305 if (dynamic_syminfo_offset != 0 && syminsz != 0)
7306 {
2cf0635d
NC		 7307 Elf_External_Syminfo * extsyminfo;
7308 Elf_External_Syminfo * extsym;
7309 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 7310
7311 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 7312 extsyminfo = (Elf_External_Syminfo *)
7313 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
7314 _("symbol information"));
a6e9f9df
AM		 7315 if (!extsyminfo)
7316 return 0;
252b5132 7317
3f5e193b 7318 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 7319 if (dynamic_syminfo == NULL)
7320 {
7321 error (_("Out of memory\n"));
7322 return 0;
7323 }
7324
7325 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 7326 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
7327 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
7328 ++syminfo, ++extsym)
252b5132 7329 {
86dba8ee
AM		 7330 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
7331 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 7332 }
7333
7334 free (extsyminfo);
7335 }
7336 }
7337
7338 if (do_dynamic && dynamic_addr)
86dba8ee
AM		 7339 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7340 dynamic_addr, dynamic_nent);
252b5132
RH		 7341 if (do_dynamic)
7342 printf (_(" Tag Type Name/Value\n"));
7343
86dba8ee
AM		 7344 for (entry = dynamic_section;
7345 entry < dynamic_section + dynamic_nent;
7346 entry++)
252b5132
RH		 7347 {
7348 if (do_dynamic)
f7a99963 7349 {
2cf0635d 7350 const char * dtype;
e699b9ff 7351
f7a99963
NC		 7352 putchar (' ');
7353 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 7354 dtype = get_dynamic_type (entry->d_tag);
7355 printf (" (%s)%*s", dtype,
7356 ((is_32bit_elf ? 27 : 19)
7357 - (int) strlen (dtype)),
f7a99963
NC		 7358 " ");
7359 }
252b5132
RH		 7360
7361 switch (entry->d_tag)
7362 {
d1133906
NC		 7363 case DT_FLAGS:
7364 if (do_dynamic)
e9e44622 7365 print_dynamic_flags (entry->d_un.d_val);
d1133906 7366 break;
76da6bbe 7367
252b5132
RH		 7368 case DT_AUXILIARY:
7369 case DT_FILTER:
019148e4
L		 7370 case DT_CONFIG:
7371 case DT_DEPAUDIT:
7372 case DT_AUDIT:
252b5132
RH		 7373 if (do_dynamic)
7374 {
019148e4 7375 switch (entry->d_tag)
b34976b6 7376 {
019148e4
L		 7377 case DT_AUXILIARY:
7378 printf (_("Auxiliary library"));
7379 break;
7380
7381 case DT_FILTER:
7382 printf (_("Filter library"));
7383 break;
7384
b34976b6 7385 case DT_CONFIG:
019148e4
L		 7386 printf (_("Configuration file"));
7387 break;
7388
7389 case DT_DEPAUDIT:
7390 printf (_("Dependency audit library"));
7391 break;
7392
7393 case DT_AUDIT:
7394 printf (_("Audit library"));
7395 break;
7396 }
252b5132 7397
d79b3d50
NC		 7398 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7399 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 7400 else
f7a99963
NC		 7401 {
7402 printf (": ");
7403 print_vma (entry->d_un.d_val, PREFIX_HEX);
7404 putchar ('\n');
7405 }
252b5132
RH		 7406 }
7407 break;
7408
dcefbbbd 7409 case DT_FEATURE:
252b5132
RH		 7410 if (do_dynamic)
7411 {
7412 printf (_("Flags:"));
86f55779 7413
252b5132
RH		 7414 if (entry->d_un.d_val == 0)
7415 printf (_(" None\n"));
7416 else
7417 {
7418 unsigned long int val = entry->d_un.d_val;
86f55779 7419
252b5132
RH		 7420 if (val & DTF_1_PARINIT)
7421 {
7422 printf (" PARINIT");
7423 val ^= DTF_1_PARINIT;
7424 }
dcefbbbd
L		 7425 if (val & DTF_1_CONFEXP)
7426 {
7427 printf (" CONFEXP");
7428 val ^= DTF_1_CONFEXP;
7429 }
252b5132
RH		 7430 if (val != 0)
7431 printf (" %lx", val);
7432 puts ("");
7433 }
7434 }
7435 break;
7436
7437 case DT_POSFLAG_1:
7438 if (do_dynamic)
7439 {
7440 printf (_("Flags:"));
86f55779 7441
252b5132
RH		 7442 if (entry->d_un.d_val == 0)
7443 printf (_(" None\n"));
7444 else
7445 {
7446 unsigned long int val = entry->d_un.d_val;
86f55779 7447
252b5132
RH		 7448 if (val & DF_P1_LAZYLOAD)
7449 {
7450 printf (" LAZYLOAD");
7451 val ^= DF_P1_LAZYLOAD;
7452 }
7453 if (val & DF_P1_GROUPPERM)
7454 {
7455 printf (" GROUPPERM");
7456 val ^= DF_P1_GROUPPERM;
7457 }
7458 if (val != 0)
7459 printf (" %lx", val);
7460 puts ("");
7461 }
7462 }
7463 break;
7464
7465 case DT_FLAGS_1:
7466 if (do_dynamic)
7467 {
7468 printf (_("Flags:"));
7469 if (entry->d_un.d_val == 0)
7470 printf (_(" None\n"));
7471 else
7472 {
7473 unsigned long int val = entry->d_un.d_val;
86f55779 7474
252b5132
RH		 7475 if (val & DF_1_NOW)
7476 {
7477 printf (" NOW");
7478 val ^= DF_1_NOW;
7479 }
7480 if (val & DF_1_GLOBAL)
7481 {
7482 printf (" GLOBAL");
7483 val ^= DF_1_GLOBAL;
7484 }
7485 if (val & DF_1_GROUP)
7486 {
7487 printf (" GROUP");
7488 val ^= DF_1_GROUP;
7489 }
7490 if (val & DF_1_NODELETE)
7491 {
7492 printf (" NODELETE");
7493 val ^= DF_1_NODELETE;
7494 }
7495 if (val & DF_1_LOADFLTR)
7496 {
7497 printf (" LOADFLTR");
7498 val ^= DF_1_LOADFLTR;
7499 }
7500 if (val & DF_1_INITFIRST)
7501 {
7502 printf (" INITFIRST");
7503 val ^= DF_1_INITFIRST;
7504 }
7505 if (val & DF_1_NOOPEN)
7506 {
7507 printf (" NOOPEN");
7508 val ^= DF_1_NOOPEN;
7509 }
7510 if (val & DF_1_ORIGIN)
7511 {
7512 printf (" ORIGIN");
7513 val ^= DF_1_ORIGIN;
7514 }
7515 if (val & DF_1_DIRECT)
7516 {
7517 printf (" DIRECT");
7518 val ^= DF_1_DIRECT;
7519 }
7520 if (val & DF_1_TRANS)
7521 {
7522 printf (" TRANS");
7523 val ^= DF_1_TRANS;
7524 }
7525 if (val & DF_1_INTERPOSE)
7526 {
7527 printf (" INTERPOSE");
7528 val ^= DF_1_INTERPOSE;
7529 }
f7db6139 7530 if (val & DF_1_NODEFLIB)
dcefbbbd 7531 {
f7db6139
L		 7532 printf (" NODEFLIB");
7533 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 7534 }
7535 if (val & DF_1_NODUMP)
7536 {
7537 printf (" NODUMP");
7538 val ^= DF_1_NODUMP;
7539 }
7540 if (val & DF_1_CONLFAT)
7541 {
7542 printf (" CONLFAT");
7543 val ^= DF_1_CONLFAT;
7544 }
252b5132
RH		 7545 if (val != 0)
7546 printf (" %lx", val);
7547 puts ("");
7548 }
7549 }
7550 break;
7551
7552 case DT_PLTREL:
566b0d53 7553 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 7554 if (do_dynamic)
7555 puts (get_dynamic_type (entry->d_un.d_val));
7556 break;
7557
7558 case DT_NULL :
7559 case DT_NEEDED :
7560 case DT_PLTGOT :
7561 case DT_HASH :
7562 case DT_STRTAB :
7563 case DT_SYMTAB :
7564 case DT_RELA :
7565 case DT_INIT :
7566 case DT_FINI :
7567 case DT_SONAME :
7568 case DT_RPATH :
7569 case DT_SYMBOLIC:
7570 case DT_REL :
7571 case DT_DEBUG :
7572 case DT_TEXTREL :
7573 case DT_JMPREL :
019148e4 7574 case DT_RUNPATH :
252b5132
RH		 7575 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7576
7577 if (do_dynamic)
7578 {
2cf0635d 7579 char * name;
252b5132 7580
d79b3d50
NC		 7581 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7582 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 7583 else
d79b3d50 7584 name = NULL;
252b5132
RH		 7585
7586 if (name)
7587 {
7588 switch (entry->d_tag)
7589 {
7590 case DT_NEEDED:
7591 printf (_("Shared library: [%s]"), name);
7592
18bd398b 7593 if (streq (name, program_interpreter))
f7a99963 7594 printf (_(" program interpreter"));
252b5132
RH		 7595 break;
7596
7597 case DT_SONAME:
f7a99963 7598 printf (_("Library soname: [%s]"), name);
252b5132
RH		 7599 break;
7600
7601 case DT_RPATH:
f7a99963 7602 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 7603 break;
7604
019148e4
L		 7605 case DT_RUNPATH:
7606 printf (_("Library runpath: [%s]"), name);
7607 break;
7608
252b5132 7609 default:
f7a99963
NC		 7610 print_vma (entry->d_un.d_val, PREFIX_HEX);
7611 break;
252b5132
RH		 7612 }
7613 }
7614 else
f7a99963
NC		 7615 print_vma (entry->d_un.d_val, PREFIX_HEX);
7616
7617 putchar ('\n');
252b5132
RH		 7618 }
7619 break;
7620
7621 case DT_PLTRELSZ:
7622 case DT_RELASZ :
7623 case DT_STRSZ :
7624 case DT_RELSZ :
7625 case DT_RELAENT :
7626 case DT_SYMENT :
7627 case DT_RELENT :
566b0d53 7628 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 7629 case DT_PLTPADSZ:
7630 case DT_MOVEENT :
7631 case DT_MOVESZ :
7632 case DT_INIT_ARRAYSZ:
7633 case DT_FINI_ARRAYSZ:
047b2264
JJ		 7634 case DT_GNU_CONFLICTSZ:
7635 case DT_GNU_LIBLISTSZ:
252b5132 7636 if (do_dynamic)
f7a99963
NC		 7637 {
7638 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 7639 printf (_(" (bytes)\n"));
f7a99963 7640 }
252b5132
RH		 7641 break;
7642
7643 case DT_VERDEFNUM:
7644 case DT_VERNEEDNUM:
7645 case DT_RELACOUNT:
7646 case DT_RELCOUNT:
7647 if (do_dynamic)
f7a99963
NC		 7648 {
7649 print_vma (entry->d_un.d_val, UNSIGNED);
7650 putchar ('\n');
7651 }
252b5132
RH		 7652 break;
7653
7654 case DT_SYMINSZ:
7655 case DT_SYMINENT:
7656 case DT_SYMINFO:
7657 case DT_USED:
7658 case DT_INIT_ARRAY:
7659 case DT_FINI_ARRAY:
7660 if (do_dynamic)
7661 {
d79b3d50
NC		 7662 if (entry->d_tag == DT_USED
7663 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 7664 {
2cf0635d 7665 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 7666
b34976b6 7667 if (*name)
252b5132
RH		 7668 {
7669 printf (_("Not needed object: [%s]\n"), name);
7670 break;
7671 }
7672 }
103f02d3 7673
f7a99963
NC		 7674 print_vma (entry->d_un.d_val, PREFIX_HEX);
7675 putchar ('\n');
252b5132
RH		 7676 }
7677 break;
7678
7679 case DT_BIND_NOW:
7680 /* The value of this entry is ignored. */
35b1837e
AM		 7681 if (do_dynamic)
7682 putchar ('\n');
252b5132 7683 break;
103f02d3 7684
047b2264
JJ		 7685 case DT_GNU_PRELINKED:
7686 if (do_dynamic)
7687 {
2cf0635d 7688 struct tm * tmp;
91d6fa6a 7689 time_t atime = entry->d_un.d_val;
047b2264 7690
91d6fa6a 7691 tmp = gmtime (&atime);
047b2264
JJ		 7692 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
7693 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7694 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7695
7696 }
7697 break;
7698
fdc90cb4
JJ		 7699 case DT_GNU_HASH:
7700 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
7701 if (do_dynamic)
7702 {
7703 print_vma (entry->d_un.d_val, PREFIX_HEX);
7704 putchar ('\n');
7705 }
7706 break;
7707
252b5132
RH		 7708 default:
7709 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 7710 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 7711 entry->d_un.d_val;
7712
7713 if (do_dynamic)
7714 {
7715 switch (elf_header.e_machine)
7716 {
7717 case EM_MIPS:
4fe85591 7718 case EM_MIPS_RS3_LE:
b2d38a17 7719 dynamic_section_mips_val (entry);
252b5132 7720 break;
103f02d3 7721 case EM_PARISC:
b2d38a17 7722 dynamic_section_parisc_val (entry);
103f02d3 7723 break;
ecc51f48 7724 case EM_IA_64:
b2d38a17 7725 dynamic_section_ia64_val (entry);
ecc51f48 7726 break;
252b5132 7727 default:
f7a99963
NC		 7728 print_vma (entry->d_un.d_val, PREFIX_HEX);
7729 putchar ('\n');
252b5132
RH		 7730 }
7731 }
7732 break;
7733 }
7734 }
7735
7736 return 1;
7737}
7738
7739static char *
d3ba0551 7740get_ver_flags (unsigned int flags)
252b5132 7741{
b34976b6 7742 static char buff[32];
252b5132
RH		 7743
7744 buff[0] = 0;
7745
7746 if (flags == 0)
7747 return _("none");
7748
7749 if (flags & VER_FLG_BASE)
7750 strcat (buff, "BASE ");
7751
7752 if (flags & VER_FLG_WEAK)
7753 {
7754 if (flags & VER_FLG_BASE)
7755 strcat (buff, "| ");
7756
7757 strcat (buff, "WEAK ");
7758 }
7759
44ec90b9
RO		 7760 if (flags & VER_FLG_INFO)
7761 {
7762 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
7763 strcat (buff, "| ");
7764
7765 strcat (buff, "INFO ");
7766 }
7767
7768 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 7769 strcat (buff, _("| <unknown>"));
252b5132
RH		 7770
7771 return buff;
7772}
7773
7774/* Display the contents of the version sections. */
98fb390a 7775
252b5132 7776static int
2cf0635d 7777process_version_sections (FILE * file)
252b5132 7778{
2cf0635d 7779 Elf_Internal_Shdr * section;
b34976b6
AM		 7780 unsigned i;
7781 int found = 0;
252b5132
RH		 7782
7783 if (! do_version)
7784 return 1;
7785
7786 for (i = 0, section = section_headers;
7787 i < elf_header.e_shnum;
b34976b6 7788 i++, section++)
252b5132
RH		 7789 {
7790 switch (section->sh_type)
7791 {
7792 case SHT_GNU_verdef:
7793 {
2cf0635d 7794 Elf_External_Verdef * edefs;
b34976b6
AM		 7795 unsigned int idx;
7796 unsigned int cnt;
2cf0635d 7797 char * endbuf;
252b5132
RH		 7798
7799 found = 1;
7800
7801 printf
72de5009 7802 (_("\nVersion definition section '%s' contains %u entries:\n"),
252b5132
RH		 7803 SECTION_NAME (section), section->sh_info);
7804
7805 printf (_(" Addr: 0x"));
7806 printf_vma (section->sh_addr);
72de5009 7807 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 7808 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 7809 section->sh_link < elf_header.e_shnum
7810 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 7811 : _("<corrupt>"));
252b5132 7812
3f5e193b
NC		 7813 edefs = (Elf_External_Verdef *)
7814 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
7815 _("version definition section"));
54806181 7816 endbuf = (char *) edefs + section->sh_size;
a6e9f9df
AM		 7817 if (!edefs)
7818 break;
252b5132 7819
b34976b6 7820 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 7821 {
2cf0635d
NC		 7822 char * vstart;
7823 Elf_External_Verdef * edef;
b34976b6 7824 Elf_Internal_Verdef ent;
2cf0635d 7825 Elf_External_Verdaux * eaux;
b34976b6
AM		 7826 Elf_Internal_Verdaux aux;
7827 int j;
7828 int isum;
103f02d3 7829
dd24e3da
NC		 7830 /* Check for negative or very large indicies. */
7831 if ((unsigned char *) edefs + idx < (unsigned char *) edefs)
7832 break;
7833
252b5132 7834 vstart = ((char *) edefs) + idx;
54806181
AM		 7835 if (vstart + sizeof (*edef) > endbuf)
7836 break;
252b5132
RH		 7837
7838 edef = (Elf_External_Verdef *) vstart;
7839
7840 ent.vd_version = BYTE_GET (edef->vd_version);
7841 ent.vd_flags = BYTE_GET (edef->vd_flags);
7842 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
7843 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
7844 ent.vd_hash = BYTE_GET (edef->vd_hash);
7845 ent.vd_aux = BYTE_GET (edef->vd_aux);
7846 ent.vd_next = BYTE_GET (edef->vd_next);
7847
7848 printf (_(" %#06x: Rev: %d Flags: %s"),
7849 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
7850
7851 printf (_(" Index: %d Cnt: %d "),
7852 ent.vd_ndx, ent.vd_cnt);
7853
dd24e3da
NC		 7854 /* Check for overflow. */
7855 if ((unsigned char *)(vstart + ent.vd_aux) < (unsigned char *) vstart
7856 || (unsigned char *)(vstart + ent.vd_aux) > (unsigned char *) endbuf)
7857 break;
7858
252b5132
RH		 7859 vstart += ent.vd_aux;
7860
7861 eaux = (Elf_External_Verdaux *) vstart;
7862
7863 aux.vda_name = BYTE_GET (eaux->vda_name);
7864 aux.vda_next = BYTE_GET (eaux->vda_next);
7865
d79b3d50
NC		 7866 if (VALID_DYNAMIC_NAME (aux.vda_name))
7867 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 7868 else
7869 printf (_("Name index: %ld\n"), aux.vda_name);
7870
7871 isum = idx + ent.vd_aux;
7872
b34976b6 7873 for (j = 1; j < ent.vd_cnt; j++)
252b5132 7874 {
dd24e3da
NC		 7875 /* Check for overflow. */
7876 if ((unsigned char *)(vstart + aux.vda_next) < (unsigned char *) vstart
7877 || (unsigned char *)(vstart + aux.vda_next) > (unsigned char *) endbuf)
7878 break;
7879
252b5132
RH		 7880 isum += aux.vda_next;
7881 vstart += aux.vda_next;
7882
7883 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 7884 if (vstart + sizeof (*eaux) > endbuf)
7885 break;
252b5132
RH		 7886
7887 aux.vda_name = BYTE_GET (eaux->vda_name);
7888 aux.vda_next = BYTE_GET (eaux->vda_next);
7889
d79b3d50 7890 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 7891 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 7892 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 7893 else
7894 printf (_(" %#06x: Parent %d, name index: %ld\n"),
7895 isum, j, aux.vda_name);
7896 }
dd24e3da 7897
54806181
AM		 7898 if (j < ent.vd_cnt)
7899 printf (_(" Version def aux past end of section\n"));
252b5132
RH		 7900
7901 idx += ent.vd_next;
7902 }
dd24e3da 7903
54806181
AM		 7904 if (cnt < section->sh_info)
7905 printf (_(" Version definition past end of section\n"));
252b5132
RH		 7906
7907 free (edefs);
7908 }
7909 break;
103f02d3 7910
252b5132
RH		 7911 case SHT_GNU_verneed:
7912 {
2cf0635d 7913 Elf_External_Verneed * eneed;
b34976b6
AM		 7914 unsigned int idx;
7915 unsigned int cnt;
2cf0635d 7916 char * endbuf;
252b5132
RH		 7917
7918 found = 1;
7919
72de5009 7920 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
252b5132
RH		 7921 SECTION_NAME (section), section->sh_info);
7922
7923 printf (_(" Addr: 0x"));
7924 printf_vma (section->sh_addr);
72de5009 7925 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 7926 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 7927 section->sh_link < elf_header.e_shnum
7928 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 7929 : _("<corrupt>"));
252b5132 7930
3f5e193b
NC		 7931 eneed = (Elf_External_Verneed *) get_data (NULL, file,
7932 section->sh_offset, 1,
7933 section->sh_size,
7934 _("version need section"));
54806181 7935 endbuf = (char *) eneed + section->sh_size;
a6e9f9df
AM		 7936 if (!eneed)
7937 break;
252b5132
RH		 7938
7939 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
7940 {
2cf0635d 7941 Elf_External_Verneed * entry;
b34976b6
AM		 7942 Elf_Internal_Verneed ent;
7943 int j;
7944 int isum;
2cf0635d 7945 char * vstart;
252b5132 7946
dd24e3da
NC		 7947 if ((unsigned char *) eneed + idx < (unsigned char *) eneed)
7948 break;
7949
252b5132 7950 vstart = ((char *) eneed) + idx;
54806181
AM		 7951 if (vstart + sizeof (*entry) > endbuf)
7952 break;
252b5132
RH		 7953
7954 entry = (Elf_External_Verneed *) vstart;
7955
7956 ent.vn_version = BYTE_GET (entry->vn_version);
7957 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
7958 ent.vn_file = BYTE_GET (entry->vn_file);
7959 ent.vn_aux = BYTE_GET (entry->vn_aux);
7960 ent.vn_next = BYTE_GET (entry->vn_next);
7961
7962 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
7963
d79b3d50
NC		 7964 if (VALID_DYNAMIC_NAME (ent.vn_file))
7965 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 7966 else
7967 printf (_(" File: %lx"), ent.vn_file);
7968
7969 printf (_(" Cnt: %d\n"), ent.vn_cnt);
7970
dd24e3da
NC		 7971 /* Check for overflow. */
7972 if ((unsigned char *)(vstart + ent.vn_aux) < (unsigned char *) vstart
7973 || (unsigned char *)(vstart + ent.vn_aux) > (unsigned char *) endbuf)
7974 break;
7975
252b5132
RH		 7976 vstart += ent.vn_aux;
7977
7978 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
7979 {
2cf0635d 7980 Elf_External_Vernaux * eaux;
b34976b6 7981 Elf_Internal_Vernaux aux;
252b5132 7982
54806181
AM		 7983 if (vstart + sizeof (*eaux) > endbuf)
7984 break;
252b5132
RH		 7985 eaux = (Elf_External_Vernaux *) vstart;
7986
7987 aux.vna_hash = BYTE_GET (eaux->vna_hash);
7988 aux.vna_flags = BYTE_GET (eaux->vna_flags);
7989 aux.vna_other = BYTE_GET (eaux->vna_other);
7990 aux.vna_name = BYTE_GET (eaux->vna_name);
7991 aux.vna_next = BYTE_GET (eaux->vna_next);
7992
d79b3d50 7993 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 7994 printf (_(" %#06x: Name: %s"),
d79b3d50 7995 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 7996 else
ecc2063b 7997 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 7998 isum, aux.vna_name);
7999
8000 printf (_(" Flags: %s Version: %d\n"),
8001 get_ver_flags (aux.vna_flags), aux.vna_other);
8002
dd24e3da
NC		 8003 /* Check for overflow. */
8004 if ((unsigned char *)(vstart + aux.vna_next) < (unsigned char *) vstart
8005 || (unsigned char *)(vstart + aux.vna_next) > (unsigned char *) endbuf)
8006 break;
8007
252b5132
RH		 8008 isum += aux.vna_next;
8009 vstart += aux.vna_next;
8010 }
54806181
AM		 8011 if (j < ent.vn_cnt)
8012 printf (_(" Version need aux past end of section\n"));
252b5132
RH		 8013
8014 idx += ent.vn_next;
8015 }
54806181
AM		 8016 if (cnt < section->sh_info)
8017 printf (_(" Version need past end of section\n"));
103f02d3 8018
252b5132
RH		 8019 free (eneed);
8020 }
8021 break;
8022
8023 case SHT_GNU_versym:
8024 {
2cf0635d 8025 Elf_Internal_Shdr * link_section;
b34976b6
AM		 8026 int total;
8027 int cnt;
2cf0635d
NC		 8028 unsigned char * edata;
8029 unsigned short * data;
8030 char * strtab;
8031 Elf_Internal_Sym * symbols;
8032 Elf_Internal_Shdr * string_sec;
d3ba0551 8033 long off;
252b5132 8034
4fbb74a6 8035 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 8036 break;
8037
4fbb74a6 8038 link_section = section_headers + section->sh_link;
08d8fa11 8039 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 8040
4fbb74a6 8041 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 8042 break;
8043
252b5132
RH		 8044 found = 1;
8045
9ad5cbcf 8046 symbols = GET_ELF_SYMBOLS (file, link_section);
dd24e3da
NC		 8047 if (symbols == NULL)
8048 break;
252b5132 8049
4fbb74a6 8050 string_sec = section_headers + link_section->sh_link;
252b5132 8051
3f5e193b
NC		 8052 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8053 string_sec->sh_size,
8054 _("version string table"));
a6e9f9df 8055 if (!strtab)
0429c154
MS		 8056 {
8057 free (symbols);
8058 break;
8059 }
252b5132
RH		 8060
8061 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8062 SECTION_NAME (section), total);
8063
8064 printf (_(" Addr: "));
8065 printf_vma (section->sh_addr);
72de5009 8066 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8067 (unsigned long) section->sh_offset, section->sh_link,
252b5132
RH		 8068 SECTION_NAME (link_section));
8069
d3ba0551
AM		 8070 off = offset_from_vma (file,
8071 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8072 total * sizeof (short));
3f5e193b
NC		 8073 edata = (unsigned char *) get_data (NULL, file, off, total,
8074 sizeof (short),
8075 _("version symbol data"));
a6e9f9df
AM		 8076 if (!edata)
8077 {
8078 free (strtab);
0429c154 8079 free (symbols);
a6e9f9df
AM		 8080 break;
8081 }
252b5132 8082
3f5e193b 8083 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 8084
8085 for (cnt = total; cnt --;)
b34976b6
AM		 8086 data[cnt] = byte_get (edata + cnt * sizeof (short),
8087 sizeof (short));
252b5132
RH		 8088
8089 free (edata);
8090
8091 for (cnt = 0; cnt < total; cnt += 4)
8092 {
8093 int j, nn;
00d93f34 8094 int check_def, check_need;
2cf0635d 8095 char * name;
252b5132
RH		 8096
8097 printf (" %03x:", cnt);
8098
8099 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 8100 switch (data[cnt + j])
252b5132
RH		 8101 {
8102 case 0:
8103 fputs (_(" 0 (*local*) "), stdout);
8104 break;
8105
8106 case 1:
8107 fputs (_(" 1 (*global*) "), stdout);
8108 break;
8109
8110 default:
c244d050
NC		 8111 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8112 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 8113
dd24e3da
NC		 8114 /* If this index value is greater than the size of the symbols
8115 array, break to avoid an out-of-bounds read, */
8116 if ((unsigned long)(cnt + j) >=
8117 ((unsigned long)link_section->sh_size /
8118 (unsigned long)link_section->sh_entsize))
8119 {
8120 warn (_("invalid index into symbol array\n"));
8121 break;
8122 }
8123
00d93f34
JJ		 8124 check_def = 1;
8125 check_need = 1;
4fbb74a6
AM		 8126 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8127 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 8128 != SHT_NOBITS)
252b5132 8129 {
b34976b6 8130 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 8131 check_def = 0;
8132 else
8133 check_need = 0;
252b5132 8134 }
00d93f34
JJ		 8135
8136 if (check_need
b34976b6 8137 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 8138 {
b34976b6
AM		 8139 Elf_Internal_Verneed ivn;
8140 unsigned long offset;
252b5132 8141
d93f0186
NC		 8142 offset = offset_from_vma
8143 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8144 sizeof (Elf_External_Verneed));
252b5132 8145
b34976b6 8146 do
252b5132 8147 {
b34976b6
AM		 8148 Elf_Internal_Vernaux ivna;
8149 Elf_External_Verneed evn;
8150 Elf_External_Vernaux evna;
8151 unsigned long a_off;
252b5132 8152
c256ffe7 8153 get_data (&evn, file, offset, sizeof (evn), 1,
a6e9f9df 8154 _("version need"));
252b5132
RH		 8155
8156 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8157 ivn.vn_next = BYTE_GET (evn.vn_next);
8158
8159 a_off = offset + ivn.vn_aux;
8160
8161 do
8162 {
a6e9f9df 8163 get_data (&evna, file, a_off, sizeof (evna),
c256ffe7 8164 1, _("version need aux (2)"));
252b5132
RH		 8165
8166 ivna.vna_next = BYTE_GET (evna.vna_next);
8167 ivna.vna_other = BYTE_GET (evna.vna_other);
8168
8169 a_off += ivna.vna_next;
8170 }
b34976b6 8171 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 8172 && ivna.vna_next != 0);
8173
b34976b6 8174 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 8175 {
8176 ivna.vna_name = BYTE_GET (evna.vna_name);
8177
54806181
AM		 8178 if (ivna.vna_name >= string_sec->sh_size)
8179 name = _("*invalid*");
8180 else
8181 name = strtab + ivna.vna_name;
252b5132 8182 nn += printf ("(%s%-*s",
16062207
ILT		 8183 name,
8184 12 - (int) strlen (name),
252b5132 8185 ")");
00d93f34 8186 check_def = 0;
252b5132
RH		 8187 break;
8188 }
8189
8190 offset += ivn.vn_next;
8191 }
8192 while (ivn.vn_next);
8193 }
00d93f34 8194
b34976b6
AM		 8195 if (check_def && data[cnt + j] != 0x8001
8196 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 8197 {
b34976b6
AM		 8198 Elf_Internal_Verdef ivd;
8199 Elf_External_Verdef evd;
8200 unsigned long offset;
252b5132 8201
d93f0186
NC		 8202 offset = offset_from_vma
8203 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8204 sizeof evd);
252b5132
RH		 8205
8206 do
8207 {
c256ffe7 8208 get_data (&evd, file, offset, sizeof (evd), 1,
a6e9f9df 8209 _("version def"));
252b5132
RH		 8210
8211 ivd.vd_next = BYTE_GET (evd.vd_next);
8212 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8213
8214 offset += ivd.vd_next;
8215 }
c244d050 8216 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 8217 && ivd.vd_next != 0);
8218
c244d050 8219 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 8220 {
b34976b6
AM		 8221 Elf_External_Verdaux evda;
8222 Elf_Internal_Verdaux ivda;
252b5132
RH		 8223
8224 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8225
a6e9f9df
AM		 8226 get_data (&evda, file,
8227 offset - ivd.vd_next + ivd.vd_aux,
c256ffe7
JJ		 8228 sizeof (evda), 1,
8229 _("version def aux"));
252b5132
RH		 8230
8231 ivda.vda_name = BYTE_GET (evda.vda_name);
8232
54806181
AM		 8233 if (ivda.vda_name >= string_sec->sh_size)
8234 name = _("*invalid*");
8235 else
8236 name = strtab + ivda.vda_name;
252b5132 8237 nn += printf ("(%s%-*s",
16062207
ILT		 8238 name,
8239 12 - (int) strlen (name),
252b5132
RH		 8240 ")");
8241 }
8242 }
8243
8244 if (nn < 18)
8245 printf ("%*c", 18 - nn, ' ');
8246 }
8247
8248 putchar ('\n');
8249 }
8250
8251 free (data);
8252 free (strtab);
8253 free (symbols);
8254 }
8255 break;
103f02d3 8256
252b5132
RH		 8257 default:
8258 break;
8259 }
8260 }
8261
8262 if (! found)
8263 printf (_("\nNo version information found in this file.\n"));
8264
8265 return 1;
8266}
8267
d1133906 8268static const char *
d3ba0551 8269get_symbol_binding (unsigned int binding)
252b5132 8270{
b34976b6 8271 static char buff[32];
252b5132
RH		 8272
8273 switch (binding)
8274 {
b34976b6
AM		 8275 case STB_LOCAL: return "LOCAL";
8276 case STB_GLOBAL: return "GLOBAL";
8277 case STB_WEAK: return "WEAK";
252b5132
RH		 8278 default:
8279 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 8280 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
8281 binding);
252b5132 8282 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 8283 {
8284 if (binding == STB_GNU_UNIQUE
8285 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
8286 /* GNU/Linux is still using the default value 0. */
8287 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8288 return "UNIQUE";
8289 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
8290 }
252b5132 8291 else
e9e44622 8292 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 8293 return buff;
8294 }
8295}
8296
d1133906 8297static const char *
d3ba0551 8298get_symbol_type (unsigned int type)
252b5132 8299{
b34976b6 8300 static char buff[32];
252b5132
RH		 8301
8302 switch (type)
8303 {
b34976b6
AM		 8304 case STT_NOTYPE: return "NOTYPE";
8305 case STT_OBJECT: return "OBJECT";
8306 case STT_FUNC: return "FUNC";
8307 case STT_SECTION: return "SECTION";
8308 case STT_FILE: return "FILE";
8309 case STT_COMMON: return "COMMON";
8310 case STT_TLS: return "TLS";
15ab5209
DB		 8311 case STT_RELC: return "RELC";
8312 case STT_SRELC: return "SRELC";
252b5132
RH		 8313 default:
8314 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af
NC		 8315 {
8316 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
103f02d3
UD		 8317 return "THUMB_FUNC";
8318
351b4b40 8319 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 8320 return "REGISTER";
8321
8322 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
8323 return "PARISC_MILLI";
8324
e9e44622 8325 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 8326 }
252b5132 8327 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 8328 {
8329 if (elf_header.e_machine == EM_PARISC)
8330 {
8331 if (type == STT_HP_OPAQUE)
8332 return "HP_OPAQUE";
8333 if (type == STT_HP_STUB)
8334 return "HP_STUB";
8335 }
8336
d8045f23
NC		 8337 if (type == STT_GNU_IFUNC
8338 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
8339 /* GNU/Linux is still using the default value 0. */
8340 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8341 return "IFUNC";
8342
e9e44622 8343 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 8344 }
252b5132 8345 else
e9e44622 8346 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 8347 return buff;
8348 }
8349}
8350
d1133906 8351static const char *
d3ba0551 8352get_symbol_visibility (unsigned int visibility)
d1133906
NC		 8353{
8354 switch (visibility)
8355 {
b34976b6
AM		 8356 case STV_DEFAULT: return "DEFAULT";
8357 case STV_INTERNAL: return "INTERNAL";
8358 case STV_HIDDEN: return "HIDDEN";
d1133906
NC		 8359 case STV_PROTECTED: return "PROTECTED";
8360 default: abort ();
8361 }
8362}
8363
5e2b0d47
NC		 8364static const char *
8365get_mips_symbol_other (unsigned int other)
8366{
8367 switch (other)
8368 {
8369 case STO_OPTIONAL: return "OPTIONAL";
8370 case STO_MIPS16: return "MIPS16";
861fb55a
DJ		 8371 case STO_MIPS_PLT: return "MIPS PLT";
8372 case STO_MIPS_PIC: return "MIPS PIC";
5e2b0d47
NC		 8373 default: return NULL;
8374 }
8375}
8376
28f997cf
TG		 8377static const char *
8378get_ia64_symbol_other (unsigned int other)
8379{
8380 if (is_ia64_vms ())
8381 {
8382 static char res[32];
8383
8384 res[0] = 0;
8385
8386 /* Function types is for images and .STB files only. */
8387 switch (elf_header.e_type)
8388 {
8389 case ET_DYN:
8390 case ET_EXEC:
8391 switch (VMS_ST_FUNC_TYPE (other))
8392 {
8393 case VMS_SFT_CODE_ADDR:
8394 strcat (res, " CA");
8395 break;
8396 case VMS_SFT_SYMV_IDX:
8397 strcat (res, " VEC");
8398 break;
8399 case VMS_SFT_FD:
8400 strcat (res, " FD");
8401 break;
8402 case VMS_SFT_RESERVE:
8403 strcat (res, " RSV");
8404 break;
8405 default:
8406 abort ();
8407 }
8408 break;
8409 default:
8410 break;
8411 }
8412 switch (VMS_ST_LINKAGE (other))
8413 {
8414 case VMS_STL_IGNORE:
8415 strcat (res, " IGN");
8416 break;
8417 case VMS_STL_RESERVE:
8418 strcat (res, " RSV");
8419 break;
8420 case VMS_STL_STD:
8421 strcat (res, " STD");
8422 break;
8423 case VMS_STL_LNK:
8424 strcat (res, " LNK");
8425 break;
8426 default:
8427 abort ();
8428 }
8429
8430 if (res[0] != 0)
8431 return res + 1;
8432 else
8433 return res;
8434 }
8435 return NULL;
8436}
8437
5e2b0d47
NC		 8438static const char *
8439get_symbol_other (unsigned int other)
8440{
8441 const char * result = NULL;
8442 static char buff [32];
8443
8444 if (other == 0)
8445 return "";
8446
8447 switch (elf_header.e_machine)
8448 {
8449 case EM_MIPS:
8450 result = get_mips_symbol_other (other);
28f997cf
TG		 8451 break;
8452 case EM_IA_64:
8453 result = get_ia64_symbol_other (other);
8454 break;
5e2b0d47
NC		 8455 default:
8456 break;
8457 }
8458
8459 if (result)
8460 return result;
8461
8462 snprintf (buff, sizeof buff, _("<other>: %x"), other);
8463 return buff;
8464}
8465
d1133906 8466static const char *
d3ba0551 8467get_symbol_index_type (unsigned int type)
252b5132 8468{
b34976b6 8469 static char buff[32];
5cf1065c 8470
252b5132
RH		 8471 switch (type)
8472 {
b34976b6
AM		 8473 case SHN_UNDEF: return "UND";
8474 case SHN_ABS: return "ABS";
8475 case SHN_COMMON: return "COM";
252b5132 8476 default:
9ce701e2
L		 8477 if (type == SHN_IA_64_ANSI_COMMON
8478 && elf_header.e_machine == EM_IA_64
8479 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
8480 return "ANSI_COM";
8a9036a4
L		 8481 else if ((elf_header.e_machine == EM_X86_64
8482 || elf_header.e_machine == EM_L1OM)
3b22753a
L		 8483 && type == SHN_X86_64_LCOMMON)
8484 return "LARGE_COM";
172553c7
TS		 8485 else if (type == SHN_MIPS_SCOMMON
8486 && elf_header.e_machine == EM_MIPS)
8487 return "SCOM";
8488 else if (type == SHN_MIPS_SUNDEFINED
8489 && elf_header.e_machine == EM_MIPS)
8490 return "SUND";
9ce701e2 8491 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 8492 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 8493 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 8494 sprintf (buff, "OS [0x%04x]", type & 0xffff);
8495 else if (type >= SHN_LORESERVE)
8496 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
252b5132 8497 else
232e7cb8 8498 sprintf (buff, "%3d", type);
5cf1065c 8499 break;
252b5132 8500 }
5cf1065c
NC		 8501
8502 return buff;
252b5132
RH		 8503}
8504
66543521 8505static bfd_vma *
2cf0635d 8506get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
252b5132 8507{
2cf0635d
NC		 8508 unsigned char * e_data;
8509 bfd_vma * i_data;
252b5132 8510
3f5e193b 8511 e_data = (unsigned char *) cmalloc (number, ent_size);
252b5132
RH		 8512
8513 if (e_data == NULL)
8514 {
8515 error (_("Out of memory\n"));
8516 return NULL;
8517 }
8518
66543521 8519 if (fread (e_data, ent_size, number, file) != number)
252b5132
RH		 8520 {
8521 error (_("Unable to read in dynamic data\n"));
8522 return NULL;
8523 }
8524
3f5e193b 8525 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
252b5132
RH		 8526
8527 if (i_data == NULL)
8528 {
8529 error (_("Out of memory\n"));
8530 free (e_data);
8531 return NULL;
8532 }
8533
8534 while (number--)
66543521 8535 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 8536
8537 free (e_data);
8538
8539 return i_data;
8540}
8541
6bd1a22c
L		 8542static void
8543print_dynamic_symbol (bfd_vma si, unsigned long hn)
8544{
2cf0635d 8545 Elf_Internal_Sym * psym;
6bd1a22c
L		 8546 int n;
8547
8548 psym = dynamic_symbols + si;
8549
8550 n = print_vma (si, DEC_5);
8551 if (n < 5)
8552 fputs (" " + n, stdout);
8553 printf (" %3lu: ", hn);
8554 print_vma (psym->st_value, LONG_HEX);
8555 putchar (' ');
8556 print_vma (psym->st_size, DEC_5);
8557
f4be36b3
AM		 8558 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
8559 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
8560 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 8561 /* Check to see if any other bits in the st_other field are set.
8562 Note - displaying this information disrupts the layout of the
8563 table being generated, but for the moment this case is very
8564 rare. */
8565 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
8566 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
8567 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
8568 if (VALID_DYNAMIC_NAME (psym->st_name))
8569 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
8570 else
2b692964 8571 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 8572 putchar ('\n');
8573}
8574
e3c8793a 8575/* Dump the symbol table. */
252b5132 8576static int
2cf0635d 8577process_symbol_table (FILE * file)
252b5132 8578{
2cf0635d 8579 Elf_Internal_Shdr * section;
66543521
AM		 8580 bfd_vma nbuckets = 0;
8581 bfd_vma nchains = 0;
2cf0635d
NC		 8582 bfd_vma * buckets = NULL;
8583 bfd_vma * chains = NULL;
fdc90cb4 8584 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 8585 bfd_vma * gnubuckets = NULL;
8586 bfd_vma * gnuchains = NULL;
6bd1a22c 8587 bfd_vma gnusymidx = 0;
252b5132 8588
2c610e4b 8589 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 8590 return 1;
8591
6bd1a22c
L		 8592 if (dynamic_info[DT_HASH]
8593 && (do_histogram
2c610e4b
L		 8594 || (do_using_dynamic
8595 && !do_dyn_syms
8596 && dynamic_strings != NULL)))
252b5132 8597 {
66543521
AM		 8598 unsigned char nb[8];
8599 unsigned char nc[8];
8600 int hash_ent_size = 4;
8601
8602 if ((elf_header.e_machine == EM_ALPHA
8603 || elf_header.e_machine == EM_S390
8604 || elf_header.e_machine == EM_S390_OLD)
8605 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
8606 hash_ent_size = 8;
8607
fb52b2f4
NC		 8608 if (fseek (file,
8609 (archive_file_offset
8610 + offset_from_vma (file, dynamic_info[DT_HASH],
8611 sizeof nb + sizeof nc)),
d93f0186 8612 SEEK_SET))
252b5132 8613 {
591a748a 8614 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 8615 goto no_hash;
252b5132
RH		 8616 }
8617
66543521 8618 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 8619 {
8620 error (_("Failed to read in number of buckets\n"));
d3a44ec6 8621 goto no_hash;
252b5132
RH		 8622 }
8623
66543521 8624 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 8625 {
8626 error (_("Failed to read in number of chains\n"));
d3a44ec6 8627 goto no_hash;
252b5132
RH		 8628 }
8629
66543521
AM		 8630 nbuckets = byte_get (nb, hash_ent_size);
8631 nchains = byte_get (nc, hash_ent_size);
252b5132 8632
66543521
AM		 8633 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
8634 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 8635
d3a44ec6 8636 no_hash:
252b5132 8637 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 8638 {
8639 if (do_using_dynamic)
8640 return 0;
8641 free (buckets);
8642 free (chains);
8643 buckets = NULL;
8644 chains = NULL;
8645 nbuckets = 0;
8646 nchains = 0;
8647 }
252b5132
RH		 8648 }
8649
6bd1a22c
L		 8650 if (dynamic_info_DT_GNU_HASH
8651 && (do_histogram
2c610e4b
L		 8652 || (do_using_dynamic
8653 && !do_dyn_syms
8654 && dynamic_strings != NULL)))
252b5132 8655 {
6bd1a22c
L		 8656 unsigned char nb[16];
8657 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
8658 bfd_vma buckets_vma;
8659
8660 if (fseek (file,
8661 (archive_file_offset
8662 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
8663 sizeof nb)),
8664 SEEK_SET))
8665 {
8666 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 8667 goto no_gnu_hash;
6bd1a22c 8668 }
252b5132 8669
6bd1a22c
L		 8670 if (fread (nb, 16, 1, file) != 1)
8671 {
8672 error (_("Failed to read in number of buckets\n"));
d3a44ec6 8673 goto no_gnu_hash;
6bd1a22c
L		 8674 }
8675
8676 ngnubuckets = byte_get (nb, 4);
8677 gnusymidx = byte_get (nb + 4, 4);
8678 bitmaskwords = byte_get (nb + 8, 4);
8679 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 8680 if (is_32bit_elf)
6bd1a22c 8681 buckets_vma += bitmaskwords * 4;
f7a99963 8682 else
6bd1a22c 8683 buckets_vma += bitmaskwords * 8;
252b5132 8684
6bd1a22c
L		 8685 if (fseek (file,
8686 (archive_file_offset
8687 + offset_from_vma (file, buckets_vma, 4)),
8688 SEEK_SET))
252b5132 8689 {
6bd1a22c 8690 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 8691 goto no_gnu_hash;
6bd1a22c
L		 8692 }
8693
8694 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 8695
6bd1a22c 8696 if (gnubuckets == NULL)
d3a44ec6 8697 goto no_gnu_hash;
6bd1a22c
L		 8698
8699 for (i = 0; i < ngnubuckets; i++)
8700 if (gnubuckets[i] != 0)
8701 {
8702 if (gnubuckets[i] < gnusymidx)
8703 return 0;
8704
8705 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
8706 maxchain = gnubuckets[i];
8707 }
8708
8709 if (maxchain == 0xffffffff)
d3a44ec6 8710 goto no_gnu_hash;
6bd1a22c
L		 8711
8712 maxchain -= gnusymidx;
8713
8714 if (fseek (file,
8715 (archive_file_offset
8716 + offset_from_vma (file, buckets_vma
8717 + 4 * (ngnubuckets + maxchain), 4)),
8718 SEEK_SET))
8719 {
8720 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 8721 goto no_gnu_hash;
6bd1a22c
L		 8722 }
8723
8724 do
8725 {
8726 if (fread (nb, 4, 1, file) != 1)
252b5132 8727 {
6bd1a22c 8728 error (_("Failed to determine last chain length\n"));
d3a44ec6 8729 goto no_gnu_hash;
6bd1a22c 8730 }
252b5132 8731
6bd1a22c 8732 if (maxchain + 1 == 0)
d3a44ec6 8733 goto no_gnu_hash;
252b5132 8734
6bd1a22c
L		 8735 ++maxchain;
8736 }
8737 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 8738
6bd1a22c
L		 8739 if (fseek (file,
8740 (archive_file_offset
8741 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
8742 SEEK_SET))
8743 {
8744 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 8745 goto no_gnu_hash;
6bd1a22c
L		 8746 }
8747
8748 gnuchains = get_dynamic_data (file, maxchain, 4);
8749
d3a44ec6 8750 no_gnu_hash:
6bd1a22c 8751 if (gnuchains == NULL)
d3a44ec6
JJ		 8752 {
8753 free (gnubuckets);
d3a44ec6
JJ		 8754 gnubuckets = NULL;
8755 ngnubuckets = 0;
f64fddf1
NC		 8756 if (do_using_dynamic)
8757 return 0;
d3a44ec6 8758 }
6bd1a22c
L		 8759 }
8760
8761 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
8762 && do_syms
8763 && do_using_dynamic
8764 && dynamic_strings != NULL)
8765 {
8766 unsigned long hn;
8767
8768 if (dynamic_info[DT_HASH])
8769 {
8770 bfd_vma si;
8771
8772 printf (_("\nSymbol table for image:\n"));
8773 if (is_32bit_elf)
8774 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8775 else
8776 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8777
8778 for (hn = 0; hn < nbuckets; hn++)
8779 {
8780 if (! buckets[hn])
8781 continue;
8782
8783 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
8784 print_dynamic_symbol (si, hn);
252b5132
RH		 8785 }
8786 }
6bd1a22c
L		 8787
8788 if (dynamic_info_DT_GNU_HASH)
8789 {
8790 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
8791 if (is_32bit_elf)
8792 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8793 else
8794 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8795
8796 for (hn = 0; hn < ngnubuckets; ++hn)
8797 if (gnubuckets[hn] != 0)
8798 {
8799 bfd_vma si = gnubuckets[hn];
8800 bfd_vma off = si - gnusymidx;
8801
8802 do
8803 {
8804 print_dynamic_symbol (si, hn);
8805 si++;
8806 }
8807 while ((gnuchains[off++] & 1) == 0);
8808 }
8809 }
252b5132 8810 }
2c610e4b 8811 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
252b5132 8812 {
b34976b6 8813 unsigned int i;
252b5132
RH		 8814
8815 for (i = 0, section = section_headers;
8816 i < elf_header.e_shnum;
8817 i++, section++)
8818 {
b34976b6 8819 unsigned int si;
2cf0635d 8820 char * strtab = NULL;
c256ffe7 8821 unsigned long int strtab_size = 0;
2cf0635d
NC		 8822 Elf_Internal_Sym * symtab;
8823 Elf_Internal_Sym * psym;
252b5132 8824
2c610e4b
L		 8825 if ((section->sh_type != SHT_SYMTAB
8826 && section->sh_type != SHT_DYNSYM)
8827 || (!do_syms
8828 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 8829 continue;
8830
dd24e3da
NC		 8831 if (section->sh_entsize == 0)
8832 {
8833 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
8834 SECTION_NAME (section));
8835 continue;
8836 }
8837
252b5132
RH		 8838 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
8839 SECTION_NAME (section),
8840 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 8841
f7a99963 8842 if (is_32bit_elf)
ca47b30c 8843 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 8844 else
ca47b30c 8845 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 8846
9ad5cbcf 8847 symtab = GET_ELF_SYMBOLS (file, section);
252b5132
RH		 8848 if (symtab == NULL)
8849 continue;
8850
8851 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 8852 {
8853 strtab = string_table;
8854 strtab_size = string_table_length;
8855 }
4fbb74a6 8856 else if (section->sh_link < elf_header.e_shnum)
252b5132 8857 {
2cf0635d 8858 Elf_Internal_Shdr * string_sec;
252b5132 8859
4fbb74a6 8860 string_sec = section_headers + section->sh_link;
252b5132 8861
3f5e193b
NC		 8862 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
8863 1, string_sec->sh_size,
8864 _("string table"));
c256ffe7 8865 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 8866 }
8867
8868 for (si = 0, psym = symtab;
8869 si < section->sh_size / section->sh_entsize;
b34976b6 8870 si++, psym++)
252b5132 8871 {
5e220199 8872 printf ("%6d: ", si);
f7a99963
NC		 8873 print_vma (psym->st_value, LONG_HEX);
8874 putchar (' ');
8875 print_vma (psym->st_size, DEC_5);
d1133906
NC		 8876 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
8877 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 8878 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 8879 /* Check to see if any other bits in the st_other field are set.
8880 Note - displaying this information disrupts the layout of the
8881 table being generated, but for the moment this case is very rare. */
8882 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
8883 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 8884 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 8885 print_symbol (25, psym->st_name < strtab_size
2b692964 8886 ? strtab + psym->st_name : _("<corrupt>"));
252b5132
RH		 8887
8888 if (section->sh_type == SHT_DYNSYM &&
b34976b6 8889 version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
252b5132 8890 {
b34976b6
AM		 8891 unsigned char data[2];
8892 unsigned short vers_data;
8893 unsigned long offset;
8894 int is_nobits;
8895 int check_def;
252b5132 8896
d93f0186
NC		 8897 offset = offset_from_vma
8898 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8899 sizeof data + si * sizeof (vers_data));
252b5132 8900
a6e9f9df 8901 get_data (&data, file, offset + si * sizeof (vers_data),
c256ffe7 8902 sizeof (data), 1, _("version data"));
252b5132
RH		 8903
8904 vers_data = byte_get (data, 2);
8905
4fbb74a6
AM		 8906 is_nobits = (psym->st_shndx < elf_header.e_shnum
8907 && section_headers[psym->st_shndx].sh_type
c256ffe7 8908 == SHT_NOBITS);
252b5132
RH		 8909
8910 check_def = (psym->st_shndx != SHN_UNDEF);
8911
c244d050 8912 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
252b5132 8913 {
b34976b6 8914 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
00d93f34 8915 && (is_nobits || ! check_def))
252b5132 8916 {
b34976b6
AM		 8917 Elf_External_Verneed evn;
8918 Elf_Internal_Verneed ivn;
8919 Elf_Internal_Vernaux ivna;
252b5132
RH		 8920
8921 /* We must test both. */
d93f0186
NC		 8922 offset = offset_from_vma
8923 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8924 sizeof evn);
252b5132 8925
252b5132
RH		 8926 do
8927 {
b34976b6 8928 unsigned long vna_off;
252b5132 8929
c256ffe7 8930 get_data (&evn, file, offset, sizeof (evn), 1,
a6e9f9df 8931 _("version need"));
dd27201e
L		 8932
8933 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8934 ivn.vn_next = BYTE_GET (evn.vn_next);
8935
252b5132
RH		 8936 vna_off = offset + ivn.vn_aux;
8937
8938 do
8939 {
b34976b6 8940 Elf_External_Vernaux evna;
252b5132 8941
a6e9f9df 8942 get_data (&evna, file, vna_off,
c256ffe7 8943 sizeof (evna), 1,
a6e9f9df 8944 _("version need aux (3)"));
252b5132
RH		 8945
8946 ivna.vna_other = BYTE_GET (evna.vna_other);
8947 ivna.vna_next = BYTE_GET (evna.vna_next);
8948 ivna.vna_name = BYTE_GET (evna.vna_name);
8949
8950 vna_off += ivna.vna_next;
8951 }
8952 while (ivna.vna_other != vers_data
8953 && ivna.vna_next != 0);
8954
8955 if (ivna.vna_other == vers_data)
8956 break;
8957
8958 offset += ivn.vn_next;
8959 }
8960 while (ivn.vn_next != 0);
8961
8962 if (ivna.vna_other == vers_data)
8963 {
8964 printf ("@%s (%d)",
c256ffe7 8965 ivna.vna_name < strtab_size
2b692964 8966 ? strtab + ivna.vna_name : _("<corrupt>"),
c256ffe7 8967 ivna.vna_other);
252b5132
RH		 8968 check_def = 0;
8969 }
8970 else if (! is_nobits)
591a748a 8971 error (_("bad dynamic symbol\n"));
252b5132
RH		 8972 else
8973 check_def = 1;
8974 }
8975
8976 if (check_def)
8977 {
00d93f34 8978 if (vers_data != 0x8001
b34976b6 8979 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 8980 {
b34976b6
AM		 8981 Elf_Internal_Verdef ivd;
8982 Elf_Internal_Verdaux ivda;
8983 Elf_External_Verdaux evda;
91d6fa6a 8984 unsigned long off;
252b5132 8985
91d6fa6a 8986 off = offset_from_vma
d93f0186
NC		 8987 (file,
8988 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8989 sizeof (Elf_External_Verdef));
252b5132
RH		 8990
8991 do
8992 {
b34976b6 8993 Elf_External_Verdef evd;
252b5132 8994
91d6fa6a 8995 get_data (&evd, file, off, sizeof (evd),
c256ffe7 8996 1, _("version def"));
252b5132 8997
b34976b6
AM		 8998 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8999 ivd.vd_aux = BYTE_GET (evd.vd_aux);
252b5132
RH		 9000 ivd.vd_next = BYTE_GET (evd.vd_next);
9001
91d6fa6a 9002 off += ivd.vd_next;
252b5132 9003 }
c244d050 9004 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
252b5132
RH		 9005 && ivd.vd_next != 0);
9006
91d6fa6a
NC		 9007 off -= ivd.vd_next;
9008 off += ivd.vd_aux;
252b5132 9009
91d6fa6a 9010 get_data (&evda, file, off, sizeof (evda),
c256ffe7 9011 1, _("version def aux"));
252b5132
RH		 9012
9013 ivda.vda_name = BYTE_GET (evda.vda_name);
9014
9015 if (psym->st_name != ivda.vda_name)
c244d050 9016 printf ((vers_data & VERSYM_HIDDEN)
252b5132 9017 ? "@%s" : "@@%s",
c256ffe7 9018 ivda.vda_name < strtab_size
2b692964 9019 ? strtab + ivda.vda_name : _("<corrupt>"));
252b5132
RH		 9020 }
9021 }
9022 }
9023 }
9024
9025 putchar ('\n');
9026 }
9027
9028 free (symtab);
9029 if (strtab != string_table)
9030 free (strtab);
9031 }
9032 }
9033 else if (do_syms)
9034 printf
9035 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9036
9037 if (do_histogram && buckets != NULL)
9038 {
2cf0635d
NC		 9039 unsigned long * lengths;
9040 unsigned long * counts;
66543521
AM		 9041 unsigned long hn;
9042 bfd_vma si;
9043 unsigned long maxlength = 0;
9044 unsigned long nzero_counts = 0;
9045 unsigned long nsyms = 0;
252b5132 9046
66543521
AM		 9047 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9048 (unsigned long) nbuckets);
252b5132
RH		 9049 printf (_(" Length Number %% of total Coverage\n"));
9050
3f5e193b 9051 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 9052 if (lengths == NULL)
9053 {
591a748a 9054 error (_("Out of memory\n"));
252b5132
RH		 9055 return 0;
9056 }
9057 for (hn = 0; hn < nbuckets; ++hn)
9058 {
f7a99963 9059 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
252b5132 9060 {
b34976b6 9061 ++nsyms;
252b5132 9062 if (maxlength < ++lengths[hn])
b34976b6 9063 ++maxlength;
252b5132
RH		 9064 }
9065 }
9066
3f5e193b 9067 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 9068 if (counts == NULL)
9069 {
591a748a 9070 error (_("Out of memory\n"));
252b5132
RH		 9071 return 0;
9072 }
9073
9074 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 9075 ++counts[lengths[hn]];
252b5132 9076
103f02d3 9077 if (nbuckets > 0)
252b5132 9078 {
66543521
AM		 9079 unsigned long i;
9080 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 9081 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 9082 for (i = 1; i <= maxlength; ++i)
103f02d3 9083 {
66543521
AM		 9084 nzero_counts += counts[i] * i;
9085 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9086 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 9087 (nzero_counts * 100.0) / nsyms);
9088 }
252b5132
RH		 9089 }
9090
9091 free (counts);
9092 free (lengths);
9093 }
9094
9095 if (buckets != NULL)
9096 {
9097 free (buckets);
9098 free (chains);
9099 }
9100
d3a44ec6 9101 if (do_histogram && gnubuckets != NULL)
fdc90cb4 9102 {
2cf0635d
NC		 9103 unsigned long * lengths;
9104 unsigned long * counts;
fdc90cb4
JJ		 9105 unsigned long hn;
9106 unsigned long maxlength = 0;
9107 unsigned long nzero_counts = 0;
9108 unsigned long nsyms = 0;
fdc90cb4 9109
3f5e193b 9110 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 9111 if (lengths == NULL)
9112 {
591a748a 9113 error (_("Out of memory\n"));
fdc90cb4
JJ		 9114 return 0;
9115 }
9116
9117 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9118 (unsigned long) ngnubuckets);
9119 printf (_(" Length Number %% of total Coverage\n"));
9120
9121 for (hn = 0; hn < ngnubuckets; ++hn)
9122 if (gnubuckets[hn] != 0)
9123 {
9124 bfd_vma off, length = 1;
9125
6bd1a22c 9126 for (off = gnubuckets[hn] - gnusymidx;
fdc90cb4
JJ		 9127 (gnuchains[off] & 1) == 0; ++off)
9128 ++length;
9129 lengths[hn] = length;
9130 if (length > maxlength)
9131 maxlength = length;
9132 nsyms += length;
9133 }
9134
3f5e193b 9135 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 9136 if (counts == NULL)
9137 {
591a748a 9138 error (_("Out of memory\n"));
fdc90cb4
JJ		 9139 return 0;
9140 }
9141
9142 for (hn = 0; hn < ngnubuckets; ++hn)
9143 ++counts[lengths[hn]];
9144
9145 if (ngnubuckets > 0)
9146 {
9147 unsigned long j;
9148 printf (" 0 %-10lu (%5.1f%%)\n",
9149 counts[0], (counts[0] * 100.0) / ngnubuckets);
9150 for (j = 1; j <= maxlength; ++j)
9151 {
9152 nzero_counts += counts[j] * j;
9153 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9154 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9155 (nzero_counts * 100.0) / nsyms);
9156 }
9157 }
9158
9159 free (counts);
9160 free (lengths);
9161 free (gnubuckets);
9162 free (gnuchains);
9163 }
9164
252b5132
RH		 9165 return 1;
9166}
9167
9168static int
2cf0635d 9169process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 9170{
b4c96d0d 9171 unsigned int i;
252b5132
RH		 9172
9173 if (dynamic_syminfo == NULL
9174 || !do_dynamic)
9175 /* No syminfo, this is ok. */
9176 return 1;
9177
9178 /* There better should be a dynamic symbol section. */
9179 if (dynamic_symbols == NULL || dynamic_strings == NULL)
9180 return 0;
9181
9182 if (dynamic_addr)
9183 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9184 dynamic_syminfo_offset, dynamic_syminfo_nent);
9185
9186 printf (_(" Num: Name BoundTo Flags\n"));
9187 for (i = 0; i < dynamic_syminfo_nent; ++i)
9188 {
9189 unsigned short int flags = dynamic_syminfo[i].si_flags;
9190
31104126 9191 printf ("%4d: ", i);
d79b3d50
NC		 9192 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9193 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9194 else
2b692964 9195 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 9196 putchar (' ');
252b5132
RH		 9197
9198 switch (dynamic_syminfo[i].si_boundto)
9199 {
9200 case SYMINFO_BT_SELF:
9201 fputs ("SELF ", stdout);
9202 break;
9203 case SYMINFO_BT_PARENT:
9204 fputs ("PARENT ", stdout);
9205 break;
9206 default:
9207 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 9208 && dynamic_syminfo[i].si_boundto < dynamic_nent
9209 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 9210 {
d79b3d50 9211 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 9212 putchar (' ' );
9213 }
252b5132
RH		 9214 else
9215 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
9216 break;
9217 }
9218
9219 if (flags & SYMINFO_FLG_DIRECT)
9220 printf (" DIRECT");
9221 if (flags & SYMINFO_FLG_PASSTHRU)
9222 printf (" PASSTHRU");
9223 if (flags & SYMINFO_FLG_COPY)
9224 printf (" COPY");
9225 if (flags & SYMINFO_FLG_LAZYLOAD)
9226 printf (" LAZYLOAD");
9227
9228 puts ("");
9229 }
9230
9231 return 1;
9232}
9233
cf13d699
NC		 9234/* Check to see if the given reloc needs to be handled in a target specific
9235 manner. If so then process the reloc and return TRUE otherwise return
9236 FALSE. */
09c11c86 9237
cf13d699
NC		 9238static bfd_boolean
9239target_specific_reloc_handling (Elf_Internal_Rela * reloc,
9240 unsigned char * start,
9241 Elf_Internal_Sym * symtab)
252b5132 9242{
cf13d699 9243 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 9244
cf13d699 9245 switch (elf_header.e_machine)
252b5132 9246 {
cf13d699
NC		 9247 case EM_MN10300:
9248 case EM_CYGNUS_MN10300:
9249 {
9250 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 9251
cf13d699
NC		 9252 switch (reloc_type)
9253 {
9254 case 34: /* R_MN10300_ALIGN */
9255 return TRUE;
9256 case 33: /* R_MN10300_SYM_DIFF */
9257 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
9258 return TRUE;
9259 case 1: /* R_MN10300_32 */
9260 case 2: /* R_MN10300_16 */
9261 if (saved_sym != NULL)
9262 {
9263 bfd_vma value;
252b5132 9264
cf13d699
NC		 9265 value = reloc->r_addend
9266 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
9267 - saved_sym->st_value);
252b5132 9268
cf13d699 9269 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 9270
cf13d699
NC		 9271 saved_sym = NULL;
9272 return TRUE;
9273 }
9274 break;
9275 default:
9276 if (saved_sym != NULL)
9277 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9278 break;
9279 }
9280 break;
9281 }
252b5132
RH		 9282 }
9283
cf13d699 9284 return FALSE;
252b5132
RH		 9285}
9286
aca88567
NC		 9287/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9288 DWARF debug sections. This is a target specific test. Note - we do not
9289 go through the whole including-target-headers-multiple-times route, (as
9290 we have already done with <elf/h8.h>) because this would become very
9291 messy and even then this function would have to contain target specific
9292 information (the names of the relocs instead of their numeric values).
9293 FIXME: This is not the correct way to solve this problem. The proper way
9294 is to have target specific reloc sizing and typing functions created by
9295 the reloc-macros.h header, in the same way that it already creates the
9296 reloc naming functions. */
9297
9298static bfd_boolean
9299is_32bit_abs_reloc (unsigned int reloc_type)
9300{
9301 switch (elf_header.e_machine)
9302 {
41e92641
NC		 9303 case EM_386:
9304 case EM_486:
9305 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 9306 case EM_68K:
9307 return reloc_type == 1; /* R_68K_32. */
9308 case EM_860:
9309 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 9310 case EM_960:
9311 return reloc_type == 2; /* R_960_32. */
aca88567 9312 case EM_ALPHA:
137b6b5f 9313 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 9314 case EM_ARC:
9315 return reloc_type == 1; /* R_ARC_32. */
9316 case EM_ARM:
9317 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 9318 case EM_AVR_OLD:
aca88567
NC		 9319 case EM_AVR:
9320 return reloc_type == 1;
9321 case EM_BLACKFIN:
9322 return reloc_type == 0x12; /* R_byte4_data. */
9323 case EM_CRIS:
9324 return reloc_type == 3; /* R_CRIS_32. */
9325 case EM_CR16:
6c03b1ed 9326 case EM_CR16_OLD:
aca88567
NC		 9327 return reloc_type == 3; /* R_CR16_NUM32. */
9328 case EM_CRX:
9329 return reloc_type == 15; /* R_CRX_NUM32. */
9330 case EM_CYGNUS_FRV:
9331 return reloc_type == 1;
41e92641
NC		 9332 case EM_CYGNUS_D10V:
9333 case EM_D10V:
9334 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 9335 case EM_CYGNUS_D30V:
9336 case EM_D30V:
9337 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 9338 case EM_DLX:
9339 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 9340 case EM_CYGNUS_FR30:
9341 case EM_FR30:
9342 return reloc_type == 3; /* R_FR30_32. */
9343 case EM_H8S:
9344 case EM_H8_300:
9345 case EM_H8_300H:
9346 return reloc_type == 1; /* R_H8_DIR32. */
3730236a
NC		 9347 case EM_IA_64:
9348 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
aca88567
NC		 9349 case EM_IP2K_OLD:
9350 case EM_IP2K:
9351 return reloc_type == 2; /* R_IP2K_32. */
9352 case EM_IQ2000:
9353 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 9354 case EM_LATTICEMICO32:
9355 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 9356 case EM_M32C_OLD:
aca88567
NC		 9357 case EM_M32C:
9358 return reloc_type == 3; /* R_M32C_32. */
9359 case EM_M32R:
9360 return reloc_type == 34; /* R_M32R_32_RELA. */
9361 case EM_MCORE:
9362 return reloc_type == 1; /* R_MCORE_ADDR32. */
9363 case EM_CYGNUS_MEP:
9364 return reloc_type == 4; /* R_MEP_32. */
137b6b5f
AM		 9365 case EM_MICROBLAZE:
9366 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 9367 case EM_MIPS:
9368 return reloc_type == 2; /* R_MIPS_32. */
9369 case EM_MMIX:
9370 return reloc_type == 4; /* R_MMIX_32. */
9371 case EM_CYGNUS_MN10200:
9372 case EM_MN10200:
9373 return reloc_type == 1; /* R_MN10200_32. */
9374 case EM_CYGNUS_MN10300:
9375 case EM_MN10300:
9376 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 9377 case EM_MOXIE:
9378 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 9379 case EM_MSP430_OLD:
9380 case EM_MSP430:
9381 return reloc_type == 1; /* R_MSP43_32. */
9382 case EM_MT:
9383 return reloc_type == 2; /* R_MT_32. */
3e0873ac
NC		 9384 case EM_ALTERA_NIOS2:
9385 case EM_NIOS32:
9386 return reloc_type == 1; /* R_NIOS_32. */
41e92641
NC		 9387 case EM_OPENRISC:
9388 case EM_OR32:
9389 return reloc_type == 1; /* R_OR32_32. */
aca88567 9390 case EM_PARISC:
5fda8eca
NC		 9391 return (reloc_type == 1 /* R_PARISC_DIR32. */
9392 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 9393 case EM_PJ:
9394 case EM_PJ_OLD:
9395 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
9396 case EM_PPC64:
9397 return reloc_type == 1; /* R_PPC64_ADDR32. */
9398 case EM_PPC:
9399 return reloc_type == 1; /* R_PPC_ADDR32. */
c7927a3c
NC		 9400 case EM_RX:
9401 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 9402 case EM_S370:
9403 return reloc_type == 1; /* R_I370_ADDR31. */
9404 case EM_S390_OLD:
9405 case EM_S390:
9406 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 9407 case EM_SCORE:
9408 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 9409 case EM_SH:
9410 return reloc_type == 1; /* R_SH_DIR32. */
9411 case EM_SPARC32PLUS:
9412 case EM_SPARCV9:
9413 case EM_SPARC:
9414 return reloc_type == 3 /* R_SPARC_32. */
9415 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 9416 case EM_SPU:
9417 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 9418 case EM_TI_C6000:
9419 return reloc_type == 1; /* R_C6000_ABS32. */
aca88567
NC		 9420 case EM_CYGNUS_V850:
9421 case EM_V850:
9422 return reloc_type == 6; /* R_V850_ABS32. */
9423 case EM_VAX:
9424 return reloc_type == 1; /* R_VAX_32. */
9425 case EM_X86_64:
8a9036a4 9426 case EM_L1OM:
aca88567 9427 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 9428 case EM_XC16X:
9429 case EM_C166:
9430 return reloc_type == 3; /* R_XC16C_ABS_32. */
aca88567
NC		 9431 case EM_XSTORMY16:
9432 return reloc_type == 1; /* R_XSTROMY16_32. */
9433 case EM_XTENSA_OLD:
9434 case EM_XTENSA:
9435 return reloc_type == 1; /* R_XTENSA_32. */
aca88567
NC		 9436 default:
9437 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
9438 elf_header.e_machine);
9439 abort ();
9440 }
9441}
9442
9443/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9444 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
9445
9446static bfd_boolean
9447is_32bit_pcrel_reloc (unsigned int reloc_type)
9448{
9449 switch (elf_header.e_machine)
9450 {
41e92641
NC		 9451 case EM_386:
9452 case EM_486:
3e0873ac 9453 return reloc_type == 2; /* R_386_PC32. */
aca88567 9454 case EM_68K:
3e0873ac 9455 return reloc_type == 4; /* R_68K_PC32. */
aca88567
NC		 9456 case EM_ALPHA:
9457 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 9458 case EM_ARM:
3e0873ac 9459 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 9460 case EM_MICROBLAZE:
9461 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
aca88567 9462 case EM_PARISC:
85acf597 9463 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 9464 case EM_PPC:
9465 return reloc_type == 26; /* R_PPC_REL32. */
9466 case EM_PPC64:
3e0873ac 9467 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 9468 case EM_S390_OLD:
9469 case EM_S390:
3e0873ac 9470 return reloc_type == 5; /* R_390_PC32. */
aca88567 9471 case EM_SH:
3e0873ac 9472 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 9473 case EM_SPARC32PLUS:
9474 case EM_SPARCV9:
9475 case EM_SPARC:
3e0873ac 9476 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 9477 case EM_SPU:
9478 return reloc_type == 13; /* R_SPU_REL32. */
aca88567 9479 case EM_X86_64:
8a9036a4 9480 case EM_L1OM:
3e0873ac 9481 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 9482 case EM_XTENSA_OLD:
9483 case EM_XTENSA:
9484 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 9485 default:
9486 /* Do not abort or issue an error message here. Not all targets use
9487 pc-relative 32-bit relocs in their DWARF debug information and we
9488 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 9489 more helpful warning message will be generated by apply_relocations
9490 anyway, so just return. */
aca88567
NC		 9491 return FALSE;
9492 }
9493}
9494
9495/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9496 a 64-bit absolute RELA relocation used in DWARF debug sections. */
9497
9498static bfd_boolean
9499is_64bit_abs_reloc (unsigned int reloc_type)
9500{
9501 switch (elf_header.e_machine)
9502 {
9503 case EM_ALPHA:
9504 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 9505 case EM_IA_64:
9506 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 9507 case EM_PARISC:
9508 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 9509 case EM_PPC64:
9510 return reloc_type == 38; /* R_PPC64_ADDR64. */
9511 case EM_SPARC32PLUS:
9512 case EM_SPARCV9:
9513 case EM_SPARC:
9514 return reloc_type == 54; /* R_SPARC_UA64. */
9515 case EM_X86_64:
8a9036a4 9516 case EM_L1OM:
aca88567 9517 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 9518 case EM_S390_OLD:
9519 case EM_S390:
9520 return reloc_type == 22; /* R_S390_64 */
85a82265
AM		 9521 case EM_MIPS:
9522 return reloc_type == 18; /* R_MIPS_64 */
aca88567
NC		 9523 default:
9524 return FALSE;
9525 }
9526}
9527
85acf597
RH		 9528/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
9529 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
9530
9531static bfd_boolean
9532is_64bit_pcrel_reloc (unsigned int reloc_type)
9533{
9534 switch (elf_header.e_machine)
9535 {
9536 case EM_ALPHA:
9537 return reloc_type == 11; /* R_ALPHA_SREL64 */
9538 case EM_IA_64:
9539 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB */
9540 case EM_PARISC:
9541 return reloc_type == 72; /* R_PARISC_PCREL64 */
9542 case EM_PPC64:
9543 return reloc_type == 44; /* R_PPC64_REL64 */
9544 case EM_SPARC32PLUS:
9545 case EM_SPARCV9:
9546 case EM_SPARC:
9547 return reloc_type == 46; /* R_SPARC_DISP64 */
9548 case EM_X86_64:
8a9036a4 9549 case EM_L1OM:
85acf597
RH		 9550 return reloc_type == 24; /* R_X86_64_PC64 */
9551 case EM_S390_OLD:
9552 case EM_S390:
9553 return reloc_type == 23; /* R_S390_PC64 */
9554 default:
9555 return FALSE;
9556 }
9557}
9558
4dc3c23d
AM		 9559/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9560 a 24-bit absolute RELA relocation used in DWARF debug sections. */
9561
9562static bfd_boolean
9563is_24bit_abs_reloc (unsigned int reloc_type)
9564{
9565 switch (elf_header.e_machine)
9566 {
9567 case EM_CYGNUS_MN10200:
9568 case EM_MN10200:
9569 return reloc_type == 4; /* R_MN10200_24. */
9570 default:
9571 return FALSE;
9572 }
9573}
9574
aca88567
NC		 9575/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9576 a 16-bit absolute RELA relocation used in DWARF debug sections. */
9577
9578static bfd_boolean
9579is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 9580{
9581 switch (elf_header.e_machine)
9582 {
aca88567
NC		 9583 case EM_AVR_OLD:
9584 case EM_AVR:
9585 return reloc_type == 4; /* R_AVR_16. */
41e92641
NC		 9586 case EM_CYGNUS_D10V:
9587 case EM_D10V:
9588 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 9589 case EM_H8S:
9590 case EM_H8_300:
9591 case EM_H8_300H:
aca88567
NC		 9592 return reloc_type == R_H8_DIR16;
9593 case EM_IP2K_OLD:
9594 case EM_IP2K:
9595 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 9596 case EM_M32C_OLD:
f4236fe4
DD		 9597 case EM_M32C:
9598 return reloc_type == 1; /* R_M32C_16 */
aca88567
NC		 9599 case EM_MSP430_OLD:
9600 case EM_MSP430:
9601 return reloc_type == 5; /* R_MSP430_16_BYTE. */
3e0873ac
NC		 9602 case EM_ALTERA_NIOS2:
9603 case EM_NIOS32:
9604 return reloc_type == 9; /* R_NIOS_16. */
40b36596
JM		 9605 case EM_TI_C6000:
9606 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 9607 case EM_XC16X:
9608 case EM_C166:
9609 return reloc_type == 2; /* R_XC16C_ABS_16. */
4b78141a 9610 default:
aca88567 9611 return FALSE;
4b78141a
NC		 9612 }
9613}
9614
2a7b2e88
JK		 9615/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
9616 relocation entries (possibly formerly used for SHT_GROUP sections). */
9617
9618static bfd_boolean
9619is_none_reloc (unsigned int reloc_type)
9620{
9621 switch (elf_header.e_machine)
9622 {
cb8f3167
NC		 9623 case EM_68K: /* R_68K_NONE. */
9624 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 9625 case EM_SPARC32PLUS:
9626 case EM_SPARCV9:
cb8f3167
NC		 9627 case EM_SPARC: /* R_SPARC_NONE. */
9628 case EM_MIPS: /* R_MIPS_NONE. */
9629 case EM_PARISC: /* R_PARISC_NONE. */
9630 case EM_ALPHA: /* R_ALPHA_NONE. */
9631 case EM_PPC: /* R_PPC_NONE. */
9632 case EM_PPC64: /* R_PPC64_NONE. */
9633 case EM_ARM: /* R_ARM_NONE. */
9634 case EM_IA_64: /* R_IA64_NONE. */
9635 case EM_SH: /* R_SH_NONE. */
2a7b2e88 9636 case EM_S390_OLD:
cb8f3167
NC		 9637 case EM_S390: /* R_390_NONE. */
9638 case EM_CRIS: /* R_CRIS_NONE. */
9639 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 9640 case EM_L1OM: /* R_X86_64_NONE. */
cb8f3167 9641 case EM_MN10300: /* R_MN10300_NONE. */
5506d11a 9642 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 9643 case EM_M32R: /* R_M32R_NONE. */
40b36596 9644 case EM_TI_C6000:/* R_C6000_NONE. */
c29aca4a
NC		 9645 case EM_XC16X:
9646 case EM_C166: /* R_XC16X_NONE. */
cb8f3167 9647 return reloc_type == 0;
58332dda
JK		 9648 case EM_XTENSA_OLD:
9649 case EM_XTENSA:
4dc3c23d
AM		 9650 return (reloc_type == 0 /* R_XTENSA_NONE. */
9651 || reloc_type == 17 /* R_XTENSA_DIFF8. */
9652 || reloc_type == 18 /* R_XTENSA_DIFF16. */
9653 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
2a7b2e88
JK		 9654 }
9655 return FALSE;
9656}
9657
cf13d699
NC		 9658/* Apply relocations to a section.
9659 Note: So far support has been added only for those relocations
9660 which can be found in debug sections.
9661 FIXME: Add support for more relocations ? */
1b315056 9662
cf13d699
NC		 9663static void
9664apply_relocations (void * file,
9665 Elf_Internal_Shdr * section,
9666 unsigned char * start)
1b315056 9667{
cf13d699
NC		 9668 Elf_Internal_Shdr * relsec;
9669 unsigned char * end = start + section->sh_size;
cb8f3167 9670
cf13d699
NC		 9671 if (elf_header.e_type != ET_REL)
9672 return;
1b315056 9673
cf13d699 9674 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 9675 for (relsec = section_headers;
9676 relsec < section_headers + elf_header.e_shnum;
9677 ++relsec)
252b5132 9678 {
41e92641
NC		 9679 bfd_boolean is_rela;
9680 unsigned long num_relocs;
2cf0635d
NC		 9681 Elf_Internal_Rela * relocs;
9682 Elf_Internal_Rela * rp;
9683 Elf_Internal_Shdr * symsec;
9684 Elf_Internal_Sym * symtab;
9685 Elf_Internal_Sym * sym;
252b5132 9686
41e92641 9687 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 9688 || relsec->sh_info >= elf_header.e_shnum
9689 || section_headers + relsec->sh_info != section
c256ffe7 9690 || relsec->sh_size == 0
4fbb74a6 9691 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 9692 continue;
428409d5 9693
41e92641
NC		 9694 is_rela = relsec->sh_type == SHT_RELA;
9695
9696 if (is_rela)
9697 {
3f5e193b
NC		 9698 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
9699 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 9700 return;
9701 }
9702 else
9703 {
3f5e193b
NC		 9704 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
9705 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 9706 return;
9707 }
9708
9709 /* SH uses RELA but uses in place value instead of the addend field. */
9710 if (elf_header.e_machine == EM_SH)
9711 is_rela = FALSE;
428409d5 9712
4fbb74a6 9713 symsec = section_headers + relsec->sh_link;
3f5e193b 9714 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec);
103f02d3 9715
41e92641 9716 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 9717 {
41e92641
NC		 9718 bfd_vma addend;
9719 unsigned int reloc_type;
9720 unsigned int reloc_size;
91d6fa6a 9721 unsigned char * rloc;
4b78141a 9722
aca88567 9723 reloc_type = get_reloc_type (rp->r_info);
41e92641 9724
98fb390a 9725 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 9726 continue;
98fb390a
NC		 9727 else if (is_none_reloc (reloc_type))
9728 continue;
9729 else if (is_32bit_abs_reloc (reloc_type)
9730 || is_32bit_pcrel_reloc (reloc_type))
aca88567 9731 reloc_size = 4;
85acf597
RH		 9732 else if (is_64bit_abs_reloc (reloc_type)
9733 || is_64bit_pcrel_reloc (reloc_type))
aca88567 9734 reloc_size = 8;
4dc3c23d
AM		 9735 else if (is_24bit_abs_reloc (reloc_type))
9736 reloc_size = 3;
aca88567
NC		 9737 else if (is_16bit_abs_reloc (reloc_type))
9738 reloc_size = 2;
9739 else
4b78141a 9740 {
41e92641 9741 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
aca88567 9742 reloc_type, SECTION_NAME (section));
4b78141a
NC		 9743 continue;
9744 }
103f02d3 9745
91d6fa6a
NC		 9746 rloc = start + rp->r_offset;
9747 if ((rloc + reloc_size) > end)
700dd8b7
L		 9748 {
9749 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
9750 (unsigned long) rp->r_offset,
9751 SECTION_NAME (section));
9752 continue;
9753 }
103f02d3 9754
41e92641
NC		 9755 sym = symtab + get_reloc_symindex (rp->r_info);
9756
9757 /* If the reloc has a symbol associated with it,
55f25fc3
L		 9758 make sure that it is of an appropriate type.
9759
9760 Relocations against symbols without type can happen.
9761 Gcc -feliminate-dwarf2-dups may generate symbols
9762 without type for debug info.
9763
9764 Icc generates relocations against function symbols
9765 instead of local labels.
9766
9767 Relocations against object symbols can happen, eg when
9768 referencing a global array. For an example of this see
9769 the _clz.o binary in libgcc.a. */
aca88567 9770 if (sym != symtab
55f25fc3 9771 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 9772 {
41e92641 9773 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 9774 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 9775 (long int)(rp - relocs),
41e92641 9776 SECTION_NAME (relsec));
aca88567 9777 continue;
5b18a4bc 9778 }
252b5132 9779
4dc3c23d
AM		 9780 addend = 0;
9781 if (is_rela)
9782 addend += rp->r_addend;
c47320c3
AM		 9783 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
9784 partial_inplace. */
4dc3c23d
AM		 9785 if (!is_rela
9786 || (elf_header.e_machine == EM_XTENSA
9787 && reloc_type == 1)
9788 || ((elf_header.e_machine == EM_PJ
9789 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 9790 && reloc_type == 1)
9791 || ((elf_header.e_machine == EM_D30V
9792 || elf_header.e_machine == EM_CYGNUS_D30V)
9793 && reloc_type == 12))
91d6fa6a 9794 addend += byte_get (rloc, reloc_size);
cb8f3167 9795
85acf597
RH		 9796 if (is_32bit_pcrel_reloc (reloc_type)
9797 || is_64bit_pcrel_reloc (reloc_type))
9798 {
9799 /* On HPPA, all pc-relative relocations are biased by 8. */
9800 if (elf_header.e_machine == EM_PARISC)
9801 addend -= 8;
91d6fa6a 9802 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 9803 reloc_size);
9804 }
41e92641 9805 else
91d6fa6a 9806 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 9807 }
252b5132 9808
5b18a4bc 9809 free (symtab);
41e92641 9810 free (relocs);
5b18a4bc
NC		 9811 break;
9812 }
5b18a4bc 9813}
103f02d3 9814
cf13d699
NC		 9815#ifdef SUPPORT_DISASSEMBLY
9816static int
9817disassemble_section (Elf_Internal_Shdr * section, FILE * file)
9818{
9819 printf (_("\nAssembly dump of section %s\n"),
9820 SECTION_NAME (section));
9821
9822 /* XXX -- to be done --- XXX */
9823
9824 return 1;
9825}
9826#endif
9827
9828/* Reads in the contents of SECTION from FILE, returning a pointer
9829 to a malloc'ed buffer or NULL if something went wrong. */
9830
9831static char *
9832get_section_contents (Elf_Internal_Shdr * section, FILE * file)
9833{
9834 bfd_size_type num_bytes;
9835
9836 num_bytes = section->sh_size;
9837
9838 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
9839 {
9840 printf (_("\nSection '%s' has no data to dump.\n"),
9841 SECTION_NAME (section));
9842 return NULL;
9843 }
9844
3f5e193b
NC		 9845 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
9846 _("section contents"));
cf13d699
NC		 9847}
9848
dd24e3da 9849
cf13d699
NC		 9850static void
9851dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
9852{
9853 Elf_Internal_Shdr * relsec;
9854 bfd_size_type num_bytes;
cf13d699
NC		 9855 char * data;
9856 char * end;
9857 char * start;
9858 char * name = SECTION_NAME (section);
9859 bfd_boolean some_strings_shown;
9860
9861 start = get_section_contents (section, file);
9862 if (start == NULL)
9863 return;
9864
9865 printf (_("\nString dump of section '%s':\n"), name);
9866
9867 /* If the section being dumped has relocations against it the user might
9868 be expecting these relocations to have been applied. Check for this
9869 case and issue a warning message in order to avoid confusion.
9870 FIXME: Maybe we ought to have an option that dumps a section with
9871 relocs applied ? */
9872 for (relsec = section_headers;
9873 relsec < section_headers + elf_header.e_shnum;
9874 ++relsec)
9875 {
9876 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
9877 || relsec->sh_info >= elf_header.e_shnum
9878 || section_headers + relsec->sh_info != section
9879 || relsec->sh_size == 0
9880 || relsec->sh_link >= elf_header.e_shnum)
9881 continue;
9882
9883 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9884 break;
9885 }
9886
9887 num_bytes = section->sh_size;
cf13d699
NC		 9888 data = start;
9889 end = start + num_bytes;
9890 some_strings_shown = FALSE;
9891
9892 while (data < end)
9893 {
9894 while (!ISPRINT (* data))
9895 if (++ data >= end)
9896 break;
9897
9898 if (data < end)
9899 {
9900#ifndef __MSVCRT__
c975cc98
NC		 9901 /* PR 11128: Use two separate invocations in order to work
9902 around bugs in the Solaris 8 implementation of printf. */
9903 printf (" [%6tx] ", data - start);
9904 printf ("%s\n", data);
cf13d699
NC		 9905#else
9906 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
9907#endif
9908 data += strlen (data);
9909 some_strings_shown = TRUE;
9910 }
9911 }
9912
9913 if (! some_strings_shown)
9914 printf (_(" No strings found in this section."));
9915
9916 free (start);
9917
9918 putchar ('\n');
9919}
9920
9921static void
9922dump_section_as_bytes (Elf_Internal_Shdr * section,
9923 FILE * file,
9924 bfd_boolean relocate)
9925{
9926 Elf_Internal_Shdr * relsec;
9927 bfd_size_type bytes;
9928 bfd_vma addr;
9929 unsigned char * data;
9930 unsigned char * start;
9931
9932 start = (unsigned char *) get_section_contents (section, file);
9933 if (start == NULL)
9934 return;
9935
9936 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
9937
9938 if (relocate)
9939 {
9940 apply_relocations (file, section, start);
9941 }
9942 else
9943 {
9944 /* If the section being dumped has relocations against it the user might
9945 be expecting these relocations to have been applied. Check for this
9946 case and issue a warning message in order to avoid confusion.
9947 FIXME: Maybe we ought to have an option that dumps a section with
9948 relocs applied ? */
9949 for (relsec = section_headers;
9950 relsec < section_headers + elf_header.e_shnum;
9951 ++relsec)
9952 {
9953 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
9954 || relsec->sh_info >= elf_header.e_shnum
9955 || section_headers + relsec->sh_info != section
9956 || relsec->sh_size == 0
9957 || relsec->sh_link >= elf_header.e_shnum)
9958 continue;
9959
9960 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9961 break;
9962 }
9963 }
9964
9965 addr = section->sh_addr;
9966 bytes = section->sh_size;
9967 data = start;
9968
9969 while (bytes)
9970 {
9971 int j;
9972 int k;
9973 int lbytes;
9974
9975 lbytes = (bytes > 16 ? 16 : bytes);
9976
9977 printf (" 0x%8.8lx ", (unsigned long) addr);
9978
9979 for (j = 0; j < 16; j++)
9980 {
9981 if (j < lbytes)
9982 printf ("%2.2x", data[j]);
9983 else
9984 printf (" ");
9985
9986 if ((j & 3) == 3)
9987 printf (" ");
9988 }
9989
9990 for (j = 0; j < lbytes; j++)
9991 {
9992 k = data[j];
9993 if (k >= ' ' && k < 0x7f)
9994 printf ("%c", k);
9995 else
9996 printf (".");
9997 }
9998
9999 putchar ('\n');
10000
10001 data += lbytes;
10002 addr += lbytes;
10003 bytes -= lbytes;
10004 }
10005
10006 free (start);
10007
10008 putchar ('\n');
10009}
10010
4a114e3e 10011/* Uncompresses a section that was compressed using zlib, in place. */
cf13d699
NC		 10012
10013static int
d3dbc530
AM		 10014uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10015 dwarf_size_type *size ATTRIBUTE_UNUSED)
cf13d699
NC		 10016{
10017#ifndef HAVE_ZLIB_H
cf13d699
NC		 10018 return FALSE;
10019#else
10020 dwarf_size_type compressed_size = *size;
10021 unsigned char * compressed_buffer = *buffer;
10022 dwarf_size_type uncompressed_size;
10023 unsigned char * uncompressed_buffer;
10024 z_stream strm;
10025 int rc;
10026 dwarf_size_type header_size = 12;
10027
10028 /* Read the zlib header. In this case, it should be "ZLIB" followed
10029 by the uncompressed section size, 8 bytes in big-endian order. */
10030 if (compressed_size < header_size
10031 || ! streq ((char *) compressed_buffer, "ZLIB"))
10032 return 0;
10033
10034 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10035 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10036 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10037 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10038 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10039 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10040 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10041 uncompressed_size += compressed_buffer[11];
10042
10043 /* It is possible the section consists of several compressed
10044 buffers concatenated together, so we uncompress in a loop. */
10045 strm.zalloc = NULL;
10046 strm.zfree = NULL;
10047 strm.opaque = NULL;
10048 strm.avail_in = compressed_size - header_size;
10049 strm.next_in = (Bytef *) compressed_buffer + header_size;
10050 strm.avail_out = uncompressed_size;
3f5e193b 10051 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
cf13d699
NC		 10052
10053 rc = inflateInit (& strm);
10054 while (strm.avail_in > 0)
10055 {
10056 if (rc != Z_OK)
10057 goto fail;
10058 strm.next_out = ((Bytef *) uncompressed_buffer
10059 + (uncompressed_size - strm.avail_out));
10060 rc = inflate (&strm, Z_FINISH);
10061 if (rc != Z_STREAM_END)
10062 goto fail;
10063 rc = inflateReset (& strm);
10064 }
10065 rc = inflateEnd (& strm);
10066 if (rc != Z_OK
10067 || strm.avail_out != 0)
10068 goto fail;
10069
10070 free (compressed_buffer);
10071 *buffer = uncompressed_buffer;
10072 *size = uncompressed_size;
10073 return 1;
10074
10075 fail:
10076 free (uncompressed_buffer);
4a114e3e
L		 10077 /* Indicate decompression failure. */
10078 *buffer = NULL;
cf13d699
NC		 10079 return 0;
10080#endif /* HAVE_ZLIB_H */
10081}
10082
d966045b
DJ		 10083static int
10084load_specific_debug_section (enum dwarf_section_display_enum debug,
2cf0635d 10085 Elf_Internal_Shdr * sec, void * file)
1007acb3 10086{
2cf0635d 10087 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 10088 char buf [64];
1007acb3 10089
19e6b90e
L		 10090 /* If it is already loaded, do nothing. */
10091 if (section->start != NULL)
10092 return 1;
1007acb3 10093
19e6b90e
L		 10094 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
10095 section->address = sec->sh_addr;
10096 section->size = sec->sh_size;
3f5e193b
NC		 10097 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
10098 sec->sh_offset, 1,
10099 sec->sh_size, buf);
4a114e3e
L		 10100 if (uncompress_section_contents (&section->start, &section->size))
10101 sec->sh_size = section->size;
10102
1b315056
CS		 10103 if (section->start == NULL)
10104 return 0;
10105
19e6b90e 10106 if (debug_displays [debug].relocate)
3f5e193b 10107 apply_relocations ((FILE *) file, sec, section->start);
1007acb3 10108
1b315056 10109 return 1;
1007acb3
L		 10110}
10111
d966045b 10112int
2cf0635d 10113load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 10114{
2cf0635d
NC		 10115 struct dwarf_section * section = &debug_displays [debug].section;
10116 Elf_Internal_Shdr * sec;
d966045b
DJ		 10117
10118 /* Locate the debug section. */
10119 sec = find_section (section->uncompressed_name);
10120 if (sec != NULL)
10121 section->name = section->uncompressed_name;
10122 else
10123 {
10124 sec = find_section (section->compressed_name);
10125 if (sec != NULL)
10126 section->name = section->compressed_name;
10127 }
10128 if (sec == NULL)
10129 return 0;
10130
3f5e193b 10131 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 10132}
10133
19e6b90e
L		 10134void
10135free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 10136{
2cf0635d 10137 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 10138
19e6b90e
L		 10139 if (section->start == NULL)
10140 return;
1007acb3 10141
19e6b90e
L		 10142 free ((char *) section->start);
10143 section->start = NULL;
10144 section->address = 0;
10145 section->size = 0;
1007acb3
L		 10146}
10147
1007acb3 10148static int
2cf0635d 10149display_debug_section (Elf_Internal_Shdr * section, FILE * file)
1007acb3 10150{
2cf0635d 10151 char * name = SECTION_NAME (section);
19e6b90e
L		 10152 bfd_size_type length;
10153 int result = 1;
3f5e193b 10154 int i;
1007acb3 10155
19e6b90e
L		 10156 length = section->sh_size;
10157 if (length == 0)
1007acb3 10158 {
19e6b90e
L		 10159 printf (_("\nSection '%s' has no debugging data.\n"), name);
10160 return 0;
1007acb3 10161 }
5dff79d8
NC		 10162 if (section->sh_type == SHT_NOBITS)
10163 {
10164 /* There is no point in dumping the contents of a debugging section
10165 which has the NOBITS type - the bits in the file will be random.
10166 This can happen when a file containing a .eh_frame section is
10167 stripped with the --only-keep-debug command line option. */
10168 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
10169 return 0;
10170 }
1007acb3 10171
0112cd26 10172 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 10173 name = ".debug_info";
1007acb3 10174
19e6b90e
L		 10175 /* See if we know how to display the contents of this section. */
10176 for (i = 0; i < max; i++)
1b315056
CS		 10177 if (streq (debug_displays[i].section.uncompressed_name, name)
10178 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 10179 {
2cf0635d 10180 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 10181 int secondary = (section != find_section (name));
10182
10183 if (secondary)
3f5e193b 10184 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 10185
2b6f5997 10186 if (streq (sec->uncompressed_name, name))
d966045b
DJ		 10187 sec->name = sec->uncompressed_name;
10188 else
10189 sec->name = sec->compressed_name;
3f5e193b
NC		 10190 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
10191 section, file))
19e6b90e
L		 10192 {
10193 result &= debug_displays[i].display (sec, file);
1007acb3 10194
d966045b 10195 if (secondary || (i != info && i != abbrev))
3f5e193b 10196 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 10197 }
1007acb3 10198
19e6b90e
L		 10199 break;
10200 }
1007acb3 10201
19e6b90e 10202 if (i == max)
1007acb3 10203 {
19e6b90e
L		 10204 printf (_("Unrecognized debug section: %s\n"), name);
10205 result = 0;
1007acb3
L		 10206 }
10207
19e6b90e 10208 return result;
5b18a4bc 10209}
103f02d3 10210
aef1f6d0
DJ		 10211/* Set DUMP_SECTS for all sections where dumps were requested
10212 based on section name. */
10213
10214static void
10215initialise_dumps_byname (void)
10216{
2cf0635d 10217 struct dump_list_entry * cur;
aef1f6d0
DJ		 10218
10219 for (cur = dump_sects_byname; cur; cur = cur->next)
10220 {
10221 unsigned int i;
10222 int any;
10223
10224 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
10225 if (streq (SECTION_NAME (section_headers + i), cur->name))
10226 {
09c11c86 10227 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 10228 any = 1;
10229 }
10230
10231 if (!any)
10232 warn (_("Section '%s' was not dumped because it does not exist!\n"),
10233 cur->name);
10234 }
10235}
10236
5b18a4bc 10237static void
2cf0635d 10238process_section_contents (FILE * file)
5b18a4bc 10239{
2cf0635d 10240 Elf_Internal_Shdr * section;
19e6b90e 10241 unsigned int i;
103f02d3 10242
19e6b90e
L		 10243 if (! do_dump)
10244 return;
103f02d3 10245
aef1f6d0
DJ		 10246 initialise_dumps_byname ();
10247
19e6b90e
L		 10248 for (i = 0, section = section_headers;
10249 i < elf_header.e_shnum && i < num_dump_sects;
10250 i++, section++)
10251 {
10252#ifdef SUPPORT_DISASSEMBLY
10253 if (dump_sects[i] & DISASS_DUMP)
10254 disassemble_section (section, file);
10255#endif
10256 if (dump_sects[i] & HEX_DUMP)
cf13d699 10257 dump_section_as_bytes (section, file, FALSE);
103f02d3 10258
cf13d699
NC		 10259 if (dump_sects[i] & RELOC_DUMP)
10260 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 10261
10262 if (dump_sects[i] & STRING_DUMP)
10263 dump_section_as_strings (section, file);
cf13d699
NC		 10264
10265 if (dump_sects[i] & DEBUG_DUMP)
10266 display_debug_section (section, file);
5b18a4bc 10267 }
103f02d3 10268
19e6b90e
L		 10269 /* Check to see if the user requested a
10270 dump of a section that does not exist. */
10271 while (i++ < num_dump_sects)
10272 if (dump_sects[i])
10273 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 10274}
103f02d3 10275
5b18a4bc 10276static void
19e6b90e 10277process_mips_fpe_exception (int mask)
5b18a4bc 10278{
19e6b90e
L		 10279 if (mask)
10280 {
10281 int first = 1;
10282 if (mask & OEX_FPU_INEX)
10283 fputs ("INEX", stdout), first = 0;
10284 if (mask & OEX_FPU_UFLO)
10285 printf ("%sUFLO", first ? "" : "|"), first = 0;
10286 if (mask & OEX_FPU_OFLO)
10287 printf ("%sOFLO", first ? "" : "|"), first = 0;
10288 if (mask & OEX_FPU_DIV0)
10289 printf ("%sDIV0", first ? "" : "|"), first = 0;
10290 if (mask & OEX_FPU_INVAL)
10291 printf ("%sINVAL", first ? "" : "|");
10292 }
5b18a4bc 10293 else
19e6b90e 10294 fputs ("0", stdout);
5b18a4bc 10295}
103f02d3 10296
11c1ff18
PB		 10297/* ARM EABI attributes section. */
10298typedef struct
10299{
10300 int tag;
2cf0635d 10301 const char * name;
11c1ff18
PB		 10302 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
10303 int type;
2cf0635d 10304 const char ** table;
11c1ff18
PB		 10305} arm_attr_public_tag;
10306
2cf0635d 10307static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 10308 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
9e3c6df6 10309 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
2cf0635d
NC		 10310static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
10311static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 10312 {"No", "Thumb-1", "Thumb-2"};
75375b3e 10313static const char * arm_attr_tag_FP_arch[] =
62f3b8c8 10314 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
2cf0635d 10315static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 10316static const char * arm_attr_tag_Advanced_SIMD_arch[] =
cd21e546 10317 {"No", "NEONv1", "NEONv1 with Fused-MAC"};
2cf0635d 10318static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 10319 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
10320 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 10321static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 10322 {"V6", "SB", "TLS", "Unused"};
2cf0635d 10323static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 10324 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 10325static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 10326 {"Absolute", "PC-relative", "None"};
2cf0635d 10327static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 10328 {"None", "direct", "GOT-indirect"};
2cf0635d 10329static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 10330 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 10331static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
10332static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 10333 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 10334static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
10335static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
10336static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 10337 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 10338static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 10339 {"Unused", "small", "int", "forced to int"};
2cf0635d 10340static const char * arm_attr_tag_ABI_HardFP_use[] =
75375b3e 10341 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
2cf0635d 10342static const char * arm_attr_tag_ABI_VFP_args[] =
11c1ff18 10343 {"AAPCS", "VFP registers", "custom"};
2cf0635d 10344static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 10345 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 10346static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 10347 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10348 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 10349static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 10350 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10351 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 10352static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 10353static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 10354 {"Not Allowed", "Allowed"};
2cf0635d 10355static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 10356 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 10357static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 10358 {"Not Allowed", "Allowed"};
10359static const char * arm_attr_tag_DIV_use[] =
dd24e3da 10360 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 10361 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 10362static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
10363static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 10364 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 10365 "TrustZone and Virtualization Extensions"};
dd24e3da 10366static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 10367 {"Not Allowed", "Allowed"};
11c1ff18
PB		 10368
10369#define LOOKUP(id, name) \
10370 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 10371static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 10372{
10373 {4, "CPU_raw_name", 1, NULL},
10374 {5, "CPU_name", 1, NULL},
10375 LOOKUP(6, CPU_arch),
10376 {7, "CPU_arch_profile", 0, NULL},
10377 LOOKUP(8, ARM_ISA_use),
10378 LOOKUP(9, THUMB_ISA_use),
75375b3e 10379 LOOKUP(10, FP_arch),
11c1ff18 10380 LOOKUP(11, WMMX_arch),
f5f53991
AS		 10381 LOOKUP(12, Advanced_SIMD_arch),
10382 LOOKUP(13, PCS_config),
11c1ff18
PB		 10383 LOOKUP(14, ABI_PCS_R9_use),
10384 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 10385 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 10386 LOOKUP(17, ABI_PCS_GOT_use),
10387 LOOKUP(18, ABI_PCS_wchar_t),
10388 LOOKUP(19, ABI_FP_rounding),
10389 LOOKUP(20, ABI_FP_denormal),
10390 LOOKUP(21, ABI_FP_exceptions),
10391 LOOKUP(22, ABI_FP_user_exceptions),
10392 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 10393 {24, "ABI_align_needed", 0, NULL},
10394 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 10395 LOOKUP(26, ABI_enum_size),
10396 LOOKUP(27, ABI_HardFP_use),
10397 LOOKUP(28, ABI_VFP_args),
10398 LOOKUP(29, ABI_WMMX_args),
10399 LOOKUP(30, ABI_optimization_goals),
10400 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 10401 {32, "compatibility", 0, NULL},
f5f53991 10402 LOOKUP(34, CPU_unaligned_access),
75375b3e 10403 LOOKUP(36, FP_HP_extension),
8e79c3df 10404 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 10405 LOOKUP(42, MPextension_use),
10406 LOOKUP(44, DIV_use),
f5f53991
AS		 10407 {64, "nodefaults", 0, NULL},
10408 {65, "also_compatible_with", 0, NULL},
10409 LOOKUP(66, T2EE_use),
10410 {67, "conformance", 1, NULL},
10411 LOOKUP(68, Virtualization_use),
cd21e546 10412 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 10413};
10414#undef LOOKUP
10415
11c1ff18 10416static unsigned char *
2cf0635d 10417display_arm_attribute (unsigned char * p)
11c1ff18
PB		 10418{
10419 int tag;
10420 unsigned int len;
10421 int val;
2cf0635d 10422 arm_attr_public_tag * attr;
11c1ff18
PB		 10423 unsigned i;
10424 int type;
10425
10426 tag = read_uleb128 (p, &len);
10427 p += len;
10428 attr = NULL;
2cf0635d 10429 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 10430 {
10431 if (arm_attr_public_tags[i].tag == tag)
10432 {
10433 attr = &arm_attr_public_tags[i];
10434 break;
10435 }
10436 }
10437
10438 if (attr)
10439 {
10440 printf (" Tag_%s: ", attr->name);
10441 switch (attr->type)
10442 {
10443 case 0:
10444 switch (tag)
10445 {
10446 case 7: /* Tag_CPU_arch_profile. */
10447 val = read_uleb128 (p, &len);
10448 p += len;
10449 switch (val)
10450 {
2b692964
NC		 10451 case 0: printf (_("None\n")); break;
10452 case 'A': printf (_("Application\n")); break;
10453 case 'R': printf (_("Realtime\n")); break;
10454 case 'M': printf (_("Microcontroller\n")); break;
10455 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 10456 default: printf ("??? (%d)\n", val); break;
10457 }
10458 break;
10459
75375b3e
MGD		 10460 case 24: /* Tag_align_needed. */
10461 val = read_uleb128 (p, &len);
10462 p += len;
10463 switch (val)
10464 {
2b692964
NC		 10465 case 0: printf (_("None\n")); break;
10466 case 1: printf (_("8-byte\n")); break;
10467 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 10468 case 3: printf ("??? 3\n"); break;
10469 default:
10470 if (val <= 12)
dd24e3da 10471 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 10472 1 << val);
10473 else
10474 printf ("??? (%d)\n", val);
10475 break;
10476 }
10477 break;
10478
10479 case 25: /* Tag_align_preserved. */
10480 val = read_uleb128 (p, &len);
10481 p += len;
10482 switch (val)
10483 {
2b692964
NC		 10484 case 0: printf (_("None\n")); break;
10485 case 1: printf (_("8-byte, except leaf SP\n")); break;
10486 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 10487 case 3: printf ("??? 3\n"); break;
10488 default:
10489 if (val <= 12)
dd24e3da 10490 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 10491 1 << val);
10492 else
10493 printf ("??? (%d)\n", val);
10494 break;
10495 }
10496 break;
10497
11c1ff18
PB		 10498 case 32: /* Tag_compatibility. */
10499 val = read_uleb128 (p, &len);
10500 p += len;
2b692964 10501 printf (_("flag = %d, vendor = %s\n"), val, p);
2cf0635d 10502 p += strlen ((char *) p) + 1;
11c1ff18
PB		 10503 break;
10504
f5f53991
AS		 10505 case 64: /* Tag_nodefaults. */
10506 p++;
2b692964 10507 printf (_("True\n"));
f5f53991
AS		 10508 break;
10509
10510 case 65: /* Tag_also_compatible_with. */
10511 val = read_uleb128 (p, &len);
10512 p += len;
10513 if (val == 6 /* Tag_CPU_arch. */)
10514 {
10515 val = read_uleb128 (p, &len);
10516 p += len;
2cf0635d 10517 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 10518 printf ("??? (%d)\n", val);
10519 else
10520 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
10521 }
10522 else
10523 printf ("???\n");
10524 while (*(p++) != '\0' /* NUL terminator. */);
10525 break;
10526
11c1ff18 10527 default:
2cf0635d 10528 abort ();
11c1ff18
PB		 10529 }
10530 return p;
10531
10532 case 1:
10533 case 2:
10534 type = attr->type;
10535 break;
10536
10537 default:
10538 assert (attr->type & 0x80);
10539 val = read_uleb128 (p, &len);
10540 p += len;
10541 type = attr->type & 0x7f;
10542 if (val >= type)
10543 printf ("??? (%d)\n", val);
10544 else
10545 printf ("%s\n", attr->table[val]);
10546 return p;
10547 }
10548 }
10549 else
10550 {
10551 if (tag & 1)
10552 type = 1; /* String. */
10553 else
10554 type = 2; /* uleb128. */
10555 printf (" Tag_unknown_%d: ", tag);
10556 }
10557
10558 if (type == 1)
10559 {
10560 printf ("\"%s\"\n", p);
2cf0635d 10561 p += strlen ((char *) p) + 1;
11c1ff18
PB		 10562 }
10563 else
10564 {
10565 val = read_uleb128 (p, &len);
10566 p += len;
10567 printf ("%d (0x%x)\n", val, val);
10568 }
10569
10570 return p;
10571}
10572
104d59d1 10573static unsigned char *
60bca95a
NC		 10574display_gnu_attribute (unsigned char * p,
10575 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
104d59d1
JM		 10576{
10577 int tag;
10578 unsigned int len;
10579 int val;
10580 int type;
10581
10582 tag = read_uleb128 (p, &len);
10583 p += len;
10584
10585 /* Tag_compatibility is the only generic GNU attribute defined at
10586 present. */
10587 if (tag == 32)
10588 {
10589 val = read_uleb128 (p, &len);
10590 p += len;
2b692964 10591 printf (_("flag = %d, vendor = %s\n"), val, p);
60bca95a 10592 p += strlen ((char *) p) + 1;
104d59d1
JM		 10593 return p;
10594 }
10595
10596 if ((tag & 2) == 0 && display_proc_gnu_attribute)
10597 return display_proc_gnu_attribute (p, tag);
10598
10599 if (tag & 1)
10600 type = 1; /* String. */
10601 else
10602 type = 2; /* uleb128. */
10603 printf (" Tag_unknown_%d: ", tag);
10604
10605 if (type == 1)
10606 {
10607 printf ("\"%s\"\n", p);
60bca95a 10608 p += strlen ((char *) p) + 1;
104d59d1
JM		 10609 }
10610 else
10611 {
10612 val = read_uleb128 (p, &len);
10613 p += len;
10614 printf ("%d (0x%x)\n", val, val);
10615 }
10616
10617 return p;
10618}
10619
34c8bcba 10620static unsigned char *
2cf0635d 10621display_power_gnu_attribute (unsigned char * p, int tag)
34c8bcba
JM		 10622{
10623 int type;
10624 unsigned int len;
10625 int val;
10626
10627 if (tag == Tag_GNU_Power_ABI_FP)
10628 {
10629 val = read_uleb128 (p, &len);
10630 p += len;
10631 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 10632
34c8bcba
JM		 10633 switch (val)
10634 {
10635 case 0:
2b692964 10636 printf (_("Hard or soft float\n"));
34c8bcba
JM		 10637 break;
10638 case 1:
2b692964 10639 printf (_("Hard float\n"));
34c8bcba
JM		 10640 break;
10641 case 2:
2b692964 10642 printf (_("Soft float\n"));
34c8bcba 10643 break;
3c7b9897 10644 case 3:
2b692964 10645 printf (_("Single-precision hard float\n"));
3c7b9897 10646 break;
34c8bcba
JM		 10647 default:
10648 printf ("??? (%d)\n", val);
10649 break;
10650 }
10651 return p;
10652 }
10653
c6e65352
DJ		 10654 if (tag == Tag_GNU_Power_ABI_Vector)
10655 {
10656 val = read_uleb128 (p, &len);
10657 p += len;
10658 printf (" Tag_GNU_Power_ABI_Vector: ");
10659 switch (val)
10660 {
10661 case 0:
2b692964 10662 printf (_("Any\n"));
c6e65352
DJ		 10663 break;
10664 case 1:
2b692964 10665 printf (_("Generic\n"));
c6e65352
DJ		 10666 break;
10667 case 2:
10668 printf ("AltiVec\n");
10669 break;
10670 case 3:
10671 printf ("SPE\n");
10672 break;
10673 default:
10674 printf ("??? (%d)\n", val);
10675 break;
10676 }
10677 return p;
10678 }
10679
f82e0623
NF		 10680 if (tag == Tag_GNU_Power_ABI_Struct_Return)
10681 {
10682 val = read_uleb128 (p, &len);
10683 p += len;
10684 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
10685 switch (val)
10686 {
10687 case 0:
2b692964 10688 printf (_("Any\n"));
f82e0623
NF		 10689 break;
10690 case 1:
10691 printf ("r3/r4\n");
10692 break;
10693 case 2:
2b692964 10694 printf (_("Memory\n"));
f82e0623
NF		 10695 break;
10696 default:
10697 printf ("??? (%d)\n", val);
10698 break;
10699 }
10700 return p;
10701 }
10702
34c8bcba
JM		 10703 if (tag & 1)
10704 type = 1; /* String. */
10705 else
10706 type = 2; /* uleb128. */
10707 printf (" Tag_unknown_%d: ", tag);
10708
10709 if (type == 1)
10710 {
10711 printf ("\"%s\"\n", p);
60bca95a 10712 p += strlen ((char *) p) + 1;
34c8bcba
JM		 10713 }
10714 else
10715 {
10716 val = read_uleb128 (p, &len);
10717 p += len;
10718 printf ("%d (0x%x)\n", val, val);
10719 }
10720
10721 return p;
10722}
10723
2cf19d5c 10724static unsigned char *
2cf0635d 10725display_mips_gnu_attribute (unsigned char * p, int tag)
2cf19d5c
JM		 10726{
10727 int type;
10728 unsigned int len;
10729 int val;
10730
10731 if (tag == Tag_GNU_MIPS_ABI_FP)
10732 {
10733 val = read_uleb128 (p, &len);
10734 p += len;
10735 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 10736
2cf19d5c
JM		 10737 switch (val)
10738 {
10739 case 0:
2b692964 10740 printf (_("Hard or soft float\n"));
2cf19d5c
JM		 10741 break;
10742 case 1:
2b692964 10743 printf (_("Hard float (double precision)\n"));
2cf19d5c
JM		 10744 break;
10745 case 2:
2b692964 10746 printf (_("Hard float (single precision)\n"));
2cf19d5c
JM		 10747 break;
10748 case 3:
2b692964 10749 printf (_("Soft float\n"));
2cf19d5c 10750 break;
42554f6a 10751 case 4:
9eeefea8 10752 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
42554f6a 10753 break;
2cf19d5c
JM		 10754 default:
10755 printf ("??? (%d)\n", val);
10756 break;
10757 }
10758 return p;
10759 }
10760
10761 if (tag & 1)
10762 type = 1; /* String. */
10763 else
10764 type = 2; /* uleb128. */
10765 printf (" Tag_unknown_%d: ", tag);
10766
10767 if (type == 1)
10768 {
10769 printf ("\"%s\"\n", p);
60bca95a 10770 p += strlen ((char *) p) + 1;
2cf19d5c
JM		 10771 }
10772 else
10773 {
10774 val = read_uleb128 (p, &len);
10775 p += len;
10776 printf ("%d (0x%x)\n", val, val);
10777 }
10778
10779 return p;
10780}
10781
59e6276b
JM		 10782static unsigned char *
10783display_tic6x_attribute (unsigned char * p)
10784{
10785 int tag;
10786 unsigned int len;
10787 int val;
10788
10789 tag = read_uleb128 (p, &len);
10790 p += len;
10791
10792 switch (tag)
10793 {
75fa6dc1 10794 case Tag_ISA:
59e6276b
JM		 10795 val = read_uleb128 (p, &len);
10796 p += len;
75fa6dc1 10797 printf (" Tag_ISA: ");
59e6276b
JM		 10798
10799 switch (val)
10800 {
75fa6dc1 10801 case C6XABI_Tag_ISA_none:
59e6276b
JM		 10802 printf (_("None\n"));
10803 break;
75fa6dc1 10804 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 10805 printf ("C62x\n");
10806 break;
75fa6dc1 10807 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 10808 printf ("C67x\n");
10809 break;
75fa6dc1 10810 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 10811 printf ("C67x+\n");
10812 break;
75fa6dc1 10813 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 10814 printf ("C64x\n");
10815 break;
75fa6dc1 10816 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 10817 printf ("C64x+\n");
10818 break;
75fa6dc1 10819 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 10820 printf ("C674x\n");
10821 break;
10822 default:
10823 printf ("??? (%d)\n", val);
10824 break;
10825 }
10826 return p;
10827
87779176
JM		 10828 case Tag_ABI_wchar_t:
10829 val = read_uleb128 (p, &len);
10830 p += len;
10831 printf (" Tag_ABI_wchar_t: ");
10832 switch (val)
10833 {
10834 case 0:
10835 printf (_("Not used\n"));
10836 break;
10837 case 1:
10838 printf (_("2 bytes\n"));
10839 break;
10840 case 2:
10841 printf (_("4 bytes\n"));
10842 break;
10843 default:
10844 printf ("??? (%d)\n", val);
10845 break;
10846 }
10847 return p;
10848
10849 case Tag_ABI_stack_align_needed:
10850 val = read_uleb128 (p, &len);
10851 p += len;
10852 printf (" Tag_ABI_stack_align_needed: ");
10853 switch (val)
10854 {
10855 case 0:
10856 printf (_("8-byte\n"));
10857 break;
10858 case 1:
10859 printf (_("16-byte\n"));
10860 break;
10861 default:
10862 printf ("??? (%d)\n", val);
10863 break;
10864 }
10865 return p;
10866
10867 case Tag_ABI_stack_align_preserved:
10868 val = read_uleb128 (p, &len);
10869 p += len;
10870 printf (" Tag_ABI_stack_align_preserved: ");
10871 switch (val)
10872 {
10873 case 0:
10874 printf (_("8-byte\n"));
10875 break;
10876 case 1:
10877 printf (_("16-byte\n"));
10878 break;
10879 default:
10880 printf ("??? (%d)\n", val);
10881 break;
10882 }
10883 return p;
10884
b5593623
JM		 10885 case Tag_ABI_DSBT:
10886 val = read_uleb128 (p, &len);
10887 p += len;
10888 printf (" Tag_ABI_DSBT: ");
10889 switch (val)
10890 {
10891 case 0:
10892 printf (_("DSBT addressing not used\n"));
10893 break;
10894 case 1:
10895 printf (_("DSBT addressing used\n"));
10896 break;
10897 default:
10898 printf ("??? (%d)\n", val);
10899 break;
10900 }
10901 return p;
10902
87779176
JM		 10903 case Tag_ABI_PID:
10904 val = read_uleb128 (p, &len);
10905 p += len;
10906 printf (" Tag_ABI_PID: ");
10907 switch (val)
10908 {
10909 case 0:
10910 printf (_("Data addressing position-dependent\n"));
10911 break;
10912 case 1:
10913 printf (_("Data addressing position-independent, GOT near DP\n"));
10914 break;
10915 case 2:
10916 printf (_("Data addressing position-independent, GOT far from DP\n"));
10917 break;
10918 default:
10919 printf ("??? (%d)\n", val);
10920 break;
10921 }
10922 return p;
10923
10924 case Tag_ABI_PIC:
10925 val = read_uleb128 (p, &len);
10926 p += len;
10927 printf (" Tag_ABI_PIC: ");
10928 switch (val)
10929 {
10930 case 0:
10931 printf (_("Code addressing position-dependent\n"));
10932 break;
10933 case 1:
10934 printf (_("Code addressing position-independent\n"));
10935 break;
10936 default:
10937 printf ("??? (%d)\n", val);
10938 break;
10939 }
10940 return p;
10941
10942 case Tag_ABI_array_object_alignment:
10943 val = read_uleb128 (p, &len);
10944 p += len;
10945 printf (" Tag_ABI_array_object_alignment: ");
10946 switch (val)
10947 {
10948 case 0:
10949 printf (_("8-byte\n"));
10950 break;
10951 case 1:
10952 printf (_("4-byte\n"));
10953 break;
10954 case 2:
10955 printf (_("16-byte\n"));
10956 break;
10957 default:
10958 printf ("??? (%d)\n", val);
10959 break;
10960 }
10961 return p;
10962
10963 case Tag_ABI_array_object_align_expected:
10964 val = read_uleb128 (p, &len);
10965 p += len;
10966 printf (" Tag_ABI_array_object_align_expected: ");
10967 switch (val)
10968 {
10969 case 0:
10970 printf (_("8-byte\n"));
10971 break;
10972 case 1:
10973 printf (_("4-byte\n"));
10974 break;
10975 case 2:
10976 printf (_("16-byte\n"));
10977 break;
10978 default:
10979 printf ("??? (%d)\n", val);
10980 break;
10981 }
10982 return p;
10983
3cbd1c06 10984 case Tag_ABI_compatibility:
59e6276b
JM		 10985 val = read_uleb128 (p, &len);
10986 p += len;
3cbd1c06 10987 printf (" Tag_ABI_compatibility: ");
59e6276b
JM		 10988 printf (_("flag = %d, vendor = %s\n"), val, p);
10989 p += strlen ((char *) p) + 1;
10990 return p;
87779176
JM		 10991
10992 case Tag_ABI_conformance:
10993 printf (" Tag_ABI_conformance: ");
10994 printf ("\"%s\"\n", p);
10995 p += strlen ((char *) p) + 1;
10996 return p;
59e6276b
JM		 10997 }
10998
10999 printf (" Tag_unknown_%d: ", tag);
11000
87779176
JM		 11001 if (tag & 1)
11002 {
11003 printf ("\"%s\"\n", p);
11004 p += strlen ((char *) p) + 1;
11005 }
11006 else
11007 {
11008 val = read_uleb128 (p, &len);
11009 p += len;
11010 printf ("%d (0x%x)\n", val, val);
11011 }
59e6276b
JM		 11012
11013 return p;
11014}
11015
11c1ff18 11016static int
60bca95a
NC		 11017process_attributes (FILE * file,
11018 const char * public_name,
104d59d1 11019 unsigned int proc_type,
60bca95a
NC		 11020 unsigned char * (* display_pub_attribute) (unsigned char *),
11021 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11c1ff18 11022{
2cf0635d
NC		 11023 Elf_Internal_Shdr * sect;
11024 unsigned char * contents;
11025 unsigned char * p;
11026 unsigned char * end;
11c1ff18
PB		 11027 bfd_vma section_len;
11028 bfd_vma len;
11029 unsigned i;
11030
11031 /* Find the section header so that we get the size. */
11032 for (i = 0, sect = section_headers;
11033 i < elf_header.e_shnum;
11034 i++, sect++)
11035 {
104d59d1 11036 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 11037 continue;
11038
3f5e193b
NC		 11039 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
11040 sect->sh_size, _("attributes"));
60bca95a 11041 if (contents == NULL)
11c1ff18 11042 continue;
60bca95a 11043
11c1ff18
PB		 11044 p = contents;
11045 if (*p == 'A')
11046 {
11047 len = sect->sh_size - 1;
11048 p++;
60bca95a 11049
11c1ff18
PB		 11050 while (len > 0)
11051 {
11052 int namelen;
11053 bfd_boolean public_section;
104d59d1 11054 bfd_boolean gnu_section;
11c1ff18
PB		 11055
11056 section_len = byte_get (p, 4);
11057 p += 4;
60bca95a 11058
11c1ff18
PB		 11059 if (section_len > len)
11060 {
11061 printf (_("ERROR: Bad section length (%d > %d)\n"),
60bca95a 11062 (int) section_len, (int) len);
11c1ff18
PB		 11063 section_len = len;
11064 }
60bca95a 11065
11c1ff18 11066 len -= section_len;
2b692964 11067 printf (_("Attribute Section: %s\n"), p);
60bca95a
NC		 11068
11069 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 11070 public_section = TRUE;
11071 else
11072 public_section = FALSE;
60bca95a
NC		 11073
11074 if (streq ((char *) p, "gnu"))
104d59d1
JM		 11075 gnu_section = TRUE;
11076 else
11077 gnu_section = FALSE;
60bca95a
NC		 11078
11079 namelen = strlen ((char *) p) + 1;
11c1ff18
PB		 11080 p += namelen;
11081 section_len -= namelen + 4;
60bca95a 11082
11c1ff18
PB		 11083 while (section_len > 0)
11084 {
11085 int tag = *(p++);
11086 int val;
11087 bfd_vma size;
60bca95a 11088
11c1ff18
PB		 11089 size = byte_get (p, 4);
11090 if (size > section_len)
11091 {
11092 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
60bca95a 11093 (int) size, (int) section_len);
11c1ff18
PB		 11094 size = section_len;
11095 }
60bca95a 11096
11c1ff18
PB		 11097 section_len -= size;
11098 end = p + size - 1;
11099 p += 4;
60bca95a 11100
11c1ff18
PB		 11101 switch (tag)
11102 {
11103 case 1:
2b692964 11104 printf (_("File Attributes\n"));
11c1ff18
PB		 11105 break;
11106 case 2:
2b692964 11107 printf (_("Section Attributes:"));
11c1ff18
PB		 11108 goto do_numlist;
11109 case 3:
2b692964 11110 printf (_("Symbol Attributes:"));
11c1ff18
PB		 11111 do_numlist:
11112 for (;;)
11113 {
91d6fa6a 11114 unsigned int j;
60bca95a 11115
91d6fa6a
NC		 11116 val = read_uleb128 (p, &j);
11117 p += j;
11c1ff18
PB		 11118 if (val == 0)
11119 break;
11120 printf (" %d", val);
11121 }
11122 printf ("\n");
11123 break;
11124 default:
2b692964 11125 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 11126 public_section = FALSE;
11127 break;
11128 }
60bca95a 11129
11c1ff18
PB		 11130 if (public_section)
11131 {
11132 while (p < end)
104d59d1
JM		 11133 p = display_pub_attribute (p);
11134 }
11135 else if (gnu_section)
11136 {
11137 while (p < end)
11138 p = display_gnu_attribute (p,
11139 display_proc_gnu_attribute);
11c1ff18
PB		 11140 }
11141 else
11142 {
11143 /* ??? Do something sensible, like dump hex. */
2b692964 11144 printf (_(" Unknown section contexts\n"));
11c1ff18
PB		 11145 p = end;
11146 }
11147 }
11148 }
11149 }
11150 else
60bca95a 11151 printf (_("Unknown format '%c'\n"), *p);
d70c5fc7 11152
60bca95a 11153 free (contents);
11c1ff18
PB		 11154 }
11155 return 1;
11156}
11157
104d59d1 11158static int
2cf0635d 11159process_arm_specific (FILE * file)
104d59d1
JM		 11160{
11161 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
11162 display_arm_attribute, NULL);
11163}
11164
34c8bcba 11165static int
2cf0635d 11166process_power_specific (FILE * file)
34c8bcba
JM		 11167{
11168 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11169 display_power_gnu_attribute);
11170}
11171
59e6276b
JM		 11172static int
11173process_tic6x_specific (FILE * file)
11174{
11175 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
11176 display_tic6x_attribute, NULL);
11177}
11178
ccb4c951
RS		 11179/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
11180 Print the Address, Access and Initial fields of an entry at VMA ADDR
11181 and return the VMA of the next entry. */
11182
11183static bfd_vma
2cf0635d 11184print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
ccb4c951
RS		 11185{
11186 printf (" ");
11187 print_vma (addr, LONG_HEX);
11188 printf (" ");
11189 if (addr < pltgot + 0xfff0)
11190 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
11191 else
11192 printf ("%10s", "");
11193 printf (" ");
11194 if (data == NULL)
2b692964 11195 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 11196 else
11197 {
11198 bfd_vma entry;
11199
11200 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11201 print_vma (entry, LONG_HEX);
11202 }
11203 return addr + (is_32bit_elf ? 4 : 8);
11204}
11205
861fb55a
DJ		 11206/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
11207 PLTGOT. Print the Address and Initial fields of an entry at VMA
11208 ADDR and return the VMA of the next entry. */
11209
11210static bfd_vma
2cf0635d 11211print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 11212{
11213 printf (" ");
11214 print_vma (addr, LONG_HEX);
11215 printf (" ");
11216 if (data == NULL)
2b692964 11217 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 11218 else
11219 {
11220 bfd_vma entry;
11221
11222 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11223 print_vma (entry, LONG_HEX);
11224 }
11225 return addr + (is_32bit_elf ? 4 : 8);
11226}
11227
19e6b90e 11228static int
2cf0635d 11229process_mips_specific (FILE * file)
5b18a4bc 11230{
2cf0635d 11231 Elf_Internal_Dyn * entry;
19e6b90e
L		 11232 size_t liblist_offset = 0;
11233 size_t liblistno = 0;
11234 size_t conflictsno = 0;
11235 size_t options_offset = 0;
11236 size_t conflicts_offset = 0;
861fb55a
DJ		 11237 size_t pltrelsz = 0;
11238 size_t pltrel = 0;
ccb4c951 11239 bfd_vma pltgot = 0;
861fb55a
DJ		 11240 bfd_vma mips_pltgot = 0;
11241 bfd_vma jmprel = 0;
ccb4c951
RS		 11242 bfd_vma local_gotno = 0;
11243 bfd_vma gotsym = 0;
11244 bfd_vma symtabno = 0;
103f02d3 11245
2cf19d5c
JM		 11246 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11247 display_mips_gnu_attribute);
11248
19e6b90e
L		 11249 /* We have a lot of special sections. Thanks SGI! */
11250 if (dynamic_section == NULL)
11251 /* No information available. */
11252 return 0;
252b5132 11253
b2d38a17 11254 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
252b5132
RH		 11255 switch (entry->d_tag)
11256 {
11257 case DT_MIPS_LIBLIST:
d93f0186
NC		 11258 liblist_offset
11259 = offset_from_vma (file, entry->d_un.d_val,
11260 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 11261 break;
11262 case DT_MIPS_LIBLISTNO:
11263 liblistno = entry->d_un.d_val;
11264 break;
11265 case DT_MIPS_OPTIONS:
d93f0186 11266 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 11267 break;
11268 case DT_MIPS_CONFLICT:
d93f0186
NC		 11269 conflicts_offset
11270 = offset_from_vma (file, entry->d_un.d_val,
11271 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 11272 break;
11273 case DT_MIPS_CONFLICTNO:
11274 conflictsno = entry->d_un.d_val;
11275 break;
ccb4c951 11276 case DT_PLTGOT:
861fb55a
DJ		 11277 pltgot = entry->d_un.d_ptr;
11278 break;
ccb4c951
RS		 11279 case DT_MIPS_LOCAL_GOTNO:
11280 local_gotno = entry->d_un.d_val;
11281 break;
11282 case DT_MIPS_GOTSYM:
11283 gotsym = entry->d_un.d_val;
11284 break;
11285 case DT_MIPS_SYMTABNO:
11286 symtabno = entry->d_un.d_val;
11287 break;
861fb55a
DJ		 11288 case DT_MIPS_PLTGOT:
11289 mips_pltgot = entry->d_un.d_ptr;
11290 break;
11291 case DT_PLTREL:
11292 pltrel = entry->d_un.d_val;
11293 break;
11294 case DT_PLTRELSZ:
11295 pltrelsz = entry->d_un.d_val;
11296 break;
11297 case DT_JMPREL:
11298 jmprel = entry->d_un.d_ptr;
11299 break;
252b5132
RH		 11300 default:
11301 break;
11302 }
11303
11304 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
11305 {
2cf0635d 11306 Elf32_External_Lib * elib;
252b5132
RH		 11307 size_t cnt;
11308
3f5e193b
NC		 11309 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
11310 liblistno,
11311 sizeof (Elf32_External_Lib),
11312 _("liblist"));
a6e9f9df 11313 if (elib)
252b5132 11314 {
2b692964 11315 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 11316 (unsigned long) liblistno);
2b692964 11317 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 11318 stdout);
11319
11320 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 11321 {
a6e9f9df 11322 Elf32_Lib liblist;
91d6fa6a 11323 time_t atime;
a6e9f9df 11324 char timebuf[20];
2cf0635d 11325 struct tm * tmp;
a6e9f9df
AM		 11326
11327 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 11328 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 11329 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
11330 liblist.l_version = BYTE_GET (elib[cnt].l_version);
11331 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
11332
91d6fa6a 11333 tmp = gmtime (&atime);
e9e44622
JJ		 11334 snprintf (timebuf, sizeof (timebuf),
11335 "%04u-%02u-%02uT%02u:%02u:%02u",
11336 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
11337 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 11338
31104126 11339 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 11340 if (VALID_DYNAMIC_NAME (liblist.l_name))
11341 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
11342 else
2b692964 11343 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 11344 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
11345 liblist.l_version);
a6e9f9df
AM		 11346
11347 if (liblist.l_flags == 0)
2b692964 11348 puts (_(" NONE"));
a6e9f9df
AM		 11349 else
11350 {
11351 static const struct
252b5132 11352 {
2cf0635d 11353 const char * name;
a6e9f9df 11354 int bit;
252b5132 11355 }
a6e9f9df
AM		 11356 l_flags_vals[] =
11357 {
11358 { " EXACT_MATCH", LL_EXACT_MATCH },
11359 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
11360 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
11361 { " EXPORTS", LL_EXPORTS },
11362 { " DELAY_LOAD", LL_DELAY_LOAD },
11363 { " DELTA", LL_DELTA }
11364 };
11365 int flags = liblist.l_flags;
11366 size_t fcnt;
11367
60bca95a 11368 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 11369 if ((flags & l_flags_vals[fcnt].bit) != 0)
11370 {
11371 fputs (l_flags_vals[fcnt].name, stdout);
11372 flags ^= l_flags_vals[fcnt].bit;
11373 }
11374 if (flags != 0)
11375 printf (" %#x", (unsigned int) flags);
252b5132 11376
a6e9f9df
AM		 11377 puts ("");
11378 }
252b5132 11379 }
252b5132 11380
a6e9f9df
AM		 11381 free (elib);
11382 }
252b5132
RH		 11383 }
11384
11385 if (options_offset != 0)
11386 {
2cf0635d
NC		 11387 Elf_External_Options * eopt;
11388 Elf_Internal_Shdr * sect = section_headers;
11389 Elf_Internal_Options * iopt;
11390 Elf_Internal_Options * option;
252b5132
RH		 11391 size_t offset;
11392 int cnt;
11393
11394 /* Find the section header so that we get the size. */
11395 while (sect->sh_type != SHT_MIPS_OPTIONS)
b34976b6 11396 ++sect;
252b5132 11397
3f5e193b
NC		 11398 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
11399 sect->sh_size, _("options"));
a6e9f9df 11400 if (eopt)
252b5132 11401 {
3f5e193b
NC		 11402 iopt = (Elf_Internal_Options *)
11403 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 11404 if (iopt == NULL)
11405 {
591a748a 11406 error (_("Out of memory\n"));
a6e9f9df
AM		 11407 return 0;
11408 }
76da6bbe 11409
a6e9f9df
AM		 11410 offset = cnt = 0;
11411 option = iopt;
252b5132 11412
a6e9f9df
AM		 11413 while (offset < sect->sh_size)
11414 {
2cf0635d 11415 Elf_External_Options * eoption;
252b5132 11416
a6e9f9df 11417 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 11418
a6e9f9df
AM		 11419 option->kind = BYTE_GET (eoption->kind);
11420 option->size = BYTE_GET (eoption->size);
11421 option->section = BYTE_GET (eoption->section);
11422 option->info = BYTE_GET (eoption->info);
76da6bbe 11423
a6e9f9df 11424 offset += option->size;
252b5132 11425
a6e9f9df
AM		 11426 ++option;
11427 ++cnt;
11428 }
252b5132 11429
a6e9f9df
AM		 11430 printf (_("\nSection '%s' contains %d entries:\n"),
11431 SECTION_NAME (sect), cnt);
76da6bbe 11432
a6e9f9df 11433 option = iopt;
252b5132 11434
a6e9f9df 11435 while (cnt-- > 0)
252b5132 11436 {
a6e9f9df
AM		 11437 size_t len;
11438
11439 switch (option->kind)
252b5132 11440 {
a6e9f9df
AM		 11441 case ODK_NULL:
11442 /* This shouldn't happen. */
11443 printf (" NULL %d %lx", option->section, option->info);
11444 break;
11445 case ODK_REGINFO:
11446 printf (" REGINFO ");
11447 if (elf_header.e_machine == EM_MIPS)
11448 {
11449 /* 32bit form. */
2cf0635d 11450 Elf32_External_RegInfo * ereg;
b34976b6 11451 Elf32_RegInfo reginfo;
a6e9f9df
AM		 11452
11453 ereg = (Elf32_External_RegInfo *) (option + 1);
11454 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
11455 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11456 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11457 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11458 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
11459 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
11460
11461 printf ("GPR %08lx GP 0x%lx\n",
11462 reginfo.ri_gprmask,
11463 (unsigned long) reginfo.ri_gp_value);
11464 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11465 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11466 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11467 }
11468 else
11469 {
11470 /* 64 bit form. */
2cf0635d 11471 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 11472 Elf64_Internal_RegInfo reginfo;
11473
11474 ereg = (Elf64_External_RegInfo *) (option + 1);
11475 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
11476 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11477 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11478 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11479 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 11480 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 11481
11482 printf ("GPR %08lx GP 0x",
11483 reginfo.ri_gprmask);
11484 printf_vma (reginfo.ri_gp_value);
11485 printf ("\n");
11486
11487 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11488 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11489 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11490 }
11491 ++option;
11492 continue;
11493 case ODK_EXCEPTIONS:
11494 fputs (" EXCEPTIONS fpe_min(", stdout);
11495 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
11496 fputs (") fpe_max(", stdout);
11497 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
11498 fputs (")", stdout);
11499
11500 if (option->info & OEX_PAGE0)
11501 fputs (" PAGE0", stdout);
11502 if (option->info & OEX_SMM)
11503 fputs (" SMM", stdout);
11504 if (option->info & OEX_FPDBUG)
11505 fputs (" FPDBUG", stdout);
11506 if (option->info & OEX_DISMISS)
11507 fputs (" DISMISS", stdout);
11508 break;
11509 case ODK_PAD:
11510 fputs (" PAD ", stdout);
11511 if (option->info & OPAD_PREFIX)
11512 fputs (" PREFIX", stdout);
11513 if (option->info & OPAD_POSTFIX)
11514 fputs (" POSTFIX", stdout);
11515 if (option->info & OPAD_SYMBOL)
11516 fputs (" SYMBOL", stdout);
11517 break;
11518 case ODK_HWPATCH:
11519 fputs (" HWPATCH ", stdout);
11520 if (option->info & OHW_R4KEOP)
11521 fputs (" R4KEOP", stdout);
11522 if (option->info & OHW_R8KPFETCH)
11523 fputs (" R8KPFETCH", stdout);
11524 if (option->info & OHW_R5KEOP)
11525 fputs (" R5KEOP", stdout);
11526 if (option->info & OHW_R5KCVTL)
11527 fputs (" R5KCVTL", stdout);
11528 break;
11529 case ODK_FILL:
11530 fputs (" FILL ", stdout);
11531 /* XXX Print content of info word? */
11532 break;
11533 case ODK_TAGS:
11534 fputs (" TAGS ", stdout);
11535 /* XXX Print content of info word? */
11536 break;
11537 case ODK_HWAND:
11538 fputs (" HWAND ", stdout);
11539 if (option->info & OHWA0_R4KEOP_CHECKED)
11540 fputs (" R4KEOP_CHECKED", stdout);
11541 if (option->info & OHWA0_R4KEOP_CLEAN)
11542 fputs (" R4KEOP_CLEAN", stdout);
11543 break;
11544 case ODK_HWOR:
11545 fputs (" HWOR ", stdout);
11546 if (option->info & OHWA0_R4KEOP_CHECKED)
11547 fputs (" R4KEOP_CHECKED", stdout);
11548 if (option->info & OHWA0_R4KEOP_CLEAN)
11549 fputs (" R4KEOP_CLEAN", stdout);
11550 break;
11551 case ODK_GP_GROUP:
11552 printf (" GP_GROUP %#06lx self-contained %#06lx",
11553 option->info & OGP_GROUP,
11554 (option->info & OGP_SELF) >> 16);
11555 break;
11556 case ODK_IDENT:
11557 printf (" IDENT %#06lx self-contained %#06lx",
11558 option->info & OGP_GROUP,
11559 (option->info & OGP_SELF) >> 16);
11560 break;
11561 default:
11562 /* This shouldn't happen. */
11563 printf (" %3d ??? %d %lx",
11564 option->kind, option->section, option->info);
11565 break;
252b5132 11566 }
a6e9f9df 11567
2cf0635d 11568 len = sizeof (* eopt);
a6e9f9df
AM		 11569 while (len < option->size)
11570 if (((char *) option)[len] >= ' '
11571 && ((char *) option)[len] < 0x7f)
11572 printf ("%c", ((char *) option)[len++]);
11573 else
11574 printf ("\\%03o", ((char *) option)[len++]);
11575
11576 fputs ("\n", stdout);
252b5132 11577 ++option;
252b5132
RH		 11578 }
11579
a6e9f9df 11580 free (eopt);
252b5132 11581 }
252b5132
RH		 11582 }
11583
11584 if (conflicts_offset != 0 && conflictsno != 0)
11585 {
2cf0635d 11586 Elf32_Conflict * iconf;
252b5132
RH		 11587 size_t cnt;
11588
11589 if (dynamic_symbols == NULL)
11590 {
591a748a 11591 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 11592 return 0;
11593 }
11594
3f5e193b 11595 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 11596 if (iconf == NULL)
11597 {
591a748a 11598 error (_("Out of memory\n"));
252b5132
RH		 11599 return 0;
11600 }
11601
9ea033b2 11602 if (is_32bit_elf)
252b5132 11603 {
2cf0635d 11604 Elf32_External_Conflict * econf32;
a6e9f9df 11605
3f5e193b
NC		 11606 econf32 = (Elf32_External_Conflict *)
11607 get_data (NULL, file, conflicts_offset, conflictsno,
11608 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 11609 if (!econf32)
11610 return 0;
252b5132
RH		 11611
11612 for (cnt = 0; cnt < conflictsno; ++cnt)
11613 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 11614
11615 free (econf32);
252b5132
RH		 11616 }
11617 else
11618 {
2cf0635d 11619 Elf64_External_Conflict * econf64;
a6e9f9df 11620
3f5e193b
NC		 11621 econf64 = (Elf64_External_Conflict *)
11622 get_data (NULL, file, conflicts_offset, conflictsno,
11623 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 11624 if (!econf64)
11625 return 0;
252b5132
RH		 11626
11627 for (cnt = 0; cnt < conflictsno; ++cnt)
11628 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 11629
11630 free (econf64);
252b5132
RH		 11631 }
11632
c7e7ca54
NC		 11633 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11634 (unsigned long) conflictsno);
252b5132
RH		 11635 puts (_(" Num: Index Value Name"));
11636
11637 for (cnt = 0; cnt < conflictsno; ++cnt)
11638 {
2cf0635d 11639 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
252b5132 11640
b34976b6 11641 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
f7a99963 11642 print_vma (psym->st_value, FULL_HEX);
31104126 11643 putchar (' ');
d79b3d50
NC		 11644 if (VALID_DYNAMIC_NAME (psym->st_name))
11645 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11646 else
2b692964 11647 printf (_("<corrupt: %14ld>"), psym->st_name);
31104126 11648 putchar ('\n');
252b5132
RH		 11649 }
11650
252b5132
RH		 11651 free (iconf);
11652 }
11653
ccb4c951
RS		 11654 if (pltgot != 0 && local_gotno != 0)
11655 {
91d6fa6a 11656 bfd_vma ent, local_end, global_end;
bbeee7ea 11657 size_t i, offset;
2cf0635d 11658 unsigned char * data;
bbeee7ea 11659 int addr_size;
ccb4c951 11660
91d6fa6a 11661 ent = pltgot;
ccb4c951
RS		 11662 addr_size = (is_32bit_elf ? 4 : 8);
11663 local_end = pltgot + local_gotno * addr_size;
11664 global_end = local_end + (symtabno - gotsym) * addr_size;
11665
11666 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b
NC		 11667 data = (unsigned char *) get_data (NULL, file, offset,
11668 global_end - pltgot, 1, _("GOT"));
ccb4c951
RS		 11669 printf (_("\nPrimary GOT:\n"));
11670 printf (_(" Canonical gp value: "));
11671 print_vma (pltgot + 0x7ff0, LONG_HEX);
11672 printf ("\n\n");
11673
11674 printf (_(" Reserved entries:\n"));
11675 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 11676 addr_size * 2, _("Address"), _("Access"),
11677 addr_size * 2, _("Initial"));
91d6fa6a 11678 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 11679 printf (_(" Lazy resolver\n"));
ccb4c951 11680 if (data
91d6fa6a 11681 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 11682 >> (addr_size * 8 - 1)) != 0)
11683 {
91d6fa6a 11684 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 11685 printf (_(" Module pointer (GNU extension)\n"));
ccb4c951
RS		 11686 }
11687 printf ("\n");
11688
91d6fa6a 11689 if (ent < local_end)
ccb4c951
RS		 11690 {
11691 printf (_(" Local entries:\n"));
cc5914eb 11692 printf (" %*s %10s %*s\n",
2b692964
NC		 11693 addr_size * 2, _("Address"), _("Access"),
11694 addr_size * 2, _("Initial"));
91d6fa6a 11695 while (ent < local_end)
ccb4c951 11696 {
91d6fa6a 11697 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 11698 printf ("\n");
11699 }
11700 printf ("\n");
11701 }
11702
11703 if (gotsym < symtabno)
11704 {
11705 int sym_width;
11706
11707 printf (_(" Global entries:\n"));
cc5914eb 11708 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
2b692964
NC		 11709 addr_size * 2, _("Address"), _("Access"),
11710 addr_size * 2, _("Initial"),
11711 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
ccb4c951
RS		 11712 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
11713 for (i = gotsym; i < symtabno; i++)
11714 {
2cf0635d 11715 Elf_Internal_Sym * psym;
ccb4c951
RS		 11716
11717 psym = dynamic_symbols + i;
91d6fa6a 11718 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 11719 printf (" ");
11720 print_vma (psym->st_value, LONG_HEX);
11721 printf (" %-7s %3s ",
11722 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
11723 get_symbol_index_type (psym->st_shndx));
11724 if (VALID_DYNAMIC_NAME (psym->st_name))
11725 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
11726 else
2b692964 11727 printf (_("<corrupt: %14ld>"), psym->st_name);
ccb4c951
RS		 11728 printf ("\n");
11729 }
11730 printf ("\n");
11731 }
11732
11733 if (data)
11734 free (data);
11735 }
11736
861fb55a
DJ		 11737 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
11738 {
91d6fa6a 11739 bfd_vma ent, end;
861fb55a
DJ		 11740 size_t offset, rel_offset;
11741 unsigned long count, i;
2cf0635d 11742 unsigned char * data;
861fb55a 11743 int addr_size, sym_width;
2cf0635d 11744 Elf_Internal_Rela * rels;
861fb55a
DJ		 11745
11746 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
11747 if (pltrel == DT_RELA)
11748 {
11749 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
11750 return 0;
11751 }
11752 else
11753 {
11754 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
11755 return 0;
11756 }
11757
91d6fa6a 11758 ent = mips_pltgot;
861fb55a
DJ		 11759 addr_size = (is_32bit_elf ? 4 : 8);
11760 end = mips_pltgot + (2 + count) * addr_size;
11761
11762 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b
NC		 11763 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
11764 1, _("PLT GOT"));
861fb55a
DJ		 11765 printf (_("\nPLT GOT:\n\n"));
11766 printf (_(" Reserved entries:\n"));
11767 printf (_(" %*s %*s Purpose\n"),
2b692964 11768 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 11769 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 11770 printf (_(" PLT lazy resolver\n"));
91d6fa6a 11771 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 11772 printf (_(" Module pointer\n"));
861fb55a
DJ		 11773 printf ("\n");
11774
11775 printf (_(" Entries:\n"));
cc5914eb 11776 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 11777 addr_size * 2, _("Address"),
11778 addr_size * 2, _("Initial"),
11779 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 11780 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
11781 for (i = 0; i < count; i++)
11782 {
2cf0635d 11783 Elf_Internal_Sym * psym;
861fb55a
DJ		 11784
11785 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
91d6fa6a 11786 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a
DJ		 11787 printf (" ");
11788 print_vma (psym->st_value, LONG_HEX);
11789 printf (" %-7s %3s ",
11790 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
11791 get_symbol_index_type (psym->st_shndx));
11792 if (VALID_DYNAMIC_NAME (psym->st_name))
11793 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
11794 else
2b692964 11795 printf (_("<corrupt: %14ld>"), psym->st_name);
861fb55a
DJ		 11796 printf ("\n");
11797 }
11798 printf ("\n");
11799
11800 if (data)
11801 free (data);
11802 free (rels);
11803 }
11804
252b5132
RH		 11805 return 1;
11806}
11807
047b2264 11808static int
2cf0635d 11809process_gnu_liblist (FILE * file)
047b2264 11810{
2cf0635d
NC		 11811 Elf_Internal_Shdr * section;
11812 Elf_Internal_Shdr * string_sec;
11813 Elf32_External_Lib * elib;
11814 char * strtab;
c256ffe7 11815 size_t strtab_size;
047b2264
JJ		 11816 size_t cnt;
11817 unsigned i;
11818
11819 if (! do_arch)
11820 return 0;
11821
11822 for (i = 0, section = section_headers;
11823 i < elf_header.e_shnum;
b34976b6 11824 i++, section++)
047b2264
JJ		 11825 {
11826 switch (section->sh_type)
11827 {
11828 case SHT_GNU_LIBLIST:
4fbb74a6 11829 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 11830 break;
11831
3f5e193b
NC		 11832 elib = (Elf32_External_Lib *)
11833 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
11834 _("liblist"));
047b2264
JJ		 11835
11836 if (elib == NULL)
11837 break;
4fbb74a6 11838 string_sec = section_headers + section->sh_link;
047b2264 11839
3f5e193b
NC		 11840 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
11841 string_sec->sh_size,
11842 _("liblist string table"));
c256ffe7 11843 strtab_size = string_sec->sh_size;
047b2264
JJ		 11844
11845 if (strtab == NULL
11846 || section->sh_entsize != sizeof (Elf32_External_Lib))
11847 {
11848 free (elib);
11849 break;
11850 }
11851
11852 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11853 SECTION_NAME (section),
0af1713e 11854 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 11855
2b692964 11856 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 11857
11858 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
11859 ++cnt)
11860 {
11861 Elf32_Lib liblist;
91d6fa6a 11862 time_t atime;
047b2264 11863 char timebuf[20];
2cf0635d 11864 struct tm * tmp;
047b2264
JJ		 11865
11866 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 11867 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 11868 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
11869 liblist.l_version = BYTE_GET (elib[cnt].l_version);
11870 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
11871
91d6fa6a 11872 tmp = gmtime (&atime);
e9e44622
JJ		 11873 snprintf (timebuf, sizeof (timebuf),
11874 "%04u-%02u-%02uT%02u:%02u:%02u",
11875 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
11876 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 11877
11878 printf ("%3lu: ", (unsigned long) cnt);
11879 if (do_wide)
c256ffe7 11880 printf ("%-20s", liblist.l_name < strtab_size
2b692964 11881 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 11882 else
c256ffe7 11883 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 11884 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 11885 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
11886 liblist.l_version, liblist.l_flags);
11887 }
11888
11889 free (elib);
11890 }
11891 }
11892
11893 return 1;
11894}
11895
9437c45b 11896static const char *
d3ba0551 11897get_note_type (unsigned e_type)
779fe533
NC		 11898{
11899 static char buff[64];
103f02d3 11900
1ec5cd37
NC		 11901 if (elf_header.e_type == ET_CORE)
11902 switch (e_type)
11903 {
57346661 11904 case NT_AUXV:
1ec5cd37 11905 return _("NT_AUXV (auxiliary vector)");
57346661 11906 case NT_PRSTATUS:
1ec5cd37 11907 return _("NT_PRSTATUS (prstatus structure)");
57346661 11908 case NT_FPREGSET:
1ec5cd37 11909 return _("NT_FPREGSET (floating point registers)");
57346661 11910 case NT_PRPSINFO:
1ec5cd37 11911 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 11912 case NT_TASKSTRUCT:
1ec5cd37 11913 return _("NT_TASKSTRUCT (task structure)");
57346661 11914 case NT_PRXFPREG:
1ec5cd37 11915 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 11916 case NT_PPC_VMX:
11917 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 11918 case NT_PPC_VSX:
11919 return _("NT_PPC_VSX (ppc VSX registers)");
4339cae0
L		 11920 case NT_X86_XSTATE:
11921 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 11922 case NT_S390_HIGH_GPRS:
11923 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 11924 case NT_S390_TIMER:
11925 return _("NT_S390_TIMER (s390 timer register)");
11926 case NT_S390_TODCMP:
11927 return _("NT_S390_TODCMP (s390 TOD comparator register)");
11928 case NT_S390_TODPREG:
11929 return _("NT_S390_TODPREG (s390 TOD programmable register)");
11930 case NT_S390_CTRS:
11931 return _("NT_S390_CTRS (s390 control registers)");
11932 case NT_S390_PREFIX:
11933 return _("NT_S390_PREFIX (s390 prefix register)");
57346661 11934 case NT_PSTATUS:
1ec5cd37 11935 return _("NT_PSTATUS (pstatus structure)");
57346661 11936 case NT_FPREGS:
1ec5cd37 11937 return _("NT_FPREGS (floating point registers)");
57346661 11938 case NT_PSINFO:
1ec5cd37 11939 return _("NT_PSINFO (psinfo structure)");
57346661 11940 case NT_LWPSTATUS:
1ec5cd37 11941 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 11942 case NT_LWPSINFO:
1ec5cd37 11943 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 11944 case NT_WIN32PSTATUS:
1ec5cd37
NC		 11945 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11946 default:
11947 break;
11948 }
11949 else
11950 switch (e_type)
11951 {
11952 case NT_VERSION:
11953 return _("NT_VERSION (version)");
11954 case NT_ARCH:
11955 return _("NT_ARCH (architecture)");
11956 default:
11957 break;
11958 }
11959
e9e44622 11960 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 11961 return buff;
779fe533
NC		 11962}
11963
1118d252
RM		 11964static const char *
11965get_gnu_elf_note_type (unsigned e_type)
11966{
11967 static char buff[64];
11968
11969 switch (e_type)
11970 {
11971 case NT_GNU_ABI_TAG:
11972 return _("NT_GNU_ABI_TAG (ABI version tag)");
11973 case NT_GNU_HWCAP:
11974 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
11975 case NT_GNU_BUILD_ID:
11976 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 11977 case NT_GNU_GOLD_VERSION:
11978 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 11979 default:
11980 break;
11981 }
11982
11983 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
11984 return buff;
11985}
11986
9437c45b 11987static const char *
d3ba0551 11988get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 11989{
11990 static char buff[64];
11991
b4db1224 11992 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 11993 {
11994 /* NetBSD core "procinfo" structure. */
11995 return _("NetBSD procinfo structure");
11996 }
11997
11998 /* As of Jan 2002 there are no other machine-independent notes
11999 defined for NetBSD core files. If the note type is less
12000 than the start of the machine-dependent note types, we don't
12001 understand it. */
12002
b4db1224 12003 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 12004 {
e9e44622 12005 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 12006 return buff;
12007 }
12008
12009 switch (elf_header.e_machine)
12010 {
12011 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
12012 and PT_GETFPREGS == mach+2. */
12013
12014 case EM_OLD_ALPHA:
12015 case EM_ALPHA:
12016 case EM_SPARC:
12017 case EM_SPARC32PLUS:
12018 case EM_SPARCV9:
12019 switch (e_type)
12020 {
2b692964 12021 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 12022 return _("PT_GETREGS (reg structure)");
2b692964 12023 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 12024 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 12025 default:
12026 break;
12027 }
12028 break;
12029
12030 /* On all other arch's, PT_GETREGS == mach+1 and
12031 PT_GETFPREGS == mach+3. */
12032 default:
12033 switch (e_type)
12034 {
2b692964 12035 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 12036 return _("PT_GETREGS (reg structure)");
2b692964 12037 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 12038 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 12039 default:
12040 break;
12041 }
12042 }
12043
e9e44622
JJ		 12044 snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
12045 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 12046 return buff;
12047}
12048
6d118b09
NC		 12049/* Note that by the ELF standard, the name field is already null byte
12050 terminated, and namesz includes the terminating null byte.
12051 I.E. the value of namesz for the name "FSF" is 4.
12052
e3c8793a 12053 If the value of namesz is zero, there is no name present. */
779fe533 12054static int
2cf0635d 12055process_note (Elf_Internal_Note * pnote)
779fe533 12056{
2cf0635d
NC		 12057 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
12058 const char * nt;
9437c45b
JT		 12059
12060 if (pnote->namesz == 0)
1ec5cd37
NC		 12061 /* If there is no note name, then use the default set of
12062 note type strings. */
12063 nt = get_note_type (pnote->type);
12064
1118d252
RM		 12065 else if (const_strneq (pnote->namedata, "GNU"))
12066 /* GNU-specific object file notes. */
12067 nt = get_gnu_elf_note_type (pnote->type);
12068
0112cd26 12069 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 12070 /* NetBSD-specific core file notes. */
12071 nt = get_netbsd_elfcore_note_type (pnote->type);
12072
b15fa79e
AM		 12073 else if (strneq (pnote->namedata, "SPU/", 4))
12074 {
12075 /* SPU-specific core file notes. */
12076 nt = pnote->namedata + 4;
12077 name = "SPU";
12078 }
12079
9437c45b 12080 else
1ec5cd37
NC		 12081 /* Don't recognize this note name; just use the default set of
12082 note type strings. */
9437c45b 12083 nt = get_note_type (pnote->type);
9437c45b 12084
b15fa79e 12085 printf (" %s\t\t0x%08lx\t%s\n", name, pnote->descsz, nt);
779fe533
NC		 12086 return 1;
12087}
12088
6d118b09 12089
779fe533 12090static int
2cf0635d 12091process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 12092{
2cf0635d
NC		 12093 Elf_External_Note * pnotes;
12094 Elf_External_Note * external;
b34976b6 12095 int res = 1;
103f02d3 12096
779fe533
NC		 12097 if (length <= 0)
12098 return 0;
103f02d3 12099
3f5e193b
NC		 12100 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
12101 _("notes"));
dd24e3da 12102 if (pnotes == NULL)
a6e9f9df 12103 return 0;
779fe533 12104
103f02d3 12105 external = pnotes;
103f02d3 12106
305c7206 12107 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 12108 (unsigned long) offset, (unsigned long) length);
779fe533 12109 printf (_(" Owner\t\tData size\tDescription\n"));
103f02d3 12110
2cf0635d 12111 while (external < (Elf_External_Note *) ((char *) pnotes + length))
779fe533 12112 {
2cf0635d 12113 Elf_External_Note * next;
b34976b6 12114 Elf_Internal_Note inote;
2cf0635d 12115 char * temp = NULL;
6d118b09
NC		 12116
12117 inote.type = BYTE_GET (external->type);
12118 inote.namesz = BYTE_GET (external->namesz);
12119 inote.namedata = external->name;
12120 inote.descsz = BYTE_GET (external->descsz);
12121 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
12122 inote.descpos = offset + (inote.descdata - (char *) pnotes);
76da6bbe 12123
2cf0635d 12124 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
3e55a963 12125
dd24e3da
NC		 12126 if ( ((char *) next > ((char *) pnotes) + length)
12127 || ((char *) next < (char *) pnotes))
3e55a963 12128 {
0fd3a477 12129 warn (_("corrupt note found at offset %lx into core notes\n"),
0af1713e 12130 (unsigned long) ((char *) external - (char *) pnotes));
0fd3a477 12131 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
3e55a963
NC		 12132 inote.type, inote.namesz, inote.descsz);
12133 break;
12134 }
12135
12136 external = next;
6d118b09 12137
dd24e3da
NC		 12138 /* Prevent out-of-bounds indexing. */
12139 if (inote.namedata + inote.namesz >= (char *) pnotes + length
12140 || inote.namedata + inote.namesz < inote.namedata)
12141 {
12142 warn (_("corrupt note found at offset %lx into core notes\n"),
12143 (unsigned long) ((char *) external - (char *) pnotes));
12144 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
12145 inote.type, inote.namesz, inote.descsz);
12146 break;
12147 }
12148
6d118b09
NC		 12149 /* Verify that name is null terminated. It appears that at least
12150 one version of Linux (RedHat 6.0) generates corefiles that don't
12151 comply with the ELF spec by failing to include the null byte in
12152 namesz. */
12153 if (inote.namedata[inote.namesz] != '\0')
12154 {
3f5e193b 12155 temp = (char *) malloc (inote.namesz + 1);
76da6bbe 12156
6d118b09
NC		 12157 if (temp == NULL)
12158 {
12159 error (_("Out of memory\n"));
12160 res = 0;
12161 break;
12162 }
76da6bbe 12163
6d118b09
NC		 12164 strncpy (temp, inote.namedata, inote.namesz);
12165 temp[inote.namesz] = 0;
76da6bbe 12166
6d118b09
NC		 12167 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
12168 inote.namedata = temp;
12169 }
12170
12171 res &= process_note (& inote);
103f02d3 12172
6d118b09
NC		 12173 if (temp != NULL)
12174 {
12175 free (temp);
12176 temp = NULL;
12177 }
779fe533
NC		 12178 }
12179
12180 free (pnotes);
103f02d3 12181
779fe533
NC		 12182 return res;
12183}
12184
12185static int
2cf0635d 12186process_corefile_note_segments (FILE * file)
779fe533 12187{
2cf0635d 12188 Elf_Internal_Phdr * segment;
b34976b6
AM		 12189 unsigned int i;
12190 int res = 1;
103f02d3 12191
d93f0186 12192 if (! get_program_headers (file))
779fe533 12193 return 0;
103f02d3 12194
779fe533
NC		 12195 for (i = 0, segment = program_headers;
12196 i < elf_header.e_phnum;
b34976b6 12197 i++, segment++)
779fe533
NC		 12198 {
12199 if (segment->p_type == PT_NOTE)
103f02d3 12200 res &= process_corefile_note_segment (file,
30800947
NC		 12201 (bfd_vma) segment->p_offset,
12202 (bfd_vma) segment->p_filesz);
779fe533 12203 }
103f02d3 12204
779fe533
NC		 12205 return res;
12206}
12207
12208static int
2cf0635d 12209process_note_sections (FILE * file)
1ec5cd37 12210{
2cf0635d 12211 Elf_Internal_Shdr * section;
1ec5cd37
NC		 12212 unsigned long i;
12213 int res = 1;
12214
12215 for (i = 0, section = section_headers;
12216 i < elf_header.e_shnum;
12217 i++, section++)
12218 if (section->sh_type == SHT_NOTE)
12219 res &= process_corefile_note_segment (file,
12220 (bfd_vma) section->sh_offset,
12221 (bfd_vma) section->sh_size);
12222
12223 return res;
12224}
12225
12226static int
2cf0635d 12227process_notes (FILE * file)
779fe533
NC		 12228{
12229 /* If we have not been asked to display the notes then do nothing. */
12230 if (! do_notes)
12231 return 1;
103f02d3 12232
779fe533 12233 if (elf_header.e_type != ET_CORE)
1ec5cd37 12234 return process_note_sections (file);
103f02d3 12235
779fe533 12236 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 12237 if (elf_header.e_phnum > 0)
12238 return process_corefile_note_segments (file);
779fe533 12239
1ec5cd37
NC		 12240 printf (_("No note segments present in the core file.\n"));
12241 return 1;
779fe533
NC		 12242}
12243
252b5132 12244static int
2cf0635d 12245process_arch_specific (FILE * file)
252b5132 12246{
a952a375
NC		 12247 if (! do_arch)
12248 return 1;
12249
252b5132
RH		 12250 switch (elf_header.e_machine)
12251 {
11c1ff18
PB		 12252 case EM_ARM:
12253 return process_arm_specific (file);
252b5132 12254 case EM_MIPS:
4fe85591 12255 case EM_MIPS_RS3_LE:
252b5132
RH		 12256 return process_mips_specific (file);
12257 break;
34c8bcba
JM		 12258 case EM_PPC:
12259 return process_power_specific (file);
12260 break;
59e6276b
JM		 12261 case EM_TI_C6000:
12262 return process_tic6x_specific (file);
12263 break;
252b5132
RH		 12264 default:
12265 break;
12266 }
12267 return 1;
12268}
12269
12270static int
2cf0635d 12271get_file_header (FILE * file)
252b5132 12272{
9ea033b2
NC		 12273 /* Read in the identity array. */
12274 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 12275 return 0;
12276
9ea033b2 12277 /* Determine how to read the rest of the header. */
b34976b6 12278 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 12279 {
12280 default: /* fall through */
12281 case ELFDATANONE: /* fall through */
adab8cdc
AO		 12282 case ELFDATA2LSB:
12283 byte_get = byte_get_little_endian;
12284 byte_put = byte_put_little_endian;
12285 break;
12286 case ELFDATA2MSB:
12287 byte_get = byte_get_big_endian;
12288 byte_put = byte_put_big_endian;
12289 break;
9ea033b2
NC		 12290 }
12291
12292 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 12293 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 12294
12295 /* Read in the rest of the header. */
12296 if (is_32bit_elf)
12297 {
12298 Elf32_External_Ehdr ehdr32;
252b5132 12299
9ea033b2
NC		 12300 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
12301 return 0;
103f02d3 12302
9ea033b2
NC		 12303 elf_header.e_type = BYTE_GET (ehdr32.e_type);
12304 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
12305 elf_header.e_version = BYTE_GET (ehdr32.e_version);
12306 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
12307 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
12308 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
12309 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
12310 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
12311 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
12312 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
12313 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
12314 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
12315 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
12316 }
252b5132 12317 else
9ea033b2
NC		 12318 {
12319 Elf64_External_Ehdr ehdr64;
a952a375
NC		 12320
12321 /* If we have been compiled with sizeof (bfd_vma) == 4, then
12322 we will not be able to cope with the 64bit data found in
12323 64 ELF files. Detect this now and abort before we start
50c2245b 12324 overwriting things. */
a952a375
NC		 12325 if (sizeof (bfd_vma) < 8)
12326 {
e3c8793a
NC		 12327 error (_("This instance of readelf has been built without support for a\n\
1232864 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 12329 return 0;
12330 }
103f02d3 12331
9ea033b2
NC		 12332 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
12333 return 0;
103f02d3 12334
9ea033b2
NC		 12335 elf_header.e_type = BYTE_GET (ehdr64.e_type);
12336 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
12337 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 12338 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
12339 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
12340 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 12341 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
12342 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
12343 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
12344 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
12345 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
12346 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
12347 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
12348 }
252b5132 12349
7ece0d85
JJ		 12350 if (elf_header.e_shoff)
12351 {
12352 /* There may be some extensions in the first section header. Don't
12353 bomb if we can't read it. */
12354 if (is_32bit_elf)
12355 get_32bit_section_headers (file, 1);
12356 else
12357 get_64bit_section_headers (file, 1);
12358 }
560f3c1c 12359
252b5132
RH		 12360 return 1;
12361}
12362
fb52b2f4
NC		 12363/* Process one ELF object file according to the command line options.
12364 This file may actually be stored in an archive. The file is
12365 positioned at the start of the ELF object. */
12366
ff78d6d6 12367static int
2cf0635d 12368process_object (char * file_name, FILE * file)
252b5132 12369{
252b5132
RH		 12370 unsigned int i;
12371
252b5132
RH		 12372 if (! get_file_header (file))
12373 {
12374 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 12375 return 1;
252b5132
RH		 12376 }
12377
12378 /* Initialise per file variables. */
60bca95a 12379 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 12380 version_info[i] = 0;
12381
60bca95a 12382 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 12383 dynamic_info[i] = 0;
5115b233 12384 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 12385
12386 /* Process the file. */
12387 if (show_name)
12388 printf (_("\nFile: %s\n"), file_name);
12389
18bd398b
NC		 12390 /* Initialise the dump_sects array from the cmdline_dump_sects array.
12391 Note we do this even if cmdline_dump_sects is empty because we
12392 must make sure that the dump_sets array is zeroed out before each
12393 object file is processed. */
12394 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 12395 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 12396
12397 if (num_cmdline_dump_sects > 0)
12398 {
12399 if (num_dump_sects == 0)
12400 /* A sneaky way of allocating the dump_sects array. */
09c11c86 12401 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 12402
12403 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 12404 memcpy (dump_sects, cmdline_dump_sects,
12405 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 12406 }
d70c5fc7 12407
252b5132 12408 if (! process_file_header ())
fb52b2f4 12409 return 1;
252b5132 12410
d1f5c6e3 12411 if (! process_section_headers (file))
2f62977e 12412 {
d1f5c6e3
L		 12413 /* Without loaded section headers we cannot process lots of
12414 things. */
2f62977e 12415 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 12416
2f62977e 12417 if (! do_using_dynamic)
2c610e4b 12418 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 12419 }
252b5132 12420
d1f5c6e3
L		 12421 if (! process_section_groups (file))
12422 {
12423 /* Without loaded section groups we cannot process unwind. */
12424 do_unwind = 0;
12425 }
12426
2f62977e 12427 if (process_program_headers (file))
b2d38a17 12428 process_dynamic_section (file);
252b5132
RH		 12429
12430 process_relocs (file);
12431
4d6ed7c8
NC		 12432 process_unwind (file);
12433
252b5132
RH		 12434 process_symbol_table (file);
12435
12436 process_syminfo (file);
12437
12438 process_version_sections (file);
12439
12440 process_section_contents (file);
f5842774 12441
1ec5cd37 12442 process_notes (file);
103f02d3 12443
047b2264
JJ		 12444 process_gnu_liblist (file);
12445
252b5132
RH		 12446 process_arch_specific (file);
12447
d93f0186
NC		 12448 if (program_headers)
12449 {
12450 free (program_headers);
12451 program_headers = NULL;
12452 }
12453
252b5132
RH		 12454 if (section_headers)
12455 {
12456 free (section_headers);
12457 section_headers = NULL;
12458 }
12459
12460 if (string_table)
12461 {
12462 free (string_table);
12463 string_table = NULL;
d40ac9bd 12464 string_table_length = 0;
252b5132
RH		 12465 }
12466
12467 if (dynamic_strings)
12468 {
12469 free (dynamic_strings);
12470 dynamic_strings = NULL;
d79b3d50 12471 dynamic_strings_length = 0;
252b5132
RH		 12472 }
12473
12474 if (dynamic_symbols)
12475 {
12476 free (dynamic_symbols);
12477 dynamic_symbols = NULL;
19936277 12478 num_dynamic_syms = 0;
252b5132
RH		 12479 }
12480
12481 if (dynamic_syminfo)
12482 {
12483 free (dynamic_syminfo);
12484 dynamic_syminfo = NULL;
12485 }
ff78d6d6 12486
293c573e
MR		 12487 if (dynamic_section)
12488 {
12489 free (dynamic_section);
12490 dynamic_section = NULL;
12491 }
12492
e4b17d5c
L		 12493 if (section_headers_groups)
12494 {
12495 free (section_headers_groups);
12496 section_headers_groups = NULL;
12497 }
12498
12499 if (section_groups)
12500 {
2cf0635d
NC		 12501 struct group_list * g;
12502 struct group_list * next;
e4b17d5c
L		 12503
12504 for (i = 0; i < group_count; i++)
12505 {
12506 for (g = section_groups [i].root; g != NULL; g = next)
12507 {
12508 next = g->next;
12509 free (g);
12510 }
12511 }
12512
12513 free (section_groups);
12514 section_groups = NULL;
12515 }
12516
19e6b90e 12517 free_debug_memory ();
18bd398b 12518
ff78d6d6 12519 return 0;
252b5132
RH		 12520}
12521
2cf0635d
NC		 12522/* Process an ELF archive.
12523 On entry the file is positioned just after the ARMAG string. */
12524
12525static int
12526process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
12527{
12528 struct archive_info arch;
12529 struct archive_info nested_arch;
12530 size_t got;
2cf0635d
NC		 12531 int ret;
12532
12533 show_name = 1;
12534
12535 /* The ARCH structure is used to hold information about this archive. */
12536 arch.file_name = NULL;
12537 arch.file = NULL;
12538 arch.index_array = NULL;
12539 arch.sym_table = NULL;
12540 arch.longnames = NULL;
12541
12542 /* The NESTED_ARCH structure is used as a single-item cache of information
12543 about a nested archive (when members of a thin archive reside within
12544 another regular archive file). */
12545 nested_arch.file_name = NULL;
12546 nested_arch.file = NULL;
12547 nested_arch.index_array = NULL;
12548 nested_arch.sym_table = NULL;
12549 nested_arch.longnames = NULL;
12550
12551 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
12552 {
12553 ret = 1;
12554 goto out;
4145f1d5 12555 }
fb52b2f4 12556
4145f1d5
NC		 12557 if (do_archive_index)
12558 {
2cf0635d 12559 if (arch.sym_table == NULL)
4145f1d5
NC		 12560 error (_("%s: unable to dump the index as none was found\n"), file_name);
12561 else
12562 {
2cf0635d 12563 unsigned int i, l;
4145f1d5
NC		 12564 unsigned long current_pos;
12565
12566 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
2cf0635d 12567 file_name, arch.index_num, arch.sym_size);
4145f1d5
NC		 12568 current_pos = ftell (file);
12569
2cf0635d 12570 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 12571 {
2cf0635d
NC		 12572 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
12573 {
12574 char * member_name;
4145f1d5 12575
2cf0635d
NC		 12576 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
12577
12578 if (member_name != NULL)
12579 {
12580 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
12581
12582 if (qualified_name != NULL)
12583 {
12584 printf (_("Binary %s contains:\n"), qualified_name);
12585 free (qualified_name);
12586 }
4145f1d5
NC		 12587 }
12588 }
2cf0635d
NC		 12589
12590 if (l >= arch.sym_size)
4145f1d5
NC		 12591 {
12592 error (_("%s: end of the symbol table reached before the end of the index\n"),
12593 file_name);
cb8f3167 12594 break;
4145f1d5 12595 }
2cf0635d
NC		 12596 printf ("\t%s\n", arch.sym_table + l);
12597 l += strlen (arch.sym_table + l) + 1;
4145f1d5
NC		 12598 }
12599
2cf0635d
NC		 12600 if (l & 01)
12601 ++l;
12602 if (l < arch.sym_size)
4145f1d5
NC		 12603 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
12604 file_name);
12605
4145f1d5
NC		 12606 if (fseek (file, current_pos, SEEK_SET) != 0)
12607 {
12608 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 12609 ret = 1;
12610 goto out;
4145f1d5 12611 }
fb52b2f4 12612 }
4145f1d5
NC		 12613
12614 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
12615 && !do_segments && !do_header && !do_dump && !do_version
12616 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 12617 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 12618 {
12619 ret = 0; /* Archive index only. */
12620 goto out;
12621 }
fb52b2f4
NC		 12622 }
12623
d989285c 12624 ret = 0;
fb52b2f4
NC		 12625
12626 while (1)
12627 {
2cf0635d
NC		 12628 char * name;
12629 size_t namelen;
12630 char * qualified_name;
12631
12632 /* Read the next archive header. */
12633 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
12634 {
12635 error (_("%s: failed to seek to next archive header\n"), file_name);
12636 return 1;
12637 }
12638 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
12639 if (got != sizeof arch.arhdr)
12640 {
12641 if (got == 0)
12642 break;
12643 error (_("%s: failed to read archive header\n"), file_name);
12644 ret = 1;
12645 break;
12646 }
12647 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
12648 {
12649 error (_("%s: did not find a valid archive header\n"), arch.file_name);
12650 ret = 1;
12651 break;
12652 }
12653
12654 arch.next_arhdr_offset += sizeof arch.arhdr;
12655
12656 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
12657 if (archive_file_size & 01)
12658 ++archive_file_size;
12659
12660 name = get_archive_member_name (&arch, &nested_arch);
12661 if (name == NULL)
fb52b2f4 12662 {
0fd3a477 12663 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 12664 ret = 1;
12665 break;
fb52b2f4 12666 }
2cf0635d 12667 namelen = strlen (name);
fb52b2f4 12668
2cf0635d
NC		 12669 qualified_name = make_qualified_name (&arch, &nested_arch, name);
12670 if (qualified_name == NULL)
fb52b2f4 12671 {
2cf0635d 12672 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 12673 ret = 1;
12674 break;
fb52b2f4
NC		 12675 }
12676
2cf0635d
NC		 12677 if (is_thin_archive && arch.nested_member_origin == 0)
12678 {
12679 /* This is a proxy for an external member of a thin archive. */
12680 FILE * member_file;
12681 char * member_file_name = adjust_relative_path (file_name, name, namelen);
12682 if (member_file_name == NULL)
12683 {
12684 ret = 1;
12685 break;
12686 }
12687
12688 member_file = fopen (member_file_name, "rb");
12689 if (member_file == NULL)
12690 {
12691 error (_("Input file '%s' is not readable.\n"), member_file_name);
12692 free (member_file_name);
12693 ret = 1;
12694 break;
12695 }
12696
12697 archive_file_offset = arch.nested_member_origin;
12698
12699 ret |= process_object (qualified_name, member_file);
12700
12701 fclose (member_file);
12702 free (member_file_name);
12703 }
12704 else if (is_thin_archive)
12705 {
12706 /* This is a proxy for a member of a nested archive. */
12707 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
12708
12709 /* The nested archive file will have been opened and setup by
12710 get_archive_member_name. */
12711 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
12712 {
12713 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
12714 ret = 1;
12715 break;
12716 }
12717
12718 ret |= process_object (qualified_name, nested_arch.file);
12719 }
12720 else
12721 {
12722 archive_file_offset = arch.next_arhdr_offset;
12723 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 12724
2cf0635d
NC		 12725 ret |= process_object (qualified_name, file);
12726 }
fb52b2f4 12727
2b52916e
L		 12728 if (dump_sects != NULL)
12729 {
12730 free (dump_sects);
12731 dump_sects = NULL;
12732 num_dump_sects = 0;
12733 }
12734
2cf0635d 12735 free (qualified_name);
fb52b2f4
NC		 12736 }
12737
4145f1d5 12738 out:
2cf0635d
NC		 12739 if (nested_arch.file != NULL)
12740 fclose (nested_arch.file);
12741 release_archive (&nested_arch);
12742 release_archive (&arch);
fb52b2f4 12743
d989285c 12744 return ret;
fb52b2f4
NC		 12745}
12746
12747static int
2cf0635d 12748process_file (char * file_name)
fb52b2f4 12749{
2cf0635d 12750 FILE * file;
fb52b2f4
NC		 12751 struct stat statbuf;
12752 char armag[SARMAG];
12753 int ret;
12754
12755 if (stat (file_name, &statbuf) < 0)
12756 {
f24ddbdd
NC		 12757 if (errno == ENOENT)
12758 error (_("'%s': No such file\n"), file_name);
12759 else
12760 error (_("Could not locate '%s'. System error message: %s\n"),
12761 file_name, strerror (errno));
12762 return 1;
12763 }
12764
12765 if (! S_ISREG (statbuf.st_mode))
12766 {
12767 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 12768 return 1;
12769 }
12770
12771 file = fopen (file_name, "rb");
12772 if (file == NULL)
12773 {
f24ddbdd 12774 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 12775 return 1;
12776 }
12777
12778 if (fread (armag, SARMAG, 1, file) != 1)
12779 {
4145f1d5 12780 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 12781 fclose (file);
12782 return 1;
12783 }
12784
12785 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 12786 ret = process_archive (file_name, file, FALSE);
12787 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
12788 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 12789 else
12790 {
4145f1d5
NC		 12791 if (do_archive_index)
12792 error (_("File %s is not an archive so its index cannot be displayed.\n"),
12793 file_name);
12794
fb52b2f4
NC		 12795 rewind (file);
12796 archive_file_size = archive_file_offset = 0;
12797 ret = process_object (file_name, file);
12798 }
12799
12800 fclose (file);
12801
12802 return ret;
12803}
12804
252b5132
RH		 12805#ifdef SUPPORT_DISASSEMBLY
12806/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 12807 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 12808 symbols. */
252b5132
RH		 12809
12810void
2cf0635d 12811print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 12812{
12813 fprintf (outfile,"0x%8.8x", addr);
12814}
12815
e3c8793a 12816/* Needed by the i386 disassembler. */
252b5132
RH		 12817void
12818db_task_printsym (unsigned int addr)
12819{
12820 print_address (addr, stderr);
12821}
12822#endif
12823
12824int
2cf0635d 12825main (int argc, char ** argv)
252b5132 12826{
ff78d6d6
L		 12827 int err;
12828
252b5132
RH		 12829#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12830 setlocale (LC_MESSAGES, "");
3882b010
L		 12831#endif
12832#if defined (HAVE_SETLOCALE)
12833 setlocale (LC_CTYPE, "");
252b5132
RH		 12834#endif
12835 bindtextdomain (PACKAGE, LOCALEDIR);
12836 textdomain (PACKAGE);
12837
869b9d07
MM		 12838 expandargv (&argc, &argv);
12839
252b5132
RH		 12840 parse_args (argc, argv);
12841
18bd398b 12842 if (num_dump_sects > 0)
59f14fc0 12843 {
18bd398b 12844 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 12845 cmdline_dump_sects = (dump_type *)
12846 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 12847 if (cmdline_dump_sects == NULL)
591a748a 12848 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 12849 else
12850 {
09c11c86
NC		 12851 memcpy (cmdline_dump_sects, dump_sects,
12852 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 12853 num_cmdline_dump_sects = num_dump_sects;
12854 }
12855 }
12856
18bd398b
NC		 12857 if (optind < (argc - 1))
12858 show_name = 1;
12859
ff78d6d6 12860 err = 0;
252b5132 12861 while (optind < argc)
18bd398b 12862 err |= process_file (argv[optind++]);
252b5132
RH		 12863
12864 if (dump_sects != NULL)
12865 free (dump_sects);
59f14fc0
AS		 12866 if (cmdline_dump_sects != NULL)
12867 free (cmdline_dump_sects);
252b5132 12868
ff78d6d6 12869 return err;
252b5132 12870}
A mirror of the official binutils-gdb repository