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