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