]> 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
2009-12-10 Michael Snyder <msnyder@vmware.com>
[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. */
732 bfd_vma info = relas[i].r_info;
733 info = (((info & 0xffffffff) << 32)
734 | ((info >> 56) & 0xff)
735 | ((info >> 40) & 0xff00)
736 | ((info >> 24) & 0xff0000)
737 | ((info >> 8) & 0xff000000));
738 relas[i].r_info = info;
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. */
828 bfd_vma info = rels[i].r_info;
829 info = (((info & 0xffffffff) << 32)
830 | ((info >> 56) & 0xff)
831 | ((info >> 40) & 0xff00)
832 | ((info >> 24) & 0xff0000)
833 | ((info >> 8) & 0xff000000));
834 rels[i].r_info = info;
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
AM		 944 bfd_vma offset;
945 bfd_vma info;
946 bfd_vma symtab_index;
947 bfd_vma type;
103f02d3 948
b34976b6
AM		 949 offset = rels[i].r_offset;
950 info = rels[i].r_info;
103f02d3 951
aca88567
NC		 952 type = get_reloc_type (info);
953 symtab_index = get_reloc_symindex (info);
252b5132 954
410f7a12
L		 955 if (is_32bit_elf)
956 {
39dbeff8
AM		 957 printf ("%8.8lx %8.8lx ",
958 (unsigned long) offset & 0xffffffff,
959 (unsigned long) info & 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 ",
967 offset, info);
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 ",
973 offset, info);
6e3d6dc1
NC		 974#else
975 printf (do_wide
976 ? "%16.16I64x %16.16I64x "
977 : "%12.12I64x %12.12I64x ",
978 offset, info);
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),
986 _bfd_int64_high (info),
987 _bfd_int64_low (info));
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
NC		 1357 {
1358 long offset = (long) (bfd_signed_vma) rels[i].r_addend;
1359
1360 if (offset < 0)
1361 printf (" - %lx", - offset);
1362 else
1363 printf (" + %lx", offset);
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"))
351b4b40
RH		 1377 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info));
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 {
aca88567
NC		 1384 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (info);
1385 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (info);
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
2cf0635d 3371get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * program_headers)
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
NC		 3384
3385 for (i = 0, internal = program_headers, external = phdrs;
3386 i < elf_header.e_phnum;
b34976b6 3387 i++, internal++, external++)
252b5132 3388 {
9ea033b2
NC		 3389 internal->p_type = BYTE_GET (external->p_type);
3390 internal->p_offset = BYTE_GET (external->p_offset);
3391 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3392 internal->p_paddr = BYTE_GET (external->p_paddr);
3393 internal->p_filesz = BYTE_GET (external->p_filesz);
3394 internal->p_memsz = BYTE_GET (external->p_memsz);
3395 internal->p_flags = BYTE_GET (external->p_flags);
3396 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 3397 }
3398
9ea033b2
NC		 3399 free (phdrs);
3400
252b5132
RH		 3401 return 1;
3402}
3403
9ea033b2 3404static int
2cf0635d 3405get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * program_headers)
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
NC		 3418
3419 for (i = 0, internal = program_headers, external = phdrs;
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
L		 3961 int field_size = is_32bit_elf ? 8 : 16;
3962 int index, size = sizeof (buff) - (field_size + 4 + 1);
3963 bfd_vma os_flags = 0;
3964 bfd_vma proc_flags = 0;
3965 bfd_vma unknown_flags = 0;
148b93f2 3966 static const struct
5477e8a0 3967 {
2cf0635d 3968 const char * str;
5477e8a0
L		 3969 int len;
3970 }
3971 flags [] =
3972 {
cfcac11d
NC		 3973 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
3974 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
3975 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
3976 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
3977 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
3978 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
3979 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
3980 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
3981 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
3982 /* 9 */ { STRING_COMMA_LEN ("TLS") },
3983 /* IA-64 specific. */
3984 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
3985 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
3986 /* IA-64 OpenVMS specific. */
3987 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
3988 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
3989 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
3990 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
3991 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
3992 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
3993 /* SPARC specific. */
3994 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
3995 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5477e8a0
L		 3996 };
3997
3998 if (do_section_details)
3999 {
8d5ff12c
L		 4000 sprintf (buff, "[%*.*lx]: ",
4001 field_size, field_size, (unsigned long) sh_flags);
4002 p += field_size + 4;
5477e8a0 4003 }
76da6bbe 4004
d1133906
NC		 4005 while (sh_flags)
4006 {
4007 bfd_vma flag;
4008
4009 flag = sh_flags & - sh_flags;
4010 sh_flags &= ~ flag;
76da6bbe 4011
5477e8a0 4012 if (do_section_details)
d1133906 4013 {
5477e8a0
L		 4014 switch (flag)
4015 {
4016 case SHF_WRITE: index = 0; break;
4017 case SHF_ALLOC: index = 1; break;
4018 case SHF_EXECINSTR: index = 2; break;
4019 case SHF_MERGE: index = 3; break;
4020 case SHF_STRINGS: index = 4; break;
4021 case SHF_INFO_LINK: index = 5; break;
4022 case SHF_LINK_ORDER: index = 6; break;
4023 case SHF_OS_NONCONFORMING: index = 7; break;
4024 case SHF_GROUP: index = 8; break;
4025 case SHF_TLS: index = 9; break;
76da6bbe 4026
5477e8a0
L		 4027 default:
4028 index = -1;
cfcac11d 4029 switch (elf_header.e_machine)
148b93f2 4030 {
cfcac11d 4031 case EM_IA_64:
148b93f2
NC		 4032 if (flag == SHF_IA_64_SHORT)
4033 index = 10;
4034 else if (flag == SHF_IA_64_NORECOV)
4035 index = 11;
4036#ifdef BFD64
4037 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4038 switch (flag)
4039 {
4040 case SHF_IA_64_VMS_GLOBAL: index = 12; break;
4041 case SHF_IA_64_VMS_OVERLAID: index = 13; break;
4042 case SHF_IA_64_VMS_SHARED: index = 14; break;
4043 case SHF_IA_64_VMS_VECTOR: index = 15; break;
4044 case SHF_IA_64_VMS_ALLOC_64BIT: index = 16; break;
4045 case SHF_IA_64_VMS_PROTECTED: index = 17; break;
4046 default: break;
4047 }
4048#endif
cfcac11d
NC		 4049 break;
4050
caa83f8b
NC		 4051 case EM_386:
4052 case EM_486:
4053 case EM_X86_64:
cfcac11d
NC		 4054 case EM_OLD_SPARCV9:
4055 case EM_SPARC32PLUS:
4056 case EM_SPARCV9:
4057 case EM_SPARC:
4058 if (flag == SHF_EXCLUDE)
4059 index = 18;
4060 else if (flag == SHF_ORDERED)
4061 index = 19;
4062 break;
4063 default:
4064 break;
148b93f2 4065 }
5477e8a0
L		 4066 }
4067
5477e8a0
L		 4068 if (index != -1)
4069 {
8d5ff12c
L		 4070 if (p != buff + field_size + 4)
4071 {
4072 if (size < (10 + 2))
4073 abort ();
4074 size -= 2;
4075 *p++ = ',';
4076 *p++ = ' ';
4077 }
4078
5477e8a0
L		 4079 size -= flags [index].len;
4080 p = stpcpy (p, flags [index].str);
4081 }
3b22753a 4082 else if (flag & SHF_MASKOS)
8d5ff12c 4083 os_flags |= flag;
d1133906 4084 else if (flag & SHF_MASKPROC)
8d5ff12c 4085 proc_flags |= flag;
d1133906 4086 else
8d5ff12c 4087 unknown_flags |= flag;
5477e8a0
L		 4088 }
4089 else
4090 {
4091 switch (flag)
4092 {
4093 case SHF_WRITE: *p = 'W'; break;
4094 case SHF_ALLOC: *p = 'A'; break;
4095 case SHF_EXECINSTR: *p = 'X'; break;
4096 case SHF_MERGE: *p = 'M'; break;
4097 case SHF_STRINGS: *p = 'S'; break;
4098 case SHF_INFO_LINK: *p = 'I'; break;
4099 case SHF_LINK_ORDER: *p = 'L'; break;
4100 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4101 case SHF_GROUP: *p = 'G'; break;
4102 case SHF_TLS: *p = 'T'; break;
4103
4104 default:
8a9036a4
L		 4105 if ((elf_header.e_machine == EM_X86_64
4106 || elf_header.e_machine == EM_L1OM)
5477e8a0
L		 4107 && flag == SHF_X86_64_LARGE)
4108 *p = 'l';
4109 else if (flag & SHF_MASKOS)
4110 {
4111 *p = 'o';
4112 sh_flags &= ~ SHF_MASKOS;
4113 }
4114 else if (flag & SHF_MASKPROC)
4115 {
4116 *p = 'p';
4117 sh_flags &= ~ SHF_MASKPROC;
4118 }
4119 else
4120 *p = 'x';
4121 break;
4122 }
4123 p++;
d1133906
NC		 4124 }
4125 }
76da6bbe 4126
8d5ff12c
L		 4127 if (do_section_details)
4128 {
4129 if (os_flags)
4130 {
4131 size -= 5 + field_size;
4132 if (p != buff + field_size + 4)
4133 {
4134 if (size < (2 + 1))
4135 abort ();
4136 size -= 2;
4137 *p++ = ',';
4138 *p++ = ' ';
4139 }
4140 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4141 (unsigned long) os_flags);
4142 p += 5 + field_size;
4143 }
4144 if (proc_flags)
4145 {
4146 size -= 7 + field_size;
4147 if (p != buff + field_size + 4)
4148 {
4149 if (size < (2 + 1))
4150 abort ();
4151 size -= 2;
4152 *p++ = ',';
4153 *p++ = ' ';
4154 }
4155 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4156 (unsigned long) proc_flags);
4157 p += 7 + field_size;
4158 }
4159 if (unknown_flags)
4160 {
4161 size -= 10 + field_size;
4162 if (p != buff + field_size + 4)
4163 {
4164 if (size < (2 + 1))
4165 abort ();
4166 size -= 2;
4167 *p++ = ',';
4168 *p++ = ' ';
4169 }
4170 sprintf (p, "UNKNOWN (%*.*lx)", field_size, field_size,
4171 (unsigned long) unknown_flags);
4172 p += 10 + field_size;
4173 }
4174 }
4175
e9e44622 4176 *p = '\0';
d1133906
NC		 4177 return buff;
4178}
4179
252b5132 4180static int
2cf0635d 4181process_section_headers (FILE * file)
252b5132 4182{
2cf0635d 4183 Elf_Internal_Shdr * section;
b34976b6 4184 unsigned int i;
252b5132
RH		 4185
4186 section_headers = NULL;
4187
4188 if (elf_header.e_shnum == 0)
4189 {
4190 if (do_sections)
4191 printf (_("\nThere are no sections in this file.\n"));
4192
4193 return 1;
4194 }
4195
4196 if (do_sections && !do_header)
9ea033b2 4197 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 4198 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4199
9ea033b2
NC		 4200 if (is_32bit_elf)
4201 {
560f3c1c 4202 if (! get_32bit_section_headers (file, elf_header.e_shnum))
9ea033b2
NC		 4203 return 0;
4204 }
560f3c1c 4205 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
252b5132
RH		 4206 return 0;
4207
4208 /* Read in the string table, so that we have names to display. */
0b49d371 4209 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 4210 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 4211 {
4fbb74a6 4212 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 4213
c256ffe7
JJ		 4214 if (section->sh_size != 0)
4215 {
3f5e193b
NC		 4216 string_table = (char *) get_data (NULL, file, section->sh_offset,
4217 1, section->sh_size,
4218 _("string table"));
0de14b54 4219
c256ffe7
JJ		 4220 string_table_length = string_table != NULL ? section->sh_size : 0;
4221 }
252b5132
RH		 4222 }
4223
4224 /* Scan the sections for the dynamic symbol table
e3c8793a 4225 and dynamic string table and debug sections. */
252b5132
RH		 4226 dynamic_symbols = NULL;
4227 dynamic_strings = NULL;
4228 dynamic_syminfo = NULL;
f1ef08cb 4229 symtab_shndx_hdr = NULL;
103f02d3 4230
89fac5e3
RS		 4231 eh_addr_size = is_32bit_elf ? 4 : 8;
4232 switch (elf_header.e_machine)
4233 {
4234 case EM_MIPS:
4235 case EM_MIPS_RS3_LE:
4236 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4237 FDE addresses. However, the ABI also has a semi-official ILP32
4238 variant for which the normal FDE address size rules apply.
4239
4240 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4241 section, where XX is the size of longs in bits. Unfortunately,
4242 earlier compilers provided no way of distinguishing ILP32 objects
4243 from LP64 objects, so if there's any doubt, we should assume that
4244 the official LP64 form is being used. */
4245 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4246 && find_section (".gcc_compiled_long32") == NULL)
4247 eh_addr_size = 8;
4248 break;
0f56a26a
DD		 4249
4250 case EM_H8_300:
4251 case EM_H8_300H:
4252 switch (elf_header.e_flags & EF_H8_MACH)
4253 {
4254 case E_H8_MACH_H8300:
4255 case E_H8_MACH_H8300HN:
4256 case E_H8_MACH_H8300SN:
4257 case E_H8_MACH_H8300SXN:
4258 eh_addr_size = 2;
4259 break;
4260 case E_H8_MACH_H8300H:
4261 case E_H8_MACH_H8300S:
4262 case E_H8_MACH_H8300SX:
4263 eh_addr_size = 4;
4264 break;
4265 }
f4236fe4
DD		 4266 break;
4267
ff7eeb89 4268 case EM_M32C_OLD:
f4236fe4
DD		 4269 case EM_M32C:
4270 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4271 {
4272 case EF_M32C_CPU_M16C:
4273 eh_addr_size = 2;
4274 break;
4275 }
4276 break;
89fac5e3
RS		 4277 }
4278
08d8fa11
JJ		 4279#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4280 do \
4281 { \
4282 size_t expected_entsize \
4283 = is_32bit_elf ? size32 : size64; \
4284 if (section->sh_entsize != expected_entsize) \
4285 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4286 i, (unsigned long int) section->sh_entsize, \
4287 (unsigned long int) expected_entsize); \
4288 section->sh_entsize = expected_entsize; \
4289 } \
4290 while (0)
4291#define CHECK_ENTSIZE(section, i, type) \
4292 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4293 sizeof (Elf64_External_##type))
4294
252b5132
RH		 4295 for (i = 0, section = section_headers;
4296 i < elf_header.e_shnum;
b34976b6 4297 i++, section++)
252b5132 4298 {
2cf0635d 4299 char * name = SECTION_NAME (section);
252b5132
RH		 4300
4301 if (section->sh_type == SHT_DYNSYM)
4302 {
4303 if (dynamic_symbols != NULL)
4304 {
4305 error (_("File contains multiple dynamic symbol tables\n"));
4306 continue;
4307 }
4308
08d8fa11 4309 CHECK_ENTSIZE (section, i, Sym);
19936277 4310 num_dynamic_syms = section->sh_size / section->sh_entsize;
9ad5cbcf 4311 dynamic_symbols = GET_ELF_SYMBOLS (file, section);
252b5132
RH		 4312 }
4313 else if (section->sh_type == SHT_STRTAB
18bd398b 4314 && streq (name, ".dynstr"))
252b5132
RH		 4315 {
4316 if (dynamic_strings != NULL)
4317 {
4318 error (_("File contains multiple dynamic string tables\n"));
4319 continue;
4320 }
4321
3f5e193b
NC		 4322 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4323 1, section->sh_size,
4324 _("dynamic strings"));
d79b3d50 4325 dynamic_strings_length = section->sh_size;
252b5132 4326 }
9ad5cbcf
AM		 4327 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4328 {
4329 if (symtab_shndx_hdr != NULL)
4330 {
4331 error (_("File contains multiple symtab shndx tables\n"));
4332 continue;
4333 }
4334 symtab_shndx_hdr = section;
4335 }
08d8fa11
JJ		 4336 else if (section->sh_type == SHT_SYMTAB)
4337 CHECK_ENTSIZE (section, i, Sym);
4338 else if (section->sh_type == SHT_GROUP)
4339 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4340 else if (section->sh_type == SHT_REL)
4341 CHECK_ENTSIZE (section, i, Rel);
4342 else if (section->sh_type == SHT_RELA)
4343 CHECK_ENTSIZE (section, i, Rela);
252b5132 4344 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 4345 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 4346 || do_debug_aranges || do_debug_frames || do_debug_macinfo
a262ae96 4347 || do_debug_str || do_debug_loc || do_debug_ranges)
1b315056
CS		 4348 && (const_strneq (name, ".debug_")
4349 || const_strneq (name, ".zdebug_")))
252b5132 4350 {
1b315056
CS		 4351 if (name[1] == 'z')
4352 name += sizeof (".zdebug_") - 1;
4353 else
4354 name += sizeof (".debug_") - 1;
252b5132
RH		 4355
4356 if (do_debugging
18bd398b 4357 || (do_debug_info && streq (name, "info"))
2b6f5997 4358 || (do_debug_info && streq (name, "types"))
18bd398b 4359 || (do_debug_abbrevs && streq (name, "abbrev"))
4cb93e3b 4360 || (do_debug_lines && streq (name, "line"))
18bd398b 4361 || (do_debug_pubnames && streq (name, "pubnames"))
f9f0e732 4362 || (do_debug_pubtypes && streq (name, "pubtypes"))
18bd398b
NC		 4363 || (do_debug_aranges && streq (name, "aranges"))
4364 || (do_debug_ranges && streq (name, "ranges"))
4365 || (do_debug_frames && streq (name, "frame"))
4366 || (do_debug_macinfo && streq (name, "macinfo"))
4367 || (do_debug_str && streq (name, "str"))
4368 || (do_debug_loc && streq (name, "loc"))
252b5132 4369 )
09c11c86 4370 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 4371 }
a262ae96 4372 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 4373 else if ((do_debugging || do_debug_info)
0112cd26 4374 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 4375 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 4376 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 4377 request_dump_bynumber (i, DEBUG_DUMP);
252b5132
RH		 4378 }
4379
4380 if (! do_sections)
4381 return 1;
4382
3a1a2036
NC		 4383 if (elf_header.e_shnum > 1)
4384 printf (_("\nSection Headers:\n"));
4385 else
4386 printf (_("\nSection Header:\n"));
76da6bbe 4387
f7a99963 4388 if (is_32bit_elf)
595cf52e 4389 {
5477e8a0 4390 if (do_section_details)
595cf52e
L		 4391 {
4392 printf (_(" [Nr] Name\n"));
5477e8a0 4393 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 4394 }
4395 else
4396 printf
4397 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4398 }
d974e256 4399 else if (do_wide)
595cf52e 4400 {
5477e8a0 4401 if (do_section_details)
595cf52e
L		 4402 {
4403 printf (_(" [Nr] Name\n"));
5477e8a0 4404 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 4405 }
4406 else
4407 printf
4408 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4409 }
f7a99963
NC		 4410 else
4411 {
5477e8a0 4412 if (do_section_details)
595cf52e
L		 4413 {
4414 printf (_(" [Nr] Name\n"));
5477e8a0
L		 4415 printf (_(" Type Address Offset Link\n"));
4416 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 4417 }
4418 else
4419 {
4420 printf (_(" [Nr] Name Type Address Offset\n"));
4421 printf (_(" Size EntSize Flags Link Info Align\n"));
4422 }
f7a99963 4423 }
252b5132 4424
5477e8a0
L		 4425 if (do_section_details)
4426 printf (_(" Flags\n"));
4427
252b5132
RH		 4428 for (i = 0, section = section_headers;
4429 i < elf_header.e_shnum;
b34976b6 4430 i++, section++)
252b5132 4431 {
5477e8a0 4432 if (do_section_details)
595cf52e
L		 4433 {
4434 printf (" [%2u] %s\n",
4fbb74a6 4435 i,
595cf52e
L		 4436 SECTION_NAME (section));
4437 if (is_32bit_elf || do_wide)
4438 printf (" %-15.15s ",
4439 get_section_type_name (section->sh_type));
4440 }
4441 else
b9eb56c1
NC		 4442 printf ((do_wide ? " [%2u] %-17s %-15s "
4443 : " [%2u] %-17.17s %-15.15s "),
4fbb74a6 4444 i,
595cf52e
L		 4445 SECTION_NAME (section),
4446 get_section_type_name (section->sh_type));
252b5132 4447
f7a99963
NC		 4448 if (is_32bit_elf)
4449 {
cfcac11d
NC		 4450 const char * link_too_big = NULL;
4451
f7a99963 4452 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 4453
f7a99963
NC		 4454 printf ( " %6.6lx %6.6lx %2.2lx",
4455 (unsigned long) section->sh_offset,
4456 (unsigned long) section->sh_size,
4457 (unsigned long) section->sh_entsize);
d1133906 4458
5477e8a0
L		 4459 if (do_section_details)
4460 fputs (" ", stdout);
4461 else
4462 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 4463
cfcac11d
NC		 4464 if (section->sh_link >= elf_header.e_shnum)
4465 {
4466 link_too_big = "";
4467 /* The sh_link value is out of range. Normally this indicates
caa83f8b 4468 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 4469 switch (elf_header.e_machine)
4470 {
caa83f8b
NC		 4471 case EM_386:
4472 case EM_486:
4473 case EM_X86_64:
cfcac11d
NC		 4474 case EM_OLD_SPARCV9:
4475 case EM_SPARC32PLUS:
4476 case EM_SPARCV9:
4477 case EM_SPARC:
4478 if (section->sh_link == (SHN_BEFORE & 0xffff))
4479 link_too_big = "BEFORE";
4480 else if (section->sh_link == (SHN_AFTER & 0xffff))
4481 link_too_big = "AFTER";
4482 break;
4483 default:
4484 break;
4485 }
4486 }
4487
4488 if (do_section_details)
4489 {
4490 if (link_too_big != NULL && * link_too_big)
4491 printf ("<%s> ", link_too_big);
4492 else
4493 printf ("%2u ", section->sh_link);
4494 printf ("%3u %2lu\n", section->sh_info,
4495 (unsigned long) section->sh_addralign);
4496 }
4497 else
4498 printf ("%2u %3u %2lu\n",
4499 section->sh_link,
4500 section->sh_info,
4501 (unsigned long) section->sh_addralign);
4502
4503 if (link_too_big && ! * link_too_big)
4504 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4505 i, section->sh_link);
f7a99963 4506 }
d974e256
JJ		 4507 else if (do_wide)
4508 {
4509 print_vma (section->sh_addr, LONG_HEX);
4510
4511 if ((long) section->sh_offset == section->sh_offset)
4512 printf (" %6.6lx", (unsigned long) section->sh_offset);
4513 else
4514 {
4515 putchar (' ');
4516 print_vma (section->sh_offset, LONG_HEX);
4517 }
4518
4519 if ((unsigned long) section->sh_size == section->sh_size)
4520 printf (" %6.6lx", (unsigned long) section->sh_size);
4521 else
4522 {
4523 putchar (' ');
4524 print_vma (section->sh_size, LONG_HEX);
4525 }
4526
4527 if ((unsigned long) section->sh_entsize == section->sh_entsize)
4528 printf (" %2.2lx", (unsigned long) section->sh_entsize);
4529 else
4530 {
4531 putchar (' ');
4532 print_vma (section->sh_entsize, LONG_HEX);
4533 }
4534
5477e8a0
L		 4535 if (do_section_details)
4536 fputs (" ", stdout);
4537 else
4538 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 4539
72de5009 4540 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 4541
4542 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 4543 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 4544 else
4545 {
4546 print_vma (section->sh_addralign, DEC);
4547 putchar ('\n');
4548 }
4549 }
5477e8a0 4550 else if (do_section_details)
595cf52e 4551 {
5477e8a0 4552 printf (" %-15.15s ",
595cf52e 4553 get_section_type_name (section->sh_type));
595cf52e
L		 4554 print_vma (section->sh_addr, LONG_HEX);
4555 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 4556 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 4557 else
4558 {
4559 printf (" ");
4560 print_vma (section->sh_offset, LONG_HEX);
4561 }
72de5009 4562 printf (" %u\n ", section->sh_link);
595cf52e 4563 print_vma (section->sh_size, LONG_HEX);
5477e8a0 4564 putchar (' ');
595cf52e
L		 4565 print_vma (section->sh_entsize, LONG_HEX);
4566
72de5009
AM		 4567 printf (" %-16u %lu\n",
4568 section->sh_info,
595cf52e
L		 4569 (unsigned long) section->sh_addralign);
4570 }
f7a99963
NC		 4571 else
4572 {
4573 putchar (' ');
4574 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 4575 if ((long) section->sh_offset == section->sh_offset)
4576 printf (" %8.8lx", (unsigned long) section->sh_offset);
4577 else
4578 {
4579 printf (" ");
4580 print_vma (section->sh_offset, LONG_HEX);
4581 }
f7a99963
NC		 4582 printf ("\n ");
4583 print_vma (section->sh_size, LONG_HEX);
4584 printf (" ");
4585 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 4586
d1133906 4587 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 4588
72de5009
AM		 4589 printf (" %2u %3u %lu\n",
4590 section->sh_link,
4591 section->sh_info,
f7a99963
NC		 4592 (unsigned long) section->sh_addralign);
4593 }
5477e8a0
L		 4594
4595 if (do_section_details)
4596 printf (" %s\n", get_elf_section_flags (section->sh_flags));
252b5132
RH		 4597 }
4598
5477e8a0
L		 4599 if (!do_section_details)
4600 printf (_("Key to Flags:\n\
e3c8793a
NC		 4601 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4602 I (info), L (link order), G (group), x (unknown)\n\
4603 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
d1133906 4604
252b5132
RH		 4605 return 1;
4606}
4607
f5842774
L		 4608static const char *
4609get_group_flags (unsigned int flags)
4610{
4611 static char buff[32];
4612 switch (flags)
4613 {
4614 case GRP_COMDAT:
4615 return "COMDAT";
4616
4617 default:
e9e44622 4618 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x]"), flags);
f5842774
L		 4619 break;
4620 }
4621 return buff;
4622}
4623
4624static int
2cf0635d 4625process_section_groups (FILE * file)
f5842774 4626{
2cf0635d 4627 Elf_Internal_Shdr * section;
f5842774 4628 unsigned int i;
2cf0635d
NC		 4629 struct group * group;
4630 Elf_Internal_Shdr * symtab_sec;
4631 Elf_Internal_Shdr * strtab_sec;
4632 Elf_Internal_Sym * symtab;
4633 char * strtab;
c256ffe7 4634 size_t strtab_size;
d1f5c6e3
L		 4635
4636 /* Don't process section groups unless needed. */
4637 if (!do_unwind && !do_section_groups)
4638 return 1;
f5842774
L		 4639
4640 if (elf_header.e_shnum == 0)
4641 {
4642 if (do_section_groups)
d1f5c6e3 4643 printf (_("\nThere are no sections in this file.\n"));
f5842774
L		 4644
4645 return 1;
4646 }
4647
4648 if (section_headers == NULL)
4649 {
4650 error (_("Section headers are not available!\n"));
4651 abort ();
4652 }
4653
3f5e193b
NC		 4654 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
4655 sizeof (struct group *));
e4b17d5c
L		 4656
4657 if (section_headers_groups == NULL)
4658 {
4659 error (_("Out of memory\n"));
4660 return 0;
4661 }
4662
f5842774 4663 /* Scan the sections for the group section. */
d1f5c6e3 4664 group_count = 0;
f5842774
L		 4665 for (i = 0, section = section_headers;
4666 i < elf_header.e_shnum;
4667 i++, section++)
e4b17d5c
L		 4668 if (section->sh_type == SHT_GROUP)
4669 group_count++;
4670
d1f5c6e3
L		 4671 if (group_count == 0)
4672 {
4673 if (do_section_groups)
4674 printf (_("\nThere are no section groups in this file.\n"));
4675
4676 return 1;
4677 }
4678
3f5e193b 4679 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 4680
4681 if (section_groups == NULL)
4682 {
4683 error (_("Out of memory\n"));
4684 return 0;
4685 }
4686
d1f5c6e3
L		 4687 symtab_sec = NULL;
4688 strtab_sec = NULL;
4689 symtab = NULL;
4690 strtab = NULL;
c256ffe7 4691 strtab_size = 0;
e4b17d5c
L		 4692 for (i = 0, section = section_headers, group = section_groups;
4693 i < elf_header.e_shnum;
4694 i++, section++)
f5842774
L		 4695 {
4696 if (section->sh_type == SHT_GROUP)
4697 {
2cf0635d
NC		 4698 char * name = SECTION_NAME (section);
4699 char * group_name;
4700 unsigned char * start;
4701 unsigned char * indices;
f5842774 4702 unsigned int entry, j, size;
2cf0635d
NC		 4703 Elf_Internal_Shdr * sec;
4704 Elf_Internal_Sym * sym;
f5842774
L		 4705
4706 /* Get the symbol table. */
4fbb74a6
AM		 4707 if (section->sh_link >= elf_header.e_shnum
4708 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 4709 != SHT_SYMTAB))
f5842774
L		 4710 {
4711 error (_("Bad sh_link in group section `%s'\n"), name);
4712 continue;
4713 }
d1f5c6e3
L		 4714
4715 if (symtab_sec != sec)
4716 {
4717 symtab_sec = sec;
4718 if (symtab)
4719 free (symtab);
4720 symtab = GET_ELF_SYMBOLS (file, symtab_sec);
4721 }
f5842774
L		 4722
4723 sym = symtab + section->sh_info;
4724
4725 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4726 {
4fbb74a6
AM		 4727 if (sym->st_shndx == 0
4728 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 4729 {
4730 error (_("Bad sh_info in group section `%s'\n"), name);
4731 continue;
4732 }
ba2685cc 4733
4fbb74a6 4734 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 4735 strtab_sec = NULL;
4736 if (strtab)
4737 free (strtab);
f5842774 4738 strtab = NULL;
c256ffe7 4739 strtab_size = 0;
f5842774
L		 4740 }
4741 else
4742 {
4743 /* Get the string table. */
4fbb74a6 4744 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 4745 {
4746 strtab_sec = NULL;
4747 if (strtab)
4748 free (strtab);
4749 strtab = NULL;
4750 strtab_size = 0;
4751 }
4752 else if (strtab_sec
4fbb74a6 4753 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 4754 {
4755 strtab_sec = sec;
4756 if (strtab)
4757 free (strtab);
3f5e193b
NC		 4758 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
4759 1, strtab_sec->sh_size,
4760 _("string table"));
c256ffe7 4761 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 4762 }
c256ffe7
JJ		 4763 group_name = sym->st_name < strtab_size
4764 ? strtab + sym->st_name : "<corrupt>";
f5842774
L		 4765 }
4766
3f5e193b
NC		 4767 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
4768 1, section->sh_size,
4769 _("section data"));
f5842774
L		 4770
4771 indices = start;
4772 size = (section->sh_size / section->sh_entsize) - 1;
4773 entry = byte_get (indices, 4);
4774 indices += 4;
e4b17d5c
L		 4775
4776 if (do_section_groups)
4777 {
391cb864
L		 4778 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4779 get_group_flags (entry), i, name, group_name, size);
ba2685cc 4780
e4b17d5c
L		 4781 printf (_(" [Index] Name\n"));
4782 }
4783
4784 group->group_index = i;
4785
f5842774
L		 4786 for (j = 0; j < size; j++)
4787 {
2cf0635d 4788 struct group_list * g;
e4b17d5c 4789
f5842774
L		 4790 entry = byte_get (indices, 4);
4791 indices += 4;
4792
4fbb74a6 4793 if (entry >= elf_header.e_shnum)
391cb864
L		 4794 {
4795 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4796 entry, i, elf_header.e_shnum - 1);
4797 continue;
4798 }
391cb864 4799
4fbb74a6 4800 if (section_headers_groups [entry] != NULL)
e4b17d5c 4801 {
d1f5c6e3
L		 4802 if (entry)
4803 {
391cb864
L		 4804 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4805 entry, i,
4fbb74a6 4806 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 4807 continue;
4808 }
4809 else
4810 {
4811 /* Intel C/C++ compiler may put section 0 in a
4812 section group. We just warn it the first time
4813 and ignore it afterwards. */
4814 static int warned = 0;
4815 if (!warned)
4816 {
4817 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 4818 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 4819 warned++;
4820 }
4821 }
e4b17d5c
L		 4822 }
4823
4fbb74a6 4824 section_headers_groups [entry] = group;
e4b17d5c
L		 4825
4826 if (do_section_groups)
4827 {
4fbb74a6 4828 sec = section_headers + entry;
c256ffe7 4829 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
ba2685cc
AM		 4830 }
4831
3f5e193b 4832 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 4833 g->section_index = entry;
4834 g->next = group->root;
4835 group->root = g;
f5842774
L		 4836 }
4837
f5842774
L		 4838 if (start)
4839 free (start);
e4b17d5c
L		 4840
4841 group++;
f5842774
L		 4842 }
4843 }
4844
d1f5c6e3
L		 4845 if (symtab)
4846 free (symtab);
4847 if (strtab)
4848 free (strtab);
f5842774
L		 4849 return 1;
4850}
4851
85b1c36d 4852static struct
566b0d53 4853{
2cf0635d 4854 const char * name;
566b0d53
L		 4855 int reloc;
4856 int size;
4857 int rela;
4858} dynamic_relocations [] =
4859{
4860 { "REL", DT_REL, DT_RELSZ, FALSE },
4861 { "RELA", DT_RELA, DT_RELASZ, TRUE },
4862 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
4863};
4864
252b5132 4865/* Process the reloc section. */
18bd398b 4866
252b5132 4867static int
2cf0635d 4868process_relocs (FILE * file)
252b5132 4869{
b34976b6
AM		 4870 unsigned long rel_size;
4871 unsigned long rel_offset;
252b5132
RH		 4872
4873
4874 if (!do_reloc)
4875 return 1;
4876
4877 if (do_using_dynamic)
4878 {
566b0d53 4879 int is_rela;
2cf0635d 4880 const char * name;
566b0d53
L		 4881 int has_dynamic_reloc;
4882 unsigned int i;
0de14b54 4883
566b0d53 4884 has_dynamic_reloc = 0;
252b5132 4885
566b0d53 4886 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 4887 {
566b0d53
L		 4888 is_rela = dynamic_relocations [i].rela;
4889 name = dynamic_relocations [i].name;
4890 rel_size = dynamic_info [dynamic_relocations [i].size];
4891 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 4892
566b0d53
L		 4893 has_dynamic_reloc |= rel_size;
4894
4895 if (is_rela == UNKNOWN)
aa903cfb 4896 {
566b0d53
L		 4897 if (dynamic_relocations [i].reloc == DT_JMPREL)
4898 switch (dynamic_info[DT_PLTREL])
4899 {
4900 case DT_REL:
4901 is_rela = FALSE;
4902 break;
4903 case DT_RELA:
4904 is_rela = TRUE;
4905 break;
4906 }
aa903cfb 4907 }
252b5132 4908
566b0d53
L		 4909 if (rel_size)
4910 {
4911 printf
4912 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4913 name, rel_offset, rel_size);
252b5132 4914
d93f0186
NC		 4915 dump_relocations (file,
4916 offset_from_vma (file, rel_offset, rel_size),
4917 rel_size,
566b0d53 4918 dynamic_symbols, num_dynamic_syms,
d79b3d50 4919 dynamic_strings, dynamic_strings_length, is_rela);
566b0d53 4920 }
252b5132 4921 }
566b0d53
L		 4922
4923 if (! has_dynamic_reloc)
252b5132
RH		 4924 printf (_("\nThere are no dynamic relocations in this file.\n"));
4925 }
4926 else
4927 {
2cf0635d 4928 Elf_Internal_Shdr * section;
b34976b6
AM		 4929 unsigned long i;
4930 int found = 0;
252b5132
RH		 4931
4932 for (i = 0, section = section_headers;
4933 i < elf_header.e_shnum;
b34976b6 4934 i++, section++)
252b5132
RH		 4935 {
4936 if ( section->sh_type != SHT_RELA
4937 && section->sh_type != SHT_REL)
4938 continue;
4939
4940 rel_offset = section->sh_offset;
4941 rel_size = section->sh_size;
4942
4943 if (rel_size)
4944 {
2cf0635d 4945 Elf_Internal_Shdr * strsec;
b34976b6 4946 int is_rela;
103f02d3 4947
252b5132
RH		 4948 printf (_("\nRelocation section "));
4949
4950 if (string_table == NULL)
19936277 4951 printf ("%d", section->sh_name);
252b5132 4952 else
3a1a2036 4953 printf (_("'%s'"), SECTION_NAME (section));
252b5132
RH		 4954
4955 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4956 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
4957
d79b3d50
NC		 4958 is_rela = section->sh_type == SHT_RELA;
4959
4fbb74a6
AM		 4960 if (section->sh_link != 0
4961 && section->sh_link < elf_header.e_shnum)
af3fc3bc 4962 {
2cf0635d
NC		 4963 Elf_Internal_Shdr * symsec;
4964 Elf_Internal_Sym * symtab;
d79b3d50 4965 unsigned long nsyms;
c256ffe7 4966 unsigned long strtablen = 0;
2cf0635d 4967 char * strtab = NULL;
57346661 4968
4fbb74a6 4969 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 4970 if (symsec->sh_type != SHT_SYMTAB
4971 && symsec->sh_type != SHT_DYNSYM)
4972 continue;
4973
af3fc3bc 4974 nsyms = symsec->sh_size / symsec->sh_entsize;
9ad5cbcf 4975 symtab = GET_ELF_SYMBOLS (file, symsec);
252b5132 4976
af3fc3bc
AM		 4977 if (symtab == NULL)
4978 continue;
252b5132 4979
4fbb74a6
AM		 4980 if (symsec->sh_link != 0
4981 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 4982 {
4fbb74a6 4983 strsec = section_headers + symsec->sh_link;
103f02d3 4984
3f5e193b
NC		 4985 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
4986 1, strsec->sh_size,
4987 _("string table"));
c256ffe7
JJ		 4988 strtablen = strtab == NULL ? 0 : strsec->sh_size;
4989 }
252b5132 4990
d79b3d50
NC		 4991 dump_relocations (file, rel_offset, rel_size,
4992 symtab, nsyms, strtab, strtablen, is_rela);
4993 if (strtab)
4994 free (strtab);
4995 free (symtab);
4996 }
4997 else
4998 dump_relocations (file, rel_offset, rel_size,
4999 NULL, 0, NULL, 0, is_rela);
252b5132
RH		 5000
5001 found = 1;
5002 }
5003 }
5004
5005 if (! found)
5006 printf (_("\nThere are no relocations in this file.\n"));
5007 }
5008
5009 return 1;
5010}
5011
57346661
AM		 5012/* Process the unwind section. */
5013
4d6ed7c8
NC		 5014#include "unwind-ia64.h"
5015
5016/* An absolute address consists of a section and an offset. If the
5017 section is NULL, the offset itself is the address, otherwise, the
5018 address equals to LOAD_ADDRESS(section) + offset. */
5019
5020struct absaddr
5021 {
5022 unsigned short section;
5023 bfd_vma offset;
5024 };
5025
1949de15
L		 5026#define ABSADDR(a) \
5027 ((a).section \
5028 ? section_headers [(a).section].sh_addr + (a).offset \
5029 : (a).offset)
5030
3f5e193b
NC		 5031struct ia64_unw_table_entry
5032 {
5033 struct absaddr start;
5034 struct absaddr end;
5035 struct absaddr info;
5036 };
5037
57346661 5038struct ia64_unw_aux_info
4d6ed7c8 5039 {
3f5e193b
NC		 5040
5041 struct ia64_unw_table_entry *table; /* Unwind table. */
b34976b6 5042 unsigned long table_len; /* Length of unwind table. */
2cf0635d 5043 unsigned char * info; /* Unwind info. */
b34976b6
AM		 5044 unsigned long info_size; /* Size of unwind info. */
5045 bfd_vma info_addr; /* starting address of unwind info. */
5046 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 5047 Elf_Internal_Sym * symtab; /* The symbol table. */
b34976b6 5048 unsigned long nsyms; /* Number of symbols. */
2cf0635d 5049 char * strtab; /* The string table. */
b34976b6 5050 unsigned long strtab_size; /* Size of string table. */
4d6ed7c8
NC		 5051 };
5052
4d6ed7c8 5053static void
2cf0635d 5054find_symbol_for_address (Elf_Internal_Sym * symtab,
57346661 5055 unsigned long nsyms,
2cf0635d 5056 const char * strtab,
57346661 5057 unsigned long strtab_size,
d3ba0551 5058 struct absaddr addr,
2cf0635d
NC		 5059 const char ** symname,
5060 bfd_vma * offset)
4d6ed7c8 5061{
d3ba0551 5062 bfd_vma dist = 0x100000;
2cf0635d
NC		 5063 Elf_Internal_Sym * sym;
5064 Elf_Internal_Sym * best = NULL;
4d6ed7c8
NC		 5065 unsigned long i;
5066
57346661 5067 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4d6ed7c8
NC		 5068 {
5069 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5070 && sym->st_name != 0
5071 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
5072 && addr.offset >= sym->st_value
5073 && addr.offset - sym->st_value < dist)
5074 {
5075 best = sym;
5076 dist = addr.offset - sym->st_value;
5077 if (!dist)
5078 break;
5079 }
5080 }
5081 if (best)
5082 {
57346661
AM		 5083 *symname = (best->st_name >= strtab_size
5084 ? "<corrupt>" : strtab + best->st_name);
4d6ed7c8
NC		 5085 *offset = dist;
5086 return;
5087 }
5088 *symname = NULL;
5089 *offset = addr.offset;
5090}
5091
5092static void
2cf0635d 5093dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 5094{
2cf0635d 5095 struct ia64_unw_table_entry * tp;
4d6ed7c8 5096 int in_body;
7036c0e1 5097
4d6ed7c8
NC		 5098 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5099 {
5100 bfd_vma stamp;
5101 bfd_vma offset;
2cf0635d
NC		 5102 const unsigned char * dp;
5103 const unsigned char * head;
5104 const char * procname;
4d6ed7c8 5105
57346661
AM		 5106 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5107 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 5108
5109 fputs ("\n<", stdout);
5110
5111 if (procname)
5112 {
5113 fputs (procname, stdout);
5114
5115 if (offset)
5116 printf ("+%lx", (unsigned long) offset);
5117 }
5118
5119 fputs (">: [", stdout);
5120 print_vma (tp->start.offset, PREFIX_HEX);
5121 fputc ('-', stdout);
5122 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 5123 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 5124 (unsigned long) (tp->info.offset - aux->seg_base));
5125
1949de15 5126 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 5127 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 5128
86f55779 5129 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 5130 (unsigned) UNW_VER (stamp),
5131 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5132 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5133 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 5134 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 5135
5136 if (UNW_VER (stamp) != 1)
5137 {
5138 printf ("\tUnknown version.\n");
5139 continue;
5140 }
5141
5142 in_body = 0;
89fac5e3 5143 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
4d6ed7c8
NC		 5144 dp = unw_decode (dp, in_body, & in_body);
5145 }
5146}
5147
5148static int
2cf0635d
NC		 5149slurp_ia64_unwind_table (FILE * file,
5150 struct ia64_unw_aux_info * aux,
5151 Elf_Internal_Shdr * sec)
4d6ed7c8 5152{
89fac5e3 5153 unsigned long size, nrelas, i;
2cf0635d
NC		 5154 Elf_Internal_Phdr * seg;
5155 struct ia64_unw_table_entry * tep;
5156 Elf_Internal_Shdr * relsec;
5157 Elf_Internal_Rela * rela;
5158 Elf_Internal_Rela * rp;
5159 unsigned char * table;
5160 unsigned char * tp;
5161 Elf_Internal_Sym * sym;
5162 const char * relname;
4d6ed7c8 5163
4d6ed7c8
NC		 5164 /* First, find the starting address of the segment that includes
5165 this section: */
5166
5167 if (elf_header.e_phnum)
5168 {
d93f0186 5169 if (! get_program_headers (file))
4d6ed7c8 5170 return 0;
4d6ed7c8 5171
d93f0186
NC		 5172 for (seg = program_headers;
5173 seg < program_headers + elf_header.e_phnum;
5174 ++seg)
4d6ed7c8
NC		 5175 {
5176 if (seg->p_type != PT_LOAD)
5177 continue;
5178
5179 if (sec->sh_addr >= seg->p_vaddr
5180 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5181 {
5182 aux->seg_base = seg->p_vaddr;
5183 break;
5184 }
5185 }
4d6ed7c8
NC		 5186 }
5187
5188 /* Second, build the unwind table from the contents of the unwind section: */
5189 size = sec->sh_size;
3f5e193b
NC		 5190 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5191 _("unwind table"));
a6e9f9df
AM		 5192 if (!table)
5193 return 0;
4d6ed7c8 5194
3f5e193b
NC		 5195 aux->table = (struct ia64_unw_table_entry *)
5196 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
89fac5e3 5197 tep = aux->table;
c6a0c689 5198 for (tp = table; tp < table + size; ++tep)
4d6ed7c8
NC		 5199 {
5200 tep->start.section = SHN_UNDEF;
5201 tep->end.section = SHN_UNDEF;
5202 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 5203 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5204 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5205 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 5206 tep->start.offset += aux->seg_base;
5207 tep->end.offset += aux->seg_base;
5208 tep->info.offset += aux->seg_base;
5209 }
5210 free (table);
5211
41e92641 5212 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 5213 for (relsec = section_headers;
5214 relsec < section_headers + elf_header.e_shnum;
5215 ++relsec)
5216 {
5217 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 5218 || relsec->sh_info >= elf_header.e_shnum
5219 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 5220 continue;
5221
5222 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5223 & rela, & nrelas))
5224 return 0;
5225
5226 for (rp = rela; rp < rela + nrelas; ++rp)
5227 {
aca88567
NC		 5228 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5229 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 5230
0112cd26 5231 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 5232 {
e5fb9629 5233 warn (_("Skipping unexpected relocation type %s\n"), relname);
4d6ed7c8
NC		 5234 continue;
5235 }
5236
89fac5e3 5237 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 5238
89fac5e3 5239 switch (rp->r_offset/eh_addr_size % 3)
4d6ed7c8
NC		 5240 {
5241 case 0:
5242 aux->table[i].start.section = sym->st_shndx;
1ffa9a18 5243 aux->table[i].start.offset += rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5244 break;
5245 case 1:
5246 aux->table[i].end.section = sym->st_shndx;
1ffa9a18 5247 aux->table[i].end.offset += rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5248 break;
5249 case 2:
5250 aux->table[i].info.section = sym->st_shndx;
1ffa9a18 5251 aux->table[i].info.offset += rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5252 break;
5253 default:
5254 break;
5255 }
5256 }
5257
5258 free (rela);
5259 }
5260
89fac5e3 5261 aux->table_len = size / (3 * eh_addr_size);
4d6ed7c8
NC		 5262 return 1;
5263}
5264
5265static int
2cf0635d 5266ia64_process_unwind (FILE * file)
4d6ed7c8 5267{
2cf0635d
NC		 5268 Elf_Internal_Shdr * sec;
5269 Elf_Internal_Shdr * unwsec = NULL;
5270 Elf_Internal_Shdr * strsec;
89fac5e3 5271 unsigned long i, unwcount = 0, unwstart = 0;
57346661 5272 struct ia64_unw_aux_info aux;
f1467e33 5273
4d6ed7c8
NC		 5274 memset (& aux, 0, sizeof (aux));
5275
4d6ed7c8
NC		 5276 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5277 {
c256ffe7 5278 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 5279 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8
NC		 5280 {
5281 aux.nsyms = sec->sh_size / sec->sh_entsize;
9ad5cbcf 5282 aux.symtab = GET_ELF_SYMBOLS (file, sec);
4d6ed7c8 5283
4fbb74a6 5284 strsec = section_headers + sec->sh_link;
3f5e193b
NC		 5285 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5286 1, strsec->sh_size,
5287 _("string table"));
c256ffe7 5288 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 5289 }
5290 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 5291 unwcount++;
5292 }
5293
5294 if (!unwcount)
5295 printf (_("\nThere are no unwind sections in this file.\n"));
5296
5297 while (unwcount-- > 0)
5298 {
2cf0635d 5299 char * suffix;
579f31ac
JJ		 5300 size_t len, len2;
5301
5302 for (i = unwstart, sec = section_headers + unwstart;
5303 i < elf_header.e_shnum; ++i, ++sec)
5304 if (sec->sh_type == SHT_IA_64_UNWIND)
5305 {
5306 unwsec = sec;
5307 break;
5308 }
5309
5310 unwstart = i + 1;
5311 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
5312
e4b17d5c
L		 5313 if ((unwsec->sh_flags & SHF_GROUP) != 0)
5314 {
5315 /* We need to find which section group it is in. */
2cf0635d 5316 struct group_list * g = section_headers_groups [i]->root;
e4b17d5c
L		 5317
5318 for (; g != NULL; g = g->next)
5319 {
4fbb74a6 5320 sec = section_headers + g->section_index;
18bd398b
NC		 5321
5322 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
57346661 5323 break;
e4b17d5c
L		 5324 }
5325
5326 if (g == NULL)
5327 i = elf_header.e_shnum;
5328 }
18bd398b 5329 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 5330 {
18bd398b 5331 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 5332 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
5333 suffix = SECTION_NAME (unwsec) + len;
5334 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5335 ++i, ++sec)
18bd398b
NC		 5336 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
5337 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 5338 break;
5339 }
5340 else
5341 {
5342 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 5343 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 5344 len = sizeof (ELF_STRING_ia64_unwind) - 1;
5345 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
5346 suffix = "";
18bd398b 5347 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 5348 suffix = SECTION_NAME (unwsec) + len;
5349 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5350 ++i, ++sec)
18bd398b
NC		 5351 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
5352 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 5353 break;
5354 }
5355
5356 if (i == elf_header.e_shnum)
5357 {
5358 printf (_("\nCould not find unwind info section for "));
5359
5360 if (string_table == NULL)
5361 printf ("%d", unwsec->sh_name);
5362 else
3a1a2036 5363 printf (_("'%s'"), SECTION_NAME (unwsec));
579f31ac
JJ		 5364 }
5365 else
4d6ed7c8
NC		 5366 {
5367 aux.info_size = sec->sh_size;
5368 aux.info_addr = sec->sh_addr;
3f5e193b
NC		 5369 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
5370 aux.info_size,
5371 _("unwind info"));
4d6ed7c8 5372
579f31ac 5373 printf (_("\nUnwind section "));
4d6ed7c8 5374
579f31ac
JJ		 5375 if (string_table == NULL)
5376 printf ("%d", unwsec->sh_name);
5377 else
3a1a2036 5378 printf (_("'%s'"), SECTION_NAME (unwsec));
4d6ed7c8 5379
579f31ac 5380 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 5381 (unsigned long) unwsec->sh_offset,
89fac5e3 5382 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 5383
579f31ac 5384 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4d6ed7c8 5385
579f31ac
JJ		 5386 if (aux.table_len > 0)
5387 dump_ia64_unwind (& aux);
5388
5389 if (aux.table)
5390 free ((char *) aux.table);
5391 if (aux.info)
5392 free ((char *) aux.info);
5393 aux.table = NULL;
5394 aux.info = NULL;
5395 }
4d6ed7c8 5396 }
4d6ed7c8 5397
4d6ed7c8
NC		 5398 if (aux.symtab)
5399 free (aux.symtab);
5400 if (aux.strtab)
5401 free ((char *) aux.strtab);
5402
5403 return 1;
5404}
5405
3f5e193b
NC		 5406struct hppa_unw_table_entry
5407 {
5408 struct absaddr start;
5409 struct absaddr end;
5410 unsigned int Cannot_unwind:1; /* 0 */
5411 unsigned int Millicode:1; /* 1 */
5412 unsigned int Millicode_save_sr0:1; /* 2 */
5413 unsigned int Region_description:2; /* 3..4 */
5414 unsigned int reserved1:1; /* 5 */
5415 unsigned int Entry_SR:1; /* 6 */
5416 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
5417 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
5418 unsigned int Args_stored:1; /* 16 */
5419 unsigned int Variable_Frame:1; /* 17 */
5420 unsigned int Separate_Package_Body:1; /* 18 */
5421 unsigned int Frame_Extension_Millicode:1; /* 19 */
5422 unsigned int Stack_Overflow_Check:1; /* 20 */
5423 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
5424 unsigned int Ada_Region:1; /* 22 */
5425 unsigned int cxx_info:1; /* 23 */
5426 unsigned int cxx_try_catch:1; /* 24 */
5427 unsigned int sched_entry_seq:1; /* 25 */
5428 unsigned int reserved2:1; /* 26 */
5429 unsigned int Save_SP:1; /* 27 */
5430 unsigned int Save_RP:1; /* 28 */
5431 unsigned int Save_MRP_in_frame:1; /* 29 */
5432 unsigned int extn_ptr_defined:1; /* 30 */
5433 unsigned int Cleanup_defined:1; /* 31 */
5434
5435 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
5436 unsigned int HP_UX_interrupt_marker:1; /* 1 */
5437 unsigned int Large_frame:1; /* 2 */
5438 unsigned int Pseudo_SP_Set:1; /* 3 */
5439 unsigned int reserved4:1; /* 4 */
5440 unsigned int Total_frame_size:27; /* 5..31 */
5441 };
5442
57346661
AM		 5443struct hppa_unw_aux_info
5444 {
3f5e193b 5445 struct hppa_unw_table_entry *table; /* Unwind table. */
57346661
AM		 5446 unsigned long table_len; /* Length of unwind table. */
5447 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 5448 Elf_Internal_Sym * symtab; /* The symbol table. */
57346661 5449 unsigned long nsyms; /* Number of symbols. */
2cf0635d 5450 char * strtab; /* The string table. */
57346661
AM		 5451 unsigned long strtab_size; /* Size of string table. */
5452 };
5453
5454static void
2cf0635d 5455dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 5456{
2cf0635d 5457 struct hppa_unw_table_entry * tp;
57346661 5458
57346661
AM		 5459 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5460 {
5461 bfd_vma offset;
2cf0635d 5462 const char * procname;
57346661
AM		 5463
5464 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5465 aux->strtab_size, tp->start, &procname,
5466 &offset);
5467
5468 fputs ("\n<", stdout);
5469
5470 if (procname)
5471 {
5472 fputs (procname, stdout);
5473
5474 if (offset)
5475 printf ("+%lx", (unsigned long) offset);
5476 }
5477
5478 fputs (">: [", stdout);
5479 print_vma (tp->start.offset, PREFIX_HEX);
5480 fputc ('-', stdout);
5481 print_vma (tp->end.offset, PREFIX_HEX);
5482 printf ("]\n\t");
5483
18bd398b
NC		 5484#define PF(_m) if (tp->_m) printf (#_m " ");
5485#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 5486 PF(Cannot_unwind);
5487 PF(Millicode);
5488 PF(Millicode_save_sr0);
18bd398b 5489 /* PV(Region_description); */
57346661
AM		 5490 PF(Entry_SR);
5491 PV(Entry_FR);
5492 PV(Entry_GR);
5493 PF(Args_stored);
5494 PF(Variable_Frame);
5495 PF(Separate_Package_Body);
5496 PF(Frame_Extension_Millicode);
5497 PF(Stack_Overflow_Check);
5498 PF(Two_Instruction_SP_Increment);
5499 PF(Ada_Region);
5500 PF(cxx_info);
5501 PF(cxx_try_catch);
5502 PF(sched_entry_seq);
5503 PF(Save_SP);
5504 PF(Save_RP);
5505 PF(Save_MRP_in_frame);
5506 PF(extn_ptr_defined);
5507 PF(Cleanup_defined);
5508 PF(MPE_XL_interrupt_marker);
5509 PF(HP_UX_interrupt_marker);
5510 PF(Large_frame);
5511 PF(Pseudo_SP_Set);
5512 PV(Total_frame_size);
5513#undef PF
5514#undef PV
5515 }
5516
18bd398b 5517 printf ("\n");
57346661
AM		 5518}
5519
5520static int
2cf0635d
NC		 5521slurp_hppa_unwind_table (FILE * file,
5522 struct hppa_unw_aux_info * aux,
5523 Elf_Internal_Shdr * sec)
57346661 5524{
1c0751b2 5525 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 5526 Elf_Internal_Phdr * seg;
5527 struct hppa_unw_table_entry * tep;
5528 Elf_Internal_Shdr * relsec;
5529 Elf_Internal_Rela * rela;
5530 Elf_Internal_Rela * rp;
5531 unsigned char * table;
5532 unsigned char * tp;
5533 Elf_Internal_Sym * sym;
5534 const char * relname;
57346661 5535
57346661
AM		 5536 /* First, find the starting address of the segment that includes
5537 this section. */
5538
5539 if (elf_header.e_phnum)
5540 {
5541 if (! get_program_headers (file))
5542 return 0;
5543
5544 for (seg = program_headers;
5545 seg < program_headers + elf_header.e_phnum;
5546 ++seg)
5547 {
5548 if (seg->p_type != PT_LOAD)
5549 continue;
5550
5551 if (sec->sh_addr >= seg->p_vaddr
5552 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5553 {
5554 aux->seg_base = seg->p_vaddr;
5555 break;
5556 }
5557 }
5558 }
5559
5560 /* Second, build the unwind table from the contents of the unwind
5561 section. */
5562 size = sec->sh_size;
3f5e193b
NC		 5563 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5564 _("unwind table"));
57346661
AM		 5565 if (!table)
5566 return 0;
5567
1c0751b2
DA		 5568 unw_ent_size = 16;
5569 nentries = size / unw_ent_size;
5570 size = unw_ent_size * nentries;
57346661 5571
3f5e193b
NC		 5572 tep = aux->table = (struct hppa_unw_table_entry *)
5573 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 5574
1c0751b2 5575 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 5576 {
5577 unsigned int tmp1, tmp2;
5578
5579 tep->start.section = SHN_UNDEF;
5580 tep->end.section = SHN_UNDEF;
5581
1c0751b2
DA		 5582 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
5583 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
5584 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
5585 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
5586
5587 tep->start.offset += aux->seg_base;
5588 tep->end.offset += aux->seg_base;
57346661
AM		 5589
5590 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
5591 tep->Millicode = (tmp1 >> 30) & 0x1;
5592 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
5593 tep->Region_description = (tmp1 >> 27) & 0x3;
5594 tep->reserved1 = (tmp1 >> 26) & 0x1;
5595 tep->Entry_SR = (tmp1 >> 25) & 0x1;
5596 tep->Entry_FR = (tmp1 >> 21) & 0xf;
5597 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
5598 tep->Args_stored = (tmp1 >> 15) & 0x1;
5599 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
5600 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
5601 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
5602 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
5603 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
5604 tep->Ada_Region = (tmp1 >> 9) & 0x1;
5605 tep->cxx_info = (tmp1 >> 8) & 0x1;
5606 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
5607 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
5608 tep->reserved2 = (tmp1 >> 5) & 0x1;
5609 tep->Save_SP = (tmp1 >> 4) & 0x1;
5610 tep->Save_RP = (tmp1 >> 3) & 0x1;
5611 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
5612 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
5613 tep->Cleanup_defined = tmp1 & 0x1;
5614
5615 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
5616 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
5617 tep->Large_frame = (tmp2 >> 29) & 0x1;
5618 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
5619 tep->reserved4 = (tmp2 >> 27) & 0x1;
5620 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 5621 }
5622 free (table);
5623
5624 /* Third, apply any relocations to the unwind table. */
57346661
AM		 5625 for (relsec = section_headers;
5626 relsec < section_headers + elf_header.e_shnum;
5627 ++relsec)
5628 {
5629 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 5630 || relsec->sh_info >= elf_header.e_shnum
5631 || section_headers + relsec->sh_info != sec)
57346661
AM		 5632 continue;
5633
5634 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5635 & rela, & nrelas))
5636 return 0;
5637
5638 for (rp = rela; rp < rela + nrelas; ++rp)
5639 {
aca88567
NC		 5640 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
5641 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 5642
5643 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 5644 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 5645 {
5646 warn (_("Skipping unexpected relocation type %s\n"), relname);
5647 continue;
5648 }
5649
5650 i = rp->r_offset / unw_ent_size;
5651
89fac5e3 5652 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 5653 {
5654 case 0:
5655 aux->table[i].start.section = sym->st_shndx;
1e456d54 5656 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 5657 break;
5658 case 1:
5659 aux->table[i].end.section = sym->st_shndx;
1e456d54 5660 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 5661 break;
5662 default:
5663 break;
5664 }
5665 }
5666
5667 free (rela);
5668 }
5669
1c0751b2 5670 aux->table_len = nentries;
57346661
AM		 5671
5672 return 1;
5673}
5674
5675static int
2cf0635d 5676hppa_process_unwind (FILE * file)
57346661 5677{
57346661 5678 struct hppa_unw_aux_info aux;
2cf0635d
NC		 5679 Elf_Internal_Shdr * unwsec = NULL;
5680 Elf_Internal_Shdr * strsec;
5681 Elf_Internal_Shdr * sec;
18bd398b 5682 unsigned long i;
57346661
AM		 5683
5684 memset (& aux, 0, sizeof (aux));
5685
c256ffe7
JJ		 5686 if (string_table == NULL)
5687 return 1;
57346661
AM		 5688
5689 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5690 {
c256ffe7 5691 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 5692 && sec->sh_link < elf_header.e_shnum)
57346661
AM		 5693 {
5694 aux.nsyms = sec->sh_size / sec->sh_entsize;
5695 aux.symtab = GET_ELF_SYMBOLS (file, sec);
5696
4fbb74a6 5697 strsec = section_headers + sec->sh_link;
3f5e193b
NC		 5698 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5699 1, strsec->sh_size,
5700 _("string table"));
c256ffe7 5701 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 5702 }
18bd398b 5703 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 5704 unwsec = sec;
5705 }
5706
5707 if (!unwsec)
5708 printf (_("\nThere are no unwind sections in this file.\n"));
5709
5710 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5711 {
18bd398b 5712 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 5713 {
57346661
AM		 5714 printf (_("\nUnwind section "));
5715 printf (_("'%s'"), SECTION_NAME (sec));
5716
5717 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5718 (unsigned long) sec->sh_offset,
89fac5e3 5719 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 5720
5721 slurp_hppa_unwind_table (file, &aux, sec);
5722 if (aux.table_len > 0)
5723 dump_hppa_unwind (&aux);
5724
5725 if (aux.table)
5726 free ((char *) aux.table);
5727 aux.table = NULL;
5728 }
5729 }
5730
5731 if (aux.symtab)
5732 free (aux.symtab);
5733 if (aux.strtab)
5734 free ((char *) aux.strtab);
5735
5736 return 1;
5737}
5738
5739static int
2cf0635d 5740process_unwind (FILE * file)
57346661 5741{
2cf0635d
NC		 5742 struct unwind_handler
5743 {
57346661 5744 int machtype;
2cf0635d
NC		 5745 int (* handler)(FILE *);
5746 } handlers[] =
5747 {
57346661
AM		 5748 { EM_IA_64, ia64_process_unwind },
5749 { EM_PARISC, hppa_process_unwind },
5750 { 0, 0 }
5751 };
5752 int i;
5753
5754 if (!do_unwind)
5755 return 1;
5756
5757 for (i = 0; handlers[i].handler != NULL; i++)
5758 if (elf_header.e_machine == handlers[i].machtype)
18bd398b 5759 return handlers[i].handler (file);
57346661
AM		 5760
5761 printf (_("\nThere are no unwind sections in this file.\n"));
5762 return 1;
5763}
5764
252b5132 5765static void
2cf0635d 5766dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 5767{
5768 switch (entry->d_tag)
5769 {
5770 case DT_MIPS_FLAGS:
5771 if (entry->d_un.d_val == 0)
5772 printf ("NONE\n");
5773 else
5774 {
5775 static const char * opts[] =
5776 {
5777 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5778 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5779 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5780 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5781 "RLD_ORDER_SAFE"
5782 };
5783 unsigned int cnt;
5784 int first = 1;
60bca95a 5785 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 5786 if (entry->d_un.d_val & (1 << cnt))
5787 {
5788 printf ("%s%s", first ? "" : " ", opts[cnt]);
5789 first = 0;
5790 }
5791 puts ("");
5792 }
5793 break;
103f02d3 5794
252b5132 5795 case DT_MIPS_IVERSION:
d79b3d50
NC		 5796 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
5797 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 5798 else
d79b3d50 5799 printf ("<corrupt: %ld>\n", (long) entry->d_un.d_ptr);
252b5132 5800 break;
103f02d3 5801
252b5132
RH		 5802 case DT_MIPS_TIME_STAMP:
5803 {
5804 char timebuf[20];
2cf0635d 5805 struct tm * tmp;
50da7a9c 5806
252b5132 5807 time_t time = entry->d_un.d_val;
50da7a9c 5808 tmp = gmtime (&time);
e9e44622
JJ		 5809 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
5810 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
5811 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
252b5132
RH		 5812 printf ("Time Stamp: %s\n", timebuf);
5813 }
5814 break;
103f02d3 5815
252b5132
RH		 5816 case DT_MIPS_RLD_VERSION:
5817 case DT_MIPS_LOCAL_GOTNO:
5818 case DT_MIPS_CONFLICTNO:
5819 case DT_MIPS_LIBLISTNO:
5820 case DT_MIPS_SYMTABNO:
5821 case DT_MIPS_UNREFEXTNO:
5822 case DT_MIPS_HIPAGENO:
5823 case DT_MIPS_DELTA_CLASS_NO:
5824 case DT_MIPS_DELTA_INSTANCE_NO:
5825 case DT_MIPS_DELTA_RELOC_NO:
5826 case DT_MIPS_DELTA_SYM_NO:
5827 case DT_MIPS_DELTA_CLASSSYM_NO:
5828 case DT_MIPS_COMPACT_SIZE:
5829 printf ("%ld\n", (long) entry->d_un.d_ptr);
5830 break;
103f02d3
UD		 5831
5832 default:
0af1713e 5833 printf ("%#lx\n", (unsigned long) entry->d_un.d_ptr);
103f02d3
UD		 5834 }
5835}
5836
5837
5838static void
2cf0635d 5839dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 5840{
5841 switch (entry->d_tag)
5842 {
5843 case DT_HP_DLD_FLAGS:
5844 {
5845 static struct
5846 {
5847 long int bit;
2cf0635d 5848 const char * str;
5e220199
NC		 5849 }
5850 flags[] =
5851 {
5852 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
5853 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
5854 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
5855 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
5856 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
5857 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
5858 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
5859 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
5860 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
5861 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 5862 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
5863 { DT_HP_GST, "HP_GST" },
5864 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
5865 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
5866 { DT_HP_NODELETE, "HP_NODELETE" },
5867 { DT_HP_GROUP, "HP_GROUP" },
5868 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 5869 };
103f02d3 5870 int first = 1;
5e220199 5871 size_t cnt;
f7a99963 5872 bfd_vma val = entry->d_un.d_val;
103f02d3 5873
60bca95a 5874 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 5875 if (val & flags[cnt].bit)
30800947
NC		 5876 {
5877 if (! first)
5878 putchar (' ');
5879 fputs (flags[cnt].str, stdout);
5880 first = 0;
5881 val ^= flags[cnt].bit;
5882 }
76da6bbe 5883
103f02d3 5884 if (val != 0 || first)
f7a99963
NC		 5885 {
5886 if (! first)
5887 putchar (' ');
5888 print_vma (val, HEX);
5889 }
103f02d3
UD		 5890 }
5891 break;
76da6bbe 5892
252b5132 5893 default:
f7a99963
NC		 5894 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5895 break;
252b5132 5896 }
35b1837e 5897 putchar ('\n');
252b5132
RH		 5898}
5899
ecc51f48 5900static void
2cf0635d 5901dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 5902{
5903 switch (entry->d_tag)
5904 {
0de14b54 5905 case DT_IA_64_PLT_RESERVE:
bdf4d63a 5906 /* First 3 slots reserved. */
ecc51f48
NC		 5907 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5908 printf (" -- ");
5909 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 5910 break;
5911
5912 default:
5913 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5914 break;
ecc51f48 5915 }
bdf4d63a 5916 putchar ('\n');
ecc51f48
NC		 5917}
5918
252b5132 5919static int
2cf0635d 5920get_32bit_dynamic_section (FILE * file)
252b5132 5921{
2cf0635d
NC		 5922 Elf32_External_Dyn * edyn;
5923 Elf32_External_Dyn * ext;
5924 Elf_Internal_Dyn * entry;
103f02d3 5925
3f5e193b
NC		 5926 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
5927 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 5928 if (!edyn)
5929 return 0;
103f02d3 5930
ba2685cc
AM		 5931/* SGI's ELF has more than one section in the DYNAMIC segment, and we
5932 might not have the luxury of section headers. Look for the DT_NULL
5933 terminator to determine the number of entries. */
5934 for (ext = edyn, dynamic_nent = 0;
5935 (char *) ext < (char *) edyn + dynamic_size;
5936 ext++)
5937 {
5938 dynamic_nent++;
5939 if (BYTE_GET (ext->d_tag) == DT_NULL)
5940 break;
5941 }
252b5132 5942
3f5e193b
NC		 5943 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
5944 sizeof (* entry));
b2d38a17 5945 if (dynamic_section == NULL)
252b5132 5946 {
9ea033b2
NC		 5947 error (_("Out of memory\n"));
5948 free (edyn);
5949 return 0;
5950 }
252b5132 5951
fb514b26 5952 for (ext = edyn, entry = dynamic_section;
ba2685cc 5953 entry < dynamic_section + dynamic_nent;
fb514b26 5954 ext++, entry++)
9ea033b2 5955 {
fb514b26
AM		 5956 entry->d_tag = BYTE_GET (ext->d_tag);
5957 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 5958 }
5959
9ea033b2
NC		 5960 free (edyn);
5961
5962 return 1;
5963}
5964
5965static int
2cf0635d 5966get_64bit_dynamic_section (FILE * file)
9ea033b2 5967{
2cf0635d
NC		 5968 Elf64_External_Dyn * edyn;
5969 Elf64_External_Dyn * ext;
5970 Elf_Internal_Dyn * entry;
103f02d3 5971
3f5e193b
NC		 5972 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
5973 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 5974 if (!edyn)
5975 return 0;
103f02d3 5976
ba2685cc
AM		 5977/* SGI's ELF has more than one section in the DYNAMIC segment, and we
5978 might not have the luxury of section headers. Look for the DT_NULL
5979 terminator to determine the number of entries. */
5980 for (ext = edyn, dynamic_nent = 0;
5981 (char *) ext < (char *) edyn + dynamic_size;
5982 ext++)
5983 {
5984 dynamic_nent++;
66543521 5985 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 5986 break;
5987 }
252b5132 5988
3f5e193b
NC		 5989 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
5990 sizeof (* entry));
b2d38a17 5991 if (dynamic_section == NULL)
252b5132
RH		 5992 {
5993 error (_("Out of memory\n"));
5994 free (edyn);
5995 return 0;
5996 }
5997
fb514b26 5998 for (ext = edyn, entry = dynamic_section;
ba2685cc 5999 entry < dynamic_section + dynamic_nent;
fb514b26 6000 ext++, entry++)
252b5132 6001 {
66543521
AM		 6002 entry->d_tag = BYTE_GET (ext->d_tag);
6003 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 6004 }
6005
6006 free (edyn);
6007
9ea033b2
NC		 6008 return 1;
6009}
6010
e9e44622
JJ		 6011static void
6012print_dynamic_flags (bfd_vma flags)
d1133906 6013{
e9e44622 6014 int first = 1;
13ae64f3 6015
d1133906
NC		 6016 while (flags)
6017 {
6018 bfd_vma flag;
6019
6020 flag = flags & - flags;
6021 flags &= ~ flag;
6022
e9e44622
JJ		 6023 if (first)
6024 first = 0;
6025 else
6026 putc (' ', stdout);
13ae64f3 6027
d1133906
NC		 6028 switch (flag)
6029 {
e9e44622
JJ		 6030 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
6031 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
6032 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
6033 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
6034 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
6035 default: fputs ("unknown", stdout); break;
d1133906
NC		 6036 }
6037 }
e9e44622 6038 puts ("");
d1133906
NC		 6039}
6040
b2d38a17
NC		 6041/* Parse and display the contents of the dynamic section. */
6042
9ea033b2 6043static int
2cf0635d 6044process_dynamic_section (FILE * file)
9ea033b2 6045{
2cf0635d 6046 Elf_Internal_Dyn * entry;
9ea033b2
NC		 6047
6048 if (dynamic_size == 0)
6049 {
6050 if (do_dynamic)
b2d38a17 6051 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 6052
6053 return 1;
6054 }
6055
6056 if (is_32bit_elf)
6057 {
b2d38a17 6058 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 6059 return 0;
6060 }
b2d38a17 6061 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 6062 return 0;
6063
252b5132
RH		 6064 /* Find the appropriate symbol table. */
6065 if (dynamic_symbols == NULL)
6066 {
86dba8ee
AM		 6067 for (entry = dynamic_section;
6068 entry < dynamic_section + dynamic_nent;
6069 ++entry)
252b5132 6070 {
c8286bd1 6071 Elf_Internal_Shdr section;
252b5132
RH		 6072
6073 if (entry->d_tag != DT_SYMTAB)
6074 continue;
6075
6076 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
6077
6078 /* Since we do not know how big the symbol table is,
6079 we default to reading in the entire file (!) and
6080 processing that. This is overkill, I know, but it
e3c8793a 6081 should work. */
d93f0186 6082 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 6083
fb52b2f4
NC		 6084 if (archive_file_offset != 0)
6085 section.sh_size = archive_file_size - section.sh_offset;
6086 else
6087 {
6088 if (fseek (file, 0, SEEK_END))
591a748a 6089 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 6090
6091 section.sh_size = ftell (file) - section.sh_offset;
6092 }
252b5132 6093
9ea033b2 6094 if (is_32bit_elf)
9ad5cbcf 6095 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 6096 else
9ad5cbcf 6097 section.sh_entsize = sizeof (Elf64_External_Sym);
252b5132 6098
9ad5cbcf 6099 num_dynamic_syms = section.sh_size / section.sh_entsize;
19936277 6100 if (num_dynamic_syms < 1)
252b5132
RH		 6101 {
6102 error (_("Unable to determine the number of symbols to load\n"));
6103 continue;
6104 }
6105
9ad5cbcf 6106 dynamic_symbols = GET_ELF_SYMBOLS (file, &section);
252b5132
RH		 6107 }
6108 }
6109
6110 /* Similarly find a string table. */
6111 if (dynamic_strings == NULL)
6112 {
86dba8ee
AM		 6113 for (entry = dynamic_section;
6114 entry < dynamic_section + dynamic_nent;
6115 ++entry)
252b5132
RH		 6116 {
6117 unsigned long offset;
b34976b6 6118 long str_tab_len;
252b5132
RH		 6119
6120 if (entry->d_tag != DT_STRTAB)
6121 continue;
6122
6123 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
6124
6125 /* Since we do not know how big the string table is,
6126 we default to reading in the entire file (!) and
6127 processing that. This is overkill, I know, but it
e3c8793a 6128 should work. */
252b5132 6129
d93f0186 6130 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 6131
6132 if (archive_file_offset != 0)
6133 str_tab_len = archive_file_size - offset;
6134 else
6135 {
6136 if (fseek (file, 0, SEEK_END))
6137 error (_("Unable to seek to end of file\n"));
6138 str_tab_len = ftell (file) - offset;
6139 }
252b5132
RH		 6140
6141 if (str_tab_len < 1)
6142 {
6143 error
6144 (_("Unable to determine the length of the dynamic string table\n"));
6145 continue;
6146 }
6147
3f5e193b
NC		 6148 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
6149 str_tab_len,
6150 _("dynamic string table"));
d79b3d50 6151 dynamic_strings_length = str_tab_len;
252b5132
RH		 6152 break;
6153 }
6154 }
6155
6156 /* And find the syminfo section if available. */
6157 if (dynamic_syminfo == NULL)
6158 {
3e8bba36 6159 unsigned long syminsz = 0;
252b5132 6160
86dba8ee
AM		 6161 for (entry = dynamic_section;
6162 entry < dynamic_section + dynamic_nent;
6163 ++entry)
252b5132
RH		 6164 {
6165 if (entry->d_tag == DT_SYMINENT)
6166 {
6167 /* Note: these braces are necessary to avoid a syntax
6168 error from the SunOS4 C compiler. */
6169 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
6170 }
6171 else if (entry->d_tag == DT_SYMINSZ)
6172 syminsz = entry->d_un.d_val;
6173 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 6174 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
6175 syminsz);
252b5132
RH		 6176 }
6177
6178 if (dynamic_syminfo_offset != 0 && syminsz != 0)
6179 {
2cf0635d
NC		 6180 Elf_External_Syminfo * extsyminfo;
6181 Elf_External_Syminfo * extsym;
6182 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 6183
6184 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 6185 extsyminfo = (Elf_External_Syminfo *)
6186 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
6187 _("symbol information"));
a6e9f9df
AM		 6188 if (!extsyminfo)
6189 return 0;
252b5132 6190
3f5e193b 6191 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 6192 if (dynamic_syminfo == NULL)
6193 {
6194 error (_("Out of memory\n"));
6195 return 0;
6196 }
6197
6198 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 6199 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
6200 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
6201 ++syminfo, ++extsym)
252b5132 6202 {
86dba8ee
AM		 6203 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
6204 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 6205 }
6206
6207 free (extsyminfo);
6208 }
6209 }
6210
6211 if (do_dynamic && dynamic_addr)
86dba8ee
AM		 6212 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
6213 dynamic_addr, dynamic_nent);
252b5132
RH		 6214 if (do_dynamic)
6215 printf (_(" Tag Type Name/Value\n"));
6216
86dba8ee
AM		 6217 for (entry = dynamic_section;
6218 entry < dynamic_section + dynamic_nent;
6219 entry++)
252b5132
RH		 6220 {
6221 if (do_dynamic)
f7a99963 6222 {
2cf0635d 6223 const char * dtype;
e699b9ff 6224
f7a99963
NC		 6225 putchar (' ');
6226 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 6227 dtype = get_dynamic_type (entry->d_tag);
6228 printf (" (%s)%*s", dtype,
6229 ((is_32bit_elf ? 27 : 19)
6230 - (int) strlen (dtype)),
f7a99963
NC		 6231 " ");
6232 }
252b5132
RH		 6233
6234 switch (entry->d_tag)
6235 {
d1133906
NC		 6236 case DT_FLAGS:
6237 if (do_dynamic)
e9e44622 6238 print_dynamic_flags (entry->d_un.d_val);
d1133906 6239 break;
76da6bbe 6240
252b5132
RH		 6241 case DT_AUXILIARY:
6242 case DT_FILTER:
019148e4
L		 6243 case DT_CONFIG:
6244 case DT_DEPAUDIT:
6245 case DT_AUDIT:
252b5132
RH		 6246 if (do_dynamic)
6247 {
019148e4 6248 switch (entry->d_tag)
b34976b6 6249 {
019148e4
L		 6250 case DT_AUXILIARY:
6251 printf (_("Auxiliary library"));
6252 break;
6253
6254 case DT_FILTER:
6255 printf (_("Filter library"));
6256 break;
6257
b34976b6 6258 case DT_CONFIG:
019148e4
L		 6259 printf (_("Configuration file"));
6260 break;
6261
6262 case DT_DEPAUDIT:
6263 printf (_("Dependency audit library"));
6264 break;
6265
6266 case DT_AUDIT:
6267 printf (_("Audit library"));
6268 break;
6269 }
252b5132 6270
d79b3d50
NC		 6271 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
6272 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 6273 else
f7a99963
NC		 6274 {
6275 printf (": ");
6276 print_vma (entry->d_un.d_val, PREFIX_HEX);
6277 putchar ('\n');
6278 }
252b5132
RH		 6279 }
6280 break;
6281
dcefbbbd 6282 case DT_FEATURE:
252b5132
RH		 6283 if (do_dynamic)
6284 {
6285 printf (_("Flags:"));
86f55779 6286
252b5132
RH		 6287 if (entry->d_un.d_val == 0)
6288 printf (_(" None\n"));
6289 else
6290 {
6291 unsigned long int val = entry->d_un.d_val;
86f55779 6292
252b5132
RH		 6293 if (val & DTF_1_PARINIT)
6294 {
6295 printf (" PARINIT");
6296 val ^= DTF_1_PARINIT;
6297 }
dcefbbbd
L		 6298 if (val & DTF_1_CONFEXP)
6299 {
6300 printf (" CONFEXP");
6301 val ^= DTF_1_CONFEXP;
6302 }
252b5132
RH		 6303 if (val != 0)
6304 printf (" %lx", val);
6305 puts ("");
6306 }
6307 }
6308 break;
6309
6310 case DT_POSFLAG_1:
6311 if (do_dynamic)
6312 {
6313 printf (_("Flags:"));
86f55779 6314
252b5132
RH		 6315 if (entry->d_un.d_val == 0)
6316 printf (_(" None\n"));
6317 else
6318 {
6319 unsigned long int val = entry->d_un.d_val;
86f55779 6320
252b5132
RH		 6321 if (val & DF_P1_LAZYLOAD)
6322 {
6323 printf (" LAZYLOAD");
6324 val ^= DF_P1_LAZYLOAD;
6325 }
6326 if (val & DF_P1_GROUPPERM)
6327 {
6328 printf (" GROUPPERM");
6329 val ^= DF_P1_GROUPPERM;
6330 }
6331 if (val != 0)
6332 printf (" %lx", val);
6333 puts ("");
6334 }
6335 }
6336 break;
6337
6338 case DT_FLAGS_1:
6339 if (do_dynamic)
6340 {
6341 printf (_("Flags:"));
6342 if (entry->d_un.d_val == 0)
6343 printf (_(" None\n"));
6344 else
6345 {
6346 unsigned long int val = entry->d_un.d_val;
86f55779 6347
252b5132
RH		 6348 if (val & DF_1_NOW)
6349 {
6350 printf (" NOW");
6351 val ^= DF_1_NOW;
6352 }
6353 if (val & DF_1_GLOBAL)
6354 {
6355 printf (" GLOBAL");
6356 val ^= DF_1_GLOBAL;
6357 }
6358 if (val & DF_1_GROUP)
6359 {
6360 printf (" GROUP");
6361 val ^= DF_1_GROUP;
6362 }
6363 if (val & DF_1_NODELETE)
6364 {
6365 printf (" NODELETE");
6366 val ^= DF_1_NODELETE;
6367 }
6368 if (val & DF_1_LOADFLTR)
6369 {
6370 printf (" LOADFLTR");
6371 val ^= DF_1_LOADFLTR;
6372 }
6373 if (val & DF_1_INITFIRST)
6374 {
6375 printf (" INITFIRST");
6376 val ^= DF_1_INITFIRST;
6377 }
6378 if (val & DF_1_NOOPEN)
6379 {
6380 printf (" NOOPEN");
6381 val ^= DF_1_NOOPEN;
6382 }
6383 if (val & DF_1_ORIGIN)
6384 {
6385 printf (" ORIGIN");
6386 val ^= DF_1_ORIGIN;
6387 }
6388 if (val & DF_1_DIRECT)
6389 {
6390 printf (" DIRECT");
6391 val ^= DF_1_DIRECT;
6392 }
6393 if (val & DF_1_TRANS)
6394 {
6395 printf (" TRANS");
6396 val ^= DF_1_TRANS;
6397 }
6398 if (val & DF_1_INTERPOSE)
6399 {
6400 printf (" INTERPOSE");
6401 val ^= DF_1_INTERPOSE;
6402 }
f7db6139 6403 if (val & DF_1_NODEFLIB)
dcefbbbd 6404 {
f7db6139
L		 6405 printf (" NODEFLIB");
6406 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 6407 }
6408 if (val & DF_1_NODUMP)
6409 {
6410 printf (" NODUMP");
6411 val ^= DF_1_NODUMP;
6412 }
6413 if (val & DF_1_CONLFAT)
6414 {
6415 printf (" CONLFAT");
6416 val ^= DF_1_CONLFAT;
6417 }
252b5132
RH		 6418 if (val != 0)
6419 printf (" %lx", val);
6420 puts ("");
6421 }
6422 }
6423 break;
6424
6425 case DT_PLTREL:
566b0d53 6426 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 6427 if (do_dynamic)
6428 puts (get_dynamic_type (entry->d_un.d_val));
6429 break;
6430
6431 case DT_NULL :
6432 case DT_NEEDED :
6433 case DT_PLTGOT :
6434 case DT_HASH :
6435 case DT_STRTAB :
6436 case DT_SYMTAB :
6437 case DT_RELA :
6438 case DT_INIT :
6439 case DT_FINI :
6440 case DT_SONAME :
6441 case DT_RPATH :
6442 case DT_SYMBOLIC:
6443 case DT_REL :
6444 case DT_DEBUG :
6445 case DT_TEXTREL :
6446 case DT_JMPREL :
019148e4 6447 case DT_RUNPATH :
252b5132
RH		 6448 dynamic_info[entry->d_tag] = entry->d_un.d_val;
6449
6450 if (do_dynamic)
6451 {
2cf0635d 6452 char * name;
252b5132 6453
d79b3d50
NC		 6454 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
6455 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 6456 else
d79b3d50 6457 name = NULL;
252b5132
RH		 6458
6459 if (name)
6460 {
6461 switch (entry->d_tag)
6462 {
6463 case DT_NEEDED:
6464 printf (_("Shared library: [%s]"), name);
6465
18bd398b 6466 if (streq (name, program_interpreter))
f7a99963 6467 printf (_(" program interpreter"));
252b5132
RH		 6468 break;
6469
6470 case DT_SONAME:
f7a99963 6471 printf (_("Library soname: [%s]"), name);
252b5132
RH		 6472 break;
6473
6474 case DT_RPATH:
f7a99963 6475 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 6476 break;
6477
019148e4
L		 6478 case DT_RUNPATH:
6479 printf (_("Library runpath: [%s]"), name);
6480 break;
6481
252b5132 6482 default:
f7a99963
NC		 6483 print_vma (entry->d_un.d_val, PREFIX_HEX);
6484 break;
252b5132
RH		 6485 }
6486 }
6487 else
f7a99963
NC		 6488 print_vma (entry->d_un.d_val, PREFIX_HEX);
6489
6490 putchar ('\n');
252b5132
RH		 6491 }
6492 break;
6493
6494 case DT_PLTRELSZ:
6495 case DT_RELASZ :
6496 case DT_STRSZ :
6497 case DT_RELSZ :
6498 case DT_RELAENT :
6499 case DT_SYMENT :
6500 case DT_RELENT :
566b0d53 6501 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 6502 case DT_PLTPADSZ:
6503 case DT_MOVEENT :
6504 case DT_MOVESZ :
6505 case DT_INIT_ARRAYSZ:
6506 case DT_FINI_ARRAYSZ:
047b2264
JJ		 6507 case DT_GNU_CONFLICTSZ:
6508 case DT_GNU_LIBLISTSZ:
252b5132 6509 if (do_dynamic)
f7a99963
NC		 6510 {
6511 print_vma (entry->d_un.d_val, UNSIGNED);
6512 printf (" (bytes)\n");
6513 }
252b5132
RH		 6514 break;
6515
6516 case DT_VERDEFNUM:
6517 case DT_VERNEEDNUM:
6518 case DT_RELACOUNT:
6519 case DT_RELCOUNT:
6520 if (do_dynamic)
f7a99963
NC		 6521 {
6522 print_vma (entry->d_un.d_val, UNSIGNED);
6523 putchar ('\n');
6524 }
252b5132
RH		 6525 break;
6526
6527 case DT_SYMINSZ:
6528 case DT_SYMINENT:
6529 case DT_SYMINFO:
6530 case DT_USED:
6531 case DT_INIT_ARRAY:
6532 case DT_FINI_ARRAY:
6533 if (do_dynamic)
6534 {
d79b3d50
NC		 6535 if (entry->d_tag == DT_USED
6536 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 6537 {
2cf0635d 6538 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 6539
b34976b6 6540 if (*name)
252b5132
RH		 6541 {
6542 printf (_("Not needed object: [%s]\n"), name);
6543 break;
6544 }
6545 }
103f02d3 6546
f7a99963
NC		 6547 print_vma (entry->d_un.d_val, PREFIX_HEX);
6548 putchar ('\n');
252b5132
RH		 6549 }
6550 break;
6551
6552 case DT_BIND_NOW:
6553 /* The value of this entry is ignored. */
35b1837e
AM		 6554 if (do_dynamic)
6555 putchar ('\n');
252b5132 6556 break;
103f02d3 6557
047b2264
JJ		 6558 case DT_GNU_PRELINKED:
6559 if (do_dynamic)
6560 {
2cf0635d 6561 struct tm * tmp;
047b2264
JJ		 6562 time_t time = entry->d_un.d_val;
6563
6564 tmp = gmtime (&time);
6565 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6566 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
6567 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
6568
6569 }
6570 break;
6571
fdc90cb4
JJ		 6572 case DT_GNU_HASH:
6573 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
6574 if (do_dynamic)
6575 {
6576 print_vma (entry->d_un.d_val, PREFIX_HEX);
6577 putchar ('\n');
6578 }
6579 break;
6580
252b5132
RH		 6581 default:
6582 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 6583 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 6584 entry->d_un.d_val;
6585
6586 if (do_dynamic)
6587 {
6588 switch (elf_header.e_machine)
6589 {
6590 case EM_MIPS:
4fe85591 6591 case EM_MIPS_RS3_LE:
b2d38a17 6592 dynamic_section_mips_val (entry);
252b5132 6593 break;
103f02d3 6594 case EM_PARISC:
b2d38a17 6595 dynamic_section_parisc_val (entry);
103f02d3 6596 break;
ecc51f48 6597 case EM_IA_64:
b2d38a17 6598 dynamic_section_ia64_val (entry);
ecc51f48 6599 break;
252b5132 6600 default:
f7a99963
NC		 6601 print_vma (entry->d_un.d_val, PREFIX_HEX);
6602 putchar ('\n');
252b5132
RH		 6603 }
6604 }
6605 break;
6606 }
6607 }
6608
6609 return 1;
6610}
6611
6612static char *
d3ba0551 6613get_ver_flags (unsigned int flags)
252b5132 6614{
b34976b6 6615 static char buff[32];
252b5132
RH		 6616
6617 buff[0] = 0;
6618
6619 if (flags == 0)
6620 return _("none");
6621
6622 if (flags & VER_FLG_BASE)
6623 strcat (buff, "BASE ");
6624
6625 if (flags & VER_FLG_WEAK)
6626 {
6627 if (flags & VER_FLG_BASE)
6628 strcat (buff, "| ");
6629
6630 strcat (buff, "WEAK ");
6631 }
6632
6633 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
6634 strcat (buff, "| <unknown>");
6635
6636 return buff;
6637}
6638
6639/* Display the contents of the version sections. */
98fb390a 6640
252b5132 6641static int
2cf0635d 6642process_version_sections (FILE * file)
252b5132 6643{
2cf0635d 6644 Elf_Internal_Shdr * section;
b34976b6
AM		 6645 unsigned i;
6646 int found = 0;
252b5132
RH		 6647
6648 if (! do_version)
6649 return 1;
6650
6651 for (i = 0, section = section_headers;
6652 i < elf_header.e_shnum;
b34976b6 6653 i++, section++)
252b5132
RH		 6654 {
6655 switch (section->sh_type)
6656 {
6657 case SHT_GNU_verdef:
6658 {
2cf0635d 6659 Elf_External_Verdef * edefs;
b34976b6
AM		 6660 unsigned int idx;
6661 unsigned int cnt;
2cf0635d 6662 char * endbuf;
252b5132
RH		 6663
6664 found = 1;
6665
6666 printf
72de5009 6667 (_("\nVersion definition section '%s' contains %u entries:\n"),
252b5132
RH		 6668 SECTION_NAME (section), section->sh_info);
6669
6670 printf (_(" Addr: 0x"));
6671 printf_vma (section->sh_addr);
72de5009 6672 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 6673 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 6674 section->sh_link < elf_header.e_shnum
6675 ? SECTION_NAME (section_headers + section->sh_link)
c256ffe7 6676 : "<corrupt>");
252b5132 6677
3f5e193b
NC		 6678 edefs = (Elf_External_Verdef *)
6679 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
6680 _("version definition section"));
54806181 6681 endbuf = (char *) edefs + section->sh_size;
a6e9f9df
AM		 6682 if (!edefs)
6683 break;
252b5132 6684
b34976b6 6685 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 6686 {
2cf0635d
NC		 6687 char * vstart;
6688 Elf_External_Verdef * edef;
b34976b6 6689 Elf_Internal_Verdef ent;
2cf0635d 6690 Elf_External_Verdaux * eaux;
b34976b6
AM		 6691 Elf_Internal_Verdaux aux;
6692 int j;
6693 int isum;
103f02d3 6694
252b5132 6695 vstart = ((char *) edefs) + idx;
54806181
AM		 6696 if (vstart + sizeof (*edef) > endbuf)
6697 break;
252b5132
RH		 6698
6699 edef = (Elf_External_Verdef *) vstart;
6700
6701 ent.vd_version = BYTE_GET (edef->vd_version);
6702 ent.vd_flags = BYTE_GET (edef->vd_flags);
6703 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
6704 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
6705 ent.vd_hash = BYTE_GET (edef->vd_hash);
6706 ent.vd_aux = BYTE_GET (edef->vd_aux);
6707 ent.vd_next = BYTE_GET (edef->vd_next);
6708
6709 printf (_(" %#06x: Rev: %d Flags: %s"),
6710 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
6711
6712 printf (_(" Index: %d Cnt: %d "),
6713 ent.vd_ndx, ent.vd_cnt);
6714
6715 vstart += ent.vd_aux;
6716
6717 eaux = (Elf_External_Verdaux *) vstart;
6718
6719 aux.vda_name = BYTE_GET (eaux->vda_name);
6720 aux.vda_next = BYTE_GET (eaux->vda_next);
6721
d79b3d50
NC		 6722 if (VALID_DYNAMIC_NAME (aux.vda_name))
6723 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 6724 else
6725 printf (_("Name index: %ld\n"), aux.vda_name);
6726
6727 isum = idx + ent.vd_aux;
6728
b34976b6 6729 for (j = 1; j < ent.vd_cnt; j++)
252b5132
RH		 6730 {
6731 isum += aux.vda_next;
6732 vstart += aux.vda_next;
6733
6734 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 6735 if (vstart + sizeof (*eaux) > endbuf)
6736 break;
252b5132
RH		 6737
6738 aux.vda_name = BYTE_GET (eaux->vda_name);
6739 aux.vda_next = BYTE_GET (eaux->vda_next);
6740
d79b3d50 6741 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 6742 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 6743 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 6744 else
6745 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6746 isum, j, aux.vda_name);
6747 }
54806181
AM		 6748 if (j < ent.vd_cnt)
6749 printf (_(" Version def aux past end of section\n"));
252b5132
RH		 6750
6751 idx += ent.vd_next;
6752 }
54806181
AM		 6753 if (cnt < section->sh_info)
6754 printf (_(" Version definition past end of section\n"));
252b5132
RH		 6755
6756 free (edefs);
6757 }
6758 break;
103f02d3 6759
252b5132
RH		 6760 case SHT_GNU_verneed:
6761 {
2cf0635d 6762 Elf_External_Verneed * eneed;
b34976b6
AM		 6763 unsigned int idx;
6764 unsigned int cnt;
2cf0635d 6765 char * endbuf;
252b5132
RH		 6766
6767 found = 1;
6768
72de5009 6769 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
252b5132
RH		 6770 SECTION_NAME (section), section->sh_info);
6771
6772 printf (_(" Addr: 0x"));
6773 printf_vma (section->sh_addr);
72de5009 6774 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 6775 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 6776 section->sh_link < elf_header.e_shnum
6777 ? SECTION_NAME (section_headers + section->sh_link)
c256ffe7 6778 : "<corrupt>");
252b5132 6779
3f5e193b
NC		 6780 eneed = (Elf_External_Verneed *) get_data (NULL, file,
6781 section->sh_offset, 1,
6782 section->sh_size,
6783 _("version need section"));
54806181 6784 endbuf = (char *) eneed + section->sh_size;
a6e9f9df
AM		 6785 if (!eneed)
6786 break;
252b5132
RH		 6787
6788 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
6789 {
2cf0635d 6790 Elf_External_Verneed * entry;
b34976b6
AM		 6791 Elf_Internal_Verneed ent;
6792 int j;
6793 int isum;
2cf0635d 6794 char * vstart;
252b5132
RH		 6795
6796 vstart = ((char *) eneed) + idx;
54806181
AM		 6797 if (vstart + sizeof (*entry) > endbuf)
6798 break;
252b5132
RH		 6799
6800 entry = (Elf_External_Verneed *) vstart;
6801
6802 ent.vn_version = BYTE_GET (entry->vn_version);
6803 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
6804 ent.vn_file = BYTE_GET (entry->vn_file);
6805 ent.vn_aux = BYTE_GET (entry->vn_aux);
6806 ent.vn_next = BYTE_GET (entry->vn_next);
6807
6808 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
6809
d79b3d50
NC		 6810 if (VALID_DYNAMIC_NAME (ent.vn_file))
6811 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 6812 else
6813 printf (_(" File: %lx"), ent.vn_file);
6814
6815 printf (_(" Cnt: %d\n"), ent.vn_cnt);
6816
6817 vstart += ent.vn_aux;
6818
6819 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
6820 {
2cf0635d 6821 Elf_External_Vernaux * eaux;
b34976b6 6822 Elf_Internal_Vernaux aux;
252b5132 6823
54806181
AM		 6824 if (vstart + sizeof (*eaux) > endbuf)
6825 break;
252b5132
RH		 6826 eaux = (Elf_External_Vernaux *) vstart;
6827
6828 aux.vna_hash = BYTE_GET (eaux->vna_hash);
6829 aux.vna_flags = BYTE_GET (eaux->vna_flags);
6830 aux.vna_other = BYTE_GET (eaux->vna_other);
6831 aux.vna_name = BYTE_GET (eaux->vna_name);
6832 aux.vna_next = BYTE_GET (eaux->vna_next);
6833
d79b3d50 6834 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 6835 printf (_(" %#06x: Name: %s"),
d79b3d50 6836 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 6837 else
ecc2063b 6838 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 6839 isum, aux.vna_name);
6840
6841 printf (_(" Flags: %s Version: %d\n"),
6842 get_ver_flags (aux.vna_flags), aux.vna_other);
6843
6844 isum += aux.vna_next;
6845 vstart += aux.vna_next;
6846 }
54806181
AM		 6847 if (j < ent.vn_cnt)
6848 printf (_(" Version need aux past end of section\n"));
252b5132
RH		 6849
6850 idx += ent.vn_next;
6851 }
54806181
AM		 6852 if (cnt < section->sh_info)
6853 printf (_(" Version need past end of section\n"));
103f02d3 6854
252b5132
RH		 6855 free (eneed);
6856 }
6857 break;
6858
6859 case SHT_GNU_versym:
6860 {
2cf0635d 6861 Elf_Internal_Shdr * link_section;
b34976b6
AM		 6862 int total;
6863 int cnt;
2cf0635d
NC		 6864 unsigned char * edata;
6865 unsigned short * data;
6866 char * strtab;
6867 Elf_Internal_Sym * symbols;
6868 Elf_Internal_Shdr * string_sec;
d3ba0551 6869 long off;
252b5132 6870
4fbb74a6 6871 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 6872 break;
6873
4fbb74a6 6874 link_section = section_headers + section->sh_link;
08d8fa11 6875 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 6876
4fbb74a6 6877 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 6878 break;
6879
252b5132
RH		 6880 found = 1;
6881
9ad5cbcf 6882 symbols = GET_ELF_SYMBOLS (file, link_section);
252b5132 6883
4fbb74a6 6884 string_sec = section_headers + link_section->sh_link;
252b5132 6885
3f5e193b
NC		 6886 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
6887 string_sec->sh_size,
6888 _("version string table"));
a6e9f9df
AM		 6889 if (!strtab)
6890 break;
252b5132
RH		 6891
6892 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6893 SECTION_NAME (section), total);
6894
6895 printf (_(" Addr: "));
6896 printf_vma (section->sh_addr);
72de5009 6897 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 6898 (unsigned long) section->sh_offset, section->sh_link,
252b5132
RH		 6899 SECTION_NAME (link_section));
6900
d3ba0551
AM		 6901 off = offset_from_vma (file,
6902 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
6903 total * sizeof (short));
3f5e193b
NC		 6904 edata = (unsigned char *) get_data (NULL, file, off, total,
6905 sizeof (short),
6906 _("version symbol data"));
a6e9f9df
AM		 6907 if (!edata)
6908 {
6909 free (strtab);
6910 break;
6911 }
252b5132 6912
3f5e193b 6913 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 6914
6915 for (cnt = total; cnt --;)
b34976b6
AM		 6916 data[cnt] = byte_get (edata + cnt * sizeof (short),
6917 sizeof (short));
252b5132
RH		 6918
6919 free (edata);
6920
6921 for (cnt = 0; cnt < total; cnt += 4)
6922 {
6923 int j, nn;
00d93f34 6924 int check_def, check_need;
2cf0635d 6925 char * name;
252b5132
RH		 6926
6927 printf (" %03x:", cnt);
6928
6929 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 6930 switch (data[cnt + j])
252b5132
RH		 6931 {
6932 case 0:
6933 fputs (_(" 0 (*local*) "), stdout);
6934 break;
6935
6936 case 1:
6937 fputs (_(" 1 (*global*) "), stdout);
6938 break;
6939
6940 default:
c244d050
NC		 6941 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
6942 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 6943
00d93f34
JJ		 6944 check_def = 1;
6945 check_need = 1;
4fbb74a6
AM		 6946 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
6947 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 6948 != SHT_NOBITS)
252b5132 6949 {
b34976b6 6950 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 6951 check_def = 0;
6952 else
6953 check_need = 0;
252b5132 6954 }
00d93f34
JJ		 6955
6956 if (check_need
b34976b6 6957 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 6958 {
b34976b6
AM		 6959 Elf_Internal_Verneed ivn;
6960 unsigned long offset;
252b5132 6961
d93f0186
NC		 6962 offset = offset_from_vma
6963 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
6964 sizeof (Elf_External_Verneed));
252b5132 6965
b34976b6 6966 do
252b5132 6967 {
b34976b6
AM		 6968 Elf_Internal_Vernaux ivna;
6969 Elf_External_Verneed evn;
6970 Elf_External_Vernaux evna;
6971 unsigned long a_off;
252b5132 6972
c256ffe7 6973 get_data (&evn, file, offset, sizeof (evn), 1,
a6e9f9df 6974 _("version need"));
252b5132
RH		 6975
6976 ivn.vn_aux = BYTE_GET (evn.vn_aux);
6977 ivn.vn_next = BYTE_GET (evn.vn_next);
6978
6979 a_off = offset + ivn.vn_aux;
6980
6981 do
6982 {
a6e9f9df 6983 get_data (&evna, file, a_off, sizeof (evna),
c256ffe7 6984 1, _("version need aux (2)"));
252b5132
RH		 6985
6986 ivna.vna_next = BYTE_GET (evna.vna_next);
6987 ivna.vna_other = BYTE_GET (evna.vna_other);
6988
6989 a_off += ivna.vna_next;
6990 }
b34976b6 6991 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 6992 && ivna.vna_next != 0);
6993
b34976b6 6994 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 6995 {
6996 ivna.vna_name = BYTE_GET (evna.vna_name);
6997
54806181
AM		 6998 if (ivna.vna_name >= string_sec->sh_size)
6999 name = _("*invalid*");
7000 else
7001 name = strtab + ivna.vna_name;
252b5132 7002 nn += printf ("(%s%-*s",
16062207
ILT		 7003 name,
7004 12 - (int) strlen (name),
252b5132 7005 ")");
00d93f34 7006 check_def = 0;
252b5132
RH		 7007 break;
7008 }
7009
7010 offset += ivn.vn_next;
7011 }
7012 while (ivn.vn_next);
7013 }
00d93f34 7014
b34976b6
AM		 7015 if (check_def && data[cnt + j] != 0x8001
7016 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 7017 {
b34976b6
AM		 7018 Elf_Internal_Verdef ivd;
7019 Elf_External_Verdef evd;
7020 unsigned long offset;
252b5132 7021
d93f0186
NC		 7022 offset = offset_from_vma
7023 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
7024 sizeof evd);
252b5132
RH		 7025
7026 do
7027 {
c256ffe7 7028 get_data (&evd, file, offset, sizeof (evd), 1,
a6e9f9df 7029 _("version def"));
252b5132
RH		 7030
7031 ivd.vd_next = BYTE_GET (evd.vd_next);
7032 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
7033
7034 offset += ivd.vd_next;
7035 }
c244d050 7036 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 7037 && ivd.vd_next != 0);
7038
c244d050 7039 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 7040 {
b34976b6
AM		 7041 Elf_External_Verdaux evda;
7042 Elf_Internal_Verdaux ivda;
252b5132
RH		 7043
7044 ivd.vd_aux = BYTE_GET (evd.vd_aux);
7045
a6e9f9df
AM		 7046 get_data (&evda, file,
7047 offset - ivd.vd_next + ivd.vd_aux,
c256ffe7
JJ		 7048 sizeof (evda), 1,
7049 _("version def aux"));
252b5132
RH		 7050
7051 ivda.vda_name = BYTE_GET (evda.vda_name);
7052
54806181
AM		 7053 if (ivda.vda_name >= string_sec->sh_size)
7054 name = _("*invalid*");
7055 else
7056 name = strtab + ivda.vda_name;
252b5132 7057 nn += printf ("(%s%-*s",
16062207
ILT		 7058 name,
7059 12 - (int) strlen (name),
252b5132
RH		 7060 ")");
7061 }
7062 }
7063
7064 if (nn < 18)
7065 printf ("%*c", 18 - nn, ' ');
7066 }
7067
7068 putchar ('\n');
7069 }
7070
7071 free (data);
7072 free (strtab);
7073 free (symbols);
7074 }
7075 break;
103f02d3 7076
252b5132
RH		 7077 default:
7078 break;
7079 }
7080 }
7081
7082 if (! found)
7083 printf (_("\nNo version information found in this file.\n"));
7084
7085 return 1;
7086}
7087
d1133906 7088static const char *
d3ba0551 7089get_symbol_binding (unsigned int binding)
252b5132 7090{
b34976b6 7091 static char buff[32];
252b5132
RH		 7092
7093 switch (binding)
7094 {
b34976b6
AM		 7095 case STB_LOCAL: return "LOCAL";
7096 case STB_GLOBAL: return "GLOBAL";
7097 case STB_WEAK: return "WEAK";
252b5132
RH		 7098 default:
7099 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 7100 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
7101 binding);
252b5132 7102 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 7103 {
7104 if (binding == STB_GNU_UNIQUE
7105 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
7106 /* GNU/Linux is still using the default value 0. */
7107 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
7108 return "UNIQUE";
7109 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
7110 }
252b5132 7111 else
e9e44622 7112 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 7113 return buff;
7114 }
7115}
7116
d1133906 7117static const char *
d3ba0551 7118get_symbol_type (unsigned int type)
252b5132 7119{
b34976b6 7120 static char buff[32];
252b5132
RH		 7121
7122 switch (type)
7123 {
b34976b6
AM		 7124 case STT_NOTYPE: return "NOTYPE";
7125 case STT_OBJECT: return "OBJECT";
7126 case STT_FUNC: return "FUNC";
7127 case STT_SECTION: return "SECTION";
7128 case STT_FILE: return "FILE";
7129 case STT_COMMON: return "COMMON";
7130 case STT_TLS: return "TLS";
15ab5209
DB		 7131 case STT_RELC: return "RELC";
7132 case STT_SRELC: return "SRELC";
252b5132
RH		 7133 default:
7134 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af
NC		 7135 {
7136 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
103f02d3
UD		 7137 return "THUMB_FUNC";
7138
351b4b40 7139 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 7140 return "REGISTER";
7141
7142 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
7143 return "PARISC_MILLI";
7144
e9e44622 7145 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 7146 }
252b5132 7147 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 7148 {
7149 if (elf_header.e_machine == EM_PARISC)
7150 {
7151 if (type == STT_HP_OPAQUE)
7152 return "HP_OPAQUE";
7153 if (type == STT_HP_STUB)
7154 return "HP_STUB";
7155 }
7156
d8045f23
NC		 7157 if (type == STT_GNU_IFUNC
7158 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
7159 /* GNU/Linux is still using the default value 0. */
7160 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
7161 return "IFUNC";
7162
e9e44622 7163 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 7164 }
252b5132 7165 else
e9e44622 7166 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 7167 return buff;
7168 }
7169}
7170
d1133906 7171static const char *
d3ba0551 7172get_symbol_visibility (unsigned int visibility)
d1133906
NC		 7173{
7174 switch (visibility)
7175 {
b34976b6
AM		 7176 case STV_DEFAULT: return "DEFAULT";
7177 case STV_INTERNAL: return "INTERNAL";
7178 case STV_HIDDEN: return "HIDDEN";
d1133906
NC		 7179 case STV_PROTECTED: return "PROTECTED";
7180 default: abort ();
7181 }
7182}
7183
5e2b0d47
NC		 7184static const char *
7185get_mips_symbol_other (unsigned int other)
7186{
7187 switch (other)
7188 {
7189 case STO_OPTIONAL: return "OPTIONAL";
7190 case STO_MIPS16: return "MIPS16";
861fb55a
DJ		 7191 case STO_MIPS_PLT: return "MIPS PLT";
7192 case STO_MIPS_PIC: return "MIPS PIC";
5e2b0d47
NC		 7193 default: return NULL;
7194 }
7195}
7196
7197static const char *
7198get_symbol_other (unsigned int other)
7199{
7200 const char * result = NULL;
7201 static char buff [32];
7202
7203 if (other == 0)
7204 return "";
7205
7206 switch (elf_header.e_machine)
7207 {
7208 case EM_MIPS:
7209 result = get_mips_symbol_other (other);
7210 default:
7211 break;
7212 }
7213
7214 if (result)
7215 return result;
7216
7217 snprintf (buff, sizeof buff, _("<other>: %x"), other);
7218 return buff;
7219}
7220
d1133906 7221static const char *
d3ba0551 7222get_symbol_index_type (unsigned int type)
252b5132 7223{
b34976b6 7224 static char buff[32];
5cf1065c 7225
252b5132
RH		 7226 switch (type)
7227 {
b34976b6
AM		 7228 case SHN_UNDEF: return "UND";
7229 case SHN_ABS: return "ABS";
7230 case SHN_COMMON: return "COM";
252b5132 7231 default:
9ce701e2
L		 7232 if (type == SHN_IA_64_ANSI_COMMON
7233 && elf_header.e_machine == EM_IA_64
7234 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
7235 return "ANSI_COM";
8a9036a4
L		 7236 else if ((elf_header.e_machine == EM_X86_64
7237 || elf_header.e_machine == EM_L1OM)
3b22753a
L		 7238 && type == SHN_X86_64_LCOMMON)
7239 return "LARGE_COM";
172553c7
TS		 7240 else if (type == SHN_MIPS_SCOMMON
7241 && elf_header.e_machine == EM_MIPS)
7242 return "SCOM";
7243 else if (type == SHN_MIPS_SUNDEFINED
7244 && elf_header.e_machine == EM_MIPS)
7245 return "SUND";
9ce701e2 7246 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 7247 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 7248 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 7249 sprintf (buff, "OS [0x%04x]", type & 0xffff);
7250 else if (type >= SHN_LORESERVE)
7251 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
252b5132 7252 else
232e7cb8 7253 sprintf (buff, "%3d", type);
5cf1065c 7254 break;
252b5132 7255 }
5cf1065c
NC		 7256
7257 return buff;
252b5132
RH		 7258}
7259
66543521 7260static bfd_vma *
2cf0635d 7261get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
252b5132 7262{
2cf0635d
NC		 7263 unsigned char * e_data;
7264 bfd_vma * i_data;
252b5132 7265
3f5e193b 7266 e_data = (unsigned char *) cmalloc (number, ent_size);
252b5132
RH		 7267
7268 if (e_data == NULL)
7269 {
7270 error (_("Out of memory\n"));
7271 return NULL;
7272 }
7273
66543521 7274 if (fread (e_data, ent_size, number, file) != number)
252b5132
RH		 7275 {
7276 error (_("Unable to read in dynamic data\n"));
7277 return NULL;
7278 }
7279
3f5e193b 7280 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
252b5132
RH		 7281
7282 if (i_data == NULL)
7283 {
7284 error (_("Out of memory\n"));
7285 free (e_data);
7286 return NULL;
7287 }
7288
7289 while (number--)
66543521 7290 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 7291
7292 free (e_data);
7293
7294 return i_data;
7295}
7296
6bd1a22c
L		 7297static void
7298print_dynamic_symbol (bfd_vma si, unsigned long hn)
7299{
2cf0635d 7300 Elf_Internal_Sym * psym;
6bd1a22c
L		 7301 int n;
7302
7303 psym = dynamic_symbols + si;
7304
7305 n = print_vma (si, DEC_5);
7306 if (n < 5)
7307 fputs (" " + n, stdout);
7308 printf (" %3lu: ", hn);
7309 print_vma (psym->st_value, LONG_HEX);
7310 putchar (' ');
7311 print_vma (psym->st_size, DEC_5);
7312
f4be36b3
AM		 7313 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
7314 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
7315 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 7316 /* Check to see if any other bits in the st_other field are set.
7317 Note - displaying this information disrupts the layout of the
7318 table being generated, but for the moment this case is very
7319 rare. */
7320 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
7321 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
7322 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
7323 if (VALID_DYNAMIC_NAME (psym->st_name))
7324 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
7325 else
7326 printf (" <corrupt: %14ld>", psym->st_name);
7327 putchar ('\n');
7328}
7329
e3c8793a 7330/* Dump the symbol table. */
252b5132 7331static int
2cf0635d 7332process_symbol_table (FILE * file)
252b5132 7333{
2cf0635d 7334 Elf_Internal_Shdr * section;
66543521
AM		 7335 bfd_vma nbuckets = 0;
7336 bfd_vma nchains = 0;
2cf0635d
NC		 7337 bfd_vma * buckets = NULL;
7338 bfd_vma * chains = NULL;
fdc90cb4 7339 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 7340 bfd_vma * gnubuckets = NULL;
7341 bfd_vma * gnuchains = NULL;
6bd1a22c 7342 bfd_vma gnusymidx = 0;
252b5132
RH		 7343
7344 if (! do_syms && !do_histogram)
7345 return 1;
7346
6bd1a22c
L		 7347 if (dynamic_info[DT_HASH]
7348 && (do_histogram
7349 || (do_using_dynamic && dynamic_strings != NULL)))
252b5132 7350 {
66543521
AM		 7351 unsigned char nb[8];
7352 unsigned char nc[8];
7353 int hash_ent_size = 4;
7354
7355 if ((elf_header.e_machine == EM_ALPHA
7356 || elf_header.e_machine == EM_S390
7357 || elf_header.e_machine == EM_S390_OLD)
7358 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
7359 hash_ent_size = 8;
7360
fb52b2f4
NC		 7361 if (fseek (file,
7362 (archive_file_offset
7363 + offset_from_vma (file, dynamic_info[DT_HASH],
7364 sizeof nb + sizeof nc)),
d93f0186 7365 SEEK_SET))
252b5132 7366 {
591a748a 7367 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 7368 goto no_hash;
252b5132
RH		 7369 }
7370
66543521 7371 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 7372 {
7373 error (_("Failed to read in number of buckets\n"));
d3a44ec6 7374 goto no_hash;
252b5132
RH		 7375 }
7376
66543521 7377 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 7378 {
7379 error (_("Failed to read in number of chains\n"));
d3a44ec6 7380 goto no_hash;
252b5132
RH		 7381 }
7382
66543521
AM		 7383 nbuckets = byte_get (nb, hash_ent_size);
7384 nchains = byte_get (nc, hash_ent_size);
252b5132 7385
66543521
AM		 7386 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
7387 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 7388
d3a44ec6 7389 no_hash:
252b5132 7390 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 7391 {
7392 if (do_using_dynamic)
7393 return 0;
7394 free (buckets);
7395 free (chains);
7396 buckets = NULL;
7397 chains = NULL;
7398 nbuckets = 0;
7399 nchains = 0;
7400 }
252b5132
RH		 7401 }
7402
6bd1a22c
L		 7403 if (dynamic_info_DT_GNU_HASH
7404 && (do_histogram
7405 || (do_using_dynamic && dynamic_strings != NULL)))
252b5132 7406 {
6bd1a22c
L		 7407 unsigned char nb[16];
7408 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
7409 bfd_vma buckets_vma;
7410
7411 if (fseek (file,
7412 (archive_file_offset
7413 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
7414 sizeof nb)),
7415 SEEK_SET))
7416 {
7417 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 7418 goto no_gnu_hash;
6bd1a22c 7419 }
252b5132 7420
6bd1a22c
L		 7421 if (fread (nb, 16, 1, file) != 1)
7422 {
7423 error (_("Failed to read in number of buckets\n"));
d3a44ec6 7424 goto no_gnu_hash;
6bd1a22c
L		 7425 }
7426
7427 ngnubuckets = byte_get (nb, 4);
7428 gnusymidx = byte_get (nb + 4, 4);
7429 bitmaskwords = byte_get (nb + 8, 4);
7430 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 7431 if (is_32bit_elf)
6bd1a22c 7432 buckets_vma += bitmaskwords * 4;
f7a99963 7433 else
6bd1a22c 7434 buckets_vma += bitmaskwords * 8;
252b5132 7435
6bd1a22c
L		 7436 if (fseek (file,
7437 (archive_file_offset
7438 + offset_from_vma (file, buckets_vma, 4)),
7439 SEEK_SET))
252b5132 7440 {
6bd1a22c 7441 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 7442 goto no_gnu_hash;
6bd1a22c
L		 7443 }
7444
7445 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 7446
6bd1a22c 7447 if (gnubuckets == NULL)
d3a44ec6 7448 goto no_gnu_hash;
6bd1a22c
L		 7449
7450 for (i = 0; i < ngnubuckets; i++)
7451 if (gnubuckets[i] != 0)
7452 {
7453 if (gnubuckets[i] < gnusymidx)
7454 return 0;
7455
7456 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
7457 maxchain = gnubuckets[i];
7458 }
7459
7460 if (maxchain == 0xffffffff)
d3a44ec6 7461 goto no_gnu_hash;
6bd1a22c
L		 7462
7463 maxchain -= gnusymidx;
7464
7465 if (fseek (file,
7466 (archive_file_offset
7467 + offset_from_vma (file, buckets_vma
7468 + 4 * (ngnubuckets + maxchain), 4)),
7469 SEEK_SET))
7470 {
7471 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 7472 goto no_gnu_hash;
6bd1a22c
L		 7473 }
7474
7475 do
7476 {
7477 if (fread (nb, 4, 1, file) != 1)
252b5132 7478 {
6bd1a22c 7479 error (_("Failed to determine last chain length\n"));
d3a44ec6 7480 goto no_gnu_hash;
6bd1a22c 7481 }
252b5132 7482
6bd1a22c 7483 if (maxchain + 1 == 0)
d3a44ec6 7484 goto no_gnu_hash;
252b5132 7485
6bd1a22c
L		 7486 ++maxchain;
7487 }
7488 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 7489
6bd1a22c
L		 7490 if (fseek (file,
7491 (archive_file_offset
7492 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
7493 SEEK_SET))
7494 {
7495 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 7496 goto no_gnu_hash;
6bd1a22c
L		 7497 }
7498
7499 gnuchains = get_dynamic_data (file, maxchain, 4);
7500
d3a44ec6 7501 no_gnu_hash:
6bd1a22c 7502 if (gnuchains == NULL)
d3a44ec6
JJ		 7503 {
7504 free (gnubuckets);
d3a44ec6
JJ		 7505 gnubuckets = NULL;
7506 ngnubuckets = 0;
f64fddf1
NC		 7507 if (do_using_dynamic)
7508 return 0;
d3a44ec6 7509 }
6bd1a22c
L		 7510 }
7511
7512 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
7513 && do_syms
7514 && do_using_dynamic
7515 && dynamic_strings != NULL)
7516 {
7517 unsigned long hn;
7518
7519 if (dynamic_info[DT_HASH])
7520 {
7521 bfd_vma si;
7522
7523 printf (_("\nSymbol table for image:\n"));
7524 if (is_32bit_elf)
7525 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7526 else
7527 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7528
7529 for (hn = 0; hn < nbuckets; hn++)
7530 {
7531 if (! buckets[hn])
7532 continue;
7533
7534 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
7535 print_dynamic_symbol (si, hn);
252b5132
RH		 7536 }
7537 }
6bd1a22c
L		 7538
7539 if (dynamic_info_DT_GNU_HASH)
7540 {
7541 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7542 if (is_32bit_elf)
7543 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7544 else
7545 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7546
7547 for (hn = 0; hn < ngnubuckets; ++hn)
7548 if (gnubuckets[hn] != 0)
7549 {
7550 bfd_vma si = gnubuckets[hn];
7551 bfd_vma off = si - gnusymidx;
7552
7553 do
7554 {
7555 print_dynamic_symbol (si, hn);
7556 si++;
7557 }
7558 while ((gnuchains[off++] & 1) == 0);
7559 }
7560 }
252b5132
RH		 7561 }
7562 else if (do_syms && !do_using_dynamic)
7563 {
b34976b6 7564 unsigned int i;
252b5132
RH		 7565
7566 for (i = 0, section = section_headers;
7567 i < elf_header.e_shnum;
7568 i++, section++)
7569 {
b34976b6 7570 unsigned int si;
2cf0635d 7571 char * strtab = NULL;
c256ffe7 7572 unsigned long int strtab_size = 0;
2cf0635d
NC		 7573 Elf_Internal_Sym * symtab;
7574 Elf_Internal_Sym * psym;
252b5132
RH		 7575
7576 if ( section->sh_type != SHT_SYMTAB
7577 && section->sh_type != SHT_DYNSYM)
7578 continue;
7579
7580 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7581 SECTION_NAME (section),
7582 (unsigned long) (section->sh_size / section->sh_entsize));
f7a99963 7583 if (is_32bit_elf)
ca47b30c 7584 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 7585 else
ca47b30c 7586 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 7587
9ad5cbcf 7588 symtab = GET_ELF_SYMBOLS (file, section);
252b5132
RH		 7589 if (symtab == NULL)
7590 continue;
7591
7592 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 7593 {
7594 strtab = string_table;
7595 strtab_size = string_table_length;
7596 }
4fbb74a6 7597 else if (section->sh_link < elf_header.e_shnum)
252b5132 7598 {
2cf0635d 7599 Elf_Internal_Shdr * string_sec;
252b5132 7600
4fbb74a6 7601 string_sec = section_headers + section->sh_link;
252b5132 7602
3f5e193b
NC		 7603 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
7604 1, string_sec->sh_size,
7605 _("string table"));
c256ffe7 7606 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 7607 }
7608
7609 for (si = 0, psym = symtab;
7610 si < section->sh_size / section->sh_entsize;
b34976b6 7611 si++, psym++)
252b5132 7612 {
5e220199 7613 printf ("%6d: ", si);
f7a99963
NC		 7614 print_vma (psym->st_value, LONG_HEX);
7615 putchar (' ');
7616 print_vma (psym->st_size, DEC_5);
d1133906
NC		 7617 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
7618 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 7619 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 7620 /* Check to see if any other bits in the st_other field are set.
7621 Note - displaying this information disrupts the layout of the
7622 table being generated, but for the moment this case is very rare. */
7623 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
7624 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 7625 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7
JJ		 7626 print_symbol (25, psym->st_name < strtab_size
7627 ? strtab + psym->st_name : "<corrupt>");
252b5132
RH		 7628
7629 if (section->sh_type == SHT_DYNSYM &&
b34976b6 7630 version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
252b5132 7631 {
b34976b6
AM		 7632 unsigned char data[2];
7633 unsigned short vers_data;
7634 unsigned long offset;
7635 int is_nobits;
7636 int check_def;
252b5132 7637
d93f0186
NC		 7638 offset = offset_from_vma
7639 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
7640 sizeof data + si * sizeof (vers_data));
252b5132 7641
a6e9f9df 7642 get_data (&data, file, offset + si * sizeof (vers_data),
c256ffe7 7643 sizeof (data), 1, _("version data"));
252b5132
RH		 7644
7645 vers_data = byte_get (data, 2);
7646
4fbb74a6
AM		 7647 is_nobits = (psym->st_shndx < elf_header.e_shnum
7648 && section_headers[psym->st_shndx].sh_type
c256ffe7 7649 == SHT_NOBITS);
252b5132
RH		 7650
7651 check_def = (psym->st_shndx != SHN_UNDEF);
7652
c244d050 7653 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
252b5132 7654 {
b34976b6 7655 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
00d93f34 7656 && (is_nobits || ! check_def))
252b5132 7657 {
b34976b6
AM		 7658 Elf_External_Verneed evn;
7659 Elf_Internal_Verneed ivn;
7660 Elf_Internal_Vernaux ivna;
252b5132
RH		 7661
7662 /* We must test both. */
d93f0186
NC		 7663 offset = offset_from_vma
7664 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
7665 sizeof evn);
252b5132 7666
252b5132
RH		 7667 do
7668 {
b34976b6 7669 unsigned long vna_off;
252b5132 7670
c256ffe7 7671 get_data (&evn, file, offset, sizeof (evn), 1,
a6e9f9df 7672 _("version need"));
dd27201e
L		 7673
7674 ivn.vn_aux = BYTE_GET (evn.vn_aux);
7675 ivn.vn_next = BYTE_GET (evn.vn_next);
7676
252b5132
RH		 7677 vna_off = offset + ivn.vn_aux;
7678
7679 do
7680 {
b34976b6 7681 Elf_External_Vernaux evna;
252b5132 7682
a6e9f9df 7683 get_data (&evna, file, vna_off,
c256ffe7 7684 sizeof (evna), 1,
a6e9f9df 7685 _("version need aux (3)"));
252b5132
RH		 7686
7687 ivna.vna_other = BYTE_GET (evna.vna_other);
7688 ivna.vna_next = BYTE_GET (evna.vna_next);
7689 ivna.vna_name = BYTE_GET (evna.vna_name);
7690
7691 vna_off += ivna.vna_next;
7692 }
7693 while (ivna.vna_other != vers_data
7694 && ivna.vna_next != 0);
7695
7696 if (ivna.vna_other == vers_data)
7697 break;
7698
7699 offset += ivn.vn_next;
7700 }
7701 while (ivn.vn_next != 0);
7702
7703 if (ivna.vna_other == vers_data)
7704 {
7705 printf ("@%s (%d)",
c256ffe7
JJ		 7706 ivna.vna_name < strtab_size
7707 ? strtab + ivna.vna_name : "<corrupt>",
7708 ivna.vna_other);
252b5132
RH		 7709 check_def = 0;
7710 }
7711 else if (! is_nobits)
591a748a 7712 error (_("bad dynamic symbol\n"));
252b5132
RH		 7713 else
7714 check_def = 1;
7715 }
7716
7717 if (check_def)
7718 {
00d93f34 7719 if (vers_data != 0x8001
b34976b6 7720 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 7721 {
b34976b6
AM		 7722 Elf_Internal_Verdef ivd;
7723 Elf_Internal_Verdaux ivda;
7724 Elf_External_Verdaux evda;
7725 unsigned long offset;
252b5132 7726
d93f0186
NC		 7727 offset = offset_from_vma
7728 (file,
7729 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
7730 sizeof (Elf_External_Verdef));
252b5132
RH		 7731
7732 do
7733 {
b34976b6 7734 Elf_External_Verdef evd;
252b5132 7735
a6e9f9df 7736 get_data (&evd, file, offset, sizeof (evd),
c256ffe7 7737 1, _("version def"));
252b5132 7738
b34976b6
AM		 7739 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
7740 ivd.vd_aux = BYTE_GET (evd.vd_aux);
252b5132
RH		 7741 ivd.vd_next = BYTE_GET (evd.vd_next);
7742
7743 offset += ivd.vd_next;
7744 }
c244d050 7745 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
252b5132
RH		 7746 && ivd.vd_next != 0);
7747
7748 offset -= ivd.vd_next;
7749 offset += ivd.vd_aux;
7750
a6e9f9df 7751 get_data (&evda, file, offset, sizeof (evda),
c256ffe7 7752 1, _("version def aux"));
252b5132
RH		 7753
7754 ivda.vda_name = BYTE_GET (evda.vda_name);
7755
7756 if (psym->st_name != ivda.vda_name)
c244d050 7757 printf ((vers_data & VERSYM_HIDDEN)
252b5132 7758 ? "@%s" : "@@%s",
c256ffe7
JJ		 7759 ivda.vda_name < strtab_size
7760 ? strtab + ivda.vda_name : "<corrupt>");
252b5132
RH		 7761 }
7762 }
7763 }
7764 }
7765
7766 putchar ('\n');
7767 }
7768
7769 free (symtab);
7770 if (strtab != string_table)
7771 free (strtab);
7772 }
7773 }
7774 else if (do_syms)
7775 printf
7776 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7777
7778 if (do_histogram && buckets != NULL)
7779 {
2cf0635d
NC		 7780 unsigned long * lengths;
7781 unsigned long * counts;
66543521
AM		 7782 unsigned long hn;
7783 bfd_vma si;
7784 unsigned long maxlength = 0;
7785 unsigned long nzero_counts = 0;
7786 unsigned long nsyms = 0;
252b5132 7787
66543521
AM		 7788 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7789 (unsigned long) nbuckets);
252b5132
RH		 7790 printf (_(" Length Number %% of total Coverage\n"));
7791
3f5e193b 7792 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 7793 if (lengths == NULL)
7794 {
591a748a 7795 error (_("Out of memory\n"));
252b5132
RH		 7796 return 0;
7797 }
7798 for (hn = 0; hn < nbuckets; ++hn)
7799 {
f7a99963 7800 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
252b5132 7801 {
b34976b6 7802 ++nsyms;
252b5132 7803 if (maxlength < ++lengths[hn])
b34976b6 7804 ++maxlength;
252b5132
RH		 7805 }
7806 }
7807
3f5e193b 7808 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 7809 if (counts == NULL)
7810 {
591a748a 7811 error (_("Out of memory\n"));
252b5132
RH		 7812 return 0;
7813 }
7814
7815 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 7816 ++counts[lengths[hn]];
252b5132 7817
103f02d3 7818 if (nbuckets > 0)
252b5132 7819 {
66543521
AM		 7820 unsigned long i;
7821 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 7822 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 7823 for (i = 1; i <= maxlength; ++i)
103f02d3 7824 {
66543521
AM		 7825 nzero_counts += counts[i] * i;
7826 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7827 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 7828 (nzero_counts * 100.0) / nsyms);
7829 }
252b5132
RH		 7830 }
7831
7832 free (counts);
7833 free (lengths);
7834 }
7835
7836 if (buckets != NULL)
7837 {
7838 free (buckets);
7839 free (chains);
7840 }
7841
d3a44ec6 7842 if (do_histogram && gnubuckets != NULL)
fdc90cb4 7843 {
2cf0635d
NC		 7844 unsigned long * lengths;
7845 unsigned long * counts;
fdc90cb4
JJ		 7846 unsigned long hn;
7847 unsigned long maxlength = 0;
7848 unsigned long nzero_counts = 0;
7849 unsigned long nsyms = 0;
fdc90cb4 7850
3f5e193b 7851 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 7852 if (lengths == NULL)
7853 {
591a748a 7854 error (_("Out of memory\n"));
fdc90cb4
JJ		 7855 return 0;
7856 }
7857
7858 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7859 (unsigned long) ngnubuckets);
7860 printf (_(" Length Number %% of total Coverage\n"));
7861
7862 for (hn = 0; hn < ngnubuckets; ++hn)
7863 if (gnubuckets[hn] != 0)
7864 {
7865 bfd_vma off, length = 1;
7866
6bd1a22c 7867 for (off = gnubuckets[hn] - gnusymidx;
fdc90cb4
JJ		 7868 (gnuchains[off] & 1) == 0; ++off)
7869 ++length;
7870 lengths[hn] = length;
7871 if (length > maxlength)
7872 maxlength = length;
7873 nsyms += length;
7874 }
7875
3f5e193b 7876 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 7877 if (counts == NULL)
7878 {
591a748a 7879 error (_("Out of memory\n"));
fdc90cb4
JJ		 7880 return 0;
7881 }
7882
7883 for (hn = 0; hn < ngnubuckets; ++hn)
7884 ++counts[lengths[hn]];
7885
7886 if (ngnubuckets > 0)
7887 {
7888 unsigned long j;
7889 printf (" 0 %-10lu (%5.1f%%)\n",
7890 counts[0], (counts[0] * 100.0) / ngnubuckets);
7891 for (j = 1; j <= maxlength; ++j)
7892 {
7893 nzero_counts += counts[j] * j;
7894 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7895 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
7896 (nzero_counts * 100.0) / nsyms);
7897 }
7898 }
7899
7900 free (counts);
7901 free (lengths);
7902 free (gnubuckets);
7903 free (gnuchains);
7904 }
7905
252b5132
RH		 7906 return 1;
7907}
7908
7909static int
2cf0635d 7910process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 7911{
b4c96d0d 7912 unsigned int i;
252b5132
RH		 7913
7914 if (dynamic_syminfo == NULL
7915 || !do_dynamic)
7916 /* No syminfo, this is ok. */
7917 return 1;
7918
7919 /* There better should be a dynamic symbol section. */
7920 if (dynamic_symbols == NULL || dynamic_strings == NULL)
7921 return 0;
7922
7923 if (dynamic_addr)
7924 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7925 dynamic_syminfo_offset, dynamic_syminfo_nent);
7926
7927 printf (_(" Num: Name BoundTo Flags\n"));
7928 for (i = 0; i < dynamic_syminfo_nent; ++i)
7929 {
7930 unsigned short int flags = dynamic_syminfo[i].si_flags;
7931
31104126 7932 printf ("%4d: ", i);
d79b3d50
NC		 7933 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
7934 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
7935 else
7936 printf ("<corrupt: %19ld>", dynamic_symbols[i].st_name);
31104126 7937 putchar (' ');
252b5132
RH		 7938
7939 switch (dynamic_syminfo[i].si_boundto)
7940 {
7941 case SYMINFO_BT_SELF:
7942 fputs ("SELF ", stdout);
7943 break;
7944 case SYMINFO_BT_PARENT:
7945 fputs ("PARENT ", stdout);
7946 break;
7947 default:
7948 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 7949 && dynamic_syminfo[i].si_boundto < dynamic_nent
7950 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 7951 {
d79b3d50 7952 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 7953 putchar (' ' );
7954 }
252b5132
RH		 7955 else
7956 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
7957 break;
7958 }
7959
7960 if (flags & SYMINFO_FLG_DIRECT)
7961 printf (" DIRECT");
7962 if (flags & SYMINFO_FLG_PASSTHRU)
7963 printf (" PASSTHRU");
7964 if (flags & SYMINFO_FLG_COPY)
7965 printf (" COPY");
7966 if (flags & SYMINFO_FLG_LAZYLOAD)
7967 printf (" LAZYLOAD");
7968
7969 puts ("");
7970 }
7971
7972 return 1;
7973}
7974
cf13d699
NC		 7975/* Check to see if the given reloc needs to be handled in a target specific
7976 manner. If so then process the reloc and return TRUE otherwise return
7977 FALSE. */
09c11c86 7978
cf13d699
NC		 7979static bfd_boolean
7980target_specific_reloc_handling (Elf_Internal_Rela * reloc,
7981 unsigned char * start,
7982 Elf_Internal_Sym * symtab)
252b5132 7983{
cf13d699 7984 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 7985
cf13d699 7986 switch (elf_header.e_machine)
252b5132 7987 {
cf13d699
NC		 7988 case EM_MN10300:
7989 case EM_CYGNUS_MN10300:
7990 {
7991 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 7992
cf13d699
NC		 7993 switch (reloc_type)
7994 {
7995 case 34: /* R_MN10300_ALIGN */
7996 return TRUE;
7997 case 33: /* R_MN10300_SYM_DIFF */
7998 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
7999 return TRUE;
8000 case 1: /* R_MN10300_32 */
8001 case 2: /* R_MN10300_16 */
8002 if (saved_sym != NULL)
8003 {
8004 bfd_vma value;
252b5132 8005
cf13d699
NC		 8006 value = reloc->r_addend
8007 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
8008 - saved_sym->st_value);
252b5132 8009
cf13d699 8010 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 8011
cf13d699
NC		 8012 saved_sym = NULL;
8013 return TRUE;
8014 }
8015 break;
8016 default:
8017 if (saved_sym != NULL)
8018 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
8019 break;
8020 }
8021 break;
8022 }
252b5132
RH		 8023 }
8024
cf13d699 8025 return FALSE;
252b5132
RH		 8026}
8027
aca88567
NC		 8028/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
8029 DWARF debug sections. This is a target specific test. Note - we do not
8030 go through the whole including-target-headers-multiple-times route, (as
8031 we have already done with <elf/h8.h>) because this would become very
8032 messy and even then this function would have to contain target specific
8033 information (the names of the relocs instead of their numeric values).
8034 FIXME: This is not the correct way to solve this problem. The proper way
8035 is to have target specific reloc sizing and typing functions created by
8036 the reloc-macros.h header, in the same way that it already creates the
8037 reloc naming functions. */
8038
8039static bfd_boolean
8040is_32bit_abs_reloc (unsigned int reloc_type)
8041{
8042 switch (elf_header.e_machine)
8043 {
41e92641
NC		 8044 case EM_386:
8045 case EM_486:
8046 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 8047 case EM_68K:
8048 return reloc_type == 1; /* R_68K_32. */
8049 case EM_860:
8050 return reloc_type == 1; /* R_860_32. */
8051 case EM_ALPHA:
8052 return reloc_type == 1; /* XXX Is this right ? */
41e92641
NC		 8053 case EM_ARC:
8054 return reloc_type == 1; /* R_ARC_32. */
8055 case EM_ARM:
8056 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 8057 case EM_AVR_OLD:
aca88567
NC		 8058 case EM_AVR:
8059 return reloc_type == 1;
8060 case EM_BLACKFIN:
8061 return reloc_type == 0x12; /* R_byte4_data. */
8062 case EM_CRIS:
8063 return reloc_type == 3; /* R_CRIS_32. */
8064 case EM_CR16:
6c03b1ed 8065 case EM_CR16_OLD:
aca88567
NC		 8066 return reloc_type == 3; /* R_CR16_NUM32. */
8067 case EM_CRX:
8068 return reloc_type == 15; /* R_CRX_NUM32. */
8069 case EM_CYGNUS_FRV:
8070 return reloc_type == 1;
41e92641
NC		 8071 case EM_CYGNUS_D10V:
8072 case EM_D10V:
8073 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 8074 case EM_CYGNUS_D30V:
8075 case EM_D30V:
8076 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 8077 case EM_DLX:
8078 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 8079 case EM_CYGNUS_FR30:
8080 case EM_FR30:
8081 return reloc_type == 3; /* R_FR30_32. */
8082 case EM_H8S:
8083 case EM_H8_300:
8084 case EM_H8_300H:
8085 return reloc_type == 1; /* R_H8_DIR32. */
3730236a
NC		 8086 case EM_IA_64:
8087 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
aca88567
NC		 8088 case EM_IP2K_OLD:
8089 case EM_IP2K:
8090 return reloc_type == 2; /* R_IP2K_32. */
8091 case EM_IQ2000:
8092 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 8093 case EM_LATTICEMICO32:
8094 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 8095 case EM_M32C_OLD:
aca88567
NC		 8096 case EM_M32C:
8097 return reloc_type == 3; /* R_M32C_32. */
8098 case EM_M32R:
8099 return reloc_type == 34; /* R_M32R_32_RELA. */
8100 case EM_MCORE:
8101 return reloc_type == 1; /* R_MCORE_ADDR32. */
8102 case EM_CYGNUS_MEP:
8103 return reloc_type == 4; /* R_MEP_32. */
8104 case EM_MIPS:
8105 return reloc_type == 2; /* R_MIPS_32. */
8106 case EM_MMIX:
8107 return reloc_type == 4; /* R_MMIX_32. */
8108 case EM_CYGNUS_MN10200:
8109 case EM_MN10200:
8110 return reloc_type == 1; /* R_MN10200_32. */
8111 case EM_CYGNUS_MN10300:
8112 case EM_MN10300:
8113 return reloc_type == 1; /* R_MN10300_32. */
8114 case EM_MSP430_OLD:
8115 case EM_MSP430:
8116 return reloc_type == 1; /* R_MSP43_32. */
8117 case EM_MT:
8118 return reloc_type == 2; /* R_MT_32. */
3e0873ac
NC		 8119 case EM_ALTERA_NIOS2:
8120 case EM_NIOS32:
8121 return reloc_type == 1; /* R_NIOS_32. */
41e92641
NC		 8122 case EM_OPENRISC:
8123 case EM_OR32:
8124 return reloc_type == 1; /* R_OR32_32. */
aca88567 8125 case EM_PARISC:
5fda8eca
NC		 8126 return (reloc_type == 1 /* R_PARISC_DIR32. */
8127 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 8128 case EM_PJ:
8129 case EM_PJ_OLD:
8130 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
8131 case EM_PPC64:
8132 return reloc_type == 1; /* R_PPC64_ADDR32. */
8133 case EM_PPC:
8134 return reloc_type == 1; /* R_PPC_ADDR32. */
c7927a3c
NC		 8135 case EM_RX:
8136 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 8137 case EM_S370:
8138 return reloc_type == 1; /* R_I370_ADDR31. */
8139 case EM_S390_OLD:
8140 case EM_S390:
8141 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 8142 case EM_SCORE:
8143 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 8144 case EM_SH:
8145 return reloc_type == 1; /* R_SH_DIR32. */
8146 case EM_SPARC32PLUS:
8147 case EM_SPARCV9:
8148 case EM_SPARC:
8149 return reloc_type == 3 /* R_SPARC_32. */
8150 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 8151 case EM_SPU:
8152 return reloc_type == 6; /* R_SPU_ADDR32 */
aca88567
NC		 8153 case EM_CYGNUS_V850:
8154 case EM_V850:
8155 return reloc_type == 6; /* R_V850_ABS32. */
8156 case EM_VAX:
8157 return reloc_type == 1; /* R_VAX_32. */
8158 case EM_X86_64:
8a9036a4 8159 case EM_L1OM:
aca88567 8160 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 8161 case EM_XC16X:
8162 case EM_C166:
8163 return reloc_type == 3; /* R_XC16C_ABS_32. */
aca88567
NC		 8164 case EM_XSTORMY16:
8165 return reloc_type == 1; /* R_XSTROMY16_32. */
8166 case EM_XTENSA_OLD:
8167 case EM_XTENSA:
8168 return reloc_type == 1; /* R_XTENSA_32. */
aca88567
NC		 8169 default:
8170 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
8171 elf_header.e_machine);
8172 abort ();
8173 }
8174}
8175
8176/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8177 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
8178
8179static bfd_boolean
8180is_32bit_pcrel_reloc (unsigned int reloc_type)
8181{
8182 switch (elf_header.e_machine)
8183 {
41e92641
NC		 8184 case EM_386:
8185 case EM_486:
3e0873ac 8186 return reloc_type == 2; /* R_386_PC32. */
aca88567 8187 case EM_68K:
3e0873ac 8188 return reloc_type == 4; /* R_68K_PC32. */
aca88567
NC		 8189 case EM_ALPHA:
8190 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 8191 case EM_ARM:
3e0873ac 8192 return reloc_type == 3; /* R_ARM_REL32 */
aca88567 8193 case EM_PARISC:
85acf597 8194 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 8195 case EM_PPC:
8196 return reloc_type == 26; /* R_PPC_REL32. */
8197 case EM_PPC64:
3e0873ac 8198 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 8199 case EM_S390_OLD:
8200 case EM_S390:
3e0873ac 8201 return reloc_type == 5; /* R_390_PC32. */
aca88567 8202 case EM_SH:
3e0873ac 8203 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 8204 case EM_SPARC32PLUS:
8205 case EM_SPARCV9:
8206 case EM_SPARC:
3e0873ac 8207 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 8208 case EM_SPU:
8209 return reloc_type == 13; /* R_SPU_REL32. */
aca88567 8210 case EM_X86_64:
8a9036a4 8211 case EM_L1OM:
3e0873ac 8212 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 8213 case EM_XTENSA_OLD:
8214 case EM_XTENSA:
8215 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 8216 default:
8217 /* Do not abort or issue an error message here. Not all targets use
8218 pc-relative 32-bit relocs in their DWARF debug information and we
8219 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 8220 more helpful warning message will be generated by apply_relocations
8221 anyway, so just return. */
aca88567
NC		 8222 return FALSE;
8223 }
8224}
8225
8226/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8227 a 64-bit absolute RELA relocation used in DWARF debug sections. */
8228
8229static bfd_boolean
8230is_64bit_abs_reloc (unsigned int reloc_type)
8231{
8232 switch (elf_header.e_machine)
8233 {
8234 case EM_ALPHA:
8235 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 8236 case EM_IA_64:
8237 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 8238 case EM_PARISC:
8239 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 8240 case EM_PPC64:
8241 return reloc_type == 38; /* R_PPC64_ADDR64. */
8242 case EM_SPARC32PLUS:
8243 case EM_SPARCV9:
8244 case EM_SPARC:
8245 return reloc_type == 54; /* R_SPARC_UA64. */
8246 case EM_X86_64:
8a9036a4 8247 case EM_L1OM:
aca88567 8248 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 8249 case EM_S390_OLD:
8250 case EM_S390:
8251 return reloc_type == 22; /* R_S390_64 */
85a82265
AM		 8252 case EM_MIPS:
8253 return reloc_type == 18; /* R_MIPS_64 */
aca88567
NC		 8254 default:
8255 return FALSE;
8256 }
8257}
8258
85acf597
RH		 8259/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
8260 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
8261
8262static bfd_boolean
8263is_64bit_pcrel_reloc (unsigned int reloc_type)
8264{
8265 switch (elf_header.e_machine)
8266 {
8267 case EM_ALPHA:
8268 return reloc_type == 11; /* R_ALPHA_SREL64 */
8269 case EM_IA_64:
8270 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB */
8271 case EM_PARISC:
8272 return reloc_type == 72; /* R_PARISC_PCREL64 */
8273 case EM_PPC64:
8274 return reloc_type == 44; /* R_PPC64_REL64 */
8275 case EM_SPARC32PLUS:
8276 case EM_SPARCV9:
8277 case EM_SPARC:
8278 return reloc_type == 46; /* R_SPARC_DISP64 */
8279 case EM_X86_64:
8a9036a4 8280 case EM_L1OM:
85acf597
RH		 8281 return reloc_type == 24; /* R_X86_64_PC64 */
8282 case EM_S390_OLD:
8283 case EM_S390:
8284 return reloc_type == 23; /* R_S390_PC64 */
8285 default:
8286 return FALSE;
8287 }
8288}
8289
4dc3c23d
AM		 8290/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8291 a 24-bit absolute RELA relocation used in DWARF debug sections. */
8292
8293static bfd_boolean
8294is_24bit_abs_reloc (unsigned int reloc_type)
8295{
8296 switch (elf_header.e_machine)
8297 {
8298 case EM_CYGNUS_MN10200:
8299 case EM_MN10200:
8300 return reloc_type == 4; /* R_MN10200_24. */
8301 default:
8302 return FALSE;
8303 }
8304}
8305
aca88567
NC		 8306/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8307 a 16-bit absolute RELA relocation used in DWARF debug sections. */
8308
8309static bfd_boolean
8310is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 8311{
8312 switch (elf_header.e_machine)
8313 {
aca88567
NC		 8314 case EM_AVR_OLD:
8315 case EM_AVR:
8316 return reloc_type == 4; /* R_AVR_16. */
41e92641
NC		 8317 case EM_CYGNUS_D10V:
8318 case EM_D10V:
8319 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 8320 case EM_H8S:
8321 case EM_H8_300:
8322 case EM_H8_300H:
aca88567
NC		 8323 return reloc_type == R_H8_DIR16;
8324 case EM_IP2K_OLD:
8325 case EM_IP2K:
8326 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 8327 case EM_M32C_OLD:
f4236fe4
DD		 8328 case EM_M32C:
8329 return reloc_type == 1; /* R_M32C_16 */
aca88567
NC		 8330 case EM_MSP430_OLD:
8331 case EM_MSP430:
8332 return reloc_type == 5; /* R_MSP430_16_BYTE. */
3e0873ac
NC		 8333 case EM_ALTERA_NIOS2:
8334 case EM_NIOS32:
8335 return reloc_type == 9; /* R_NIOS_16. */
c29aca4a
NC		 8336 case EM_XC16X:
8337 case EM_C166:
8338 return reloc_type == 2; /* R_XC16C_ABS_16. */
4b78141a 8339 default:
aca88567 8340 return FALSE;
4b78141a
NC		 8341 }
8342}
8343
2a7b2e88
JK		 8344/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
8345 relocation entries (possibly formerly used for SHT_GROUP sections). */
8346
8347static bfd_boolean
8348is_none_reloc (unsigned int reloc_type)
8349{
8350 switch (elf_header.e_machine)
8351 {
cb8f3167
NC		 8352 case EM_68K: /* R_68K_NONE. */
8353 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 8354 case EM_SPARC32PLUS:
8355 case EM_SPARCV9:
cb8f3167
NC		 8356 case EM_SPARC: /* R_SPARC_NONE. */
8357 case EM_MIPS: /* R_MIPS_NONE. */
8358 case EM_PARISC: /* R_PARISC_NONE. */
8359 case EM_ALPHA: /* R_ALPHA_NONE. */
8360 case EM_PPC: /* R_PPC_NONE. */
8361 case EM_PPC64: /* R_PPC64_NONE. */
8362 case EM_ARM: /* R_ARM_NONE. */
8363 case EM_IA_64: /* R_IA64_NONE. */
8364 case EM_SH: /* R_SH_NONE. */
2a7b2e88 8365 case EM_S390_OLD:
cb8f3167
NC		 8366 case EM_S390: /* R_390_NONE. */
8367 case EM_CRIS: /* R_CRIS_NONE. */
8368 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 8369 case EM_L1OM: /* R_X86_64_NONE. */
cb8f3167
NC		 8370 case EM_MN10300: /* R_MN10300_NONE. */
8371 case EM_M32R: /* R_M32R_NONE. */
c29aca4a
NC		 8372 case EM_XC16X:
8373 case EM_C166: /* R_XC16X_NONE. */
cb8f3167 8374 return reloc_type == 0;
58332dda
JK		 8375 case EM_XTENSA_OLD:
8376 case EM_XTENSA:
4dc3c23d
AM		 8377 return (reloc_type == 0 /* R_XTENSA_NONE. */
8378 || reloc_type == 17 /* R_XTENSA_DIFF8. */
8379 || reloc_type == 18 /* R_XTENSA_DIFF16. */
8380 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
2a7b2e88
JK		 8381 }
8382 return FALSE;
8383}
8384
cf13d699
NC		 8385/* Apply relocations to a section.
8386 Note: So far support has been added only for those relocations
8387 which can be found in debug sections.
8388 FIXME: Add support for more relocations ? */
1b315056 8389
cf13d699
NC		 8390static void
8391apply_relocations (void * file,
8392 Elf_Internal_Shdr * section,
8393 unsigned char * start)
1b315056 8394{
cf13d699
NC		 8395 Elf_Internal_Shdr * relsec;
8396 unsigned char * end = start + section->sh_size;
cb8f3167 8397
cf13d699
NC		 8398 if (elf_header.e_type != ET_REL)
8399 return;
1b315056 8400
cf13d699 8401 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 8402 for (relsec = section_headers;
8403 relsec < section_headers + elf_header.e_shnum;
8404 ++relsec)
252b5132 8405 {
41e92641
NC		 8406 bfd_boolean is_rela;
8407 unsigned long num_relocs;
2cf0635d
NC		 8408 Elf_Internal_Rela * relocs;
8409 Elf_Internal_Rela * rp;
8410 Elf_Internal_Shdr * symsec;
8411 Elf_Internal_Sym * symtab;
8412 Elf_Internal_Sym * sym;
252b5132 8413
41e92641 8414 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 8415 || relsec->sh_info >= elf_header.e_shnum
8416 || section_headers + relsec->sh_info != section
c256ffe7 8417 || relsec->sh_size == 0
4fbb74a6 8418 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 8419 continue;
428409d5 8420
41e92641
NC		 8421 is_rela = relsec->sh_type == SHT_RELA;
8422
8423 if (is_rela)
8424 {
3f5e193b
NC		 8425 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
8426 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 8427 return;
8428 }
8429 else
8430 {
3f5e193b
NC		 8431 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
8432 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 8433 return;
8434 }
8435
8436 /* SH uses RELA but uses in place value instead of the addend field. */
8437 if (elf_header.e_machine == EM_SH)
8438 is_rela = FALSE;
428409d5 8439
4fbb74a6 8440 symsec = section_headers + relsec->sh_link;
3f5e193b 8441 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec);
103f02d3 8442
41e92641 8443 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 8444 {
41e92641
NC		 8445 bfd_vma addend;
8446 unsigned int reloc_type;
8447 unsigned int reloc_size;
8448 unsigned char * loc;
4b78141a 8449
aca88567 8450 reloc_type = get_reloc_type (rp->r_info);
41e92641 8451
98fb390a 8452 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 8453 continue;
98fb390a
NC		 8454 else if (is_none_reloc (reloc_type))
8455 continue;
8456 else if (is_32bit_abs_reloc (reloc_type)
8457 || is_32bit_pcrel_reloc (reloc_type))
aca88567 8458 reloc_size = 4;
85acf597
RH		 8459 else if (is_64bit_abs_reloc (reloc_type)
8460 || is_64bit_pcrel_reloc (reloc_type))
aca88567 8461 reloc_size = 8;
4dc3c23d
AM		 8462 else if (is_24bit_abs_reloc (reloc_type))
8463 reloc_size = 3;
aca88567
NC		 8464 else if (is_16bit_abs_reloc (reloc_type))
8465 reloc_size = 2;
8466 else
4b78141a 8467 {
41e92641 8468 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
aca88567 8469 reloc_type, SECTION_NAME (section));
4b78141a
NC		 8470 continue;
8471 }
103f02d3 8472
700dd8b7
L		 8473 loc = start + rp->r_offset;
8474 if ((loc + reloc_size) > end)
8475 {
8476 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8477 (unsigned long) rp->r_offset,
8478 SECTION_NAME (section));
8479 continue;
8480 }
103f02d3 8481
41e92641
NC		 8482 sym = symtab + get_reloc_symindex (rp->r_info);
8483
8484 /* If the reloc has a symbol associated with it,
55f25fc3
L		 8485 make sure that it is of an appropriate type.
8486
8487 Relocations against symbols without type can happen.
8488 Gcc -feliminate-dwarf2-dups may generate symbols
8489 without type for debug info.
8490
8491 Icc generates relocations against function symbols
8492 instead of local labels.
8493
8494 Relocations against object symbols can happen, eg when
8495 referencing a global array. For an example of this see
8496 the _clz.o binary in libgcc.a. */
aca88567 8497 if (sym != symtab
55f25fc3 8498 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 8499 {
41e92641 8500 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 8501 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 8502 (long int)(rp - relocs),
41e92641 8503 SECTION_NAME (relsec));
aca88567 8504 continue;
5b18a4bc 8505 }
252b5132 8506
4dc3c23d
AM		 8507 addend = 0;
8508 if (is_rela)
8509 addend += rp->r_addend;
8510 /* R_XTENSA_32 and R_PJ_DATA_DIR32 are partial_inplace. */
8511 if (!is_rela
8512 || (elf_header.e_machine == EM_XTENSA
8513 && reloc_type == 1)
8514 || ((elf_header.e_machine == EM_PJ
8515 || elf_header.e_machine == EM_PJ_OLD)
8516 && reloc_type == 1))
8517 addend += byte_get (loc, reloc_size);
cb8f3167 8518
85acf597
RH		 8519 if (is_32bit_pcrel_reloc (reloc_type)
8520 || is_64bit_pcrel_reloc (reloc_type))
8521 {
8522 /* On HPPA, all pc-relative relocations are biased by 8. */
8523 if (elf_header.e_machine == EM_PARISC)
8524 addend -= 8;
8525 byte_put (loc, (addend + sym->st_value) - rp->r_offset,
8526 reloc_size);
8527 }
41e92641
NC		 8528 else
8529 byte_put (loc, addend + sym->st_value, reloc_size);
5b18a4bc 8530 }
252b5132 8531
5b18a4bc 8532 free (symtab);
41e92641 8533 free (relocs);
5b18a4bc
NC		 8534 break;
8535 }
5b18a4bc 8536}
103f02d3 8537
cf13d699
NC		 8538#ifdef SUPPORT_DISASSEMBLY
8539static int
8540disassemble_section (Elf_Internal_Shdr * section, FILE * file)
8541{
8542 printf (_("\nAssembly dump of section %s\n"),
8543 SECTION_NAME (section));
8544
8545 /* XXX -- to be done --- XXX */
8546
8547 return 1;
8548}
8549#endif
8550
8551/* Reads in the contents of SECTION from FILE, returning a pointer
8552 to a malloc'ed buffer or NULL if something went wrong. */
8553
8554static char *
8555get_section_contents (Elf_Internal_Shdr * section, FILE * file)
8556{
8557 bfd_size_type num_bytes;
8558
8559 num_bytes = section->sh_size;
8560
8561 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
8562 {
8563 printf (_("\nSection '%s' has no data to dump.\n"),
8564 SECTION_NAME (section));
8565 return NULL;
8566 }
8567
3f5e193b
NC		 8568 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
8569 _("section contents"));
cf13d699
NC		 8570}
8571
8572
8573static void
8574dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
8575{
8576 Elf_Internal_Shdr * relsec;
8577 bfd_size_type num_bytes;
8578 bfd_vma addr;
8579 char * data;
8580 char * end;
8581 char * start;
8582 char * name = SECTION_NAME (section);
8583 bfd_boolean some_strings_shown;
8584
8585 start = get_section_contents (section, file);
8586 if (start == NULL)
8587 return;
8588
8589 printf (_("\nString dump of section '%s':\n"), name);
8590
8591 /* If the section being dumped has relocations against it the user might
8592 be expecting these relocations to have been applied. Check for this
8593 case and issue a warning message in order to avoid confusion.
8594 FIXME: Maybe we ought to have an option that dumps a section with
8595 relocs applied ? */
8596 for (relsec = section_headers;
8597 relsec < section_headers + elf_header.e_shnum;
8598 ++relsec)
8599 {
8600 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
8601 || relsec->sh_info >= elf_header.e_shnum
8602 || section_headers + relsec->sh_info != section
8603 || relsec->sh_size == 0
8604 || relsec->sh_link >= elf_header.e_shnum)
8605 continue;
8606
8607 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
8608 break;
8609 }
8610
8611 num_bytes = section->sh_size;
8612 addr = section->sh_addr;
8613 data = start;
8614 end = start + num_bytes;
8615 some_strings_shown = FALSE;
8616
8617 while (data < end)
8618 {
8619 while (!ISPRINT (* data))
8620 if (++ data >= end)
8621 break;
8622
8623 if (data < end)
8624 {
8625#ifndef __MSVCRT__
8626 printf (" [%6tx] %s\n", data - start, data);
8627#else
8628 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
8629#endif
8630 data += strlen (data);
8631 some_strings_shown = TRUE;
8632 }
8633 }
8634
8635 if (! some_strings_shown)
8636 printf (_(" No strings found in this section."));
8637
8638 free (start);
8639
8640 putchar ('\n');
8641}
8642
8643static void
8644dump_section_as_bytes (Elf_Internal_Shdr * section,
8645 FILE * file,
8646 bfd_boolean relocate)
8647{
8648 Elf_Internal_Shdr * relsec;
8649 bfd_size_type bytes;
8650 bfd_vma addr;
8651 unsigned char * data;
8652 unsigned char * start;
8653
8654 start = (unsigned char *) get_section_contents (section, file);
8655 if (start == NULL)
8656 return;
8657
8658 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
8659
8660 if (relocate)
8661 {
8662 apply_relocations (file, section, start);
8663 }
8664 else
8665 {
8666 /* If the section being dumped has relocations against it the user might
8667 be expecting these relocations to have been applied. Check for this
8668 case and issue a warning message in order to avoid confusion.
8669 FIXME: Maybe we ought to have an option that dumps a section with
8670 relocs applied ? */
8671 for (relsec = section_headers;
8672 relsec < section_headers + elf_header.e_shnum;
8673 ++relsec)
8674 {
8675 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
8676 || relsec->sh_info >= elf_header.e_shnum
8677 || section_headers + relsec->sh_info != section
8678 || relsec->sh_size == 0
8679 || relsec->sh_link >= elf_header.e_shnum)
8680 continue;
8681
8682 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
8683 break;
8684 }
8685 }
8686
8687 addr = section->sh_addr;
8688 bytes = section->sh_size;
8689 data = start;
8690
8691 while (bytes)
8692 {
8693 int j;
8694 int k;
8695 int lbytes;
8696
8697 lbytes = (bytes > 16 ? 16 : bytes);
8698
8699 printf (" 0x%8.8lx ", (unsigned long) addr);
8700
8701 for (j = 0; j < 16; j++)
8702 {
8703 if (j < lbytes)
8704 printf ("%2.2x", data[j]);
8705 else
8706 printf (" ");
8707
8708 if ((j & 3) == 3)
8709 printf (" ");
8710 }
8711
8712 for (j = 0; j < lbytes; j++)
8713 {
8714 k = data[j];
8715 if (k >= ' ' && k < 0x7f)
8716 printf ("%c", k);
8717 else
8718 printf (".");
8719 }
8720
8721 putchar ('\n');
8722
8723 data += lbytes;
8724 addr += lbytes;
8725 bytes -= lbytes;
8726 }
8727
8728 free (start);
8729
8730 putchar ('\n');
8731}
8732
8733/* Uncompresses a section that was compressed using zlib, in place.
8734 This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
8735
8736static int
8737uncompress_section_contents (unsigned char ** buffer, dwarf_size_type * size)
8738{
8739#ifndef HAVE_ZLIB_H
8740 /* These are just to quiet gcc. */
8741 buffer = 0;
8742 size = 0;
8743 return FALSE;
8744#else
8745 dwarf_size_type compressed_size = *size;
8746 unsigned char * compressed_buffer = *buffer;
8747 dwarf_size_type uncompressed_size;
8748 unsigned char * uncompressed_buffer;
8749 z_stream strm;
8750 int rc;
8751 dwarf_size_type header_size = 12;
8752
8753 /* Read the zlib header. In this case, it should be "ZLIB" followed
8754 by the uncompressed section size, 8 bytes in big-endian order. */
8755 if (compressed_size < header_size
8756 || ! streq ((char *) compressed_buffer, "ZLIB"))
8757 return 0;
8758
8759 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
8760 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
8761 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
8762 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
8763 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
8764 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
8765 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
8766 uncompressed_size += compressed_buffer[11];
8767
8768 /* It is possible the section consists of several compressed
8769 buffers concatenated together, so we uncompress in a loop. */
8770 strm.zalloc = NULL;
8771 strm.zfree = NULL;
8772 strm.opaque = NULL;
8773 strm.avail_in = compressed_size - header_size;
8774 strm.next_in = (Bytef *) compressed_buffer + header_size;
8775 strm.avail_out = uncompressed_size;
3f5e193b 8776 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
cf13d699
NC		 8777
8778 rc = inflateInit (& strm);
8779 while (strm.avail_in > 0)
8780 {
8781 if (rc != Z_OK)
8782 goto fail;
8783 strm.next_out = ((Bytef *) uncompressed_buffer
8784 + (uncompressed_size - strm.avail_out));
8785 rc = inflate (&strm, Z_FINISH);
8786 if (rc != Z_STREAM_END)
8787 goto fail;
8788 rc = inflateReset (& strm);
8789 }
8790 rc = inflateEnd (& strm);
8791 if (rc != Z_OK
8792 || strm.avail_out != 0)
8793 goto fail;
8794
8795 free (compressed_buffer);
8796 *buffer = uncompressed_buffer;
8797 *size = uncompressed_size;
8798 return 1;
8799
8800 fail:
8801 free (uncompressed_buffer);
8802 return 0;
8803#endif /* HAVE_ZLIB_H */
8804}
8805
d966045b
DJ		 8806static int
8807load_specific_debug_section (enum dwarf_section_display_enum debug,
2cf0635d 8808 Elf_Internal_Shdr * sec, void * file)
1007acb3 8809{
2cf0635d 8810 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 8811 char buf [64];
1b315056 8812 int section_is_compressed;
1007acb3 8813
19e6b90e
L		 8814 /* If it is already loaded, do nothing. */
8815 if (section->start != NULL)
8816 return 1;
1007acb3 8817
a71cc8e0 8818 section_is_compressed = section->name == section->compressed_name;
1007acb3 8819
19e6b90e
L		 8820 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
8821 section->address = sec->sh_addr;
8822 section->size = sec->sh_size;
3f5e193b
NC		 8823 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
8824 sec->sh_offset, 1,
8825 sec->sh_size, buf);
1b315056
CS		 8826 if (section->start == NULL)
8827 return 0;
8828
8829 if (section_is_compressed)
8830 if (! uncompress_section_contents (&section->start, &section->size))
8831 return 0;
1007acb3 8832
19e6b90e 8833 if (debug_displays [debug].relocate)
3f5e193b 8834 apply_relocations ((FILE *) file, sec, section->start);
1007acb3 8835
1b315056 8836 return 1;
1007acb3
L		 8837}
8838
d966045b 8839int
2cf0635d 8840load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 8841{
2cf0635d
NC		 8842 struct dwarf_section * section = &debug_displays [debug].section;
8843 Elf_Internal_Shdr * sec;
d966045b
DJ		 8844
8845 /* Locate the debug section. */
8846 sec = find_section (section->uncompressed_name);
8847 if (sec != NULL)
8848 section->name = section->uncompressed_name;
8849 else
8850 {
8851 sec = find_section (section->compressed_name);
8852 if (sec != NULL)
8853 section->name = section->compressed_name;
8854 }
8855 if (sec == NULL)
8856 return 0;
8857
3f5e193b 8858 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 8859}
8860
19e6b90e
L		 8861void
8862free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 8863{
2cf0635d 8864 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 8865
19e6b90e
L		 8866 if (section->start == NULL)
8867 return;
1007acb3 8868
19e6b90e
L		 8869 free ((char *) section->start);
8870 section->start = NULL;
8871 section->address = 0;
8872 section->size = 0;
1007acb3
L		 8873}
8874
1007acb3 8875static int
2cf0635d 8876display_debug_section (Elf_Internal_Shdr * section, FILE * file)
1007acb3 8877{
2cf0635d 8878 char * name = SECTION_NAME (section);
19e6b90e
L		 8879 bfd_size_type length;
8880 int result = 1;
3f5e193b 8881 int i;
1007acb3 8882
19e6b90e
L		 8883 length = section->sh_size;
8884 if (length == 0)
1007acb3 8885 {
19e6b90e
L		 8886 printf (_("\nSection '%s' has no debugging data.\n"), name);
8887 return 0;
1007acb3 8888 }
5dff79d8
NC		 8889 if (section->sh_type == SHT_NOBITS)
8890 {
8891 /* There is no point in dumping the contents of a debugging section
8892 which has the NOBITS type - the bits in the file will be random.
8893 This can happen when a file containing a .eh_frame section is
8894 stripped with the --only-keep-debug command line option. */
8895 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
8896 return 0;
8897 }
1007acb3 8898
0112cd26 8899 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 8900 name = ".debug_info";
1007acb3 8901
19e6b90e
L		 8902 /* See if we know how to display the contents of this section. */
8903 for (i = 0; i < max; i++)
1b315056
CS		 8904 if (streq (debug_displays[i].section.uncompressed_name, name)
8905 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 8906 {
2cf0635d 8907 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 8908 int secondary = (section != find_section (name));
8909
8910 if (secondary)
3f5e193b 8911 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 8912
2b6f5997 8913 if (streq (sec->uncompressed_name, name))
d966045b
DJ		 8914 sec->name = sec->uncompressed_name;
8915 else
8916 sec->name = sec->compressed_name;
3f5e193b
NC		 8917 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
8918 section, file))
19e6b90e
L		 8919 {
8920 result &= debug_displays[i].display (sec, file);
1007acb3 8921
d966045b 8922 if (secondary || (i != info && i != abbrev))
3f5e193b 8923 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 8924 }
1007acb3 8925
19e6b90e
L		 8926 break;
8927 }
1007acb3 8928
19e6b90e 8929 if (i == max)
1007acb3 8930 {
19e6b90e
L		 8931 printf (_("Unrecognized debug section: %s\n"), name);
8932 result = 0;
1007acb3
L		 8933 }
8934
19e6b90e 8935 return result;
5b18a4bc 8936}
103f02d3 8937
aef1f6d0
DJ		 8938/* Set DUMP_SECTS for all sections where dumps were requested
8939 based on section name. */
8940
8941static void
8942initialise_dumps_byname (void)
8943{
2cf0635d 8944 struct dump_list_entry * cur;
aef1f6d0
DJ		 8945
8946 for (cur = dump_sects_byname; cur; cur = cur->next)
8947 {
8948 unsigned int i;
8949 int any;
8950
8951 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
8952 if (streq (SECTION_NAME (section_headers + i), cur->name))
8953 {
09c11c86 8954 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 8955 any = 1;
8956 }
8957
8958 if (!any)
8959 warn (_("Section '%s' was not dumped because it does not exist!\n"),
8960 cur->name);
8961 }
8962}
8963
5b18a4bc 8964static void
2cf0635d 8965process_section_contents (FILE * file)
5b18a4bc 8966{
2cf0635d 8967 Elf_Internal_Shdr * section;
19e6b90e 8968 unsigned int i;
103f02d3 8969
19e6b90e
L		 8970 if (! do_dump)
8971 return;
103f02d3 8972
aef1f6d0
DJ		 8973 initialise_dumps_byname ();
8974
19e6b90e
L		 8975 for (i = 0, section = section_headers;
8976 i < elf_header.e_shnum && i < num_dump_sects;
8977 i++, section++)
8978 {
8979#ifdef SUPPORT_DISASSEMBLY
8980 if (dump_sects[i] & DISASS_DUMP)
8981 disassemble_section (section, file);
8982#endif
8983 if (dump_sects[i] & HEX_DUMP)
cf13d699 8984 dump_section_as_bytes (section, file, FALSE);
103f02d3 8985
cf13d699
NC		 8986 if (dump_sects[i] & RELOC_DUMP)
8987 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 8988
8989 if (dump_sects[i] & STRING_DUMP)
8990 dump_section_as_strings (section, file);
cf13d699
NC		 8991
8992 if (dump_sects[i] & DEBUG_DUMP)
8993 display_debug_section (section, file);
5b18a4bc 8994 }
103f02d3 8995
19e6b90e
L		 8996 /* Check to see if the user requested a
8997 dump of a section that does not exist. */
8998 while (i++ < num_dump_sects)
8999 if (dump_sects[i])
9000 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 9001}
103f02d3 9002
5b18a4bc 9003static void
19e6b90e 9004process_mips_fpe_exception (int mask)
5b18a4bc 9005{
19e6b90e
L		 9006 if (mask)
9007 {
9008 int first = 1;
9009 if (mask & OEX_FPU_INEX)
9010 fputs ("INEX", stdout), first = 0;
9011 if (mask & OEX_FPU_UFLO)
9012 printf ("%sUFLO", first ? "" : "|"), first = 0;
9013 if (mask & OEX_FPU_OFLO)
9014 printf ("%sOFLO", first ? "" : "|"), first = 0;
9015 if (mask & OEX_FPU_DIV0)
9016 printf ("%sDIV0", first ? "" : "|"), first = 0;
9017 if (mask & OEX_FPU_INVAL)
9018 printf ("%sINVAL", first ? "" : "|");
9019 }
5b18a4bc 9020 else
19e6b90e 9021 fputs ("0", stdout);
5b18a4bc 9022}
103f02d3 9023
11c1ff18
PB		 9024/* ARM EABI attributes section. */
9025typedef struct
9026{
9027 int tag;
2cf0635d 9028 const char * name;
11c1ff18
PB		 9029 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
9030 int type;
2cf0635d 9031 const char ** table;
11c1ff18
PB		 9032} arm_attr_public_tag;
9033
2cf0635d 9034static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 9035 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
9e3c6df6 9036 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
2cf0635d
NC		 9037static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
9038static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 9039 {"No", "Thumb-1", "Thumb-2"};
2cf0635d 9040static const char * arm_attr_tag_VFP_arch[] =
62f3b8c8 9041 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
2cf0635d
NC		 9042static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
9043static const char * arm_attr_tag_Advanced_SIMD_arch[] = {"No", "NEONv1"};
9044static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 9045 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
9046 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 9047static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 9048 {"V6", "SB", "TLS", "Unused"};
2cf0635d 9049static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 9050 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 9051static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 9052 {"Absolute", "PC-relative", "None"};
2cf0635d 9053static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 9054 {"None", "direct", "GOT-indirect"};
2cf0635d 9055static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 9056 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 9057static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
9058static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 9059 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 9060static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
9061static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
9062static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 9063 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d
NC		 9064static const char * arm_attr_tag_ABI_align8_needed[] = {"No", "Yes", "4-byte"};
9065static const char * arm_attr_tag_ABI_align8_preserved[] =
11c1ff18 9066 {"No", "Yes, except leaf SP", "Yes"};
2cf0635d 9067static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 9068 {"Unused", "small", "int", "forced to int"};
2cf0635d 9069static const char * arm_attr_tag_ABI_HardFP_use[] =
11c1ff18 9070 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
2cf0635d 9071static const char * arm_attr_tag_ABI_VFP_args[] =
11c1ff18 9072 {"AAPCS", "VFP registers", "custom"};
2cf0635d 9073static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 9074 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 9075static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 9076 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
9077 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 9078static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 9079 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
9080 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d
NC		 9081static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
9082static const char * arm_attr_tag_VFP_HP_extension[] =
8e79c3df 9083 {"Not Allowed", "Allowed"};
2cf0635d 9084static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 9085 {"None", "IEEE 754", "Alternative Format"};
2cf0635d
NC		 9086static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
9087static const char * arm_attr_tag_Virtualization_use[] =
f5f53991 9088 {"Not Allowed", "Allowed"};
2cf0635d 9089static const char * arm_attr_tag_MPextension_use[] = {"Not Allowed", "Allowed"};
11c1ff18
PB		 9090
9091#define LOOKUP(id, name) \
9092 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 9093static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 9094{
9095 {4, "CPU_raw_name", 1, NULL},
9096 {5, "CPU_name", 1, NULL},
9097 LOOKUP(6, CPU_arch),
9098 {7, "CPU_arch_profile", 0, NULL},
9099 LOOKUP(8, ARM_ISA_use),
9100 LOOKUP(9, THUMB_ISA_use),
9101 LOOKUP(10, VFP_arch),
9102 LOOKUP(11, WMMX_arch),
f5f53991
AS		 9103 LOOKUP(12, Advanced_SIMD_arch),
9104 LOOKUP(13, PCS_config),
11c1ff18
PB		 9105 LOOKUP(14, ABI_PCS_R9_use),
9106 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 9107 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 9108 LOOKUP(17, ABI_PCS_GOT_use),
9109 LOOKUP(18, ABI_PCS_wchar_t),
9110 LOOKUP(19, ABI_FP_rounding),
9111 LOOKUP(20, ABI_FP_denormal),
9112 LOOKUP(21, ABI_FP_exceptions),
9113 LOOKUP(22, ABI_FP_user_exceptions),
9114 LOOKUP(23, ABI_FP_number_model),
9115 LOOKUP(24, ABI_align8_needed),
9116 LOOKUP(25, ABI_align8_preserved),
9117 LOOKUP(26, ABI_enum_size),
9118 LOOKUP(27, ABI_HardFP_use),
9119 LOOKUP(28, ABI_VFP_args),
9120 LOOKUP(29, ABI_WMMX_args),
9121 LOOKUP(30, ABI_optimization_goals),
9122 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 9123 {32, "compatibility", 0, NULL},
f5f53991 9124 LOOKUP(34, CPU_unaligned_access),
8e79c3df
CM		 9125 LOOKUP(36, VFP_HP_extension),
9126 LOOKUP(38, ABI_FP_16bit_format),
f5f53991
AS		 9127 {64, "nodefaults", 0, NULL},
9128 {65, "also_compatible_with", 0, NULL},
9129 LOOKUP(66, T2EE_use),
9130 {67, "conformance", 1, NULL},
9131 LOOKUP(68, Virtualization_use),
9132 LOOKUP(70, MPextension_use)
11c1ff18
PB		 9133};
9134#undef LOOKUP
9135
9136/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
9137 bytes read. */
2cf0635d 9138
11c1ff18 9139static unsigned int
2cf0635d 9140read_uleb128 (unsigned char * p, unsigned int * plen)
11c1ff18
PB		 9141{
9142 unsigned char c;
9143 unsigned int val;
9144 int shift;
9145 int len;
9146
9147 val = 0;
9148 shift = 0;
9149 len = 0;
9150 do
9151 {
9152 c = *(p++);
9153 len++;
9154 val |= ((unsigned int)c & 0x7f) << shift;
9155 shift += 7;
9156 }
9157 while (c & 0x80);
9158
9159 *plen = len;
9160 return val;
9161}
9162
9163static unsigned char *
2cf0635d 9164display_arm_attribute (unsigned char * p)
11c1ff18
PB		 9165{
9166 int tag;
9167 unsigned int len;
9168 int val;
2cf0635d 9169 arm_attr_public_tag * attr;
11c1ff18
PB		 9170 unsigned i;
9171 int type;
9172
9173 tag = read_uleb128 (p, &len);
9174 p += len;
9175 attr = NULL;
2cf0635d 9176 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 9177 {
9178 if (arm_attr_public_tags[i].tag == tag)
9179 {
9180 attr = &arm_attr_public_tags[i];
9181 break;
9182 }
9183 }
9184
9185 if (attr)
9186 {
9187 printf (" Tag_%s: ", attr->name);
9188 switch (attr->type)
9189 {
9190 case 0:
9191 switch (tag)
9192 {
9193 case 7: /* Tag_CPU_arch_profile. */
9194 val = read_uleb128 (p, &len);
9195 p += len;
9196 switch (val)
9197 {
9198 case 0: printf ("None\n"); break;
9199 case 'A': printf ("Application\n"); break;
9200 case 'R': printf ("Realtime\n"); break;
9201 case 'M': printf ("Microcontroller\n"); break;
9202 default: printf ("??? (%d)\n", val); break;
9203 }
9204 break;
9205
9206 case 32: /* Tag_compatibility. */
9207 val = read_uleb128 (p, &len);
9208 p += len;
9209 printf ("flag = %d, vendor = %s\n", val, p);
2cf0635d 9210 p += strlen ((char *) p) + 1;
11c1ff18
PB		 9211 break;
9212
f5f53991
AS		 9213 case 64: /* Tag_nodefaults. */
9214 p++;
9215 printf ("True\n");
9216 break;
9217
9218 case 65: /* Tag_also_compatible_with. */
9219 val = read_uleb128 (p, &len);
9220 p += len;
9221 if (val == 6 /* Tag_CPU_arch. */)
9222 {
9223 val = read_uleb128 (p, &len);
9224 p += len;
2cf0635d 9225 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 9226 printf ("??? (%d)\n", val);
9227 else
9228 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
9229 }
9230 else
9231 printf ("???\n");
9232 while (*(p++) != '\0' /* NUL terminator. */);
9233 break;
9234
11c1ff18 9235 default:
2cf0635d 9236 abort ();
11c1ff18
PB		 9237 }
9238 return p;
9239
9240 case 1:
9241 case 2:
9242 type = attr->type;
9243 break;
9244
9245 default:
9246 assert (attr->type & 0x80);
9247 val = read_uleb128 (p, &len);
9248 p += len;
9249 type = attr->type & 0x7f;
9250 if (val >= type)
9251 printf ("??? (%d)\n", val);
9252 else
9253 printf ("%s\n", attr->table[val]);
9254 return p;
9255 }
9256 }
9257 else
9258 {
9259 if (tag & 1)
9260 type = 1; /* String. */
9261 else
9262 type = 2; /* uleb128. */
9263 printf (" Tag_unknown_%d: ", tag);
9264 }
9265
9266 if (type == 1)
9267 {
9268 printf ("\"%s\"\n", p);
2cf0635d 9269 p += strlen ((char *) p) + 1;
11c1ff18
PB		 9270 }
9271 else
9272 {
9273 val = read_uleb128 (p, &len);
9274 p += len;
9275 printf ("%d (0x%x)\n", val, val);
9276 }
9277
9278 return p;
9279}
9280
104d59d1 9281static unsigned char *
60bca95a
NC		 9282display_gnu_attribute (unsigned char * p,
9283 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
104d59d1
JM		 9284{
9285 int tag;
9286 unsigned int len;
9287 int val;
9288 int type;
9289
9290 tag = read_uleb128 (p, &len);
9291 p += len;
9292
9293 /* Tag_compatibility is the only generic GNU attribute defined at
9294 present. */
9295 if (tag == 32)
9296 {
9297 val = read_uleb128 (p, &len);
9298 p += len;
9299 printf ("flag = %d, vendor = %s\n", val, p);
60bca95a 9300 p += strlen ((char *) p) + 1;
104d59d1
JM		 9301 return p;
9302 }
9303
9304 if ((tag & 2) == 0 && display_proc_gnu_attribute)
9305 return display_proc_gnu_attribute (p, tag);
9306
9307 if (tag & 1)
9308 type = 1; /* String. */
9309 else
9310 type = 2; /* uleb128. */
9311 printf (" Tag_unknown_%d: ", tag);
9312
9313 if (type == 1)
9314 {
9315 printf ("\"%s\"\n", p);
60bca95a 9316 p += strlen ((char *) p) + 1;
104d59d1
JM		 9317 }
9318 else
9319 {
9320 val = read_uleb128 (p, &len);
9321 p += len;
9322 printf ("%d (0x%x)\n", val, val);
9323 }
9324
9325 return p;
9326}
9327
34c8bcba 9328static unsigned char *
2cf0635d 9329display_power_gnu_attribute (unsigned char * p, int tag)
34c8bcba
JM		 9330{
9331 int type;
9332 unsigned int len;
9333 int val;
9334
9335 if (tag == Tag_GNU_Power_ABI_FP)
9336 {
9337 val = read_uleb128 (p, &len);
9338 p += len;
9339 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 9340
34c8bcba
JM		 9341 switch (val)
9342 {
9343 case 0:
9344 printf ("Hard or soft float\n");
9345 break;
9346 case 1:
9347 printf ("Hard float\n");
9348 break;
9349 case 2:
9350 printf ("Soft float\n");
9351 break;
3c7b9897
AM		 9352 case 3:
9353 printf ("Single-precision hard float\n");
9354 break;
34c8bcba
JM		 9355 default:
9356 printf ("??? (%d)\n", val);
9357 break;
9358 }
9359 return p;
9360 }
9361
c6e65352
DJ		 9362 if (tag == Tag_GNU_Power_ABI_Vector)
9363 {
9364 val = read_uleb128 (p, &len);
9365 p += len;
9366 printf (" Tag_GNU_Power_ABI_Vector: ");
9367 switch (val)
9368 {
9369 case 0:
9370 printf ("Any\n");
9371 break;
9372 case 1:
9373 printf ("Generic\n");
9374 break;
9375 case 2:
9376 printf ("AltiVec\n");
9377 break;
9378 case 3:
9379 printf ("SPE\n");
9380 break;
9381 default:
9382 printf ("??? (%d)\n", val);
9383 break;
9384 }
9385 return p;
9386 }
9387
f82e0623
NF		 9388 if (tag == Tag_GNU_Power_ABI_Struct_Return)
9389 {
9390 val = read_uleb128 (p, &len);
9391 p += len;
9392 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
9393 switch (val)
9394 {
9395 case 0:
9396 printf ("Any\n");
9397 break;
9398 case 1:
9399 printf ("r3/r4\n");
9400 break;
9401 case 2:
9402 printf ("Memory\n");
9403 break;
9404 default:
9405 printf ("??? (%d)\n", val);
9406 break;
9407 }
9408 return p;
9409 }
9410
34c8bcba
JM		 9411 if (tag & 1)
9412 type = 1; /* String. */
9413 else
9414 type = 2; /* uleb128. */
9415 printf (" Tag_unknown_%d: ", tag);
9416
9417 if (type == 1)
9418 {
9419 printf ("\"%s\"\n", p);
60bca95a 9420 p += strlen ((char *) p) + 1;
34c8bcba
JM		 9421 }
9422 else
9423 {
9424 val = read_uleb128 (p, &len);
9425 p += len;
9426 printf ("%d (0x%x)\n", val, val);
9427 }
9428
9429 return p;
9430}
9431
2cf19d5c 9432static unsigned char *
2cf0635d 9433display_mips_gnu_attribute (unsigned char * p, int tag)
2cf19d5c
JM		 9434{
9435 int type;
9436 unsigned int len;
9437 int val;
9438
9439 if (tag == Tag_GNU_MIPS_ABI_FP)
9440 {
9441 val = read_uleb128 (p, &len);
9442 p += len;
9443 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 9444
2cf19d5c
JM		 9445 switch (val)
9446 {
9447 case 0:
9448 printf ("Hard or soft float\n");
9449 break;
9450 case 1:
9451 printf ("Hard float (-mdouble-float)\n");
9452 break;
9453 case 2:
9454 printf ("Hard float (-msingle-float)\n");
9455 break;
9456 case 3:
9457 printf ("Soft float\n");
9458 break;
42554f6a
TS		 9459 case 4:
9460 printf ("64-bit float (-mips32r2 -mfp64)\n");
9461 break;
2cf19d5c
JM		 9462 default:
9463 printf ("??? (%d)\n", val);
9464 break;
9465 }
9466 return p;
9467 }
9468
9469 if (tag & 1)
9470 type = 1; /* String. */
9471 else
9472 type = 2; /* uleb128. */
9473 printf (" Tag_unknown_%d: ", tag);
9474
9475 if (type == 1)
9476 {
9477 printf ("\"%s\"\n", p);
60bca95a 9478 p += strlen ((char *) p) + 1;
2cf19d5c
JM		 9479 }
9480 else
9481 {
9482 val = read_uleb128 (p, &len);
9483 p += len;
9484 printf ("%d (0x%x)\n", val, val);
9485 }
9486
9487 return p;
9488}
9489
11c1ff18 9490static int
60bca95a
NC		 9491process_attributes (FILE * file,
9492 const char * public_name,
104d59d1 9493 unsigned int proc_type,
60bca95a
NC		 9494 unsigned char * (* display_pub_attribute) (unsigned char *),
9495 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11c1ff18 9496{
2cf0635d
NC		 9497 Elf_Internal_Shdr * sect;
9498 unsigned char * contents;
9499 unsigned char * p;
9500 unsigned char * end;
11c1ff18
PB		 9501 bfd_vma section_len;
9502 bfd_vma len;
9503 unsigned i;
9504
9505 /* Find the section header so that we get the size. */
9506 for (i = 0, sect = section_headers;
9507 i < elf_header.e_shnum;
9508 i++, sect++)
9509 {
104d59d1 9510 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 9511 continue;
9512
3f5e193b
NC		 9513 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
9514 sect->sh_size, _("attributes"));
60bca95a 9515 if (contents == NULL)
11c1ff18 9516 continue;
60bca95a 9517
11c1ff18
PB		 9518 p = contents;
9519 if (*p == 'A')
9520 {
9521 len = sect->sh_size - 1;
9522 p++;
60bca95a 9523
11c1ff18
PB		 9524 while (len > 0)
9525 {
9526 int namelen;
9527 bfd_boolean public_section;
104d59d1 9528 bfd_boolean gnu_section;
11c1ff18
PB		 9529
9530 section_len = byte_get (p, 4);
9531 p += 4;
60bca95a 9532
11c1ff18
PB		 9533 if (section_len > len)
9534 {
9535 printf (_("ERROR: Bad section length (%d > %d)\n"),
60bca95a 9536 (int) section_len, (int) len);
11c1ff18
PB		 9537 section_len = len;
9538 }
60bca95a 9539
11c1ff18
PB		 9540 len -= section_len;
9541 printf ("Attribute Section: %s\n", p);
60bca95a
NC		 9542
9543 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 9544 public_section = TRUE;
9545 else
9546 public_section = FALSE;
60bca95a
NC		 9547
9548 if (streq ((char *) p, "gnu"))
104d59d1
JM		 9549 gnu_section = TRUE;
9550 else
9551 gnu_section = FALSE;
60bca95a
NC		 9552
9553 namelen = strlen ((char *) p) + 1;
11c1ff18
PB		 9554 p += namelen;
9555 section_len -= namelen + 4;
60bca95a 9556
11c1ff18
PB		 9557 while (section_len > 0)
9558 {
9559 int tag = *(p++);
9560 int val;
9561 bfd_vma size;
60bca95a 9562
11c1ff18
PB		 9563 size = byte_get (p, 4);
9564 if (size > section_len)
9565 {
9566 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
60bca95a 9567 (int) size, (int) section_len);
11c1ff18
PB		 9568 size = section_len;
9569 }
60bca95a 9570
11c1ff18
PB		 9571 section_len -= size;
9572 end = p + size - 1;
9573 p += 4;
60bca95a 9574
11c1ff18
PB		 9575 switch (tag)
9576 {
9577 case 1:
9578 printf ("File Attributes\n");
9579 break;
9580 case 2:
9581 printf ("Section Attributes:");
9582 goto do_numlist;
9583 case 3:
9584 printf ("Symbol Attributes:");
9585 do_numlist:
9586 for (;;)
9587 {
9588 unsigned int i;
60bca95a 9589
11c1ff18
PB		 9590 val = read_uleb128 (p, &i);
9591 p += i;
9592 if (val == 0)
9593 break;
9594 printf (" %d", val);
9595 }
9596 printf ("\n");
9597 break;
9598 default:
9599 printf ("Unknown tag: %d\n", tag);
9600 public_section = FALSE;
9601 break;
9602 }
60bca95a 9603
11c1ff18
PB		 9604 if (public_section)
9605 {
9606 while (p < end)
104d59d1
JM		 9607 p = display_pub_attribute (p);
9608 }
9609 else if (gnu_section)
9610 {
9611 while (p < end)
9612 p = display_gnu_attribute (p,
9613 display_proc_gnu_attribute);
11c1ff18
PB		 9614 }
9615 else
9616 {
9617 /* ??? Do something sensible, like dump hex. */
9618 printf (" Unknown section contexts\n");
9619 p = end;
9620 }
9621 }
9622 }
9623 }
9624 else
60bca95a 9625 printf (_("Unknown format '%c'\n"), *p);
d70c5fc7 9626
60bca95a 9627 free (contents);
11c1ff18
PB		 9628 }
9629 return 1;
9630}
9631
104d59d1 9632static int
2cf0635d 9633process_arm_specific (FILE * file)
104d59d1
JM		 9634{
9635 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
9636 display_arm_attribute, NULL);
9637}
9638
34c8bcba 9639static int
2cf0635d 9640process_power_specific (FILE * file)
34c8bcba
JM		 9641{
9642 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
9643 display_power_gnu_attribute);
9644}
9645
ccb4c951
RS		 9646/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
9647 Print the Address, Access and Initial fields of an entry at VMA ADDR
9648 and return the VMA of the next entry. */
9649
9650static bfd_vma
2cf0635d 9651print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
ccb4c951
RS		 9652{
9653 printf (" ");
9654 print_vma (addr, LONG_HEX);
9655 printf (" ");
9656 if (addr < pltgot + 0xfff0)
9657 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
9658 else
9659 printf ("%10s", "");
9660 printf (" ");
9661 if (data == NULL)
9662 printf ("%*s", is_32bit_elf ? 8 : 16, "<unknown>");
9663 else
9664 {
9665 bfd_vma entry;
9666
9667 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
9668 print_vma (entry, LONG_HEX);
9669 }
9670 return addr + (is_32bit_elf ? 4 : 8);
9671}
9672
861fb55a
DJ		 9673/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
9674 PLTGOT. Print the Address and Initial fields of an entry at VMA
9675 ADDR and return the VMA of the next entry. */
9676
9677static bfd_vma
2cf0635d 9678print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 9679{
9680 printf (" ");
9681 print_vma (addr, LONG_HEX);
9682 printf (" ");
9683 if (data == NULL)
9684 printf ("%*s", is_32bit_elf ? 8 : 16, "<unknown>");
9685 else
9686 {
9687 bfd_vma entry;
9688
9689 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
9690 print_vma (entry, LONG_HEX);
9691 }
9692 return addr + (is_32bit_elf ? 4 : 8);
9693}
9694
19e6b90e 9695static int
2cf0635d 9696process_mips_specific (FILE * file)
5b18a4bc 9697{
2cf0635d 9698 Elf_Internal_Dyn * entry;
19e6b90e
L		 9699 size_t liblist_offset = 0;
9700 size_t liblistno = 0;
9701 size_t conflictsno = 0;
9702 size_t options_offset = 0;
9703 size_t conflicts_offset = 0;
861fb55a
DJ		 9704 size_t pltrelsz = 0;
9705 size_t pltrel = 0;
ccb4c951 9706 bfd_vma pltgot = 0;
861fb55a
DJ		 9707 bfd_vma mips_pltgot = 0;
9708 bfd_vma jmprel = 0;
ccb4c951
RS		 9709 bfd_vma local_gotno = 0;
9710 bfd_vma gotsym = 0;
9711 bfd_vma symtabno = 0;
103f02d3 9712
2cf19d5c
JM		 9713 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
9714 display_mips_gnu_attribute);
9715
19e6b90e
L		 9716 /* We have a lot of special sections. Thanks SGI! */
9717 if (dynamic_section == NULL)
9718 /* No information available. */
9719 return 0;
252b5132 9720
b2d38a17 9721 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
252b5132
RH		 9722 switch (entry->d_tag)
9723 {
9724 case DT_MIPS_LIBLIST:
d93f0186
NC		 9725 liblist_offset
9726 = offset_from_vma (file, entry->d_un.d_val,
9727 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 9728 break;
9729 case DT_MIPS_LIBLISTNO:
9730 liblistno = entry->d_un.d_val;
9731 break;
9732 case DT_MIPS_OPTIONS:
d93f0186 9733 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 9734 break;
9735 case DT_MIPS_CONFLICT:
d93f0186
NC		 9736 conflicts_offset
9737 = offset_from_vma (file, entry->d_un.d_val,
9738 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 9739 break;
9740 case DT_MIPS_CONFLICTNO:
9741 conflictsno = entry->d_un.d_val;
9742 break;
ccb4c951 9743 case DT_PLTGOT:
861fb55a
DJ		 9744 pltgot = entry->d_un.d_ptr;
9745 break;
ccb4c951
RS		 9746 case DT_MIPS_LOCAL_GOTNO:
9747 local_gotno = entry->d_un.d_val;
9748 break;
9749 case DT_MIPS_GOTSYM:
9750 gotsym = entry->d_un.d_val;
9751 break;
9752 case DT_MIPS_SYMTABNO:
9753 symtabno = entry->d_un.d_val;
9754 break;
861fb55a
DJ		 9755 case DT_MIPS_PLTGOT:
9756 mips_pltgot = entry->d_un.d_ptr;
9757 break;
9758 case DT_PLTREL:
9759 pltrel = entry->d_un.d_val;
9760 break;
9761 case DT_PLTRELSZ:
9762 pltrelsz = entry->d_un.d_val;
9763 break;
9764 case DT_JMPREL:
9765 jmprel = entry->d_un.d_ptr;
9766 break;
252b5132
RH		 9767 default:
9768 break;
9769 }
9770
9771 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
9772 {
2cf0635d 9773 Elf32_External_Lib * elib;
252b5132
RH		 9774 size_t cnt;
9775
3f5e193b
NC		 9776 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
9777 liblistno,
9778 sizeof (Elf32_External_Lib),
9779 _("liblist"));
a6e9f9df 9780 if (elib)
252b5132 9781 {
a6e9f9df
AM		 9782 printf ("\nSection '.liblist' contains %lu entries:\n",
9783 (unsigned long) liblistno);
9784 fputs (" Library Time Stamp Checksum Version Flags\n",
9785 stdout);
9786
9787 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 9788 {
a6e9f9df
AM		 9789 Elf32_Lib liblist;
9790 time_t time;
9791 char timebuf[20];
2cf0635d 9792 struct tm * tmp;
a6e9f9df
AM		 9793
9794 liblist.l_name = BYTE_GET (elib[cnt].l_name);
9795 time = BYTE_GET (elib[cnt].l_time_stamp);
9796 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
9797 liblist.l_version = BYTE_GET (elib[cnt].l_version);
9798 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
9799
9800 tmp = gmtime (&time);
e9e44622
JJ		 9801 snprintf (timebuf, sizeof (timebuf),
9802 "%04u-%02u-%02uT%02u:%02u:%02u",
9803 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9804 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 9805
31104126 9806 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 9807 if (VALID_DYNAMIC_NAME (liblist.l_name))
9808 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
9809 else
9810 printf ("<corrupt: %9ld>", liblist.l_name);
31104126
NC		 9811 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
9812 liblist.l_version);
a6e9f9df
AM		 9813
9814 if (liblist.l_flags == 0)
9815 puts (" NONE");
9816 else
9817 {
9818 static const struct
252b5132 9819 {
2cf0635d 9820 const char * name;
a6e9f9df 9821 int bit;
252b5132 9822 }
a6e9f9df
AM		 9823 l_flags_vals[] =
9824 {
9825 { " EXACT_MATCH", LL_EXACT_MATCH },
9826 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
9827 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
9828 { " EXPORTS", LL_EXPORTS },
9829 { " DELAY_LOAD", LL_DELAY_LOAD },
9830 { " DELTA", LL_DELTA }
9831 };
9832 int flags = liblist.l_flags;
9833 size_t fcnt;
9834
60bca95a 9835 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 9836 if ((flags & l_flags_vals[fcnt].bit) != 0)
9837 {
9838 fputs (l_flags_vals[fcnt].name, stdout);
9839 flags ^= l_flags_vals[fcnt].bit;
9840 }
9841 if (flags != 0)
9842 printf (" %#x", (unsigned int) flags);
252b5132 9843
a6e9f9df
AM		 9844 puts ("");
9845 }
252b5132 9846 }
252b5132 9847
a6e9f9df
AM		 9848 free (elib);
9849 }
252b5132
RH		 9850 }
9851
9852 if (options_offset != 0)
9853 {
2cf0635d
NC		 9854 Elf_External_Options * eopt;
9855 Elf_Internal_Shdr * sect = section_headers;
9856 Elf_Internal_Options * iopt;
9857 Elf_Internal_Options * option;
252b5132
RH		 9858 size_t offset;
9859 int cnt;
9860
9861 /* Find the section header so that we get the size. */
9862 while (sect->sh_type != SHT_MIPS_OPTIONS)
b34976b6 9863 ++sect;
252b5132 9864
3f5e193b
NC		 9865 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
9866 sect->sh_size, _("options"));
a6e9f9df 9867 if (eopt)
252b5132 9868 {
3f5e193b
NC		 9869 iopt = (Elf_Internal_Options *)
9870 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 9871 if (iopt == NULL)
9872 {
591a748a 9873 error (_("Out of memory\n"));
a6e9f9df
AM		 9874 return 0;
9875 }
76da6bbe 9876
a6e9f9df
AM		 9877 offset = cnt = 0;
9878 option = iopt;
252b5132 9879
a6e9f9df
AM		 9880 while (offset < sect->sh_size)
9881 {
2cf0635d 9882 Elf_External_Options * eoption;
252b5132 9883
a6e9f9df 9884 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 9885
a6e9f9df
AM		 9886 option->kind = BYTE_GET (eoption->kind);
9887 option->size = BYTE_GET (eoption->size);
9888 option->section = BYTE_GET (eoption->section);
9889 option->info = BYTE_GET (eoption->info);
76da6bbe 9890
a6e9f9df 9891 offset += option->size;
252b5132 9892
a6e9f9df
AM		 9893 ++option;
9894 ++cnt;
9895 }
252b5132 9896
a6e9f9df
AM		 9897 printf (_("\nSection '%s' contains %d entries:\n"),
9898 SECTION_NAME (sect), cnt);
76da6bbe 9899
a6e9f9df 9900 option = iopt;
252b5132 9901
a6e9f9df 9902 while (cnt-- > 0)
252b5132 9903 {
a6e9f9df
AM		 9904 size_t len;
9905
9906 switch (option->kind)
252b5132 9907 {
a6e9f9df
AM		 9908 case ODK_NULL:
9909 /* This shouldn't happen. */
9910 printf (" NULL %d %lx", option->section, option->info);
9911 break;
9912 case ODK_REGINFO:
9913 printf (" REGINFO ");
9914 if (elf_header.e_machine == EM_MIPS)
9915 {
9916 /* 32bit form. */
2cf0635d 9917 Elf32_External_RegInfo * ereg;
b34976b6 9918 Elf32_RegInfo reginfo;
a6e9f9df
AM		 9919
9920 ereg = (Elf32_External_RegInfo *) (option + 1);
9921 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
9922 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9923 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9924 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9925 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9926 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
9927
9928 printf ("GPR %08lx GP 0x%lx\n",
9929 reginfo.ri_gprmask,
9930 (unsigned long) reginfo.ri_gp_value);
9931 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9932 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9933 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9934 }
9935 else
9936 {
9937 /* 64 bit form. */
2cf0635d 9938 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 9939 Elf64_Internal_RegInfo reginfo;
9940
9941 ereg = (Elf64_External_RegInfo *) (option + 1);
9942 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
9943 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9944 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9945 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9946 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 9947 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 9948
9949 printf ("GPR %08lx GP 0x",
9950 reginfo.ri_gprmask);
9951 printf_vma (reginfo.ri_gp_value);
9952 printf ("\n");
9953
9954 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9955 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9956 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9957 }
9958 ++option;
9959 continue;
9960 case ODK_EXCEPTIONS:
9961 fputs (" EXCEPTIONS fpe_min(", stdout);
9962 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
9963 fputs (") fpe_max(", stdout);
9964 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
9965 fputs (")", stdout);
9966
9967 if (option->info & OEX_PAGE0)
9968 fputs (" PAGE0", stdout);
9969 if (option->info & OEX_SMM)
9970 fputs (" SMM", stdout);
9971 if (option->info & OEX_FPDBUG)
9972 fputs (" FPDBUG", stdout);
9973 if (option->info & OEX_DISMISS)
9974 fputs (" DISMISS", stdout);
9975 break;
9976 case ODK_PAD:
9977 fputs (" PAD ", stdout);
9978 if (option->info & OPAD_PREFIX)
9979 fputs (" PREFIX", stdout);
9980 if (option->info & OPAD_POSTFIX)
9981 fputs (" POSTFIX", stdout);
9982 if (option->info & OPAD_SYMBOL)
9983 fputs (" SYMBOL", stdout);
9984 break;
9985 case ODK_HWPATCH:
9986 fputs (" HWPATCH ", stdout);
9987 if (option->info & OHW_R4KEOP)
9988 fputs (" R4KEOP", stdout);
9989 if (option->info & OHW_R8KPFETCH)
9990 fputs (" R8KPFETCH", stdout);
9991 if (option->info & OHW_R5KEOP)
9992 fputs (" R5KEOP", stdout);
9993 if (option->info & OHW_R5KCVTL)
9994 fputs (" R5KCVTL", stdout);
9995 break;
9996 case ODK_FILL:
9997 fputs (" FILL ", stdout);
9998 /* XXX Print content of info word? */
9999 break;
10000 case ODK_TAGS:
10001 fputs (" TAGS ", stdout);
10002 /* XXX Print content of info word? */
10003 break;
10004 case ODK_HWAND:
10005 fputs (" HWAND ", stdout);
10006 if (option->info & OHWA0_R4KEOP_CHECKED)
10007 fputs (" R4KEOP_CHECKED", stdout);
10008 if (option->info & OHWA0_R4KEOP_CLEAN)
10009 fputs (" R4KEOP_CLEAN", stdout);
10010 break;
10011 case ODK_HWOR:
10012 fputs (" HWOR ", stdout);
10013 if (option->info & OHWA0_R4KEOP_CHECKED)
10014 fputs (" R4KEOP_CHECKED", stdout);
10015 if (option->info & OHWA0_R4KEOP_CLEAN)
10016 fputs (" R4KEOP_CLEAN", stdout);
10017 break;
10018 case ODK_GP_GROUP:
10019 printf (" GP_GROUP %#06lx self-contained %#06lx",
10020 option->info & OGP_GROUP,
10021 (option->info & OGP_SELF) >> 16);
10022 break;
10023 case ODK_IDENT:
10024 printf (" IDENT %#06lx self-contained %#06lx",
10025 option->info & OGP_GROUP,
10026 (option->info & OGP_SELF) >> 16);
10027 break;
10028 default:
10029 /* This shouldn't happen. */
10030 printf (" %3d ??? %d %lx",
10031 option->kind, option->section, option->info);
10032 break;
252b5132 10033 }
a6e9f9df 10034
2cf0635d 10035 len = sizeof (* eopt);
a6e9f9df
AM		 10036 while (len < option->size)
10037 if (((char *) option)[len] >= ' '
10038 && ((char *) option)[len] < 0x7f)
10039 printf ("%c", ((char *) option)[len++]);
10040 else
10041 printf ("\\%03o", ((char *) option)[len++]);
10042
10043 fputs ("\n", stdout);
252b5132 10044 ++option;
252b5132
RH		 10045 }
10046
a6e9f9df 10047 free (eopt);
252b5132 10048 }
252b5132
RH		 10049 }
10050
10051 if (conflicts_offset != 0 && conflictsno != 0)
10052 {
2cf0635d 10053 Elf32_Conflict * iconf;
252b5132
RH		 10054 size_t cnt;
10055
10056 if (dynamic_symbols == NULL)
10057 {
591a748a 10058 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 10059 return 0;
10060 }
10061
3f5e193b 10062 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 10063 if (iconf == NULL)
10064 {
591a748a 10065 error (_("Out of memory\n"));
252b5132
RH		 10066 return 0;
10067 }
10068
9ea033b2 10069 if (is_32bit_elf)
252b5132 10070 {
2cf0635d 10071 Elf32_External_Conflict * econf32;
a6e9f9df 10072
3f5e193b
NC		 10073 econf32 = (Elf32_External_Conflict *)
10074 get_data (NULL, file, conflicts_offset, conflictsno,
10075 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 10076 if (!econf32)
10077 return 0;
252b5132
RH		 10078
10079 for (cnt = 0; cnt < conflictsno; ++cnt)
10080 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 10081
10082 free (econf32);
252b5132
RH		 10083 }
10084 else
10085 {
2cf0635d 10086 Elf64_External_Conflict * econf64;
a6e9f9df 10087
3f5e193b
NC		 10088 econf64 = (Elf64_External_Conflict *)
10089 get_data (NULL, file, conflicts_offset, conflictsno,
10090 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 10091 if (!econf64)
10092 return 0;
252b5132
RH		 10093
10094 for (cnt = 0; cnt < conflictsno; ++cnt)
10095 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 10096
10097 free (econf64);
252b5132
RH		 10098 }
10099
c7e7ca54
NC		 10100 printf (_("\nSection '.conflict' contains %lu entries:\n"),
10101 (unsigned long) conflictsno);
252b5132
RH		 10102 puts (_(" Num: Index Value Name"));
10103
10104 for (cnt = 0; cnt < conflictsno; ++cnt)
10105 {
2cf0635d 10106 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
252b5132 10107
b34976b6 10108 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
f7a99963 10109 print_vma (psym->st_value, FULL_HEX);
31104126 10110 putchar (' ');
d79b3d50
NC		 10111 if (VALID_DYNAMIC_NAME (psym->st_name))
10112 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10113 else
10114 printf ("<corrupt: %14ld>", psym->st_name);
31104126 10115 putchar ('\n');
252b5132
RH		 10116 }
10117
252b5132
RH		 10118 free (iconf);
10119 }
10120
ccb4c951
RS		 10121 if (pltgot != 0 && local_gotno != 0)
10122 {
10123 bfd_vma entry, local_end, global_end;
bbeee7ea 10124 size_t i, offset;
2cf0635d 10125 unsigned char * data;
bbeee7ea 10126 int addr_size;
ccb4c951
RS		 10127
10128 entry = pltgot;
10129 addr_size = (is_32bit_elf ? 4 : 8);
10130 local_end = pltgot + local_gotno * addr_size;
10131 global_end = local_end + (symtabno - gotsym) * addr_size;
10132
10133 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b
NC		 10134 data = (unsigned char *) get_data (NULL, file, offset,
10135 global_end - pltgot, 1, _("GOT"));
ccb4c951
RS		 10136 printf (_("\nPrimary GOT:\n"));
10137 printf (_(" Canonical gp value: "));
10138 print_vma (pltgot + 0x7ff0, LONG_HEX);
10139 printf ("\n\n");
10140
10141 printf (_(" Reserved entries:\n"));
10142 printf (_(" %*s %10s %*s Purpose\n"),
10143 addr_size * 2, "Address", "Access",
10144 addr_size * 2, "Initial");
10145 entry = print_mips_got_entry (data, pltgot, entry);
10146 printf (" Lazy resolver\n");
10147 if (data
10148 && (byte_get (data + entry - pltgot, addr_size)
10149 >> (addr_size * 8 - 1)) != 0)
10150 {
10151 entry = print_mips_got_entry (data, pltgot, entry);
10152 printf (" Module pointer (GNU extension)\n");
10153 }
10154 printf ("\n");
10155
10156 if (entry < local_end)
10157 {
10158 printf (_(" Local entries:\n"));
10159 printf (_(" %*s %10s %*s\n"),
10160 addr_size * 2, "Address", "Access",
10161 addr_size * 2, "Initial");
10162 while (entry < local_end)
10163 {
10164 entry = print_mips_got_entry (data, pltgot, entry);
10165 printf ("\n");
10166 }
10167 printf ("\n");
10168 }
10169
10170 if (gotsym < symtabno)
10171 {
10172 int sym_width;
10173
10174 printf (_(" Global entries:\n"));
10175 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
10176 addr_size * 2, "Address", "Access",
10177 addr_size * 2, "Initial",
10178 addr_size * 2, "Sym.Val.", "Type", "Ndx", "Name");
10179 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
10180 for (i = gotsym; i < symtabno; i++)
10181 {
2cf0635d 10182 Elf_Internal_Sym * psym;
ccb4c951
RS		 10183
10184 psym = dynamic_symbols + i;
10185 entry = print_mips_got_entry (data, pltgot, entry);
10186 printf (" ");
10187 print_vma (psym->st_value, LONG_HEX);
10188 printf (" %-7s %3s ",
10189 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
10190 get_symbol_index_type (psym->st_shndx));
10191 if (VALID_DYNAMIC_NAME (psym->st_name))
10192 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
10193 else
10194 printf ("<corrupt: %14ld>", psym->st_name);
10195 printf ("\n");
10196 }
10197 printf ("\n");
10198 }
10199
10200 if (data)
10201 free (data);
10202 }
10203
861fb55a
DJ		 10204 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
10205 {
10206 bfd_vma entry, end;
10207 size_t offset, rel_offset;
10208 unsigned long count, i;
2cf0635d 10209 unsigned char * data;
861fb55a 10210 int addr_size, sym_width;
2cf0635d 10211 Elf_Internal_Rela * rels;
861fb55a
DJ		 10212
10213 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
10214 if (pltrel == DT_RELA)
10215 {
10216 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
10217 return 0;
10218 }
10219 else
10220 {
10221 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
10222 return 0;
10223 }
10224
10225 entry = mips_pltgot;
10226 addr_size = (is_32bit_elf ? 4 : 8);
10227 end = mips_pltgot + (2 + count) * addr_size;
10228
10229 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b
NC		 10230 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
10231 1, _("PLT GOT"));
861fb55a
DJ		 10232 printf (_("\nPLT GOT:\n\n"));
10233 printf (_(" Reserved entries:\n"));
10234 printf (_(" %*s %*s Purpose\n"),
10235 addr_size * 2, "Address", addr_size * 2, "Initial");
10236 entry = print_mips_pltgot_entry (data, mips_pltgot, entry);
10237 printf (" PLT lazy resolver\n");
10238 entry = print_mips_pltgot_entry (data, mips_pltgot, entry);
10239 printf (" Module pointer\n");
10240 printf ("\n");
10241
10242 printf (_(" Entries:\n"));
10243 printf (_(" %*s %*s %*s %-7s %3s %s\n"),
10244 addr_size * 2, "Address",
10245 addr_size * 2, "Initial",
10246 addr_size * 2, "Sym.Val.", "Type", "Ndx", "Name");
10247 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
10248 for (i = 0; i < count; i++)
10249 {
2cf0635d 10250 Elf_Internal_Sym * psym;
861fb55a
DJ		 10251
10252 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
10253 entry = print_mips_pltgot_entry (data, mips_pltgot, entry);
10254 printf (" ");
10255 print_vma (psym->st_value, LONG_HEX);
10256 printf (" %-7s %3s ",
10257 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
10258 get_symbol_index_type (psym->st_shndx));
10259 if (VALID_DYNAMIC_NAME (psym->st_name))
10260 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
10261 else
10262 printf ("<corrupt: %14ld>", psym->st_name);
10263 printf ("\n");
10264 }
10265 printf ("\n");
10266
10267 if (data)
10268 free (data);
10269 free (rels);
10270 }
10271
252b5132
RH		 10272 return 1;
10273}
10274
047b2264 10275static int
2cf0635d 10276process_gnu_liblist (FILE * file)
047b2264 10277{
2cf0635d
NC		 10278 Elf_Internal_Shdr * section;
10279 Elf_Internal_Shdr * string_sec;
10280 Elf32_External_Lib * elib;
10281 char * strtab;
c256ffe7 10282 size_t strtab_size;
047b2264
JJ		 10283 size_t cnt;
10284 unsigned i;
10285
10286 if (! do_arch)
10287 return 0;
10288
10289 for (i = 0, section = section_headers;
10290 i < elf_header.e_shnum;
b34976b6 10291 i++, section++)
047b2264
JJ		 10292 {
10293 switch (section->sh_type)
10294 {
10295 case SHT_GNU_LIBLIST:
4fbb74a6 10296 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 10297 break;
10298
3f5e193b
NC		 10299 elib = (Elf32_External_Lib *)
10300 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
10301 _("liblist"));
047b2264
JJ		 10302
10303 if (elib == NULL)
10304 break;
4fbb74a6 10305 string_sec = section_headers + section->sh_link;
047b2264 10306
3f5e193b
NC		 10307 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
10308 string_sec->sh_size,
10309 _("liblist string table"));
c256ffe7 10310 strtab_size = string_sec->sh_size;
047b2264
JJ		 10311
10312 if (strtab == NULL
10313 || section->sh_entsize != sizeof (Elf32_External_Lib))
10314 {
10315 free (elib);
10316 break;
10317 }
10318
10319 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
10320 SECTION_NAME (section),
0af1713e 10321 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264
JJ		 10322
10323 puts (" Library Time Stamp Checksum Version Flags");
10324
10325 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
10326 ++cnt)
10327 {
10328 Elf32_Lib liblist;
10329 time_t time;
10330 char timebuf[20];
2cf0635d 10331 struct tm * tmp;
047b2264
JJ		 10332
10333 liblist.l_name = BYTE_GET (elib[cnt].l_name);
10334 time = BYTE_GET (elib[cnt].l_time_stamp);
10335 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
10336 liblist.l_version = BYTE_GET (elib[cnt].l_version);
10337 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
10338
10339 tmp = gmtime (&time);
e9e44622
JJ		 10340 snprintf (timebuf, sizeof (timebuf),
10341 "%04u-%02u-%02uT%02u:%02u:%02u",
10342 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10343 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 10344
10345 printf ("%3lu: ", (unsigned long) cnt);
10346 if (do_wide)
c256ffe7
JJ		 10347 printf ("%-20s", liblist.l_name < strtab_size
10348 ? strtab + liblist.l_name : "<corrupt>");
047b2264 10349 else
c256ffe7
JJ		 10350 printf ("%-20.20s", liblist.l_name < strtab_size
10351 ? strtab + liblist.l_name : "<corrupt>");
047b2264
JJ		 10352 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
10353 liblist.l_version, liblist.l_flags);
10354 }
10355
10356 free (elib);
10357 }
10358 }
10359
10360 return 1;
10361}
10362
9437c45b 10363static const char *
d3ba0551 10364get_note_type (unsigned e_type)
779fe533
NC		 10365{
10366 static char buff[64];
103f02d3 10367
1ec5cd37
NC		 10368 if (elf_header.e_type == ET_CORE)
10369 switch (e_type)
10370 {
57346661 10371 case NT_AUXV:
1ec5cd37 10372 return _("NT_AUXV (auxiliary vector)");
57346661 10373 case NT_PRSTATUS:
1ec5cd37 10374 return _("NT_PRSTATUS (prstatus structure)");
57346661 10375 case NT_FPREGSET:
1ec5cd37 10376 return _("NT_FPREGSET (floating point registers)");
57346661 10377 case NT_PRPSINFO:
1ec5cd37 10378 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 10379 case NT_TASKSTRUCT:
1ec5cd37 10380 return _("NT_TASKSTRUCT (task structure)");
57346661 10381 case NT_PRXFPREG:
1ec5cd37 10382 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 10383 case NT_PPC_VMX:
10384 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 10385 case NT_PPC_VSX:
10386 return _("NT_PPC_VSX (ppc VSX registers)");
57346661 10387 case NT_PSTATUS:
1ec5cd37 10388 return _("NT_PSTATUS (pstatus structure)");
57346661 10389 case NT_FPREGS:
1ec5cd37 10390 return _("NT_FPREGS (floating point registers)");
57346661 10391 case NT_PSINFO:
1ec5cd37 10392 return _("NT_PSINFO (psinfo structure)");
57346661 10393 case NT_LWPSTATUS:
1ec5cd37 10394 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 10395 case NT_LWPSINFO:
1ec5cd37 10396 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 10397 case NT_WIN32PSTATUS:
1ec5cd37
NC		 10398 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
10399 default:
10400 break;
10401 }
10402 else
10403 switch (e_type)
10404 {
10405 case NT_VERSION:
10406 return _("NT_VERSION (version)");
10407 case NT_ARCH:
10408 return _("NT_ARCH (architecture)");
10409 default:
10410 break;
10411 }
10412
e9e44622 10413 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 10414 return buff;
779fe533
NC		 10415}
10416
1118d252
RM		 10417static const char *
10418get_gnu_elf_note_type (unsigned e_type)
10419{
10420 static char buff[64];
10421
10422 switch (e_type)
10423 {
10424 case NT_GNU_ABI_TAG:
10425 return _("NT_GNU_ABI_TAG (ABI version tag)");
10426 case NT_GNU_HWCAP:
10427 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
10428 case NT_GNU_BUILD_ID:
10429 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 10430 case NT_GNU_GOLD_VERSION:
10431 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 10432 default:
10433 break;
10434 }
10435
10436 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
10437 return buff;
10438}
10439
9437c45b 10440static const char *
d3ba0551 10441get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 10442{
10443 static char buff[64];
10444
b4db1224 10445 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 10446 {
10447 /* NetBSD core "procinfo" structure. */
10448 return _("NetBSD procinfo structure");
10449 }
10450
10451 /* As of Jan 2002 there are no other machine-independent notes
10452 defined for NetBSD core files. If the note type is less
10453 than the start of the machine-dependent note types, we don't
10454 understand it. */
10455
b4db1224 10456 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 10457 {
e9e44622 10458 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 10459 return buff;
10460 }
10461
10462 switch (elf_header.e_machine)
10463 {
10464 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10465 and PT_GETFPREGS == mach+2. */
10466
10467 case EM_OLD_ALPHA:
10468 case EM_ALPHA:
10469 case EM_SPARC:
10470 case EM_SPARC32PLUS:
10471 case EM_SPARCV9:
10472 switch (e_type)
10473 {
b4db1224
JT		 10474 case NT_NETBSDCORE_FIRSTMACH+0:
10475 return _("PT_GETREGS (reg structure)");
10476 case NT_NETBSDCORE_FIRSTMACH+2:
10477 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 10478 default:
10479 break;
10480 }
10481 break;
10482
10483 /* On all other arch's, PT_GETREGS == mach+1 and
10484 PT_GETFPREGS == mach+3. */
10485 default:
10486 switch (e_type)
10487 {
b4db1224
JT		 10488 case NT_NETBSDCORE_FIRSTMACH+1:
10489 return _("PT_GETREGS (reg structure)");
10490 case NT_NETBSDCORE_FIRSTMACH+3:
10491 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 10492 default:
10493 break;
10494 }
10495 }
10496
e9e44622
JJ		 10497 snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
10498 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 10499 return buff;
10500}
10501
6d118b09
NC		 10502/* Note that by the ELF standard, the name field is already null byte
10503 terminated, and namesz includes the terminating null byte.
10504 I.E. the value of namesz for the name "FSF" is 4.
10505
e3c8793a 10506 If the value of namesz is zero, there is no name present. */
779fe533 10507static int
2cf0635d 10508process_note (Elf_Internal_Note * pnote)
779fe533 10509{
2cf0635d
NC		 10510 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
10511 const char * nt;
9437c45b
JT		 10512
10513 if (pnote->namesz == 0)
1ec5cd37
NC		 10514 /* If there is no note name, then use the default set of
10515 note type strings. */
10516 nt = get_note_type (pnote->type);
10517
1118d252
RM		 10518 else if (const_strneq (pnote->namedata, "GNU"))
10519 /* GNU-specific object file notes. */
10520 nt = get_gnu_elf_note_type (pnote->type);
10521
0112cd26 10522 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 10523 /* NetBSD-specific core file notes. */
10524 nt = get_netbsd_elfcore_note_type (pnote->type);
10525
b15fa79e
AM		 10526 else if (strneq (pnote->namedata, "SPU/", 4))
10527 {
10528 /* SPU-specific core file notes. */
10529 nt = pnote->namedata + 4;
10530 name = "SPU";
10531 }
10532
9437c45b 10533 else
1ec5cd37
NC		 10534 /* Don't recognize this note name; just use the default set of
10535 note type strings. */
9437c45b 10536 nt = get_note_type (pnote->type);
9437c45b 10537
b15fa79e 10538 printf (" %s\t\t0x%08lx\t%s\n", name, pnote->descsz, nt);
779fe533
NC		 10539 return 1;
10540}
10541
6d118b09 10542
779fe533 10543static int
2cf0635d 10544process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 10545{
2cf0635d
NC		 10546 Elf_External_Note * pnotes;
10547 Elf_External_Note * external;
b34976b6 10548 int res = 1;
103f02d3 10549
779fe533
NC		 10550 if (length <= 0)
10551 return 0;
103f02d3 10552
3f5e193b
NC		 10553 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
10554 _("notes"));
a6e9f9df
AM		 10555 if (!pnotes)
10556 return 0;
779fe533 10557
103f02d3 10558 external = pnotes;
103f02d3 10559
305c7206 10560 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 10561 (unsigned long) offset, (unsigned long) length);
779fe533 10562 printf (_(" Owner\t\tData size\tDescription\n"));
103f02d3 10563
2cf0635d 10564 while (external < (Elf_External_Note *) ((char *) pnotes + length))
779fe533 10565 {
2cf0635d 10566 Elf_External_Note * next;
b34976b6 10567 Elf_Internal_Note inote;
2cf0635d 10568 char * temp = NULL;
6d118b09
NC		 10569
10570 inote.type = BYTE_GET (external->type);
10571 inote.namesz = BYTE_GET (external->namesz);
10572 inote.namedata = external->name;
10573 inote.descsz = BYTE_GET (external->descsz);
10574 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
10575 inote.descpos = offset + (inote.descdata - (char *) pnotes);
76da6bbe 10576
2cf0635d 10577 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
3e55a963
NC		 10578
10579 if (((char *) next) > (((char *) pnotes) + length))
10580 {
0fd3a477 10581 warn (_("corrupt note found at offset %lx into core notes\n"),
0af1713e 10582 (unsigned long) ((char *) external - (char *) pnotes));
0fd3a477 10583 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
3e55a963
NC		 10584 inote.type, inote.namesz, inote.descsz);
10585 break;
10586 }
10587
10588 external = next;
6d118b09
NC		 10589
10590 /* Verify that name is null terminated. It appears that at least
10591 one version of Linux (RedHat 6.0) generates corefiles that don't
10592 comply with the ELF spec by failing to include the null byte in
10593 namesz. */
10594 if (inote.namedata[inote.namesz] != '\0')
10595 {
3f5e193b 10596 temp = (char *) malloc (inote.namesz + 1);
76da6bbe 10597
6d118b09
NC		 10598 if (temp == NULL)
10599 {
10600 error (_("Out of memory\n"));
10601 res = 0;
10602 break;
10603 }
76da6bbe 10604
6d118b09
NC		 10605 strncpy (temp, inote.namedata, inote.namesz);
10606 temp[inote.namesz] = 0;
76da6bbe 10607
6d118b09
NC		 10608 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10609 inote.namedata = temp;
10610 }
10611
10612 res &= process_note (& inote);
103f02d3 10613
6d118b09
NC		 10614 if (temp != NULL)
10615 {
10616 free (temp);
10617 temp = NULL;
10618 }
779fe533
NC		 10619 }
10620
10621 free (pnotes);
103f02d3 10622
779fe533
NC		 10623 return res;
10624}
10625
10626static int
2cf0635d 10627process_corefile_note_segments (FILE * file)
779fe533 10628{
2cf0635d 10629 Elf_Internal_Phdr * segment;
b34976b6
AM		 10630 unsigned int i;
10631 int res = 1;
103f02d3 10632
d93f0186 10633 if (! get_program_headers (file))
779fe533 10634 return 0;
103f02d3 10635
779fe533
NC		 10636 for (i = 0, segment = program_headers;
10637 i < elf_header.e_phnum;
b34976b6 10638 i++, segment++)
779fe533
NC		 10639 {
10640 if (segment->p_type == PT_NOTE)
103f02d3 10641 res &= process_corefile_note_segment (file,
30800947
NC		 10642 (bfd_vma) segment->p_offset,
10643 (bfd_vma) segment->p_filesz);
779fe533 10644 }
103f02d3 10645
779fe533
NC		 10646 return res;
10647}
10648
10649static int
2cf0635d 10650process_note_sections (FILE * file)
1ec5cd37 10651{
2cf0635d 10652 Elf_Internal_Shdr * section;
1ec5cd37
NC		 10653 unsigned long i;
10654 int res = 1;
10655
10656 for (i = 0, section = section_headers;
10657 i < elf_header.e_shnum;
10658 i++, section++)
10659 if (section->sh_type == SHT_NOTE)
10660 res &= process_corefile_note_segment (file,
10661 (bfd_vma) section->sh_offset,
10662 (bfd_vma) section->sh_size);
10663
10664 return res;
10665}
10666
10667static int
2cf0635d 10668process_notes (FILE * file)
779fe533
NC		 10669{
10670 /* If we have not been asked to display the notes then do nothing. */
10671 if (! do_notes)
10672 return 1;
103f02d3 10673
779fe533 10674 if (elf_header.e_type != ET_CORE)
1ec5cd37 10675 return process_note_sections (file);
103f02d3 10676
779fe533 10677 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 10678 if (elf_header.e_phnum > 0)
10679 return process_corefile_note_segments (file);
779fe533 10680
1ec5cd37
NC		 10681 printf (_("No note segments present in the core file.\n"));
10682 return 1;
779fe533
NC		 10683}
10684
252b5132 10685static int
2cf0635d 10686process_arch_specific (FILE * file)
252b5132 10687{
a952a375
NC		 10688 if (! do_arch)
10689 return 1;
10690
252b5132
RH		 10691 switch (elf_header.e_machine)
10692 {
11c1ff18
PB		 10693 case EM_ARM:
10694 return process_arm_specific (file);
252b5132 10695 case EM_MIPS:
4fe85591 10696 case EM_MIPS_RS3_LE:
252b5132
RH		 10697 return process_mips_specific (file);
10698 break;
34c8bcba
JM		 10699 case EM_PPC:
10700 return process_power_specific (file);
10701 break;
252b5132
RH		 10702 default:
10703 break;
10704 }
10705 return 1;
10706}
10707
10708static int
2cf0635d 10709get_file_header (FILE * file)
252b5132 10710{
9ea033b2
NC		 10711 /* Read in the identity array. */
10712 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 10713 return 0;
10714
9ea033b2 10715 /* Determine how to read the rest of the header. */
b34976b6 10716 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 10717 {
10718 default: /* fall through */
10719 case ELFDATANONE: /* fall through */
adab8cdc
AO		 10720 case ELFDATA2LSB:
10721 byte_get = byte_get_little_endian;
10722 byte_put = byte_put_little_endian;
10723 break;
10724 case ELFDATA2MSB:
10725 byte_get = byte_get_big_endian;
10726 byte_put = byte_put_big_endian;
10727 break;
9ea033b2
NC		 10728 }
10729
10730 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 10731 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 10732
10733 /* Read in the rest of the header. */
10734 if (is_32bit_elf)
10735 {
10736 Elf32_External_Ehdr ehdr32;
252b5132 10737
9ea033b2
NC		 10738 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
10739 return 0;
103f02d3 10740
9ea033b2
NC		 10741 elf_header.e_type = BYTE_GET (ehdr32.e_type);
10742 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
10743 elf_header.e_version = BYTE_GET (ehdr32.e_version);
10744 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
10745 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
10746 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
10747 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
10748 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
10749 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
10750 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
10751 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
10752 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
10753 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
10754 }
252b5132 10755 else
9ea033b2
NC		 10756 {
10757 Elf64_External_Ehdr ehdr64;
a952a375
NC		 10758
10759 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10760 we will not be able to cope with the 64bit data found in
10761 64 ELF files. Detect this now and abort before we start
50c2245b 10762 overwriting things. */
a952a375
NC		 10763 if (sizeof (bfd_vma) < 8)
10764 {
e3c8793a
NC		 10765 error (_("This instance of readelf has been built without support for a\n\
1076664 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 10767 return 0;
10768 }
103f02d3 10769
9ea033b2
NC		 10770 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
10771 return 0;
103f02d3 10772
9ea033b2
NC		 10773 elf_header.e_type = BYTE_GET (ehdr64.e_type);
10774 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
10775 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 10776 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
10777 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
10778 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 10779 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
10780 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
10781 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
10782 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
10783 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
10784 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
10785 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
10786 }
252b5132 10787
7ece0d85
JJ		 10788 if (elf_header.e_shoff)
10789 {
10790 /* There may be some extensions in the first section header. Don't
10791 bomb if we can't read it. */
10792 if (is_32bit_elf)
10793 get_32bit_section_headers (file, 1);
10794 else
10795 get_64bit_section_headers (file, 1);
10796 }
560f3c1c 10797
252b5132
RH		 10798 return 1;
10799}
10800
fb52b2f4
NC		 10801/* Process one ELF object file according to the command line options.
10802 This file may actually be stored in an archive. The file is
10803 positioned at the start of the ELF object. */
10804
ff78d6d6 10805static int
2cf0635d 10806process_object (char * file_name, FILE * file)
252b5132 10807{
252b5132
RH		 10808 unsigned int i;
10809
252b5132
RH		 10810 if (! get_file_header (file))
10811 {
10812 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 10813 return 1;
252b5132
RH		 10814 }
10815
10816 /* Initialise per file variables. */
60bca95a 10817 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 10818 version_info[i] = 0;
10819
60bca95a 10820 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132
RH		 10821 dynamic_info[i] = 0;
10822
10823 /* Process the file. */
10824 if (show_name)
10825 printf (_("\nFile: %s\n"), file_name);
10826
18bd398b
NC		 10827 /* Initialise the dump_sects array from the cmdline_dump_sects array.
10828 Note we do this even if cmdline_dump_sects is empty because we
10829 must make sure that the dump_sets array is zeroed out before each
10830 object file is processed. */
10831 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 10832 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 10833
10834 if (num_cmdline_dump_sects > 0)
10835 {
10836 if (num_dump_sects == 0)
10837 /* A sneaky way of allocating the dump_sects array. */
09c11c86 10838 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 10839
10840 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 10841 memcpy (dump_sects, cmdline_dump_sects,
10842 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 10843 }
d70c5fc7 10844
252b5132 10845 if (! process_file_header ())
fb52b2f4 10846 return 1;
252b5132 10847
d1f5c6e3 10848 if (! process_section_headers (file))
2f62977e 10849 {
d1f5c6e3
L		 10850 /* Without loaded section headers we cannot process lots of
10851 things. */
2f62977e 10852 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 10853
2f62977e
NC		 10854 if (! do_using_dynamic)
10855 do_syms = do_reloc = 0;
10856 }
252b5132 10857
d1f5c6e3
L		 10858 if (! process_section_groups (file))
10859 {
10860 /* Without loaded section groups we cannot process unwind. */
10861 do_unwind = 0;
10862 }
10863
2f62977e 10864 if (process_program_headers (file))
b2d38a17 10865 process_dynamic_section (file);
252b5132
RH		 10866
10867 process_relocs (file);
10868
4d6ed7c8
NC		 10869 process_unwind (file);
10870
252b5132
RH		 10871 process_symbol_table (file);
10872
10873 process_syminfo (file);
10874
10875 process_version_sections (file);
10876
10877 process_section_contents (file);
f5842774 10878
1ec5cd37 10879 process_notes (file);
103f02d3 10880
047b2264
JJ		 10881 process_gnu_liblist (file);
10882
252b5132
RH		 10883 process_arch_specific (file);
10884
d93f0186
NC		 10885 if (program_headers)
10886 {
10887 free (program_headers);
10888 program_headers = NULL;
10889 }
10890
252b5132
RH		 10891 if (section_headers)
10892 {
10893 free (section_headers);
10894 section_headers = NULL;
10895 }
10896
10897 if (string_table)
10898 {
10899 free (string_table);
10900 string_table = NULL;
d40ac9bd 10901 string_table_length = 0;
252b5132
RH		 10902 }
10903
10904 if (dynamic_strings)
10905 {
10906 free (dynamic_strings);
10907 dynamic_strings = NULL;
d79b3d50 10908 dynamic_strings_length = 0;
252b5132
RH		 10909 }
10910
10911 if (dynamic_symbols)
10912 {
10913 free (dynamic_symbols);
10914 dynamic_symbols = NULL;
19936277 10915 num_dynamic_syms = 0;
252b5132
RH		 10916 }
10917
10918 if (dynamic_syminfo)
10919 {
10920 free (dynamic_syminfo);
10921 dynamic_syminfo = NULL;
10922 }
ff78d6d6 10923
e4b17d5c
L		 10924 if (section_headers_groups)
10925 {
10926 free (section_headers_groups);
10927 section_headers_groups = NULL;
10928 }
10929
10930 if (section_groups)
10931 {
2cf0635d
NC		 10932 struct group_list * g;
10933 struct group_list * next;
e4b17d5c
L		 10934
10935 for (i = 0; i < group_count; i++)
10936 {
10937 for (g = section_groups [i].root; g != NULL; g = next)
10938 {
10939 next = g->next;
10940 free (g);
10941 }
10942 }
10943
10944 free (section_groups);
10945 section_groups = NULL;
10946 }
10947
19e6b90e 10948 free_debug_memory ();
18bd398b 10949
ff78d6d6 10950 return 0;
252b5132
RH		 10951}
10952
2cf0635d
NC		 10953/* Return the path name for a proxy entry in a thin archive, adjusted relative
10954 to the path name of the thin archive itself if necessary. Always returns
10955 a pointer to malloc'ed memory. */
10956
10957static char *
10958adjust_relative_path (char * file_name, char * name, int name_len)
10959{
10960 char * member_file_name;
10961 const char * base_name = lbasename (file_name);
10962
10963 /* This is a proxy entry for a thin archive member.
10964 If the extended name table contains an absolute path
10965 name, or if the archive is in the current directory,
10966 use the path name as given. Otherwise, we need to
10967 find the member relative to the directory where the
10968 archive is located. */
10969 if (IS_ABSOLUTE_PATH (name) || base_name == file_name)
10970 {
3f5e193b 10971 member_file_name = (char *) malloc (name_len + 1);
2cf0635d
NC		 10972 if (member_file_name == NULL)
10973 {
10974 error (_("Out of memory\n"));
10975 return NULL;
10976 }
10977 memcpy (member_file_name, name, name_len);
10978 member_file_name[name_len] = '\0';
10979 }
10980 else
10981 {
10982 /* Concatenate the path components of the archive file name
10983 to the relative path name from the extended name table. */
10984 size_t prefix_len = base_name - file_name;
3f5e193b 10985 member_file_name = (char *) malloc (prefix_len + name_len + 1);
2cf0635d
NC		 10986 if (member_file_name == NULL)
10987 {
10988 error (_("Out of memory\n"));
10989 return NULL;
10990 }
10991 memcpy (member_file_name, file_name, prefix_len);
10992 memcpy (member_file_name + prefix_len, name, name_len);
10993 member_file_name[prefix_len + name_len] = '\0';
10994 }
10995 return member_file_name;
10996}
10997
10998/* Structure to hold information about an archive file. */
10999
11000struct archive_info
11001{
11002 char * file_name; /* Archive file name. */
11003 FILE * file; /* Open file descriptor. */
11004 unsigned long index_num; /* Number of symbols in table. */
11005 unsigned long * index_array; /* The array of member offsets. */
11006 char * sym_table; /* The symbol table. */
11007 unsigned long sym_size; /* Size of the symbol table. */
11008 char * longnames; /* The long file names table. */
11009 unsigned long longnames_size; /* Size of the long file names table. */
11010 unsigned long nested_member_origin; /* Origin in the nested archive of the current member. */
11011 unsigned long next_arhdr_offset; /* Offset of the next archive header. */
11012 bfd_boolean is_thin_archive; /* TRUE if this is a thin archive. */
11013 struct ar_hdr arhdr; /* Current archive header. */
11014};
11015
11016/* Read the symbol table and long-name table from an archive. */
fb52b2f4
NC		 11017
11018static int
2cf0635d
NC		 11019setup_archive (struct archive_info * arch, char * file_name, FILE * file,
11020 bfd_boolean is_thin_archive, bfd_boolean read_symbols)
fb52b2f4 11021{
fb52b2f4
NC		 11022 size_t got;
11023 unsigned long size;
fb52b2f4 11024
2cf0635d
NC		 11025 arch->file_name = strdup (file_name);
11026 arch->file = file;
11027 arch->index_num = 0;
11028 arch->index_array = NULL;
11029 arch->sym_table = NULL;
11030 arch->sym_size = 0;
11031 arch->longnames = NULL;
11032 arch->longnames_size = 0;
11033 arch->nested_member_origin = 0;
11034 arch->is_thin_archive = is_thin_archive;
11035 arch->next_arhdr_offset = SARMAG;
11036
11037 /* Read the first archive member header. */
11038 if (fseek (file, SARMAG, SEEK_SET) != 0)
11039 {
11040 error (_("%s: failed to seek to first archive header\n"), file_name);
11041 return 1;
11042 }
11043 got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
11044 if (got != sizeof arch->arhdr)
fb52b2f4
NC		 11045 {
11046 if (got == 0)
11047 return 0;
11048
11049 error (_("%s: failed to read archive header\n"), file_name);
11050 return 1;
11051 }
11052
4145f1d5 11053 /* See if this is the archive symbol table. */
2cf0635d
NC		 11054 if (const_strneq (arch->arhdr.ar_name, "/ ")
11055 || const_strneq (arch->arhdr.ar_name, "/SYM64/ "))
fb52b2f4 11056 {
2cf0635d 11057 size = strtoul (arch->arhdr.ar_size, NULL, 10);
4145f1d5
NC		 11058 size = size + (size & 1);
11059
2cf0635d
NC		 11060 arch->next_arhdr_offset += sizeof arch->arhdr + size;
11061
11062 if (read_symbols)
fb52b2f4 11063 {
4145f1d5
NC		 11064 unsigned long i;
11065 /* A buffer used to hold numbers read in from an archive index.
11066 These are always 4 bytes long and stored in big-endian format. */
11067#define SIZEOF_AR_INDEX_NUMBERS 4
11068 unsigned char integer_buffer[SIZEOF_AR_INDEX_NUMBERS];
11069 unsigned char * index_buffer;
11070
11071 /* Check the size of the archive index. */
11072 if (size < SIZEOF_AR_INDEX_NUMBERS)
11073 {
11074 error (_("%s: the archive index is empty\n"), file_name);
11075 return 1;
11076 }
11077
11078 /* Read the numer of entries in the archive index. */
11079 got = fread (integer_buffer, 1, sizeof integer_buffer, file);
11080 if (got != sizeof (integer_buffer))
11081 {
11082 error (_("%s: failed to read archive index\n"), file_name);
11083 return 1;
11084 }
2cf0635d 11085 arch->index_num = byte_get_big_endian (integer_buffer, sizeof integer_buffer);
4145f1d5
NC		 11086 size -= SIZEOF_AR_INDEX_NUMBERS;
11087
11088 /* Read in the archive index. */
2cf0635d 11089 if (size < arch->index_num * SIZEOF_AR_INDEX_NUMBERS)
4145f1d5
NC		 11090 {
11091 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
2cf0635d 11092 file_name, arch->index_num);
4145f1d5
NC		 11093 return 1;
11094 }
3f5e193b
NC		 11095 index_buffer = (unsigned char *)
11096 malloc (arch->index_num * SIZEOF_AR_INDEX_NUMBERS);
4145f1d5
NC		 11097 if (index_buffer == NULL)
11098 {
11099 error (_("Out of memory whilst trying to read archive symbol index\n"));
11100 return 1;
11101 }
2cf0635d
NC		 11102 got = fread (index_buffer, SIZEOF_AR_INDEX_NUMBERS, arch->index_num, file);
11103 if (got != arch->index_num)
4145f1d5
NC		 11104 {
11105 free (index_buffer);
11106 error (_("%s: failed to read archive index\n"), file_name);
2cf0635d 11107 return 1;
4145f1d5 11108 }
2cf0635d 11109 size -= arch->index_num * SIZEOF_AR_INDEX_NUMBERS;
4145f1d5
NC		 11110
11111 /* Convert the index numbers into the host's numeric format. */
3f5e193b
NC		 11112 arch->index_array = (long unsigned int *)
11113 malloc (arch->index_num * sizeof (* arch->index_array));
2cf0635d 11114 if (arch->index_array == NULL)
4145f1d5
NC		 11115 {
11116 free (index_buffer);
11117 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
11118 return 1;
11119 }
11120
2cf0635d
NC		 11121 for (i = 0; i < arch->index_num; i++)
11122 arch->index_array[i] = byte_get_big_endian ((unsigned char *) (index_buffer + (i * SIZEOF_AR_INDEX_NUMBERS)),
11123 SIZEOF_AR_INDEX_NUMBERS);
4145f1d5
NC		 11124 free (index_buffer);
11125
11126 /* The remaining space in the header is taken up by the symbol table. */
11127 if (size < 1)
11128 {
11129 error (_("%s: the archive has an index but no symbols\n"), file_name);
2cf0635d 11130 return 1;
4145f1d5 11131 }
3f5e193b 11132 arch->sym_table = (char *) malloc (size);
2cf0635d
NC		 11133 arch->sym_size = size;
11134 if (arch->sym_table == NULL)
4145f1d5
NC		 11135 {
11136 error (_("Out of memory whilst trying to read archive index symbol table\n"));
2cf0635d 11137 return 1;
4145f1d5 11138 }
2cf0635d 11139 got = fread (arch->sym_table, 1, size, file);
4145f1d5
NC		 11140 if (got != size)
11141 {
11142 error (_("%s: failed to read archive index symbol table\n"), file_name);
2cf0635d 11143 return 1;
cb8f3167 11144 }
4145f1d5
NC		 11145 }
11146 else
11147 {
11148 if (fseek (file, size, SEEK_CUR) != 0)
11149 {
11150 error (_("%s: failed to skip archive symbol table\n"), file_name);
11151 return 1;
11152 }
fb52b2f4
NC		 11153 }
11154
2cf0635d
NC		 11155 /* Read the next archive header. */
11156 got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
11157 if (got != sizeof arch->arhdr)
fb52b2f4
NC		 11158 {
11159 if (got == 0)
2cf0635d 11160 return 0;
4145f1d5 11161 error (_("%s: failed to read archive header following archive index\n"), file_name);
2cf0635d 11162 return 1;
fb52b2f4
NC		 11163 }
11164 }
2cf0635d 11165 else if (read_symbols)
4145f1d5 11166 printf (_("%s has no archive index\n"), file_name);
fb52b2f4 11167
2cf0635d 11168 if (const_strneq (arch->arhdr.ar_name, "// "))
fb52b2f4 11169 {
2cf0635d
NC		 11170 /* This is the archive string table holding long member names. */
11171 arch->longnames_size = strtoul (arch->arhdr.ar_size, NULL, 10);
11172 arch->next_arhdr_offset += sizeof arch->arhdr + arch->longnames_size;
fb52b2f4 11173
3f5e193b 11174 arch->longnames = (char *) malloc (arch->longnames_size);
2cf0635d 11175 if (arch->longnames == NULL)
fb52b2f4 11176 {
4145f1d5 11177 error (_("Out of memory reading long symbol names in archive\n"));
2cf0635d 11178 return 1;
fb52b2f4
NC		 11179 }
11180
2cf0635d 11181 if (fread (arch->longnames, arch->longnames_size, 1, file) != 1)
fb52b2f4 11182 {
2cf0635d
NC		 11183 free (arch->longnames);
11184 arch->longnames = NULL;
4145f1d5 11185 error (_("%s: failed to read long symbol name string table\n"), file_name);
2cf0635d 11186 return 1;
fb52b2f4
NC		 11187 }
11188
2cf0635d 11189 if ((arch->longnames_size & 1) != 0)
fb52b2f4 11190 getc (file);
2cf0635d 11191 }
fb52b2f4 11192
2cf0635d
NC		 11193 return 0;
11194}
11195
11196/* Release the memory used for the archive information. */
11197
11198static void
11199release_archive (struct archive_info * arch)
11200{
11201 if (arch->file_name != NULL)
11202 free (arch->file_name);
11203 if (arch->index_array != NULL)
11204 free (arch->index_array);
11205 if (arch->sym_table != NULL)
11206 free (arch->sym_table);
11207 if (arch->longnames != NULL)
11208 free (arch->longnames);
11209}
11210
11211/* Open and setup a nested archive, if not already open. */
11212
11213static int
11214setup_nested_archive (struct archive_info * nested_arch, char * member_file_name)
11215{
11216 FILE * member_file;
11217
11218 /* Have we already setup this archive? */
11219 if (nested_arch->file_name != NULL
11220 && streq (nested_arch->file_name, member_file_name))
11221 return 0;
11222
11223 /* Close previous file and discard cached information. */
11224 if (nested_arch->file != NULL)
11225 fclose (nested_arch->file);
11226 release_archive (nested_arch);
11227
11228 member_file = fopen (member_file_name, "rb");
11229 if (member_file == NULL)
11230 return 1;
11231 return setup_archive (nested_arch, member_file_name, member_file, FALSE, FALSE);
11232}
11233
11234static char *
11235get_archive_member_name_at (struct archive_info * arch,
11236 unsigned long offset,
11237 struct archive_info * nested_arch);
11238
11239/* Get the name of an archive member from the current archive header.
11240 For simple names, this will modify the ar_name field of the current
11241 archive header. For long names, it will return a pointer to the
11242 longnames table. For nested archives, it will open the nested archive
11243 and get the name recursively. NESTED_ARCH is a single-entry cache so
11244 we don't keep rereading the same information from a nested archive. */
11245
11246static char *
11247get_archive_member_name (struct archive_info * arch,
11248 struct archive_info * nested_arch)
11249{
11250 unsigned long j, k;
11251
11252 if (arch->arhdr.ar_name[0] == '/')
11253 {
11254 /* We have a long name. */
11255 char * endp;
11256 char * member_file_name;
11257 char * member_name;
11258
11259 arch->nested_member_origin = 0;
11260 k = j = strtoul (arch->arhdr.ar_name + 1, &endp, 10);
11261 if (arch->is_thin_archive && endp != NULL && * endp == ':')
11262 arch->nested_member_origin = strtoul (endp + 1, NULL, 10);
11263
11264 while ((j < arch->longnames_size)
11265 && (arch->longnames[j] != '\n')
11266 && (arch->longnames[j] != '\0'))
11267 j++;
11268 if (arch->longnames[j-1] == '/')
11269 j--;
11270 arch->longnames[j] = '\0';
11271
11272 if (!arch->is_thin_archive || arch->nested_member_origin == 0)
11273 return arch->longnames + k;
11274
11275 /* This is a proxy for a member of a nested archive.
11276 Find the name of the member in that archive. */
11277 member_file_name = adjust_relative_path (arch->file_name, arch->longnames + k, j - k);
11278 if (member_file_name != NULL
11279 && setup_nested_archive (nested_arch, member_file_name) == 0
11280 && (member_name = get_archive_member_name_at (nested_arch, arch->nested_member_origin, NULL)) != NULL)
11281 {
11282 free (member_file_name);
11283 return member_name;
11284 }
11285 free (member_file_name);
11286
11287 /* Last resort: just return the name of the nested archive. */
11288 return arch->longnames + k;
11289 }
11290
11291 /* We have a normal (short) name. */
11292 j = 0;
11293 while ((arch->arhdr.ar_name[j] != '/') && (j < 16))
11294 j++;
11295 arch->arhdr.ar_name[j] = '\0';
11296 return arch->arhdr.ar_name;
11297}
11298
11299/* Get the name of an archive member at a given OFFSET within an archive ARCH. */
11300
11301static char *
11302get_archive_member_name_at (struct archive_info * arch,
11303 unsigned long offset,
11304 struct archive_info * nested_arch)
11305{
11306 size_t got;
11307
11308 if (fseek (arch->file, offset, SEEK_SET) != 0)
11309 {
11310 error (_("%s: failed to seek to next file name\n"), arch->file_name);
11311 return NULL;
11312 }
11313 got = fread (&arch->arhdr, 1, sizeof arch->arhdr, arch->file);
11314 if (got != sizeof arch->arhdr)
11315 {
11316 error (_("%s: failed to read archive header\n"), arch->file_name);
11317 return NULL;
11318 }
11319 if (memcmp (arch->arhdr.ar_fmag, ARFMAG, 2) != 0)
11320 {
11321 error (_("%s: did not find a valid archive header\n"), arch->file_name);
11322 return NULL;
11323 }
11324
11325 return get_archive_member_name (arch, nested_arch);
11326}
11327
11328/* Construct a string showing the name of the archive member, qualified
11329 with the name of the containing archive file. For thin archives, we
11330 use square brackets to denote the indirection. For nested archives,
11331 we show the qualified name of the external member inside the square
11332 brackets (e.g., "thin.a[normal.a(foo.o)]"). */
11333
11334static char *
11335make_qualified_name (struct archive_info * arch,
11336 struct archive_info * nested_arch,
11337 char * member_name)
11338{
11339 size_t len;
11340 char * name;
11341
11342 len = strlen (arch->file_name) + strlen (member_name) + 3;
11343 if (arch->is_thin_archive && arch->nested_member_origin != 0)
11344 len += strlen (nested_arch->file_name) + 2;
11345
3f5e193b 11346 name = (char *) malloc (len);
2cf0635d
NC		 11347 if (name == NULL)
11348 {
11349 error (_("Out of memory\n"));
11350 return NULL;
11351 }
11352
11353 if (arch->is_thin_archive && arch->nested_member_origin != 0)
11354 snprintf (name, len, "%s[%s(%s)]", arch->file_name, nested_arch->file_name, member_name);
11355 else if (arch->is_thin_archive)
11356 snprintf (name, len, "%s[%s]", arch->file_name, member_name);
11357 else
11358 snprintf (name, len, "%s(%s)", arch->file_name, member_name);
11359
11360 return name;
11361}
11362
11363/* Process an ELF archive.
11364 On entry the file is positioned just after the ARMAG string. */
11365
11366static int
11367process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
11368{
11369 struct archive_info arch;
11370 struct archive_info nested_arch;
11371 size_t got;
11372 size_t file_name_size;
11373 int ret;
11374
11375 show_name = 1;
11376
11377 /* The ARCH structure is used to hold information about this archive. */
11378 arch.file_name = NULL;
11379 arch.file = NULL;
11380 arch.index_array = NULL;
11381 arch.sym_table = NULL;
11382 arch.longnames = NULL;
11383
11384 /* The NESTED_ARCH structure is used as a single-item cache of information
11385 about a nested archive (when members of a thin archive reside within
11386 another regular archive file). */
11387 nested_arch.file_name = NULL;
11388 nested_arch.file = NULL;
11389 nested_arch.index_array = NULL;
11390 nested_arch.sym_table = NULL;
11391 nested_arch.longnames = NULL;
11392
11393 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
11394 {
11395 ret = 1;
11396 goto out;
4145f1d5 11397 }
fb52b2f4 11398
4145f1d5
NC		 11399 if (do_archive_index)
11400 {
2cf0635d 11401 if (arch.sym_table == NULL)
4145f1d5
NC		 11402 error (_("%s: unable to dump the index as none was found\n"), file_name);
11403 else
11404 {
2cf0635d 11405 unsigned int i, l;
4145f1d5
NC		 11406 unsigned long current_pos;
11407
11408 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
2cf0635d 11409 file_name, arch.index_num, arch.sym_size);
4145f1d5
NC		 11410 current_pos = ftell (file);
11411
2cf0635d 11412 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 11413 {
2cf0635d
NC		 11414 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
11415 {
11416 char * member_name;
4145f1d5 11417
2cf0635d
NC		 11418 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
11419
11420 if (member_name != NULL)
11421 {
11422 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
11423
11424 if (qualified_name != NULL)
11425 {
11426 printf (_("Binary %s contains:\n"), qualified_name);
11427 free (qualified_name);
11428 }
4145f1d5
NC		 11429 }
11430 }
2cf0635d
NC		 11431
11432 if (l >= arch.sym_size)
4145f1d5
NC		 11433 {
11434 error (_("%s: end of the symbol table reached before the end of the index\n"),
11435 file_name);
cb8f3167 11436 break;
4145f1d5 11437 }
2cf0635d
NC		 11438 printf ("\t%s\n", arch.sym_table + l);
11439 l += strlen (arch.sym_table + l) + 1;
4145f1d5
NC		 11440 }
11441
2cf0635d
NC		 11442 if (l & 01)
11443 ++l;
11444 if (l < arch.sym_size)
4145f1d5
NC		 11445 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
11446 file_name);
11447
4145f1d5
NC		 11448 if (fseek (file, current_pos, SEEK_SET) != 0)
11449 {
11450 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 11451 ret = 1;
11452 goto out;
4145f1d5 11453 }
fb52b2f4 11454 }
4145f1d5
NC		 11455
11456 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
11457 && !do_segments && !do_header && !do_dump && !do_version
11458 && !do_histogram && !do_debugging && !do_arch && !do_notes
11459 && !do_section_groups)
2cf0635d
NC		 11460 {
11461 ret = 0; /* Archive index only. */
11462 goto out;
11463 }
fb52b2f4
NC		 11464 }
11465
11466 file_name_size = strlen (file_name);
d989285c 11467 ret = 0;
fb52b2f4
NC		 11468
11469 while (1)
11470 {
2cf0635d
NC		 11471 char * name;
11472 size_t namelen;
11473 char * qualified_name;
11474
11475 /* Read the next archive header. */
11476 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
11477 {
11478 error (_("%s: failed to seek to next archive header\n"), file_name);
11479 return 1;
11480 }
11481 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
11482 if (got != sizeof arch.arhdr)
11483 {
11484 if (got == 0)
11485 break;
11486 error (_("%s: failed to read archive header\n"), file_name);
11487 ret = 1;
11488 break;
11489 }
11490 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
11491 {
11492 error (_("%s: did not find a valid archive header\n"), arch.file_name);
11493 ret = 1;
11494 break;
11495 }
11496
11497 arch.next_arhdr_offset += sizeof arch.arhdr;
11498
11499 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
11500 if (archive_file_size & 01)
11501 ++archive_file_size;
11502
11503 name = get_archive_member_name (&arch, &nested_arch);
11504 if (name == NULL)
fb52b2f4 11505 {
0fd3a477 11506 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 11507 ret = 1;
11508 break;
fb52b2f4 11509 }
2cf0635d 11510 namelen = strlen (name);
fb52b2f4 11511
2cf0635d
NC		 11512 qualified_name = make_qualified_name (&arch, &nested_arch, name);
11513 if (qualified_name == NULL)
fb52b2f4 11514 {
2cf0635d 11515 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 11516 ret = 1;
11517 break;
fb52b2f4
NC		 11518 }
11519
2cf0635d
NC		 11520 if (is_thin_archive && arch.nested_member_origin == 0)
11521 {
11522 /* This is a proxy for an external member of a thin archive. */
11523 FILE * member_file;
11524 char * member_file_name = adjust_relative_path (file_name, name, namelen);
11525 if (member_file_name == NULL)
11526 {
11527 ret = 1;
11528 break;
11529 }
11530
11531 member_file = fopen (member_file_name, "rb");
11532 if (member_file == NULL)
11533 {
11534 error (_("Input file '%s' is not readable.\n"), member_file_name);
11535 free (member_file_name);
11536 ret = 1;
11537 break;
11538 }
11539
11540 archive_file_offset = arch.nested_member_origin;
11541
11542 ret |= process_object (qualified_name, member_file);
11543
11544 fclose (member_file);
11545 free (member_file_name);
11546 }
11547 else if (is_thin_archive)
11548 {
11549 /* This is a proxy for a member of a nested archive. */
11550 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
11551
11552 /* The nested archive file will have been opened and setup by
11553 get_archive_member_name. */
11554 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
11555 {
11556 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
11557 ret = 1;
11558 break;
11559 }
11560
11561 ret |= process_object (qualified_name, nested_arch.file);
11562 }
11563 else
11564 {
11565 archive_file_offset = arch.next_arhdr_offset;
11566 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 11567
2cf0635d
NC		 11568 ret |= process_object (qualified_name, file);
11569 }
fb52b2f4 11570
2cf0635d 11571 free (qualified_name);
fb52b2f4
NC		 11572 }
11573
4145f1d5 11574 out:
2cf0635d
NC		 11575 if (nested_arch.file != NULL)
11576 fclose (nested_arch.file);
11577 release_archive (&nested_arch);
11578 release_archive (&arch);
fb52b2f4 11579
d989285c 11580 return ret;
fb52b2f4
NC		 11581}
11582
11583static int
2cf0635d 11584process_file (char * file_name)
fb52b2f4 11585{
2cf0635d 11586 FILE * file;
fb52b2f4
NC		 11587 struct stat statbuf;
11588 char armag[SARMAG];
11589 int ret;
11590
11591 if (stat (file_name, &statbuf) < 0)
11592 {
f24ddbdd
NC		 11593 if (errno == ENOENT)
11594 error (_("'%s': No such file\n"), file_name);
11595 else
11596 error (_("Could not locate '%s'. System error message: %s\n"),
11597 file_name, strerror (errno));
11598 return 1;
11599 }
11600
11601 if (! S_ISREG (statbuf.st_mode))
11602 {
11603 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 11604 return 1;
11605 }
11606
11607 file = fopen (file_name, "rb");
11608 if (file == NULL)
11609 {
f24ddbdd 11610 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 11611 return 1;
11612 }
11613
11614 if (fread (armag, SARMAG, 1, file) != 1)
11615 {
4145f1d5 11616 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 11617 fclose (file);
11618 return 1;
11619 }
11620
11621 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 11622 ret = process_archive (file_name, file, FALSE);
11623 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
11624 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 11625 else
11626 {
4145f1d5
NC		 11627 if (do_archive_index)
11628 error (_("File %s is not an archive so its index cannot be displayed.\n"),
11629 file_name);
11630
fb52b2f4
NC		 11631 rewind (file);
11632 archive_file_size = archive_file_offset = 0;
11633 ret = process_object (file_name, file);
11634 }
11635
11636 fclose (file);
11637
11638 return ret;
11639}
11640
252b5132
RH		 11641#ifdef SUPPORT_DISASSEMBLY
11642/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 11643 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 11644 symbols. */
252b5132
RH		 11645
11646void
2cf0635d 11647print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 11648{
11649 fprintf (outfile,"0x%8.8x", addr);
11650}
11651
e3c8793a 11652/* Needed by the i386 disassembler. */
252b5132
RH		 11653void
11654db_task_printsym (unsigned int addr)
11655{
11656 print_address (addr, stderr);
11657}
11658#endif
11659
11660int
2cf0635d 11661main (int argc, char ** argv)
252b5132 11662{
ff78d6d6
L		 11663 int err;
11664
252b5132
RH		 11665#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
11666 setlocale (LC_MESSAGES, "");
3882b010
L		 11667#endif
11668#if defined (HAVE_SETLOCALE)
11669 setlocale (LC_CTYPE, "");
252b5132
RH		 11670#endif
11671 bindtextdomain (PACKAGE, LOCALEDIR);
11672 textdomain (PACKAGE);
11673
869b9d07
MM		 11674 expandargv (&argc, &argv);
11675
252b5132
RH		 11676 parse_args (argc, argv);
11677
18bd398b 11678 if (num_dump_sects > 0)
59f14fc0 11679 {
18bd398b 11680 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 11681 cmdline_dump_sects = (dump_type *)
11682 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 11683 if (cmdline_dump_sects == NULL)
591a748a 11684 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 11685 else
11686 {
09c11c86
NC		 11687 memcpy (cmdline_dump_sects, dump_sects,
11688 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 11689 num_cmdline_dump_sects = num_dump_sects;
11690 }
11691 }
11692
18bd398b
NC		 11693 if (optind < (argc - 1))
11694 show_name = 1;
11695
ff78d6d6 11696 err = 0;
252b5132 11697 while (optind < argc)
18bd398b 11698 err |= process_file (argv[optind++]);
252b5132
RH		 11699
11700 if (dump_sects != NULL)
11701 free (dump_sects);
59f14fc0
AS		 11702 if (cmdline_dump_sects != NULL)
11703 free (cmdline_dump_sects);
252b5132 11704
ff78d6d6 11705 return err;
252b5132 11706}
A mirror of the official binutils-gdb repository