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