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