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