]> Git Repo - binutils.git/blame - binutils/readelf.c
projects / binutils.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* dwarf2read.c: Remove unused typedef dwarf2_cu_per_cu_data_ptr
[binutils.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 <[email protected]>
12ab83a9 7 Modifications by Nick Clifton <[email protected]>
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"
5506d11a 128#include "elf/moxie.h"
4970f871 129#include "elf/mt.h"
2469cfa2 130#include "elf/msp430.h"
3b16e843 131#include "elf/or32.h"
7d466069 132#include "elf/pj.h"
3b16e843 133#include "elf/ppc.h"
c833c019 134#include "elf/ppc64.h"
c7927a3c 135#include "elf/rx.h"
a85d7ed0 136#include "elf/s390.h"
1c0d3aa6 137#include "elf/score.h"
3b16e843
NC		 138#include "elf/sh.h"
139#include "elf/sparc.h"
e9f53129 140#include "elf/spu.h"
40b36596 141#include "elf/tic6x.h"
3b16e843 142#include "elf/v850.h"
179d3252 143#include "elf/vax.h"
3b16e843 144#include "elf/x86-64.h"
c29aca4a 145#include "elf/xc16x.h"
93fbbb04 146#include "elf/xstormy16.h"
88da6820 147#include "elf/xtensa.h"
252b5132 148
fb52b2f4
NC		 149#include "aout/ar.h"
150
252b5132 151#include "getopt.h"
566b0d53 152#include "libiberty.h"
09c11c86 153#include "safe-ctype.h"
2cf0635d 154#include "filenames.h"
252b5132 155
2cf0635d 156char * program_name = "readelf";
85b1c36d
BE		 157static long archive_file_offset;
158static unsigned long archive_file_size;
159static unsigned long dynamic_addr;
160static bfd_size_type dynamic_size;
161static unsigned int dynamic_nent;
2cf0635d 162static char * dynamic_strings;
85b1c36d 163static unsigned long dynamic_strings_length;
2cf0635d 164static char * string_table;
85b1c36d
BE		 165static unsigned long string_table_length;
166static unsigned long num_dynamic_syms;
2cf0635d
NC		 167static Elf_Internal_Sym * dynamic_symbols;
168static Elf_Internal_Syminfo * dynamic_syminfo;
85b1c36d
BE		 169static unsigned long dynamic_syminfo_offset;
170static unsigned int dynamic_syminfo_nent;
f8eae8b2 171static char program_interpreter[PATH_MAX];
bb8a0291 172static bfd_vma dynamic_info[DT_ENCODING];
fdc90cb4 173static bfd_vma dynamic_info_DT_GNU_HASH;
85b1c36d
BE		 174static bfd_vma version_info[16];
175static Elf_Internal_Ehdr elf_header;
2cf0635d
NC		 176static Elf_Internal_Shdr * section_headers;
177static Elf_Internal_Phdr * program_headers;
178static Elf_Internal_Dyn * dynamic_section;
179static Elf_Internal_Shdr * symtab_shndx_hdr;
85b1c36d
BE		 180static int show_name;
181static int do_dynamic;
182static int do_syms;
2c610e4b 183static int do_dyn_syms;
85b1c36d
BE		 184static int do_reloc;
185static int do_sections;
186static int do_section_groups;
5477e8a0 187static int do_section_details;
85b1c36d
BE		 188static int do_segments;
189static int do_unwind;
190static int do_using_dynamic;
191static int do_header;
192static int do_dump;
193static int do_version;
85b1c36d
BE		 194static int do_histogram;
195static int do_debugging;
85b1c36d
BE		 196static int do_arch;
197static int do_notes;
4145f1d5 198static int do_archive_index;
85b1c36d 199static int is_32bit_elf;
252b5132 200
e4b17d5c
L		 201struct group_list
202{
2cf0635d 203 struct group_list * next;
e4b17d5c
L		 204 unsigned int section_index;
205};
206
207struct group
208{
2cf0635d 209 struct group_list * root;
e4b17d5c
L		 210 unsigned int group_index;
211};
212
85b1c36d 213static size_t group_count;
2cf0635d
NC		 214static struct group * section_groups;
215static struct group ** section_headers_groups;
e4b17d5c 216
09c11c86
NC		 217
218/* Flag bits indicating particular types of dump. */
219#define HEX_DUMP (1 << 0) /* The -x command line switch. */
220#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
221#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
222#define STRING_DUMP (1 << 3) /* The -p command line switch. */
cf13d699 223#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
09c11c86
NC		 224
225typedef unsigned char dump_type;
226
227/* A linked list of the section names for which dumps were requested. */
aef1f6d0
DJ		 228struct dump_list_entry
229{
2cf0635d 230 char * name;
09c11c86 231 dump_type type;
2cf0635d 232 struct dump_list_entry * next;
aef1f6d0 233};
2cf0635d 234static struct dump_list_entry * dump_sects_byname;
aef1f6d0 235
09c11c86
NC		 236/* A dynamic array of flags indicating for which sections a dump
237 has been requested via command line switches. */
238static dump_type * cmdline_dump_sects = NULL;
239static unsigned int num_cmdline_dump_sects = 0;
18bd398b
NC		 240
241/* A dynamic array of flags indicating for which sections a dump of
242 some kind has been requested. It is reset on a per-object file
aef1f6d0
DJ		 243 basis and then initialised from the cmdline_dump_sects array,
244 the results of interpreting the -w switch, and the
245 dump_sects_byname list. */
09c11c86
NC		 246static dump_type * dump_sects = NULL;
247static unsigned int num_dump_sects = 0;
252b5132 248
252b5132 249
c256ffe7 250/* How to print a vma value. */
843dd992
NC		 251typedef enum print_mode
252{
253 HEX,
254 DEC,
255 DEC_5,
256 UNSIGNED,
257 PREFIX_HEX,
258 FULL_HEX,
259 LONG_HEX
260}
261print_mode;
262
2cf0635d 263static void (* byte_put) (unsigned char *, bfd_vma, int);
252b5132 264
9c19a809
NC		 265#define UNKNOWN -1
266
2b692964
NC		 267#define SECTION_NAME(X) \
268 ((X) == NULL ? _("<none>") \
269 : string_table == NULL ? _("<no-name>") \
270 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
0b49d371 271 : string_table + (X)->sh_name))
252b5132 272
ee42cf8c 273#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
252b5132 274
7036c0e1 275#define BYTE_GET(field) byte_get (field, sizeof (field))
a952a375 276
9ad5cbcf
AM		 277#define GET_ELF_SYMBOLS(file, section) \
278 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
279 : get_64bit_elf_symbols (file, section))
9ea033b2 280
d79b3d50
NC		 281#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
282/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
283 already been called and verified that the string exists. */
284#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
18bd398b
NC		 285
286/* This is just a bit of syntatic sugar. */
60bca95a
NC		 287#define streq(a,b) (strcmp ((a), (b)) == 0)
288#define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
0112cd26 289#define const_strneq(a,b) (strncmp ((a), (b), sizeof (b) - 1) == 0)
0b6ae522
DJ		 290
291#define REMOVE_ARCH_BITS(ADDR) do { \
292 if (elf_header.e_machine == EM_ARM) \
293 (ADDR) &= ~1; \
294 } while (0)
d79b3d50 295\f
c256ffe7 296static void *
2cf0635d
NC		 297get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
298 const char * reason)
a6e9f9df 299{
2cf0635d 300 void * mvar;
a6e9f9df 301
c256ffe7 302 if (size == 0 || nmemb == 0)
a6e9f9df
AM		 303 return NULL;
304
fb52b2f4 305 if (fseek (file, archive_file_offset + offset, SEEK_SET))
a6e9f9df 306 {
0fd3a477 307 error (_("Unable to seek to 0x%lx for %s\n"),
0af1713e 308 (unsigned long) archive_file_offset + offset, reason);
a6e9f9df
AM		 309 return NULL;
310 }
311
312 mvar = var;
313 if (mvar == NULL)
314 {
c256ffe7
JJ		 315 /* Check for overflow. */
316 if (nmemb < (~(size_t) 0 - 1) / size)
317 /* + 1 so that we can '\0' terminate invalid string table sections. */
318 mvar = malloc (size * nmemb + 1);
a6e9f9df
AM		 319
320 if (mvar == NULL)
321 {
0fd3a477
JW		 322 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
323 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM		 324 return NULL;
325 }
c256ffe7
JJ		 326
327 ((char *) mvar)[size * nmemb] = '\0';
a6e9f9df
AM		 328 }
329
c256ffe7 330 if (fread (mvar, size, nmemb, file) != nmemb)
a6e9f9df 331 {
0fd3a477
JW		 332 error (_("Unable to read in 0x%lx bytes of %s\n"),
333 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM		 334 if (mvar != var)
335 free (mvar);
336 return NULL;
337 }
338
339 return mvar;
340}
341
adab8cdc 342static void
2cf0635d 343byte_put_little_endian (unsigned char * field, bfd_vma value, int size)
adab8cdc
AO		 344{
345 switch (size)
346 {
347 case 8:
348 field[7] = (((value >> 24) >> 24) >> 8) & 0xff;
349 field[6] = ((value >> 24) >> 24) & 0xff;
350 field[5] = ((value >> 24) >> 16) & 0xff;
351 field[4] = ((value >> 24) >> 8) & 0xff;
352 /* Fall through. */
353 case 4:
354 field[3] = (value >> 24) & 0xff;
4dc3c23d
AM		 355 /* Fall through. */
356 case 3:
adab8cdc
AO		 357 field[2] = (value >> 16) & 0xff;
358 /* Fall through. */
359 case 2:
360 field[1] = (value >> 8) & 0xff;
361 /* Fall through. */
362 case 1:
363 field[0] = value & 0xff;
364 break;
365
366 default:
367 error (_("Unhandled data length: %d\n"), size);
368 abort ();
369 }
370}
371
14a91970 372/* Print a VMA value. */
cb8f3167 373
66543521 374static int
14a91970 375print_vma (bfd_vma vma, print_mode mode)
66543521 376{
66543521
AM		 377 int nc = 0;
378
14a91970 379 switch (mode)
66543521 380 {
14a91970
AM		 381 case FULL_HEX:
382 nc = printf ("0x");
383 /* Drop through. */
66543521 384
14a91970 385 case LONG_HEX:
f7a99963 386#ifdef BFD64
14a91970 387 if (is_32bit_elf)
437c2fb7 388 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
f7a99963 389#endif
14a91970
AM		 390 printf_vma (vma);
391 return nc + 16;
b19aac67 392
14a91970
AM		 393 case DEC_5:
394 if (vma <= 99999)
395 return printf ("%5" BFD_VMA_FMT "d", vma);
396 /* Drop through. */
66543521 397
14a91970
AM		 398 case PREFIX_HEX:
399 nc = printf ("0x");
400 /* Drop through. */
66543521 401
14a91970
AM		 402 case HEX:
403 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 404
14a91970
AM		 405 case DEC:
406 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 407
14a91970
AM		 408 case UNSIGNED:
409 return printf ("%" BFD_VMA_FMT "u", vma);
f7a99963 410 }
66543521 411 return 0;
f7a99963
NC		 412}
413
171191ba 414/* Display a symbol on stdout. Handles the display of non-printing characters.
31104126 415
171191ba
NC		 416 If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
417 truncating as necessary. If WIDTH is negative then format the string to be
418 exactly - WIDTH characters, truncating or padding as necessary.
419
420 Returns the number of emitted characters. */
421
422static unsigned int
2cf0635d 423print_symbol (int width, const char * symbol)
31104126 424{
961c521f 425 const char * c;
171191ba
NC		 426 bfd_boolean extra_padding = FALSE;
427 unsigned int num_printed = 0;
961c521f 428
31104126 429 if (do_wide)
961c521f 430 {
961c521f
NC		 431 /* Set the width to a very large value. This simplifies the code below. */
432 width = INT_MAX;
433 }
31104126 434 else if (width < 0)
961c521f 435 {
961c521f
NC		 436 /* Keep the width positive. This also helps. */
437 width = - width;
171191ba 438 extra_padding = TRUE;
961c521f
NC		 439 }
440
441 while (width)
442 {
443 int len;
444
445 c = symbol;
446
447 /* Look for non-printing symbols inside the symbol's name.
448 This test is triggered in particular by the names generated
449 by the assembler for local labels. */
450 while (ISPRINT (* c))
451 c++;
452
453 len = c - symbol;
454
455 if (len)
456 {
457 if (len > width)
458 len = width;
cb8f3167 459
171191ba 460 printf ("%.*s", len, symbol);
961c521f
NC		 461
462 width -= len;
171191ba 463 num_printed += len;
961c521f
NC		 464 }
465
466 if (* c == 0 || width == 0)
467 break;
468
469 /* Now display the non-printing character, if
470 there is room left in which to dipslay it. */
471 if (*c < 32)
472 {
473 if (width < 2)
474 break;
475
476 printf ("^%c", *c + 0x40);
477
478 width -= 2;
171191ba 479 num_printed += 2;
961c521f
NC		 480 }
481 else
482 {
483 if (width < 6)
484 break;
cb8f3167 485
961c521f
NC		 486 printf ("<0x%.2x>", *c);
487
488 width -= 6;
171191ba 489 num_printed += 6;
961c521f
NC		 490 }
491
492 symbol = c + 1;
493 }
171191ba
NC		 494
495 if (extra_padding && width > 0)
496 {
497 /* Fill in the remaining spaces. */
498 printf ("%-*s", width, " ");
499 num_printed += 2;
500 }
501
502 return num_printed;
31104126
NC		 503}
504
adab8cdc 505static void
2cf0635d 506byte_put_big_endian (unsigned char * field, bfd_vma value, int size)
adab8cdc
AO		 507{
508 switch (size)
509 {
510 case 8:
511 field[7] = value & 0xff;
512 field[6] = (value >> 8) & 0xff;
513 field[5] = (value >> 16) & 0xff;
514 field[4] = (value >> 24) & 0xff;
515 value >>= 16;
516 value >>= 16;
517 /* Fall through. */
518 case 4:
519 field[3] = value & 0xff;
4dc3c23d
AM		 520 value >>= 8;
521 /* Fall through. */
522 case 3:
523 field[2] = value & 0xff;
524 value >>= 8;
adab8cdc
AO		 525 /* Fall through. */
526 case 2:
527 field[1] = value & 0xff;
528 value >>= 8;
529 /* Fall through. */
530 case 1:
531 field[0] = value & 0xff;
532 break;
533
534 default:
535 error (_("Unhandled data length: %d\n"), size);
536 abort ();
537 }
538}
539
89fac5e3
RS		 540/* Return a pointer to section NAME, or NULL if no such section exists. */
541
542static Elf_Internal_Shdr *
2cf0635d 543find_section (const char * name)
89fac5e3
RS		 544{
545 unsigned int i;
546
547 for (i = 0; i < elf_header.e_shnum; i++)
548 if (streq (SECTION_NAME (section_headers + i), name))
549 return section_headers + i;
550
551 return NULL;
552}
553
0b6ae522
DJ		 554/* Return a pointer to a section containing ADDR, or NULL if no such
555 section exists. */
556
557static Elf_Internal_Shdr *
558find_section_by_address (bfd_vma addr)
559{
560 unsigned int i;
561
562 for (i = 0; i < elf_header.e_shnum; i++)
563 {
564 Elf_Internal_Shdr *sec = section_headers + i;
565 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
566 return sec;
567 }
568
569 return NULL;
570}
571
572/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
573 bytes read. */
574
575static unsigned long
576read_uleb128 (unsigned char *data, unsigned int *length_return)
577{
578 return read_leb128 (data, length_return, 0);
579}
580
28f997cf
TG		 581/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
582 This OS has so many departures from the ELF standard that we test it at
583 many places. */
584
585static inline int
586is_ia64_vms (void)
587{
588 return elf_header.e_machine == EM_IA_64
589 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
590}
591
bcedfee6 592/* Guess the relocation size commonly used by the specific machines. */
252b5132 593
252b5132 594static int
2dc4cec1 595guess_is_rela (unsigned int e_machine)
252b5132 596{
9c19a809 597 switch (e_machine)
252b5132
RH		 598 {
599 /* Targets that use REL relocations. */
252b5132
RH		 600 case EM_386:
601 case EM_486:
63fcb9e9 602 case EM_960:
e9f53129 603 case EM_ARM:
2b0337b0 604 case EM_D10V:
252b5132 605 case EM_CYGNUS_D10V:
e9f53129 606 case EM_DLX:
252b5132 607 case EM_MIPS:
4fe85591 608 case EM_MIPS_RS3_LE:
e9f53129
AM		 609 case EM_CYGNUS_M32R:
610 case EM_OPENRISC:
611 case EM_OR32:
1c0d3aa6 612 case EM_SCORE:
9c19a809 613 return FALSE;
103f02d3 614
252b5132
RH		 615 /* Targets that use RELA relocations. */
616 case EM_68K:
e9f53129
AM		 617 case EM_860:
618 case EM_ALPHA:
619 case EM_ALTERA_NIOS2:
620 case EM_AVR:
621 case EM_AVR_OLD:
622 case EM_BLACKFIN:
60bca95a 623 case EM_CR16:
6c03b1ed 624 case EM_CR16_OLD:
e9f53129
AM		 625 case EM_CRIS:
626 case EM_CRX:
2b0337b0 627 case EM_D30V:
252b5132 628 case EM_CYGNUS_D30V:
2b0337b0 629 case EM_FR30:
252b5132 630 case EM_CYGNUS_FR30:
5c70f934 631 case EM_CYGNUS_FRV:
e9f53129
AM		 632 case EM_H8S:
633 case EM_H8_300:
634 case EM_H8_300H:
800eeca4 635 case EM_IA_64:
1e4cf259
NC		 636 case EM_IP2K:
637 case EM_IP2K_OLD:
3b36097d 638 case EM_IQ2000:
84e94c90 639 case EM_LATTICEMICO32:
ff7eeb89 640 case EM_M32C_OLD:
49f58d10 641 case EM_M32C:
e9f53129
AM		 642 case EM_M32R:
643 case EM_MCORE:
15ab5209 644 case EM_CYGNUS_MEP:
e9f53129
AM		 645 case EM_MMIX:
646 case EM_MN10200:
647 case EM_CYGNUS_MN10200:
648 case EM_MN10300:
649 case EM_CYGNUS_MN10300:
5506d11a 650 case EM_MOXIE:
e9f53129
AM		 651 case EM_MSP430:
652 case EM_MSP430_OLD:
d031aafb 653 case EM_MT:
64fd6348 654 case EM_NIOS32:
e9f53129
AM		 655 case EM_PPC64:
656 case EM_PPC:
c7927a3c 657 case EM_RX:
e9f53129
AM		 658 case EM_S390:
659 case EM_S390_OLD:
660 case EM_SH:
661 case EM_SPARC:
662 case EM_SPARC32PLUS:
663 case EM_SPARCV9:
664 case EM_SPU:
40b36596 665 case EM_TI_C6000:
e9f53129
AM		 666 case EM_V850:
667 case EM_CYGNUS_V850:
668 case EM_VAX:
669 case EM_X86_64:
8a9036a4 670 case EM_L1OM:
e9f53129
AM		 671 case EM_XSTORMY16:
672 case EM_XTENSA:
673 case EM_XTENSA_OLD:
7ba29e2a
NC		 674 case EM_MICROBLAZE:
675 case EM_MICROBLAZE_OLD:
9c19a809 676 return TRUE;
103f02d3 677
e9f53129
AM		 678 case EM_68HC05:
679 case EM_68HC08:
680 case EM_68HC11:
681 case EM_68HC16:
682 case EM_FX66:
683 case EM_ME16:
d1133906 684 case EM_MMA:
d1133906
NC		 685 case EM_NCPU:
686 case EM_NDR1:
e9f53129 687 case EM_PCP:
d1133906 688 case EM_ST100:
e9f53129 689 case EM_ST19:
d1133906 690 case EM_ST7:
e9f53129
AM		 691 case EM_ST9PLUS:
692 case EM_STARCORE:
d1133906 693 case EM_SVX:
e9f53129 694 case EM_TINYJ:
9c19a809
NC		 695 default:
696 warn (_("Don't know about relocations on this machine architecture\n"));
697 return FALSE;
698 }
699}
252b5132 700
9c19a809 701static int
2cf0635d 702slurp_rela_relocs (FILE * file,
d3ba0551
AM		 703 unsigned long rel_offset,
704 unsigned long rel_size,
2cf0635d
NC		 705 Elf_Internal_Rela ** relasp,
706 unsigned long * nrelasp)
9c19a809 707{
2cf0635d 708 Elf_Internal_Rela * relas;
4d6ed7c8
NC		 709 unsigned long nrelas;
710 unsigned int i;
252b5132 711
4d6ed7c8
NC		 712 if (is_32bit_elf)
713 {
2cf0635d 714 Elf32_External_Rela * erelas;
103f02d3 715
3f5e193b
NC		 716 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
717 rel_size, _("relocs"));
a6e9f9df
AM		 718 if (!erelas)
719 return 0;
252b5132 720
4d6ed7c8 721 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 722
3f5e193b
NC		 723 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
724 sizeof (Elf_Internal_Rela));
103f02d3 725
4d6ed7c8
NC		 726 if (relas == NULL)
727 {
c256ffe7 728 free (erelas);
591a748a 729 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 730 return 0;
731 }
103f02d3 732
4d6ed7c8
NC		 733 for (i = 0; i < nrelas; i++)
734 {
735 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
736 relas[i].r_info = BYTE_GET (erelas[i].r_info);
737 relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
738 }
103f02d3 739
4d6ed7c8
NC		 740 free (erelas);
741 }
742 else
743 {
2cf0635d 744 Elf64_External_Rela * erelas;
103f02d3 745
3f5e193b
NC		 746 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
747 rel_size, _("relocs"));
a6e9f9df
AM		 748 if (!erelas)
749 return 0;
4d6ed7c8
NC		 750
751 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 752
3f5e193b
NC		 753 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
754 sizeof (Elf_Internal_Rela));
103f02d3 755
4d6ed7c8
NC		 756 if (relas == NULL)
757 {
c256ffe7 758 free (erelas);
591a748a 759 error (_("out of memory parsing relocs\n"));
4d6ed7c8 760 return 0;
9c19a809 761 }
4d6ed7c8
NC		 762
763 for (i = 0; i < nrelas; i++)
9c19a809 764 {
66543521
AM		 765 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
766 relas[i].r_info = BYTE_GET (erelas[i].r_info);
767 relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
861fb55a
DJ		 768
769 /* The #ifdef BFD64 below is to prevent a compile time
770 warning. We know that if we do not have a 64 bit data
771 type that we will never execute this code anyway. */
772#ifdef BFD64
773 if (elf_header.e_machine == EM_MIPS
774 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
775 {
776 /* In little-endian objects, r_info isn't really a
777 64-bit little-endian value: it has a 32-bit
778 little-endian symbol index followed by four
779 individual byte fields. Reorder INFO
780 accordingly. */
91d6fa6a
NC		 781 bfd_vma inf = relas[i].r_info;
782 inf = (((inf & 0xffffffff) << 32)
783 | ((inf >> 56) & 0xff)
784 | ((inf >> 40) & 0xff00)
785 | ((inf >> 24) & 0xff0000)
786 | ((inf >> 8) & 0xff000000));
787 relas[i].r_info = inf;
861fb55a
DJ		 788 }
789#endif /* BFD64 */
4d6ed7c8 790 }
103f02d3 791
4d6ed7c8
NC		 792 free (erelas);
793 }
794 *relasp = relas;
795 *nrelasp = nrelas;
796 return 1;
797}
103f02d3 798
4d6ed7c8 799static int
2cf0635d 800slurp_rel_relocs (FILE * file,
d3ba0551
AM		 801 unsigned long rel_offset,
802 unsigned long rel_size,
2cf0635d
NC		 803 Elf_Internal_Rela ** relsp,
804 unsigned long * nrelsp)
4d6ed7c8 805{
2cf0635d 806 Elf_Internal_Rela * rels;
4d6ed7c8
NC		 807 unsigned long nrels;
808 unsigned int i;
103f02d3 809
4d6ed7c8
NC		 810 if (is_32bit_elf)
811 {
2cf0635d 812 Elf32_External_Rel * erels;
103f02d3 813
3f5e193b
NC		 814 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
815 rel_size, _("relocs"));
a6e9f9df
AM		 816 if (!erels)
817 return 0;
103f02d3 818
4d6ed7c8 819 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 820
3f5e193b 821 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 822
4d6ed7c8
NC		 823 if (rels == NULL)
824 {
c256ffe7 825 free (erels);
591a748a 826 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 827 return 0;
828 }
829
830 for (i = 0; i < nrels; i++)
831 {
832 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
833 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 834 rels[i].r_addend = 0;
9ea033b2 835 }
4d6ed7c8
NC		 836
837 free (erels);
9c19a809
NC		 838 }
839 else
840 {
2cf0635d 841 Elf64_External_Rel * erels;
9ea033b2 842
3f5e193b
NC		 843 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
844 rel_size, _("relocs"));
a6e9f9df
AM		 845 if (!erels)
846 return 0;
103f02d3 847
4d6ed7c8 848 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 849
3f5e193b 850 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 851
4d6ed7c8 852 if (rels == NULL)
9c19a809 853 {
c256ffe7 854 free (erels);
591a748a 855 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 856 return 0;
857 }
103f02d3 858
4d6ed7c8
NC		 859 for (i = 0; i < nrels; i++)
860 {
66543521
AM		 861 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
862 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 863 rels[i].r_addend = 0;
861fb55a
DJ		 864
865 /* The #ifdef BFD64 below is to prevent a compile time
866 warning. We know that if we do not have a 64 bit data
867 type that we will never execute this code anyway. */
868#ifdef BFD64
869 if (elf_header.e_machine == EM_MIPS
870 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
871 {
872 /* In little-endian objects, r_info isn't really a
873 64-bit little-endian value: it has a 32-bit
874 little-endian symbol index followed by four
875 individual byte fields. Reorder INFO
876 accordingly. */
91d6fa6a
NC		 877 bfd_vma inf = rels[i].r_info;
878 inf = (((inf & 0xffffffff) << 32)
879 | ((inf >> 56) & 0xff)
880 | ((inf >> 40) & 0xff00)
881 | ((inf >> 24) & 0xff0000)
882 | ((inf >> 8) & 0xff000000));
883 rels[i].r_info = inf;
861fb55a
DJ		 884 }
885#endif /* BFD64 */
4d6ed7c8 886 }
103f02d3 887
4d6ed7c8
NC		 888 free (erels);
889 }
890 *relsp = rels;
891 *nrelsp = nrels;
892 return 1;
893}
103f02d3 894
aca88567
NC		 895/* Returns the reloc type extracted from the reloc info field. */
896
897static unsigned int
898get_reloc_type (bfd_vma reloc_info)
899{
900 if (is_32bit_elf)
901 return ELF32_R_TYPE (reloc_info);
902
903 switch (elf_header.e_machine)
904 {
905 case EM_MIPS:
906 /* Note: We assume that reloc_info has already been adjusted for us. */
907 return ELF64_MIPS_R_TYPE (reloc_info);
908
909 case EM_SPARCV9:
910 return ELF64_R_TYPE_ID (reloc_info);
911
912 default:
913 return ELF64_R_TYPE (reloc_info);
914 }
915}
916
917/* Return the symbol index extracted from the reloc info field. */
918
919static bfd_vma
920get_reloc_symindex (bfd_vma reloc_info)
921{
922 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
923}
924
d3ba0551
AM		 925/* Display the contents of the relocation data found at the specified
926 offset. */
ee42cf8c 927
41e92641 928static void
2cf0635d 929dump_relocations (FILE * file,
d3ba0551
AM		 930 unsigned long rel_offset,
931 unsigned long rel_size,
2cf0635d 932 Elf_Internal_Sym * symtab,
d3ba0551 933 unsigned long nsyms,
2cf0635d 934 char * strtab,
d79b3d50 935 unsigned long strtablen,
d3ba0551 936 int is_rela)
4d6ed7c8 937{
b34976b6 938 unsigned int i;
2cf0635d 939 Elf_Internal_Rela * rels;
103f02d3 940
4d6ed7c8
NC		 941 if (is_rela == UNKNOWN)
942 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 943
4d6ed7c8
NC		 944 if (is_rela)
945 {
c8286bd1 946 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 947 return;
4d6ed7c8
NC		 948 }
949 else
950 {
951 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 952 return;
252b5132
RH		 953 }
954
410f7a12
L		 955 if (is_32bit_elf)
956 {
957 if (is_rela)
2c71103e
NC		 958 {
959 if (do_wide)
960 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
961 else
962 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
963 }
410f7a12 964 else
2c71103e
NC		 965 {
966 if (do_wide)
967 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
968 else
969 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
970 }
410f7a12 971 }
252b5132 972 else
410f7a12
L		 973 {
974 if (is_rela)
2c71103e
NC		 975 {
976 if (do_wide)
8beeaeb7 977 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 978 else
979 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
980 }
410f7a12 981 else
2c71103e
NC		 982 {
983 if (do_wide)
8beeaeb7 984 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 985 else
986 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
987 }
410f7a12 988 }
252b5132
RH		 989
990 for (i = 0; i < rel_size; i++)
991 {
2cf0635d 992 const char * rtype;
b34976b6 993 bfd_vma offset;
91d6fa6a 994 bfd_vma inf;
b34976b6
AM		 995 bfd_vma symtab_index;
996 bfd_vma type;
103f02d3 997
b34976b6 998 offset = rels[i].r_offset;
91d6fa6a 999 inf = rels[i].r_info;
103f02d3 1000
91d6fa6a
NC		 1001 type = get_reloc_type (inf);
1002 symtab_index = get_reloc_symindex (inf);
252b5132 1003
410f7a12
L		 1004 if (is_32bit_elf)
1005 {
39dbeff8
AM		 1006 printf ("%8.8lx %8.8lx ",
1007 (unsigned long) offset & 0xffffffff,
91d6fa6a 1008 (unsigned long) inf & 0xffffffff);
410f7a12
L		 1009 }
1010 else
1011 {
39dbeff8
AM		 1012#if BFD_HOST_64BIT_LONG
1013 printf (do_wide
1014 ? "%16.16lx %16.16lx "
1015 : "%12.12lx %12.12lx ",
91d6fa6a 1016 offset, inf);
39dbeff8 1017#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 1018#ifndef __MSVCRT__
39dbeff8
AM		 1019 printf (do_wide
1020 ? "%16.16llx %16.16llx "
1021 : "%12.12llx %12.12llx ",
91d6fa6a 1022 offset, inf);
6e3d6dc1
NC		 1023#else
1024 printf (do_wide
1025 ? "%16.16I64x %16.16I64x "
1026 : "%12.12I64x %12.12I64x ",
91d6fa6a 1027 offset, inf);
6e3d6dc1 1028#endif
39dbeff8 1029#else
2c71103e
NC		 1030 printf (do_wide
1031 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1032 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 1033 _bfd_int64_high (offset),
1034 _bfd_int64_low (offset),
91d6fa6a
NC		 1035 _bfd_int64_high (inf),
1036 _bfd_int64_low (inf));
9ea033b2 1037#endif
410f7a12 1038 }
103f02d3 1039
252b5132
RH		 1040 switch (elf_header.e_machine)
1041 {
1042 default:
1043 rtype = NULL;
1044 break;
1045
2b0337b0 1046 case EM_M32R:
252b5132 1047 case EM_CYGNUS_M32R:
9ea033b2 1048 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 1049 break;
1050
1051 case EM_386:
1052 case EM_486:
9ea033b2 1053 rtype = elf_i386_reloc_type (type);
252b5132
RH		 1054 break;
1055
ba2685cc
AM		 1056 case EM_68HC11:
1057 case EM_68HC12:
1058 rtype = elf_m68hc11_reloc_type (type);
1059 break;
75751cd9 1060
252b5132 1061 case EM_68K:
9ea033b2 1062 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1063 break;
1064
63fcb9e9 1065 case EM_960:
9ea033b2 1066 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1067 break;
1068
adde6300 1069 case EM_AVR:
2b0337b0 1070 case EM_AVR_OLD:
adde6300
AM		 1071 rtype = elf_avr_reloc_type (type);
1072 break;
1073
9ea033b2
NC		 1074 case EM_OLD_SPARCV9:
1075 case EM_SPARC32PLUS:
1076 case EM_SPARCV9:
252b5132 1077 case EM_SPARC:
9ea033b2 1078 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1079 break;
1080
e9f53129
AM		 1081 case EM_SPU:
1082 rtype = elf_spu_reloc_type (type);
1083 break;
1084
2b0337b0 1085 case EM_V850:
252b5132 1086 case EM_CYGNUS_V850:
9ea033b2 1087 rtype = v850_reloc_type (type);
252b5132
RH		 1088 break;
1089
2b0337b0 1090 case EM_D10V:
252b5132 1091 case EM_CYGNUS_D10V:
9ea033b2 1092 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1093 break;
1094
2b0337b0 1095 case EM_D30V:
252b5132 1096 case EM_CYGNUS_D30V:
9ea033b2 1097 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1098 break;
1099
d172d4ba
NC		 1100 case EM_DLX:
1101 rtype = elf_dlx_reloc_type (type);
1102 break;
1103
252b5132 1104 case EM_SH:
9ea033b2 1105 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1106 break;
1107
2b0337b0 1108 case EM_MN10300:
252b5132 1109 case EM_CYGNUS_MN10300:
9ea033b2 1110 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1111 break;
1112
2b0337b0 1113 case EM_MN10200:
252b5132 1114 case EM_CYGNUS_MN10200:
9ea033b2 1115 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1116 break;
1117
2b0337b0 1118 case EM_FR30:
252b5132 1119 case EM_CYGNUS_FR30:
9ea033b2 1120 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1121 break;
1122
ba2685cc
AM		 1123 case EM_CYGNUS_FRV:
1124 rtype = elf_frv_reloc_type (type);
1125 break;
5c70f934 1126
252b5132 1127 case EM_MCORE:
9ea033b2 1128 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1129 break;
1130
3c3bdf30
NC		 1131 case EM_MMIX:
1132 rtype = elf_mmix_reloc_type (type);
1133 break;
1134
5506d11a
AM		 1135 case EM_MOXIE:
1136 rtype = elf_moxie_reloc_type (type);
1137 break;
1138
2469cfa2
NC		 1139 case EM_MSP430:
1140 case EM_MSP430_OLD:
1141 rtype = elf_msp430_reloc_type (type);
1142 break;
1143
252b5132 1144 case EM_PPC:
9ea033b2 1145 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1146 break;
1147
c833c019
AM		 1148 case EM_PPC64:
1149 rtype = elf_ppc64_reloc_type (type);
1150 break;
1151
252b5132 1152 case EM_MIPS:
4fe85591 1153 case EM_MIPS_RS3_LE:
9ea033b2 1154 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1155 break;
1156
1157 case EM_ALPHA:
9ea033b2 1158 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1159 break;
1160
1161 case EM_ARM:
9ea033b2 1162 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1163 break;
1164
584da044 1165 case EM_ARC:
9ea033b2 1166 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1167 break;
1168
1169 case EM_PARISC:
69e617ca 1170 rtype = elf_hppa_reloc_type (type);
252b5132 1171 break;
7d466069 1172
b8720f9d
JL		 1173 case EM_H8_300:
1174 case EM_H8_300H:
1175 case EM_H8S:
1176 rtype = elf_h8_reloc_type (type);
1177 break;
1178
3b16e843
NC		 1179 case EM_OPENRISC:
1180 case EM_OR32:
1181 rtype = elf_or32_reloc_type (type);
1182 break;
1183
7d466069 1184 case EM_PJ:
2b0337b0 1185 case EM_PJ_OLD:
7d466069
ILT		 1186 rtype = elf_pj_reloc_type (type);
1187 break;
800eeca4
JW		 1188 case EM_IA_64:
1189 rtype = elf_ia64_reloc_type (type);
1190 break;
1b61cf92
HPN		 1191
1192 case EM_CRIS:
1193 rtype = elf_cris_reloc_type (type);
1194 break;
535c37ff
JE		 1195
1196 case EM_860:
1197 rtype = elf_i860_reloc_type (type);
1198 break;
bcedfee6
NC		 1199
1200 case EM_X86_64:
8a9036a4 1201 case EM_L1OM:
bcedfee6
NC		 1202 rtype = elf_x86_64_reloc_type (type);
1203 break;
a85d7ed0 1204
35b1837e
AM		 1205 case EM_S370:
1206 rtype = i370_reloc_type (type);
1207 break;
1208
53c7db4b
KH		 1209 case EM_S390_OLD:
1210 case EM_S390:
1211 rtype = elf_s390_reloc_type (type);
1212 break;
93fbbb04 1213
1c0d3aa6
NC		 1214 case EM_SCORE:
1215 rtype = elf_score_reloc_type (type);
1216 break;
1217
93fbbb04
GK		 1218 case EM_XSTORMY16:
1219 rtype = elf_xstormy16_reloc_type (type);
1220 break;
179d3252 1221
1fe1f39c
NC		 1222 case EM_CRX:
1223 rtype = elf_crx_reloc_type (type);
1224 break;
1225
179d3252
JT		 1226 case EM_VAX:
1227 rtype = elf_vax_reloc_type (type);
1228 break;
1e4cf259
NC		 1229
1230 case EM_IP2K:
1231 case EM_IP2K_OLD:
1232 rtype = elf_ip2k_reloc_type (type);
1233 break;
3b36097d
SC		 1234
1235 case EM_IQ2000:
1236 rtype = elf_iq2000_reloc_type (type);
1237 break;
88da6820
NC		 1238
1239 case EM_XTENSA_OLD:
1240 case EM_XTENSA:
1241 rtype = elf_xtensa_reloc_type (type);
1242 break;
a34e3ecb 1243
84e94c90
NC		 1244 case EM_LATTICEMICO32:
1245 rtype = elf_lm32_reloc_type (type);
1246 break;
1247
ff7eeb89 1248 case EM_M32C_OLD:
49f58d10
JB		 1249 case EM_M32C:
1250 rtype = elf_m32c_reloc_type (type);
1251 break;
1252
d031aafb
NS		 1253 case EM_MT:
1254 rtype = elf_mt_reloc_type (type);
a34e3ecb 1255 break;
1d65ded4
CM		 1256
1257 case EM_BLACKFIN:
1258 rtype = elf_bfin_reloc_type (type);
1259 break;
15ab5209
DB		 1260
1261 case EM_CYGNUS_MEP:
1262 rtype = elf_mep_reloc_type (type);
1263 break;
60bca95a
NC		 1264
1265 case EM_CR16:
6c03b1ed 1266 case EM_CR16_OLD:
60bca95a
NC		 1267 rtype = elf_cr16_reloc_type (type);
1268 break;
7ba29e2a
NC		 1269
1270 case EM_MICROBLAZE:
1271 case EM_MICROBLAZE_OLD:
1272 rtype = elf_microblaze_reloc_type (type);
1273 break;
c7927a3c
NC		 1274
1275 case EM_RX:
1276 rtype = elf_rx_reloc_type (type);
1277 break;
c29aca4a
NC		 1278
1279 case EM_XC16X:
1280 case EM_C166:
1281 rtype = elf_xc16x_reloc_type (type);
1282 break;
40b36596
JM		 1283
1284 case EM_TI_C6000:
1285 rtype = elf_tic6x_reloc_type (type);
1286 break;
252b5132
RH		 1287 }
1288
1289 if (rtype == NULL)
39dbeff8 1290 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1291 else
8beeaeb7 1292 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1293
7ace3541 1294 if (elf_header.e_machine == EM_ALPHA
157c2599 1295 && rtype != NULL
7ace3541
RH		 1296 && streq (rtype, "R_ALPHA_LITUSE")
1297 && is_rela)
1298 {
1299 switch (rels[i].r_addend)
1300 {
1301 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1302 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1303 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1304 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1305 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1306 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1307 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1308 default: rtype = NULL;
1309 }
1310 if (rtype)
1311 printf (" (%s)", rtype);
1312 else
1313 {
1314 putchar (' ');
1315 printf (_("<unknown addend: %lx>"),
1316 (unsigned long) rels[i].r_addend);
1317 }
1318 }
1319 else if (symtab_index)
252b5132 1320 {
af3fc3bc 1321 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1322 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1323 else
19936277 1324 {
2cf0635d 1325 Elf_Internal_Sym * psym;
19936277 1326
af3fc3bc 1327 psym = symtab + symtab_index;
103f02d3 1328
af3fc3bc 1329 printf (" ");
171191ba 1330
d8045f23
NC		 1331 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1332 {
1333 const char * name;
1334 unsigned int len;
1335 unsigned int width = is_32bit_elf ? 8 : 14;
1336
1337 /* Relocations against GNU_IFUNC symbols do not use the value
1338 of the symbol as the address to relocate against. Instead
1339 they invoke the function named by the symbol and use its
1340 result as the address for relocation.
1341
1342 To indicate this to the user, do not display the value of
1343 the symbol in the "Symbols's Value" field. Instead show
1344 its name followed by () as a hint that the symbol is
1345 invoked. */
1346
1347 if (strtab == NULL
1348 || psym->st_name == 0
1349 || psym->st_name >= strtablen)
1350 name = "??";
1351 else
1352 name = strtab + psym->st_name;
1353
1354 len = print_symbol (width, name);
1355 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1356 }
1357 else
1358 {
1359 print_vma (psym->st_value, LONG_HEX);
171191ba 1360
d8045f23
NC		 1361 printf (is_32bit_elf ? " " : " ");
1362 }
103f02d3 1363
af3fc3bc 1364 if (psym->st_name == 0)
f1ef08cb 1365 {
2cf0635d 1366 const char * sec_name = "<null>";
f1ef08cb
AM		 1367 char name_buf[40];
1368
1369 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1370 {
4fbb74a6
AM		 1371 if (psym->st_shndx < elf_header.e_shnum)
1372 sec_name
1373 = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1374 else if (psym->st_shndx == SHN_ABS)
1375 sec_name = "ABS";
1376 else if (psym->st_shndx == SHN_COMMON)
1377 sec_name = "COMMON";
172553c7
TS		 1378 else if (elf_header.e_machine == EM_MIPS
1379 && psym->st_shndx == SHN_MIPS_SCOMMON)
1380 sec_name = "SCOMMON";
1381 else if (elf_header.e_machine == EM_MIPS
1382 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1383 sec_name = "SUNDEF";
8a9036a4
L		 1384 else if ((elf_header.e_machine == EM_X86_64
1385 || elf_header.e_machine == EM_L1OM)
3b22753a
L		 1386 && psym->st_shndx == SHN_X86_64_LCOMMON)
1387 sec_name = "LARGE_COMMON";
9ce701e2
L		 1388 else if (elf_header.e_machine == EM_IA_64
1389 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1390 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1391 sec_name = "ANSI_COM";
28f997cf 1392 else if (is_ia64_vms ()
148b93f2
NC		 1393 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1394 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1395 else
1396 {
1397 sprintf (name_buf, "<section 0x%x>",
1398 (unsigned int) psym->st_shndx);
1399 sec_name = name_buf;
1400 }
1401 }
1402 print_symbol (22, sec_name);
1403 }
af3fc3bc 1404 else if (strtab == NULL)
d79b3d50 1405 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1406 else if (psym->st_name >= strtablen)
d79b3d50 1407 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1408 else
2c71103e 1409 print_symbol (22, strtab + psym->st_name);
103f02d3 1410
af3fc3bc 1411 if (is_rela)
171191ba 1412 {
91d6fa6a 1413 long off = (long) (bfd_signed_vma) rels[i].r_addend;
171191ba 1414
91d6fa6a
NC		 1415 if (off < 0)
1416 printf (" - %lx", - off);
171191ba 1417 else
91d6fa6a 1418 printf (" + %lx", off);
171191ba 1419 }
19936277 1420 }
252b5132 1421 }
1b228002 1422 else if (is_rela)
f7a99963 1423 {
18bd398b
NC		 1424 printf ("%*c", is_32bit_elf ?
1425 (do_wide ? 34 : 28) : (do_wide ? 26 : 20), ' ');
c8286bd1 1426 print_vma (rels[i].r_addend, LONG_HEX);
f7a99963 1427 }
252b5132 1428
157c2599
NC		 1429 if (elf_header.e_machine == EM_SPARCV9
1430 && rtype != NULL
1431 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1432 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1433
252b5132 1434 putchar ('\n');
2c71103e 1435
aca88567 1436#ifdef BFD64
53c7db4b 1437 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1438 {
91d6fa6a
NC		 1439 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1440 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1441 const char * rtype2 = elf_mips_reloc_type (type2);
1442 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1443
2c71103e
NC		 1444 printf (" Type2: ");
1445
1446 if (rtype2 == NULL)
39dbeff8
AM		 1447 printf (_("unrecognized: %-7lx"),
1448 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1449 else
1450 printf ("%-17.17s", rtype2);
1451
18bd398b 1452 printf ("\n Type3: ");
2c71103e
NC		 1453
1454 if (rtype3 == NULL)
39dbeff8
AM		 1455 printf (_("unrecognized: %-7lx"),
1456 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1457 else
1458 printf ("%-17.17s", rtype3);
1459
53c7db4b 1460 putchar ('\n');
2c71103e 1461 }
aca88567 1462#endif /* BFD64 */
252b5132
RH		 1463 }
1464
c8286bd1 1465 free (rels);
252b5132
RH		 1466}
1467
1468static const char *
d3ba0551 1469get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1470{
1471 switch (type)
1472 {
1473 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1474 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1475 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1476 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1477 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1478 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1479 case DT_MIPS_MSYM: return "MIPS_MSYM";
1480 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1481 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1482 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1483 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1484 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1485 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1486 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1487 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1488 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1489 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1490 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1491 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1492 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1493 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1494 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1495 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1496 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1497 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1498 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1499 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1500 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1501 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1502 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1503 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1504 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1505 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1506 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1507 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1508 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1509 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1510 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1511 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1512 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1513 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1514 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1515 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1516 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1517 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1518 default:
1519 return NULL;
1520 }
1521}
1522
9a097730 1523static const char *
d3ba0551 1524get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1525{
1526 switch (type)
1527 {
1528 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1529 default:
1530 return NULL;
1531 }
103f02d3
UD		 1532}
1533
7490d522
AM		 1534static const char *
1535get_ppc_dynamic_type (unsigned long type)
1536{
1537 switch (type)
1538 {
a7f2871e
AM		 1539 case DT_PPC_GOT: return "PPC_GOT";
1540 case DT_PPC_TLSOPT: return "PPC_TLSOPT";
7490d522
AM		 1541 default:
1542 return NULL;
1543 }
1544}
1545
f1cb7e17 1546static const char *
d3ba0551 1547get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1548{
1549 switch (type)
1550 {
a7f2871e
AM		 1551 case DT_PPC64_GLINK: return "PPC64_GLINK";
1552 case DT_PPC64_OPD: return "PPC64_OPD";
1553 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1554 case DT_PPC64_TLSOPT: return "PPC64_TLSOPT";
f1cb7e17
AM		 1555 default:
1556 return NULL;
1557 }
1558}
1559
103f02d3 1560static const char *
d3ba0551 1561get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1562{
1563 switch (type)
1564 {
1565 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1566 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1567 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1568 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1569 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1570 case DT_HP_PREINIT: return "HP_PREINIT";
1571 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1572 case DT_HP_NEEDED: return "HP_NEEDED";
1573 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1574 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1575 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1576 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1577 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1578 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1579 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1580 case DT_HP_FILTERED: return "HP_FILTERED";
1581 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1582 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1583 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1584 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1585 case DT_PLT: return "PLT";
1586 case DT_PLT_SIZE: return "PLT_SIZE";
1587 case DT_DLT: return "DLT";
1588 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1589 default:
1590 return NULL;
1591 }
1592}
9a097730 1593
ecc51f48 1594static const char *
d3ba0551 1595get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1596{
1597 switch (type)
1598 {
148b93f2
NC		 1599 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1600 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1601 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1602 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1603 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1604 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1605 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1606 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1607 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1608 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1609 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1610 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1611 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1612 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1613 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1614 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1615 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1616 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1617 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1618 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1619 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1620 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1621 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1622 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1623 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1624 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1625 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1626 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1627 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1628 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1629 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1630 default:
1631 return NULL;
1632 }
1633}
1634
fabcb361
RH		 1635static const char *
1636get_alpha_dynamic_type (unsigned long type)
1637{
1638 switch (type)
1639 {
1640 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1641 default:
1642 return NULL;
1643 }
1644}
1645
1c0d3aa6
NC		 1646static const char *
1647get_score_dynamic_type (unsigned long type)
1648{
1649 switch (type)
1650 {
1651 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1652 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1653 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1654 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1655 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1656 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1657 default:
1658 return NULL;
1659 }
1660}
1661
40b36596
JM		 1662static const char *
1663get_tic6x_dynamic_type (unsigned long type)
1664{
1665 switch (type)
1666 {
1667 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1668 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1669 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1670 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1671 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1672 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1673 default:
1674 return NULL;
1675 }
1676}
1c0d3aa6 1677
252b5132 1678static const char *
d3ba0551 1679get_dynamic_type (unsigned long type)
252b5132 1680{
e9e44622 1681 static char buff[64];
252b5132
RH		 1682
1683 switch (type)
1684 {
1685 case DT_NULL: return "NULL";
1686 case DT_NEEDED: return "NEEDED";
1687 case DT_PLTRELSZ: return "PLTRELSZ";
1688 case DT_PLTGOT: return "PLTGOT";
1689 case DT_HASH: return "HASH";
1690 case DT_STRTAB: return "STRTAB";
1691 case DT_SYMTAB: return "SYMTAB";
1692 case DT_RELA: return "RELA";
1693 case DT_RELASZ: return "RELASZ";
1694 case DT_RELAENT: return "RELAENT";
1695 case DT_STRSZ: return "STRSZ";
1696 case DT_SYMENT: return "SYMENT";
1697 case DT_INIT: return "INIT";
1698 case DT_FINI: return "FINI";
1699 case DT_SONAME: return "SONAME";
1700 case DT_RPATH: return "RPATH";
1701 case DT_SYMBOLIC: return "SYMBOLIC";
1702 case DT_REL: return "REL";
1703 case DT_RELSZ: return "RELSZ";
1704 case DT_RELENT: return "RELENT";
1705 case DT_PLTREL: return "PLTREL";
1706 case DT_DEBUG: return "DEBUG";
1707 case DT_TEXTREL: return "TEXTREL";
1708 case DT_JMPREL: return "JMPREL";
1709 case DT_BIND_NOW: return "BIND_NOW";
1710 case DT_INIT_ARRAY: return "INIT_ARRAY";
1711 case DT_FINI_ARRAY: return "FINI_ARRAY";
1712 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1713 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1714 case DT_RUNPATH: return "RUNPATH";
1715 case DT_FLAGS: return "FLAGS";
2d0e6f43 1716
d1133906
NC		 1717 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1718 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1719
05107a46 1720 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1721 case DT_PLTPADSZ: return "PLTPADSZ";
1722 case DT_MOVEENT: return "MOVEENT";
1723 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1724 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1725 case DT_POSFLAG_1: return "POSFLAG_1";
1726 case DT_SYMINSZ: return "SYMINSZ";
1727 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1728
252b5132 1729 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1730 case DT_CONFIG: return "CONFIG";
1731 case DT_DEPAUDIT: return "DEPAUDIT";
1732 case DT_AUDIT: return "AUDIT";
1733 case DT_PLTPAD: return "PLTPAD";
1734 case DT_MOVETAB: return "MOVETAB";
252b5132 1735 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1736
252b5132 1737 case DT_VERSYM: return "VERSYM";
103f02d3 1738
67a4f2b7
AO		 1739 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1740 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1741 case DT_RELACOUNT: return "RELACOUNT";
1742 case DT_RELCOUNT: return "RELCOUNT";
1743 case DT_FLAGS_1: return "FLAGS_1";
1744 case DT_VERDEF: return "VERDEF";
1745 case DT_VERDEFNUM: return "VERDEFNUM";
1746 case DT_VERNEED: return "VERNEED";
1747 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1748
019148e4 1749 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1750 case DT_USED: return "USED";
1751 case DT_FILTER: return "FILTER";
103f02d3 1752
047b2264
JJ		 1753 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1754 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1755 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1756 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1757 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1758 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1759
252b5132
RH		 1760 default:
1761 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1762 {
2cf0635d 1763 const char * result;
103f02d3 1764
252b5132
RH		 1765 switch (elf_header.e_machine)
1766 {
1767 case EM_MIPS:
4fe85591 1768 case EM_MIPS_RS3_LE:
252b5132
RH		 1769 result = get_mips_dynamic_type (type);
1770 break;
9a097730
RH		 1771 case EM_SPARCV9:
1772 result = get_sparc64_dynamic_type (type);
1773 break;
7490d522
AM		 1774 case EM_PPC:
1775 result = get_ppc_dynamic_type (type);
1776 break;
f1cb7e17
AM		 1777 case EM_PPC64:
1778 result = get_ppc64_dynamic_type (type);
1779 break;
ecc51f48
NC		 1780 case EM_IA_64:
1781 result = get_ia64_dynamic_type (type);
1782 break;
fabcb361
RH		 1783 case EM_ALPHA:
1784 result = get_alpha_dynamic_type (type);
1785 break;
1c0d3aa6
NC		 1786 case EM_SCORE:
1787 result = get_score_dynamic_type (type);
1788 break;
40b36596
JM		 1789 case EM_TI_C6000:
1790 result = get_tic6x_dynamic_type (type);
1791 break;
252b5132
RH		 1792 default:
1793 result = NULL;
1794 break;
1795 }
1796
1797 if (result != NULL)
1798 return result;
1799
e9e44622 1800 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 1801 }
eec8f817
DA		 1802 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1803 || (elf_header.e_machine == EM_PARISC
1804 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 1805 {
2cf0635d 1806 const char * result;
103f02d3
UD		 1807
1808 switch (elf_header.e_machine)
1809 {
1810 case EM_PARISC:
1811 result = get_parisc_dynamic_type (type);
1812 break;
148b93f2
NC		 1813 case EM_IA_64:
1814 result = get_ia64_dynamic_type (type);
1815 break;
103f02d3
UD		 1816 default:
1817 result = NULL;
1818 break;
1819 }
1820
1821 if (result != NULL)
1822 return result;
1823
e9e44622
JJ		 1824 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1825 type);
103f02d3 1826 }
252b5132 1827 else
e9e44622 1828 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 1829
252b5132
RH		 1830 return buff;
1831 }
1832}
1833
1834static char *
d3ba0551 1835get_file_type (unsigned e_type)
252b5132 1836{
b34976b6 1837 static char buff[32];
252b5132
RH		 1838
1839 switch (e_type)
1840 {
1841 case ET_NONE: return _("NONE (None)");
1842 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 1843 case ET_EXEC: return _("EXEC (Executable file)");
1844 case ET_DYN: return _("DYN (Shared object file)");
1845 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 1846
1847 default:
1848 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 1849 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 1850 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 1851 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 1852 else
e9e44622 1853 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 1854 return buff;
1855 }
1856}
1857
1858static char *
d3ba0551 1859get_machine_name (unsigned e_machine)
252b5132 1860{
b34976b6 1861 static char buff[64]; /* XXX */
252b5132
RH		 1862
1863 switch (e_machine)
1864 {
c45021f2
NC		 1865 case EM_NONE: return _("None");
1866 case EM_M32: return "WE32100";
1867 case EM_SPARC: return "Sparc";
e9f53129 1868 case EM_SPU: return "SPU";
c45021f2
NC		 1869 case EM_386: return "Intel 80386";
1870 case EM_68K: return "MC68000";
1871 case EM_88K: return "MC88000";
1872 case EM_486: return "Intel 80486";
1873 case EM_860: return "Intel 80860";
1874 case EM_MIPS: return "MIPS R3000";
1875 case EM_S370: return "IBM System/370";
7036c0e1 1876 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 1877 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 1878 case EM_PARISC: return "HPPA";
252b5132 1879 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 1880 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 1881 case EM_960: return "Intel 90860";
1882 case EM_PPC: return "PowerPC";
285d1771 1883 case EM_PPC64: return "PowerPC64";
c45021f2
NC		 1884 case EM_V800: return "NEC V800";
1885 case EM_FR20: return "Fujitsu FR20";
1886 case EM_RH32: return "TRW RH32";
b34976b6 1887 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 1888 case EM_ARM: return "ARM";
1889 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 1890 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 1891 case EM_SPARCV9: return "Sparc v9";
1892 case EM_TRICORE: return "Siemens Tricore";
584da044 1893 case EM_ARC: return "ARC";
c2dcd04e
NC		 1894 case EM_H8_300: return "Renesas H8/300";
1895 case EM_H8_300H: return "Renesas H8/300H";
1896 case EM_H8S: return "Renesas H8S";
1897 case EM_H8_500: return "Renesas H8/500";
30800947 1898 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 1899 case EM_MIPS_X: return "Stanford MIPS-X";
1900 case EM_COLDFIRE: return "Motorola Coldfire";
1901 case EM_68HC12: return "Motorola M68HC12";
c45021f2 1902 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 1903 case EM_CYGNUS_D10V:
1904 case EM_D10V: return "d10v";
1905 case EM_CYGNUS_D30V:
b34976b6 1906 case EM_D30V: return "d30v";
2b0337b0 1907 case EM_CYGNUS_M32R:
26597c86 1908 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0
AO		 1909 case EM_CYGNUS_V850:
1910 case EM_V850: return "NEC v850";
1911 case EM_CYGNUS_MN10300:
1912 case EM_MN10300: return "mn10300";
1913 case EM_CYGNUS_MN10200:
1914 case EM_MN10200: return "mn10200";
5506d11a 1915 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 1916 case EM_CYGNUS_FR30:
1917 case EM_FR30: return "Fujitsu FR30";
b34976b6 1918 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 1919 case EM_PJ_OLD:
b34976b6 1920 case EM_PJ: return "picoJava";
7036c0e1
AJ		 1921 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1922 case EM_PCP: return "Siemens PCP";
1923 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1924 case EM_NDR1: return "Denso NDR1 microprocesspr";
1925 case EM_STARCORE: return "Motorola Star*Core processor";
1926 case EM_ME16: return "Toyota ME16 processor";
1927 case EM_ST100: return "STMicroelectronics ST100 processor";
1928 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 1929 case EM_PDSP: return "Sony DSP processor";
1930 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
1931 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 1932 case EM_FX66: return "Siemens FX66 microcontroller";
1933 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1934 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1935 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1936 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1937 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1938 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1939 case EM_SVX: return "Silicon Graphics SVx";
1940 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1941 case EM_VAX: return "Digital VAX";
2b0337b0 1942 case EM_AVR_OLD:
b34976b6 1943 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 1944 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 1945 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1946 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1947 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 1948 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 1949 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 1950 case EM_PRISM: return "Vitesse Prism";
bcedfee6 1951 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 1952 case EM_L1OM: return "Intel L1OM";
b7498e0e 1953 case EM_S390_OLD:
b34976b6 1954 case EM_S390: return "IBM S/390";
1c0d3aa6 1955 case EM_SCORE: return "SUNPLUS S+Core";
93fbbb04 1956 case EM_XSTORMY16: return "Sanyo Xstormy16 CPU core";
3b16e843
NC		 1957 case EM_OPENRISC:
1958 case EM_OR32: return "OpenRISC";
11636f9e 1959 case EM_ARC_A5: return "ARC International ARCompact processor";
1fe1f39c 1960 case EM_CRX: return "National Semiconductor CRX microprocessor";
d172d4ba 1961 case EM_DLX: return "OpenDLX";
1e4cf259 1962 case EM_IP2K_OLD:
b34976b6 1963 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 1964 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 1965 case EM_XTENSA_OLD:
1966 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 1967 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
1968 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
1969 case EM_NS32K: return "National Semiconductor 32000 series";
1970 case EM_TPC: return "Tenor Network TPC processor";
1971 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
1972 case EM_MAX: return "MAX Processor";
1973 case EM_CR: return "National Semiconductor CompactRISC";
1974 case EM_F2MC16: return "Fujitsu F2MC16";
1975 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 1976 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 1977 case EM_M32C_OLD:
49f58d10 1978 case EM_M32C: return "Renesas M32c";
d031aafb 1979 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 1980 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 1981 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
1982 case EM_SEP: return "Sharp embedded microprocessor";
1983 case EM_ARCA: return "Arca RISC microprocessor";
1984 case EM_UNICORE: return "Unicore";
1985 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
1986 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 1987 case EM_NIOS32: return "Altera Nios";
1988 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 1989 case EM_C166:
d70c5fc7 1990 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 1991 case EM_M16C: return "Renesas M16C series microprocessors";
1992 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
1993 case EM_CE: return "Freescale Communication Engine RISC core";
1994 case EM_TSK3000: return "Altium TSK3000 core";
1995 case EM_RS08: return "Freescale RS08 embedded processor";
1996 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
1997 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
1998 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
1999 case EM_SE_C17: return "Seiko Epson C17 family";
2000 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2001 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2002 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2003 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2004 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2005 case EM_R32C: return "Renesas R32C series microprocessors";
2006 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2007 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2008 case EM_8051: return "Intel 8051 and variants";
2009 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2010 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2011 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2012 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2013 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2014 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2015 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 2016 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 2017 case EM_CR16:
6c03b1ed 2018 case EM_CR16_OLD: return "National Semiconductor's CR16";
7ba29e2a
NC		 2019 case EM_MICROBLAZE: return "Xilinx MicroBlaze";
2020 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
c7927a3c 2021 case EM_RX: return "Renesas RX";
11636f9e
JM		 2022 case EM_METAG: return "Imagination Technologies META processor architecture";
2023 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2024 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2025 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2026 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2027 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2028 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2029 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2030 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
2031 case EM_CUDA: return "NVIDIA CUDA architecture";
252b5132 2032 default:
35d9dd2f 2033 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2034 return buff;
2035 }
2036}
2037
f3485b74 2038static void
d3ba0551 2039decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2040{
2041 unsigned eabi;
2042 int unknown = 0;
2043
2044 eabi = EF_ARM_EABI_VERSION (e_flags);
2045 e_flags &= ~ EF_ARM_EABIMASK;
2046
2047 /* Handle "generic" ARM flags. */
2048 if (e_flags & EF_ARM_RELEXEC)
2049 {
2050 strcat (buf, ", relocatable executable");
2051 e_flags &= ~ EF_ARM_RELEXEC;
2052 }
76da6bbe 2053
f3485b74
NC		 2054 if (e_flags & EF_ARM_HASENTRY)
2055 {
2056 strcat (buf, ", has entry point");
2057 e_flags &= ~ EF_ARM_HASENTRY;
2058 }
76da6bbe 2059
f3485b74
NC		 2060 /* Now handle EABI specific flags. */
2061 switch (eabi)
2062 {
2063 default:
2c71103e 2064 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2065 if (e_flags)
2066 unknown = 1;
2067 break;
2068
2069 case EF_ARM_EABI_VER1:
a5bcd848 2070 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2071 while (e_flags)
2072 {
2073 unsigned flag;
76da6bbe 2074
f3485b74
NC		 2075 /* Process flags one bit at a time. */
2076 flag = e_flags & - e_flags;
2077 e_flags &= ~ flag;
76da6bbe 2078
f3485b74
NC		 2079 switch (flag)
2080 {
a5bcd848 2081 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2082 strcat (buf, ", sorted symbol tables");
2083 break;
76da6bbe 2084
f3485b74
NC		 2085 default:
2086 unknown = 1;
2087 break;
2088 }
2089 }
2090 break;
76da6bbe 2091
a5bcd848
PB		 2092 case EF_ARM_EABI_VER2:
2093 strcat (buf, ", Version2 EABI");
2094 while (e_flags)
2095 {
2096 unsigned flag;
2097
2098 /* Process flags one bit at a time. */
2099 flag = e_flags & - e_flags;
2100 e_flags &= ~ flag;
2101
2102 switch (flag)
2103 {
2104 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2105 strcat (buf, ", sorted symbol tables");
2106 break;
2107
2108 case EF_ARM_DYNSYMSUSESEGIDX:
2109 strcat (buf, ", dynamic symbols use segment index");
2110 break;
2111
2112 case EF_ARM_MAPSYMSFIRST:
2113 strcat (buf, ", mapping symbols precede others");
2114 break;
2115
2116 default:
2117 unknown = 1;
2118 break;
2119 }
2120 }
2121 break;
2122
d507cf36
PB		 2123 case EF_ARM_EABI_VER3:
2124 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2125 break;
2126
2127 case EF_ARM_EABI_VER4:
2128 strcat (buf, ", Version4 EABI");
3a4a14e9
PB		 2129 goto eabi;
2130
2131 case EF_ARM_EABI_VER5:
2132 strcat (buf, ", Version5 EABI");
2133 eabi:
d507cf36
PB		 2134 while (e_flags)
2135 {
2136 unsigned flag;
2137
2138 /* Process flags one bit at a time. */
2139 flag = e_flags & - e_flags;
2140 e_flags &= ~ flag;
2141
2142 switch (flag)
2143 {
2144 case EF_ARM_BE8:
2145 strcat (buf, ", BE8");
2146 break;
2147
2148 case EF_ARM_LE8:
2149 strcat (buf, ", LE8");
2150 break;
2151
2152 default:
2153 unknown = 1;
2154 break;
2155 }
2156 }
2157 break;
2158
f3485b74 2159 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2160 strcat (buf, ", GNU EABI");
f3485b74
NC		 2161 while (e_flags)
2162 {
2163 unsigned flag;
76da6bbe 2164
f3485b74
NC		 2165 /* Process flags one bit at a time. */
2166 flag = e_flags & - e_flags;
2167 e_flags &= ~ flag;
76da6bbe 2168
f3485b74
NC		 2169 switch (flag)
2170 {
a5bcd848 2171 case EF_ARM_INTERWORK:
f3485b74
NC		 2172 strcat (buf, ", interworking enabled");
2173 break;
76da6bbe 2174
a5bcd848 2175 case EF_ARM_APCS_26:
f3485b74
NC		 2176 strcat (buf, ", uses APCS/26");
2177 break;
76da6bbe 2178
a5bcd848 2179 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2180 strcat (buf, ", uses APCS/float");
2181 break;
76da6bbe 2182
a5bcd848 2183 case EF_ARM_PIC:
f3485b74
NC		 2184 strcat (buf, ", position independent");
2185 break;
76da6bbe 2186
a5bcd848 2187 case EF_ARM_ALIGN8:
f3485b74
NC		 2188 strcat (buf, ", 8 bit structure alignment");
2189 break;
76da6bbe 2190
a5bcd848 2191 case EF_ARM_NEW_ABI:
f3485b74
NC		 2192 strcat (buf, ", uses new ABI");
2193 break;
76da6bbe 2194
a5bcd848 2195 case EF_ARM_OLD_ABI:
f3485b74
NC		 2196 strcat (buf, ", uses old ABI");
2197 break;
76da6bbe 2198
a5bcd848 2199 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2200 strcat (buf, ", software FP");
2201 break;
76da6bbe 2202
90e01f86
ILT		 2203 case EF_ARM_VFP_FLOAT:
2204 strcat (buf, ", VFP");
2205 break;
2206
fde78edd
NC		 2207 case EF_ARM_MAVERICK_FLOAT:
2208 strcat (buf, ", Maverick FP");
2209 break;
2210
f3485b74
NC		 2211 default:
2212 unknown = 1;
2213 break;
2214 }
2215 }
2216 }
f3485b74
NC		 2217
2218 if (unknown)
2b692964 2219 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2220}
2221
252b5132 2222static char *
d3ba0551 2223get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2224{
b34976b6 2225 static char buf[1024];
252b5132
RH		 2226
2227 buf[0] = '\0';
76da6bbe 2228
252b5132
RH		 2229 if (e_flags)
2230 {
2231 switch (e_machine)
2232 {
2233 default:
2234 break;
2235
f3485b74
NC		 2236 case EM_ARM:
2237 decode_ARM_machine_flags (e_flags, buf);
2238 break;
76da6bbe 2239
ec2dfb42
AO		 2240 case EM_CYGNUS_FRV:
2241 switch (e_flags & EF_FRV_CPU_MASK)
2242 {
2243 case EF_FRV_CPU_GENERIC:
2244 break;
2245
2246 default:
2247 strcat (buf, ", fr???");
2248 break;
57346661 2249
ec2dfb42
AO		 2250 case EF_FRV_CPU_FR300:
2251 strcat (buf, ", fr300");
2252 break;
2253
2254 case EF_FRV_CPU_FR400:
2255 strcat (buf, ", fr400");
2256 break;
2257 case EF_FRV_CPU_FR405:
2258 strcat (buf, ", fr405");
2259 break;
2260
2261 case EF_FRV_CPU_FR450:
2262 strcat (buf, ", fr450");
2263 break;
2264
2265 case EF_FRV_CPU_FR500:
2266 strcat (buf, ", fr500");
2267 break;
2268 case EF_FRV_CPU_FR550:
2269 strcat (buf, ", fr550");
2270 break;
2271
2272 case EF_FRV_CPU_SIMPLE:
2273 strcat (buf, ", simple");
2274 break;
2275 case EF_FRV_CPU_TOMCAT:
2276 strcat (buf, ", tomcat");
2277 break;
2278 }
1c877e87 2279 break;
ec2dfb42 2280
53c7db4b 2281 case EM_68K:
425c6cb0 2282 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2283 strcat (buf, ", m68000");
425c6cb0 2284 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2285 strcat (buf, ", cpu32");
2286 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2287 strcat (buf, ", fido_a");
425c6cb0 2288 else
266abb8f 2289 {
2cf0635d
NC		 2290 char const * isa = _("unknown");
2291 char const * mac = _("unknown mac");
2292 char const * additional = NULL;
0112cd26 2293
c694fd50 2294 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2295 {
c694fd50 2296 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2297 isa = "A";
2298 additional = ", nodiv";
2299 break;
c694fd50 2300 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2301 isa = "A";
2302 break;
c694fd50 2303 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2304 isa = "A+";
2305 break;
c694fd50 2306 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2307 isa = "B";
2308 additional = ", nousp";
2309 break;
c694fd50 2310 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2311 isa = "B";
2312 break;
2313 }
2314 strcat (buf, ", cf, isa ");
2315 strcat (buf, isa);
0b2e31dc
NS		 2316 if (additional)
2317 strcat (buf, additional);
c694fd50 2318 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2319 strcat (buf, ", float");
c694fd50 2320 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2321 {
2322 case 0:
2323 mac = NULL;
2324 break;
c694fd50 2325 case EF_M68K_CF_MAC:
266abb8f
NS		 2326 mac = "mac";
2327 break;
c694fd50 2328 case EF_M68K_CF_EMAC:
266abb8f
NS		 2329 mac = "emac";
2330 break;
2331 }
2332 if (mac)
2333 {
2334 strcat (buf, ", ");
2335 strcat (buf, mac);
2336 }
266abb8f 2337 }
53c7db4b 2338 break;
33c63f9d 2339
252b5132
RH		 2340 case EM_PPC:
2341 if (e_flags & EF_PPC_EMB)
2342 strcat (buf, ", emb");
2343
2344 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2345 strcat (buf, _(", relocatable"));
252b5132
RH		 2346
2347 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 2348 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 2349 break;
2350
2b0337b0 2351 case EM_V850:
252b5132
RH		 2352 case EM_CYGNUS_V850:
2353 switch (e_flags & EF_V850_ARCH)
2354 {
8ad30312
NC		 2355 case E_V850E1_ARCH:
2356 strcat (buf, ", v850e1");
2357 break;
252b5132
RH		 2358 case E_V850E_ARCH:
2359 strcat (buf, ", v850e");
2360 break;
252b5132
RH		 2361 case E_V850_ARCH:
2362 strcat (buf, ", v850");
2363 break;
2364 default:
2b692964 2365 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 2366 break;
2367 }
2368 break;
2369
2b0337b0 2370 case EM_M32R:
252b5132
RH		 2371 case EM_CYGNUS_M32R:
2372 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2373 strcat (buf, ", m32r");
252b5132
RH		 2374 break;
2375
2376 case EM_MIPS:
4fe85591 2377 case EM_MIPS_RS3_LE:
252b5132
RH		 2378 if (e_flags & EF_MIPS_NOREORDER)
2379 strcat (buf, ", noreorder");
2380
2381 if (e_flags & EF_MIPS_PIC)
2382 strcat (buf, ", pic");
2383
2384 if (e_flags & EF_MIPS_CPIC)
2385 strcat (buf, ", cpic");
2386
d1bdd336
TS		 2387 if (e_flags & EF_MIPS_UCODE)
2388 strcat (buf, ", ugen_reserved");
2389
252b5132
RH		 2390 if (e_flags & EF_MIPS_ABI2)
2391 strcat (buf, ", abi2");
2392
43521d43
TS		 2393 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2394 strcat (buf, ", odk first");
2395
a5d22d2a
TS		 2396 if (e_flags & EF_MIPS_32BITMODE)
2397 strcat (buf, ", 32bitmode");
2398
156c2f8b
NC		 2399 switch ((e_flags & EF_MIPS_MACH))
2400 {
2401 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2402 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2403 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 2404 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 2405 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2406 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2407 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2408 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 2409 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 2410 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 2411 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2412 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
05c6f050 2413 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 2414 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
52b6b6b9 2415 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 2416 case 0:
2417 /* We simply ignore the field in this case to avoid confusion:
2418 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2419 extension. */
2420 break;
2b692964 2421 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 2422 }
43521d43
TS		 2423
2424 switch ((e_flags & EF_MIPS_ABI))
2425 {
2426 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2427 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2428 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2429 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2430 case 0:
2431 /* We simply ignore the field in this case to avoid confusion:
2432 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2433 This means it is likely to be an o32 file, but not for
2434 sure. */
2435 break;
2b692964 2436 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 2437 }
2438
2439 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2440 strcat (buf, ", mdmx");
2441
2442 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2443 strcat (buf, ", mips16");
2444
2445 switch ((e_flags & EF_MIPS_ARCH))
2446 {
2447 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2448 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2449 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2450 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2451 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2452 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 2453 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
43521d43 2454 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 2455 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2b692964 2456 default: strcat (buf, _(", unknown ISA")); break;
43521d43
TS		 2457 }
2458
8e45593f
NC		 2459 if (e_flags & EF_SH_PIC)
2460 strcat (buf, ", pic");
2461
2462 if (e_flags & EF_SH_FDPIC)
2463 strcat (buf, ", fdpic");
252b5132 2464 break;
351b4b40 2465
ccde1100
AO		 2466 case EM_SH:
2467 switch ((e_flags & EF_SH_MACH_MASK))
2468 {
2469 case EF_SH1: strcat (buf, ", sh1"); break;
2470 case EF_SH2: strcat (buf, ", sh2"); break;
2471 case EF_SH3: strcat (buf, ", sh3"); break;
2472 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2473 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2474 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2475 case EF_SH3E: strcat (buf, ", sh3e"); break;
2476 case EF_SH4: strcat (buf, ", sh4"); break;
2477 case EF_SH5: strcat (buf, ", sh5"); break;
2478 case EF_SH2E: strcat (buf, ", sh2e"); break;
2479 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 2480 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 2481 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2482 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 2483 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 2484 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2485 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2486 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2487 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2488 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2489 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 2490 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 2491 }
2492
2493 break;
57346661 2494
351b4b40
RH		 2495 case EM_SPARCV9:
2496 if (e_flags & EF_SPARC_32PLUS)
2497 strcat (buf, ", v8+");
2498
2499 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 2500 strcat (buf, ", ultrasparcI");
2501
2502 if (e_flags & EF_SPARC_SUN_US3)
2503 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 2504
2505 if (e_flags & EF_SPARC_HAL_R1)
2506 strcat (buf, ", halr1");
2507
2508 if (e_flags & EF_SPARC_LEDATA)
2509 strcat (buf, ", ledata");
2510
2511 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2512 strcat (buf, ", tso");
2513
2514 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2515 strcat (buf, ", pso");
2516
2517 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2518 strcat (buf, ", rmo");
2519 break;
7d466069 2520
103f02d3
UD		 2521 case EM_PARISC:
2522 switch (e_flags & EF_PARISC_ARCH)
2523 {
2524 case EFA_PARISC_1_0:
2525 strcpy (buf, ", PA-RISC 1.0");
2526 break;
2527 case EFA_PARISC_1_1:
2528 strcpy (buf, ", PA-RISC 1.1");
2529 break;
2530 case EFA_PARISC_2_0:
2531 strcpy (buf, ", PA-RISC 2.0");
2532 break;
2533 default:
2534 break;
2535 }
2536 if (e_flags & EF_PARISC_TRAPNIL)
2537 strcat (buf, ", trapnil");
2538 if (e_flags & EF_PARISC_EXT)
2539 strcat (buf, ", ext");
2540 if (e_flags & EF_PARISC_LSB)
2541 strcat (buf, ", lsb");
2542 if (e_flags & EF_PARISC_WIDE)
2543 strcat (buf, ", wide");
2544 if (e_flags & EF_PARISC_NO_KABP)
2545 strcat (buf, ", no kabp");
2546 if (e_flags & EF_PARISC_LAZYSWAP)
2547 strcat (buf, ", lazyswap");
30800947 2548 break;
76da6bbe 2549
7d466069 2550 case EM_PJ:
2b0337b0 2551 case EM_PJ_OLD:
7d466069
ILT		 2552 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2553 strcat (buf, ", new calling convention");
2554
2555 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2556 strcat (buf, ", gnu calling convention");
2557 break;
4d6ed7c8
NC		 2558
2559 case EM_IA_64:
2560 if ((e_flags & EF_IA_64_ABI64))
2561 strcat (buf, ", 64-bit");
2562 else
2563 strcat (buf, ", 32-bit");
2564 if ((e_flags & EF_IA_64_REDUCEDFP))
2565 strcat (buf, ", reduced fp model");
2566 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2567 strcat (buf, ", no function descriptors, constant gp");
2568 else if ((e_flags & EF_IA_64_CONS_GP))
2569 strcat (buf, ", constant gp");
2570 if ((e_flags & EF_IA_64_ABSOLUTE))
2571 strcat (buf, ", absolute");
28f997cf
TG		 2572 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2573 {
2574 if ((e_flags & EF_IA_64_VMS_LINKAGES))
2575 strcat (buf, ", vms_linkages");
2576 switch ((e_flags & EF_IA_64_VMS_COMCOD))
2577 {
2578 case EF_IA_64_VMS_COMCOD_SUCCESS:
2579 break;
2580 case EF_IA_64_VMS_COMCOD_WARNING:
2581 strcat (buf, ", warning");
2582 break;
2583 case EF_IA_64_VMS_COMCOD_ERROR:
2584 strcat (buf, ", error");
2585 break;
2586 case EF_IA_64_VMS_COMCOD_ABORT:
2587 strcat (buf, ", abort");
2588 break;
2589 default:
2590 abort ();
2591 }
2592 }
4d6ed7c8 2593 break;
179d3252
JT		 2594
2595 case EM_VAX:
2596 if ((e_flags & EF_VAX_NONPIC))
2597 strcat (buf, ", non-PIC");
2598 if ((e_flags & EF_VAX_DFLOAT))
2599 strcat (buf, ", D-Float");
2600 if ((e_flags & EF_VAX_GFLOAT))
2601 strcat (buf, ", G-Float");
2602 break;
c7927a3c
NC		 2603
2604 case EM_RX:
2605 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2606 strcat (buf, ", 64-bit doubles");
2607 if (e_flags & E_FLAG_RX_DSP)
2608 strcat (buf, ", dsp");
55786da2
AK		 2609
2610 case EM_S390:
2611 if (e_flags & EF_S390_HIGH_GPRS)
2612 strcat (buf, ", highgprs");
40b36596
JM		 2613
2614 case EM_TI_C6000:
2615 if ((e_flags & EF_C6000_REL))
2616 strcat (buf, ", relocatable module");
252b5132
RH		 2617 }
2618 }
2619
2620 return buf;
2621}
2622
252b5132 2623static const char *
d3ba0551
AM		 2624get_osabi_name (unsigned int osabi)
2625{
2626 static char buff[32];
2627
2628 switch (osabi)
2629 {
2630 case ELFOSABI_NONE: return "UNIX - System V";
2631 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2632 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
2633 case ELFOSABI_LINUX: return "UNIX - Linux";
2634 case ELFOSABI_HURD: return "GNU/Hurd";
2635 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2636 case ELFOSABI_AIX: return "UNIX - AIX";
2637 case ELFOSABI_IRIX: return "UNIX - IRIX";
2638 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2639 case ELFOSABI_TRU64: return "UNIX - TRU64";
2640 case ELFOSABI_MODESTO: return "Novell - Modesto";
2641 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2642 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2643 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 2644 case ELFOSABI_AROS: return "AROS";
11636f9e 2645 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 2646 default:
40b36596
JM		 2647 if (osabi >= 64)
2648 switch (elf_header.e_machine)
2649 {
2650 case EM_ARM:
2651 switch (osabi)
2652 {
2653 case ELFOSABI_ARM: return "ARM";
2654 default:
2655 break;
2656 }
2657 break;
2658
2659 case EM_MSP430:
2660 case EM_MSP430_OLD:
2661 switch (osabi)
2662 {
2663 case ELFOSABI_STANDALONE: return _("Standalone App");
2664 default:
2665 break;
2666 }
2667 break;
2668
2669 case EM_TI_C6000:
2670 switch (osabi)
2671 {
2672 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
2673 case ELFOSABI_C6000_LINUX: return "Linux C6000";
2674 default:
2675 break;
2676 }
2677 break;
2678
2679 default:
2680 break;
2681 }
e9e44622 2682 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 2683 return buff;
2684 }
2685}
2686
b294bdf8
MM		 2687static const char *
2688get_arm_segment_type (unsigned long type)
2689{
2690 switch (type)
2691 {
2692 case PT_ARM_EXIDX:
2693 return "EXIDX";
2694 default:
2695 break;
2696 }
2697
2698 return NULL;
2699}
2700
d3ba0551
AM		 2701static const char *
2702get_mips_segment_type (unsigned long type)
252b5132
RH		 2703{
2704 switch (type)
2705 {
2706 case PT_MIPS_REGINFO:
2707 return "REGINFO";
2708 case PT_MIPS_RTPROC:
2709 return "RTPROC";
2710 case PT_MIPS_OPTIONS:
2711 return "OPTIONS";
2712 default:
2713 break;
2714 }
2715
2716 return NULL;
2717}
2718
103f02d3 2719static const char *
d3ba0551 2720get_parisc_segment_type (unsigned long type)
103f02d3
UD		 2721{
2722 switch (type)
2723 {
2724 case PT_HP_TLS: return "HP_TLS";
2725 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2726 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2727 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2728 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2729 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2730 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2731 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2732 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2733 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2734 case PT_HP_PARALLEL: return "HP_PARALLEL";
2735 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 2736 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
2737 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
2738 case PT_HP_STACK: return "HP_STACK";
2739 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 2740 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2741 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 2742 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 2743 default:
2744 break;
2745 }
2746
2747 return NULL;
2748}
2749
4d6ed7c8 2750static const char *
d3ba0551 2751get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 2752{
2753 switch (type)
2754 {
2755 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2756 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 2757 case PT_HP_TLS: return "HP_TLS";
2758 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2759 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2760 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 2761 default:
2762 break;
2763 }
2764
2765 return NULL;
2766}
2767
40b36596
JM		 2768static const char *
2769get_tic6x_segment_type (unsigned long type)
2770{
2771 switch (type)
2772 {
2773 case PT_C6000_PHATTR: return "C6000_PHATTR";
2774 default:
2775 break;
2776 }
2777
2778 return NULL;
2779}
2780
252b5132 2781static const char *
d3ba0551 2782get_segment_type (unsigned long p_type)
252b5132 2783{
b34976b6 2784 static char buff[32];
252b5132
RH		 2785
2786 switch (p_type)
2787 {
b34976b6
AM		 2788 case PT_NULL: return "NULL";
2789 case PT_LOAD: return "LOAD";
252b5132 2790 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 2791 case PT_INTERP: return "INTERP";
2792 case PT_NOTE: return "NOTE";
2793 case PT_SHLIB: return "SHLIB";
2794 case PT_PHDR: return "PHDR";
13ae64f3 2795 case PT_TLS: return "TLS";
252b5132 2796
65765700
JJ		 2797 case PT_GNU_EH_FRAME:
2798 return "GNU_EH_FRAME";
2b05f1b7 2799 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 2800 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 2801
252b5132
RH		 2802 default:
2803 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2804 {
2cf0635d 2805 const char * result;
103f02d3 2806
252b5132
RH		 2807 switch (elf_header.e_machine)
2808 {
b294bdf8
MM		 2809 case EM_ARM:
2810 result = get_arm_segment_type (p_type);
2811 break;
252b5132 2812 case EM_MIPS:
4fe85591 2813 case EM_MIPS_RS3_LE:
252b5132
RH		 2814 result = get_mips_segment_type (p_type);
2815 break;
103f02d3
UD		 2816 case EM_PARISC:
2817 result = get_parisc_segment_type (p_type);
2818 break;
4d6ed7c8
NC		 2819 case EM_IA_64:
2820 result = get_ia64_segment_type (p_type);
2821 break;
40b36596
JM		 2822 case EM_TI_C6000:
2823 result = get_tic6x_segment_type (p_type);
2824 break;
252b5132
RH		 2825 default:
2826 result = NULL;
2827 break;
2828 }
103f02d3 2829
252b5132
RH		 2830 if (result != NULL)
2831 return result;
103f02d3 2832
252b5132
RH		 2833 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2834 }
2835 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 2836 {
2cf0635d 2837 const char * result;
103f02d3
UD		 2838
2839 switch (elf_header.e_machine)
2840 {
2841 case EM_PARISC:
2842 result = get_parisc_segment_type (p_type);
2843 break;
00428cca
AM		 2844 case EM_IA_64:
2845 result = get_ia64_segment_type (p_type);
2846 break;
103f02d3
UD		 2847 default:
2848 result = NULL;
2849 break;
2850 }
2851
2852 if (result != NULL)
2853 return result;
2854
2855 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2856 }
252b5132 2857 else
e9e44622 2858 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 2859
2860 return buff;
2861 }
2862}
2863
2864static const char *
d3ba0551 2865get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 2866{
2867 switch (sh_type)
2868 {
b34976b6
AM		 2869 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
2870 case SHT_MIPS_MSYM: return "MIPS_MSYM";
2871 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
2872 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
2873 case SHT_MIPS_UCODE: return "MIPS_UCODE";
2874 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
2875 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
2876 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
2877 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
2878 case SHT_MIPS_RELD: return "MIPS_RELD";
2879 case SHT_MIPS_IFACE: return "MIPS_IFACE";
2880 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
2881 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
2882 case SHT_MIPS_SHDR: return "MIPS_SHDR";
2883 case SHT_MIPS_FDESC: return "MIPS_FDESC";
2884 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
2885 case SHT_MIPS_DENSE: return "MIPS_DENSE";
2886 case SHT_MIPS_PDESC: return "MIPS_PDESC";
2887 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
2888 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
2889 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
2890 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
2891 case SHT_MIPS_LINE: return "MIPS_LINE";
2892 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
2893 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
2894 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
2895 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
2896 case SHT_MIPS_DWARF: return "MIPS_DWARF";
2897 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
2898 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
2899 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
2900 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
2901 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
2902 case SHT_MIPS_XLATE: return "MIPS_XLATE";
2903 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
2904 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
2905 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
2906 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132
RH		 2907 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2908 default:
2909 break;
2910 }
2911 return NULL;
2912}
2913
103f02d3 2914static const char *
d3ba0551 2915get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 2916{
2917 switch (sh_type)
2918 {
2919 case SHT_PARISC_EXT: return "PARISC_EXT";
2920 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
2921 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 2922 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
2923 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
2924 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 2925 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 2926 default:
2927 break;
2928 }
2929 return NULL;
2930}
2931
4d6ed7c8 2932static const char *
d3ba0551 2933get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 2934{
18bd398b 2935 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 2936 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
2937 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 2938
4d6ed7c8
NC		 2939 switch (sh_type)
2940 {
148b93f2
NC		 2941 case SHT_IA_64_EXT: return "IA_64_EXT";
2942 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
2943 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
2944 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
2945 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
2946 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
2947 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
2948 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
2949 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
2950 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 2951 default:
2952 break;
2953 }
2954 return NULL;
2955}
2956
d2b2c203
DJ		 2957static const char *
2958get_x86_64_section_type_name (unsigned int sh_type)
2959{
2960 switch (sh_type)
2961 {
2962 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
2963 default:
2964 break;
2965 }
2966 return NULL;
2967}
2968
40a18ebd
NC		 2969static const char *
2970get_arm_section_type_name (unsigned int sh_type)
2971{
2972 switch (sh_type)
2973 {
7f6fed87
NC		 2974 case SHT_ARM_EXIDX: return "ARM_EXIDX";
2975 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
2976 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
2977 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
2978 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 2979 default:
2980 break;
2981 }
2982 return NULL;
2983}
2984
40b36596
JM		 2985static const char *
2986get_tic6x_section_type_name (unsigned int sh_type)
2987{
2988 switch (sh_type)
2989 {
2990 case SHT_C6000_UNWIND:
2991 return "C6000_UNWIND";
2992 case SHT_C6000_PREEMPTMAP:
2993 return "C6000_PREEMPTMAP";
2994 case SHT_C6000_ATTRIBUTES:
2995 return "C6000_ATTRIBUTES";
2996 case SHT_TI_ICODE:
2997 return "TI_ICODE";
2998 case SHT_TI_XREF:
2999 return "TI_XREF";
3000 case SHT_TI_HANDLER:
3001 return "TI_HANDLER";
3002 case SHT_TI_INITINFO:
3003 return "TI_INITINFO";
3004 case SHT_TI_PHATTRS:
3005 return "TI_PHATTRS";
3006 default:
3007 break;
3008 }
3009 return NULL;
3010}
3011
252b5132 3012static const char *
d3ba0551 3013get_section_type_name (unsigned int sh_type)
252b5132 3014{
b34976b6 3015 static char buff[32];
252b5132
RH		 3016
3017 switch (sh_type)
3018 {
3019 case SHT_NULL: return "NULL";
3020 case SHT_PROGBITS: return "PROGBITS";
3021 case SHT_SYMTAB: return "SYMTAB";
3022 case SHT_STRTAB: return "STRTAB";
3023 case SHT_RELA: return "RELA";
3024 case SHT_HASH: return "HASH";
3025 case SHT_DYNAMIC: return "DYNAMIC";
3026 case SHT_NOTE: return "NOTE";
3027 case SHT_NOBITS: return "NOBITS";
3028 case SHT_REL: return "REL";
3029 case SHT_SHLIB: return "SHLIB";
3030 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3031 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3032 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3033 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3034 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3035 case SHT_GROUP: return "GROUP";
3036 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3037 case SHT_GNU_verdef: return "VERDEF";
3038 case SHT_GNU_verneed: return "VERNEED";
3039 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3040 case 0x6ffffff0: return "VERSYM";
3041 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3042 case 0x7ffffffd: return "AUXILIARY";
3043 case 0x7fffffff: return "FILTER";
047b2264 3044 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3045
3046 default:
3047 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3048 {
2cf0635d 3049 const char * result;
252b5132
RH		 3050
3051 switch (elf_header.e_machine)
3052 {
3053 case EM_MIPS:
4fe85591 3054 case EM_MIPS_RS3_LE:
252b5132
RH		 3055 result = get_mips_section_type_name (sh_type);
3056 break;
103f02d3
UD		 3057 case EM_PARISC:
3058 result = get_parisc_section_type_name (sh_type);
3059 break;
4d6ed7c8
NC		 3060 case EM_IA_64:
3061 result = get_ia64_section_type_name (sh_type);
3062 break;
d2b2c203 3063 case EM_X86_64:
8a9036a4 3064 case EM_L1OM:
d2b2c203
DJ		 3065 result = get_x86_64_section_type_name (sh_type);
3066 break;
40a18ebd
NC		 3067 case EM_ARM:
3068 result = get_arm_section_type_name (sh_type);
3069 break;
40b36596
JM		 3070 case EM_TI_C6000:
3071 result = get_tic6x_section_type_name (sh_type);
3072 break;
252b5132
RH		 3073 default:
3074 result = NULL;
3075 break;
3076 }
3077
3078 if (result != NULL)
3079 return result;
3080
c91d0dfb 3081 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3082 }
3083 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3084 {
2cf0635d 3085 const char * result;
148b93f2
NC		 3086
3087 switch (elf_header.e_machine)
3088 {
3089 case EM_IA_64:
3090 result = get_ia64_section_type_name (sh_type);
3091 break;
3092 default:
3093 result = NULL;
3094 break;
3095 }
3096
3097 if (result != NULL)
3098 return result;
3099
3100 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3101 }
252b5132 3102 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
c91d0dfb 3103 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
252b5132 3104 else
e9e44622 3105 snprintf (buff, sizeof (buff), _("<unknown>: %x"), sh_type);
103f02d3 3106
252b5132
RH		 3107 return buff;
3108 }
3109}
3110
2979dc34 3111#define OPTION_DEBUG_DUMP 512
2c610e4b 3112#define OPTION_DYN_SYMS 513
2979dc34 3113
85b1c36d 3114static struct option options[] =
252b5132 3115{
b34976b6 3116 {"all", no_argument, 0, 'a'},
252b5132
RH		 3117 {"file-header", no_argument, 0, 'h'},
3118 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3119 {"headers", no_argument, 0, 'e'},
3120 {"histogram", no_argument, 0, 'I'},
3121 {"segments", no_argument, 0, 'l'},
3122 {"sections", no_argument, 0, 'S'},
252b5132 3123 {"section-headers", no_argument, 0, 'S'},
f5842774 3124 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3125 {"section-details", no_argument, 0, 't'},
595cf52e 3126 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3127 {"symbols", no_argument, 0, 's'},
3128 {"syms", no_argument, 0, 's'},
2c610e4b 3129 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3130 {"relocs", no_argument, 0, 'r'},
3131 {"notes", no_argument, 0, 'n'},
3132 {"dynamic", no_argument, 0, 'd'},
a952a375 3133 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3134 {"version-info", no_argument, 0, 'V'},
3135 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3136 {"unwind", no_argument, 0, 'u'},
4145f1d5 3137 {"archive-index", no_argument, 0, 'c'},
b34976b6 3138 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3139 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3140 {"string-dump", required_argument, 0, 'p'},
252b5132
RH		 3141#ifdef SUPPORT_DISASSEMBLY
3142 {"instruction-dump", required_argument, 0, 'i'},
3143#endif
cf13d699 3144 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3145
b34976b6
AM		 3146 {"version", no_argument, 0, 'v'},
3147 {"wide", no_argument, 0, 'W'},
3148 {"help", no_argument, 0, 'H'},
3149 {0, no_argument, 0, 0}
252b5132
RH		 3150};
3151
3152static void
2cf0635d 3153usage (FILE * stream)
252b5132 3154{
92f01d61
JM		 3155 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3156 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3157 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3158 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3159 -h --file-header Display the ELF file header\n\
3160 -l --program-headers Display the program headers\n\
3161 --segments An alias for --program-headers\n\
3162 -S --section-headers Display the sections' header\n\
3163 --sections An alias for --section-headers\n\
f5842774 3164 -g --section-groups Display the section groups\n\
5477e8a0 3165 -t --section-details Display the section details\n\
8b53311e
NC		 3166 -e --headers Equivalent to: -h -l -S\n\
3167 -s --syms Display the symbol table\n\
3f08eb35 3168 --symbols An alias for --syms\n\
2c610e4b 3169 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3170 -n --notes Display the core notes (if present)\n\
3171 -r --relocs Display the relocations (if present)\n\
3172 -u --unwind Display the unwind info (if present)\n\
b2d38a17 3173 -d --dynamic Display the dynamic section (if present)\n\
8b53311e
NC		 3174 -V --version-info Display the version sections (if present)\n\
3175 -A --arch-specific Display architecture specific information (if any).\n\
4145f1d5 3176 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 3177 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 3178 -x --hex-dump=<number|name>\n\
3179 Dump the contents of section <number|name> as bytes\n\
3180 -p --string-dump=<number|name>\n\
3181 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 3182 -R --relocated-dump=<number|name>\n\
3183 Dump the contents of section <number|name> as relocated bytes\n\
f9f0e732 3184 -w[lLiaprmfFsoRt] or\n\
1ed06042 3185 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884
TG		 3186 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3187 =trace_info,=trace_abbrev,=trace_aranges]\n\
8b53311e 3188 Display the contents of DWARF2 debug sections\n"));
252b5132 3189#ifdef SUPPORT_DISASSEMBLY
92f01d61 3190 fprintf (stream, _("\
09c11c86
NC		 3191 -i --instruction-dump=<number|name>\n\
3192 Disassemble the contents of section <number|name>\n"));
252b5132 3193#endif
92f01d61 3194 fprintf (stream, _("\
8b53311e
NC		 3195 -I --histogram Display histogram of bucket list lengths\n\
3196 -W --wide Allow output width to exceed 80 characters\n\
07012eee 3197 @<file> Read options from <file>\n\
8b53311e
NC		 3198 -H --help Display this information\n\
3199 -v --version Display the version number of readelf\n"));
1118d252 3200
92f01d61
JM		 3201 if (REPORT_BUGS_TO[0] && stream == stdout)
3202 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 3203
92f01d61 3204 exit (stream == stdout ? 0 : 1);
252b5132
RH		 3205}
3206
18bd398b
NC		 3207/* Record the fact that the user wants the contents of section number
3208 SECTION to be displayed using the method(s) encoded as flags bits
3209 in TYPE. Note, TYPE can be zero if we are creating the array for
3210 the first time. */
3211
252b5132 3212static void
09c11c86 3213request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 3214{
3215 if (section >= num_dump_sects)
3216 {
2cf0635d 3217 dump_type * new_dump_sects;
252b5132 3218
3f5e193b
NC		 3219 new_dump_sects = (dump_type *) calloc (section + 1,
3220 sizeof (* dump_sects));
252b5132
RH		 3221
3222 if (new_dump_sects == NULL)
591a748a 3223 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 3224 else
3225 {
3226 /* Copy current flag settings. */
09c11c86 3227 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 3228
3229 free (dump_sects);
3230
3231 dump_sects = new_dump_sects;
3232 num_dump_sects = section + 1;
3233 }
3234 }
3235
3236 if (dump_sects)
b34976b6 3237 dump_sects[section] |= type;
252b5132
RH		 3238
3239 return;
3240}
3241
aef1f6d0
DJ		 3242/* Request a dump by section name. */
3243
3244static void
2cf0635d 3245request_dump_byname (const char * section, dump_type type)
aef1f6d0 3246{
2cf0635d 3247 struct dump_list_entry * new_request;
aef1f6d0 3248
3f5e193b
NC		 3249 new_request = (struct dump_list_entry *)
3250 malloc (sizeof (struct dump_list_entry));
aef1f6d0 3251 if (!new_request)
591a748a 3252 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3253
3254 new_request->name = strdup (section);
3255 if (!new_request->name)
591a748a 3256 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3257
3258 new_request->type = type;
3259
3260 new_request->next = dump_sects_byname;
3261 dump_sects_byname = new_request;
3262}
3263
cf13d699
NC		 3264static inline void
3265request_dump (dump_type type)
3266{
3267 int section;
3268 char * cp;
3269
3270 do_dump++;
3271 section = strtoul (optarg, & cp, 0);
3272
3273 if (! *cp && section >= 0)
3274 request_dump_bynumber (section, type);
3275 else
3276 request_dump_byname (optarg, type);
3277}
3278
3279
252b5132 3280static void
2cf0635d 3281parse_args (int argc, char ** argv)
252b5132
RH		 3282{
3283 int c;
3284
3285 if (argc < 2)
92f01d61 3286 usage (stderr);
252b5132
RH		 3287
3288 while ((c = getopt_long
cf13d699 3289 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
252b5132 3290 {
252b5132
RH		 3291 switch (c)
3292 {
3293 case 0:
3294 /* Long options. */
3295 break;
3296 case 'H':
92f01d61 3297 usage (stdout);
252b5132
RH		 3298 break;
3299
3300 case 'a':
b34976b6
AM		 3301 do_syms++;
3302 do_reloc++;
3303 do_unwind++;
3304 do_dynamic++;
3305 do_header++;
3306 do_sections++;
f5842774 3307 do_section_groups++;
b34976b6
AM		 3308 do_segments++;
3309 do_version++;
3310 do_histogram++;
3311 do_arch++;
3312 do_notes++;
252b5132 3313 break;
f5842774
L		 3314 case 'g':
3315 do_section_groups++;
3316 break;
5477e8a0 3317 case 't':
595cf52e 3318 case 'N':
5477e8a0
L		 3319 do_sections++;
3320 do_section_details++;
595cf52e 3321 break;
252b5132 3322 case 'e':
b34976b6
AM		 3323 do_header++;
3324 do_sections++;
3325 do_segments++;
252b5132 3326 break;
a952a375 3327 case 'A':
b34976b6 3328 do_arch++;
a952a375 3329 break;
252b5132 3330 case 'D':
b34976b6 3331 do_using_dynamic++;
252b5132
RH		 3332 break;
3333 case 'r':
b34976b6 3334 do_reloc++;
252b5132 3335 break;
4d6ed7c8 3336 case 'u':
b34976b6 3337 do_unwind++;
4d6ed7c8 3338 break;
252b5132 3339 case 'h':
b34976b6 3340 do_header++;
252b5132
RH		 3341 break;
3342 case 'l':
b34976b6 3343 do_segments++;
252b5132
RH		 3344 break;
3345 case 's':
b34976b6 3346 do_syms++;
252b5132
RH		 3347 break;
3348 case 'S':
b34976b6 3349 do_sections++;
252b5132
RH		 3350 break;
3351 case 'd':
b34976b6 3352 do_dynamic++;
252b5132 3353 break;
a952a375 3354 case 'I':
b34976b6 3355 do_histogram++;
a952a375 3356 break;
779fe533 3357 case 'n':
b34976b6 3358 do_notes++;
779fe533 3359 break;
4145f1d5
NC		 3360 case 'c':
3361 do_archive_index++;
3362 break;
252b5132 3363 case 'x':
cf13d699 3364 request_dump (HEX_DUMP);
aef1f6d0 3365 break;
09c11c86 3366 case 'p':
cf13d699
NC		 3367 request_dump (STRING_DUMP);
3368 break;
3369 case 'R':
3370 request_dump (RELOC_DUMP);
09c11c86 3371 break;
252b5132 3372 case 'w':
b34976b6 3373 do_dump++;
252b5132 3374 if (optarg == 0)
613ff48b
CC		 3375 {
3376 do_debugging = 1;
3377 dwarf_select_sections_all ();
3378 }
252b5132
RH		 3379 else
3380 {
3381 do_debugging = 0;
4cb93e3b 3382 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 3383 }
3384 break;
2979dc34 3385 case OPTION_DEBUG_DUMP:
b34976b6 3386 do_dump++;
2979dc34
JJ		 3387 if (optarg == 0)
3388 do_debugging = 1;
3389 else
3390 {
2979dc34 3391 do_debugging = 0;
4cb93e3b 3392 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 3393 }
3394 break;
2c610e4b
L		 3395 case OPTION_DYN_SYMS:
3396 do_dyn_syms++;
3397 break;
252b5132
RH		 3398#ifdef SUPPORT_DISASSEMBLY
3399 case 'i':
cf13d699
NC		 3400 request_dump (DISASS_DUMP);
3401 break;
252b5132
RH		 3402#endif
3403 case 'v':
3404 print_version (program_name);
3405 break;
3406 case 'V':
b34976b6 3407 do_version++;
252b5132 3408 break;
d974e256 3409 case 'W':
b34976b6 3410 do_wide++;
d974e256 3411 break;
252b5132 3412 default:
252b5132
RH		 3413 /* xgettext:c-format */
3414 error (_("Invalid option '-%c'\n"), c);
3415 /* Drop through. */
3416 case '?':
92f01d61 3417 usage (stderr);
252b5132
RH		 3418 }
3419 }
3420
4d6ed7c8 3421 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 3422 && !do_segments && !do_header && !do_dump && !do_version
f5842774 3423 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 3424 && !do_section_groups && !do_archive_index
3425 && !do_dyn_syms)
92f01d61 3426 usage (stderr);
252b5132
RH		 3427 else if (argc < 3)
3428 {
3429 warn (_("Nothing to do.\n"));
92f01d61 3430 usage (stderr);
252b5132
RH		 3431 }
3432}
3433
3434static const char *
d3ba0551 3435get_elf_class (unsigned int elf_class)
252b5132 3436{
b34976b6 3437 static char buff[32];
103f02d3 3438
252b5132
RH		 3439 switch (elf_class)
3440 {
3441 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 3442 case ELFCLASS32: return "ELF32";
3443 case ELFCLASS64: return "ELF64";
ab5e7794 3444 default:
e9e44622 3445 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 3446 return buff;
252b5132
RH		 3447 }
3448}
3449
3450static const char *
d3ba0551 3451get_data_encoding (unsigned int encoding)
252b5132 3452{
b34976b6 3453 static char buff[32];
103f02d3 3454
252b5132
RH		 3455 switch (encoding)
3456 {
3457 case ELFDATANONE: return _("none");
33c63f9d
CM		 3458 case ELFDATA2LSB: return _("2's complement, little endian");
3459 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 3460 default:
e9e44622 3461 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 3462 return buff;
252b5132
RH		 3463 }
3464}
3465
252b5132 3466/* Decode the data held in 'elf_header'. */
ee42cf8c 3467
252b5132 3468static int
d3ba0551 3469process_file_header (void)
252b5132 3470{
b34976b6
AM		 3471 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3472 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3473 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3474 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 3475 {
3476 error
3477 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3478 return 0;
3479 }
3480
2dc4cec1
L		 3481 init_dwarf_regnames (elf_header.e_machine);
3482
252b5132
RH		 3483 if (do_header)
3484 {
3485 int i;
3486
3487 printf (_("ELF Header:\n"));
3488 printf (_(" Magic: "));
b34976b6
AM		 3489 for (i = 0; i < EI_NIDENT; i++)
3490 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 3491 printf ("\n");
3492 printf (_(" Class: %s\n"),
b34976b6 3493 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 3494 printf (_(" Data: %s\n"),
b34976b6 3495 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 3496 printf (_(" Version: %d %s\n"),
b34976b6
AM		 3497 elf_header.e_ident[EI_VERSION],
3498 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 3499 ? "(current)"
b34976b6 3500 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 3501 ? _("<unknown: %lx>")
789be9f7 3502 : "")));
252b5132 3503 printf (_(" OS/ABI: %s\n"),
b34976b6 3504 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 3505 printf (_(" ABI Version: %d\n"),
b34976b6 3506 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 3507 printf (_(" Type: %s\n"),
3508 get_file_type (elf_header.e_type));
3509 printf (_(" Machine: %s\n"),
3510 get_machine_name (elf_header.e_machine));
3511 printf (_(" Version: 0x%lx\n"),
3512 (unsigned long) elf_header.e_version);
76da6bbe 3513
f7a99963
NC		 3514 printf (_(" Entry point address: "));
3515 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3516 printf (_("\n Start of program headers: "));
3517 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3518 printf (_(" (bytes into file)\n Start of section headers: "));
3519 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3520 printf (_(" (bytes into file)\n"));
76da6bbe 3521
252b5132
RH		 3522 printf (_(" Flags: 0x%lx%s\n"),
3523 (unsigned long) elf_header.e_flags,
3524 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3525 printf (_(" Size of this header: %ld (bytes)\n"),
3526 (long) elf_header.e_ehsize);
3527 printf (_(" Size of program headers: %ld (bytes)\n"),
3528 (long) elf_header.e_phentsize);
2046a35d 3529 printf (_(" Number of program headers: %ld"),
252b5132 3530 (long) elf_header.e_phnum);
2046a35d
AM		 3531 if (section_headers != NULL
3532 && elf_header.e_phnum == PN_XNUM
3533 && section_headers[0].sh_info != 0)
3534 printf (_(" (%ld)"), (long) section_headers[0].sh_info);
3535 putc ('\n', stdout);
252b5132
RH		 3536 printf (_(" Size of section headers: %ld (bytes)\n"),
3537 (long) elf_header.e_shentsize);
560f3c1c 3538 printf (_(" Number of section headers: %ld"),
252b5132 3539 (long) elf_header.e_shnum);
4fbb74a6 3540 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 3541 printf (" (%ld)", (long) section_headers[0].sh_size);
3542 putc ('\n', stdout);
3543 printf (_(" Section header string table index: %ld"),
252b5132 3544 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 3545 if (section_headers != NULL
3546 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 3547 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 3548 else if (elf_header.e_shstrndx != SHN_UNDEF
3549 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 3550 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 3551 putc ('\n', stdout);
3552 }
3553
3554 if (section_headers != NULL)
3555 {
2046a35d
AM		 3556 if (elf_header.e_phnum == PN_XNUM
3557 && section_headers[0].sh_info != 0)
3558 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 3559 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 3560 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 3561 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 3562 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 3563 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 3564 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 3565 free (section_headers);
3566 section_headers = NULL;
252b5132 3567 }
103f02d3 3568
9ea033b2
NC		 3569 return 1;
3570}
3571
252b5132 3572
9ea033b2 3573static int
91d6fa6a 3574get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3575{
2cf0635d
NC		 3576 Elf32_External_Phdr * phdrs;
3577 Elf32_External_Phdr * external;
3578 Elf_Internal_Phdr * internal;
b34976b6 3579 unsigned int i;
103f02d3 3580
3f5e193b
NC		 3581 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3582 elf_header.e_phentsize,
3583 elf_header.e_phnum,
3584 _("program headers"));
a6e9f9df
AM		 3585 if (!phdrs)
3586 return 0;
9ea033b2 3587
91d6fa6a 3588 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3589 i < elf_header.e_phnum;
b34976b6 3590 i++, internal++, external++)
252b5132 3591 {
9ea033b2
NC		 3592 internal->p_type = BYTE_GET (external->p_type);
3593 internal->p_offset = BYTE_GET (external->p_offset);
3594 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3595 internal->p_paddr = BYTE_GET (external->p_paddr);
3596 internal->p_filesz = BYTE_GET (external->p_filesz);
3597 internal->p_memsz = BYTE_GET (external->p_memsz);
3598 internal->p_flags = BYTE_GET (external->p_flags);
3599 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 3600 }
3601
9ea033b2
NC		 3602 free (phdrs);
3603
252b5132
RH		 3604 return 1;
3605}
3606
9ea033b2 3607static int
91d6fa6a 3608get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3609{
2cf0635d
NC		 3610 Elf64_External_Phdr * phdrs;
3611 Elf64_External_Phdr * external;
3612 Elf_Internal_Phdr * internal;
b34976b6 3613 unsigned int i;
103f02d3 3614
3f5e193b
NC		 3615 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3616 elf_header.e_phentsize,
3617 elf_header.e_phnum,
3618 _("program headers"));
a6e9f9df
AM		 3619 if (!phdrs)
3620 return 0;
9ea033b2 3621
91d6fa6a 3622 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3623 i < elf_header.e_phnum;
b34976b6 3624 i++, internal++, external++)
9ea033b2
NC		 3625 {
3626 internal->p_type = BYTE_GET (external->p_type);
3627 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 3628 internal->p_offset = BYTE_GET (external->p_offset);
3629 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3630 internal->p_paddr = BYTE_GET (external->p_paddr);
3631 internal->p_filesz = BYTE_GET (external->p_filesz);
3632 internal->p_memsz = BYTE_GET (external->p_memsz);
3633 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 3634 }
3635
3636 free (phdrs);
3637
3638 return 1;
3639}
252b5132 3640
d93f0186
NC		 3641/* Returns 1 if the program headers were read into `program_headers'. */
3642
3643static int
2cf0635d 3644get_program_headers (FILE * file)
d93f0186 3645{
2cf0635d 3646 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 3647
3648 /* Check cache of prior read. */
3649 if (program_headers != NULL)
3650 return 1;
3651
3f5e193b
NC		 3652 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3653 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 3654
3655 if (phdrs == NULL)
3656 {
3657 error (_("Out of memory\n"));
3658 return 0;
3659 }
3660
3661 if (is_32bit_elf
3662 ? get_32bit_program_headers (file, phdrs)
3663 : get_64bit_program_headers (file, phdrs))
3664 {
3665 program_headers = phdrs;
3666 return 1;
3667 }
3668
3669 free (phdrs);
3670 return 0;
3671}
3672
2f62977e
NC		 3673/* Returns 1 if the program headers were loaded. */
3674
252b5132 3675static int
2cf0635d 3676process_program_headers (FILE * file)
252b5132 3677{
2cf0635d 3678 Elf_Internal_Phdr * segment;
b34976b6 3679 unsigned int i;
252b5132
RH		 3680
3681 if (elf_header.e_phnum == 0)
3682 {
3683 if (do_segments)
3684 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 3685 return 0;
252b5132
RH		 3686 }
3687
3688 if (do_segments && !do_header)
3689 {
f7a99963
NC		 3690 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3691 printf (_("Entry point "));
3692 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3693 printf (_("\nThere are %d program headers, starting at offset "),
3694 elf_header.e_phnum);
3695 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3696 printf ("\n");
252b5132
RH		 3697 }
3698
d93f0186 3699 if (! get_program_headers (file))
252b5132 3700 return 0;
103f02d3 3701
252b5132
RH		 3702 if (do_segments)
3703 {
3a1a2036
NC		 3704 if (elf_header.e_phnum > 1)
3705 printf (_("\nProgram Headers:\n"));
3706 else
3707 printf (_("\nProgram Headers:\n"));
76da6bbe 3708
f7a99963
NC		 3709 if (is_32bit_elf)
3710 printf
3711 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 3712 else if (do_wide)
3713 printf
3714 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 3715 else
3716 {
3717 printf
3718 (_(" Type Offset VirtAddr PhysAddr\n"));
3719 printf
3720 (_(" FileSiz MemSiz Flags Align\n"));
3721 }
252b5132
RH		 3722 }
3723
252b5132 3724 dynamic_addr = 0;
1b228002 3725 dynamic_size = 0;
252b5132
RH		 3726
3727 for (i = 0, segment = program_headers;
3728 i < elf_header.e_phnum;
b34976b6 3729 i++, segment++)
252b5132
RH		 3730 {
3731 if (do_segments)
3732 {
103f02d3 3733 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 3734
3735 if (is_32bit_elf)
3736 {
3737 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3738 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3739 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3740 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3741 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3742 printf ("%c%c%c ",
3743 (segment->p_flags & PF_R ? 'R' : ' '),
3744 (segment->p_flags & PF_W ? 'W' : ' '),
3745 (segment->p_flags & PF_X ? 'E' : ' '));
3746 printf ("%#lx", (unsigned long) segment->p_align);
3747 }
d974e256
JJ		 3748 else if (do_wide)
3749 {
3750 if ((unsigned long) segment->p_offset == segment->p_offset)
3751 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3752 else
3753 {
3754 print_vma (segment->p_offset, FULL_HEX);
3755 putchar (' ');
3756 }
3757
3758 print_vma (segment->p_vaddr, FULL_HEX);
3759 putchar (' ');
3760 print_vma (segment->p_paddr, FULL_HEX);
3761 putchar (' ');
3762
3763 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3764 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3765 else
3766 {
3767 print_vma (segment->p_filesz, FULL_HEX);
3768 putchar (' ');
3769 }
3770
3771 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3772 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3773 else
3774 {
3775 print_vma (segment->p_offset, FULL_HEX);
3776 }
3777
3778 printf (" %c%c%c ",
3779 (segment->p_flags & PF_R ? 'R' : ' '),
3780 (segment->p_flags & PF_W ? 'W' : ' '),
3781 (segment->p_flags & PF_X ? 'E' : ' '));
3782
3783 if ((unsigned long) segment->p_align == segment->p_align)
3784 printf ("%#lx", (unsigned long) segment->p_align);
3785 else
3786 {
3787 print_vma (segment->p_align, PREFIX_HEX);
3788 }
3789 }
f7a99963
NC		 3790 else
3791 {
3792 print_vma (segment->p_offset, FULL_HEX);
3793 putchar (' ');
3794 print_vma (segment->p_vaddr, FULL_HEX);
3795 putchar (' ');
3796 print_vma (segment->p_paddr, FULL_HEX);
3797 printf ("\n ");
3798 print_vma (segment->p_filesz, FULL_HEX);
3799 putchar (' ');
3800 print_vma (segment->p_memsz, FULL_HEX);
3801 printf (" %c%c%c ",
3802 (segment->p_flags & PF_R ? 'R' : ' '),
3803 (segment->p_flags & PF_W ? 'W' : ' '),
3804 (segment->p_flags & PF_X ? 'E' : ' '));
3805 print_vma (segment->p_align, HEX);
3806 }
252b5132
RH		 3807 }
3808
3809 switch (segment->p_type)
3810 {
252b5132
RH		 3811 case PT_DYNAMIC:
3812 if (dynamic_addr)
3813 error (_("more than one dynamic segment\n"));
3814
20737c13
AM		 3815 /* By default, assume that the .dynamic section is the first
3816 section in the DYNAMIC segment. */
3817 dynamic_addr = segment->p_offset;
3818 dynamic_size = segment->p_filesz;
3819
b2d38a17
NC		 3820 /* Try to locate the .dynamic section. If there is
3821 a section header table, we can easily locate it. */
3822 if (section_headers != NULL)
3823 {
2cf0635d 3824 Elf_Internal_Shdr * sec;
b2d38a17 3825
89fac5e3
RS		 3826 sec = find_section (".dynamic");
3827 if (sec == NULL || sec->sh_size == 0)
b2d38a17 3828 {
28f997cf
TG		 3829 /* A corresponding .dynamic section is expected, but on
3830 IA-64/OpenVMS it is OK for it to be missing. */
3831 if (!is_ia64_vms ())
3832 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 3833 break;
3834 }
3835
42bb2e33 3836 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 3837 {
3838 dynamic_size = 0;
3839 break;
3840 }
42bb2e33 3841
b2d38a17
NC		 3842 dynamic_addr = sec->sh_offset;
3843 dynamic_size = sec->sh_size;
3844
3845 if (dynamic_addr < segment->p_offset
3846 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 3847 warn (_("the .dynamic section is not contained"
3848 " within the dynamic segment\n"));
b2d38a17 3849 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 3850 warn (_("the .dynamic section is not the first section"
3851 " in the dynamic segment.\n"));
b2d38a17 3852 }
252b5132
RH		 3853 break;
3854
3855 case PT_INTERP:
fb52b2f4
NC		 3856 if (fseek (file, archive_file_offset + (long) segment->p_offset,
3857 SEEK_SET))
252b5132
RH		 3858 error (_("Unable to find program interpreter name\n"));
3859 else
3860 {
f8eae8b2
L		 3861 char fmt [32];
3862 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
3863
3864 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 3865 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 3866
252b5132 3867 program_interpreter[0] = 0;
7bd7b3ef
AM		 3868 if (fscanf (file, fmt, program_interpreter) <= 0)
3869 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 3870
3871 if (do_segments)
3872 printf (_("\n [Requesting program interpreter: %s]"),
3873 program_interpreter);
3874 }
3875 break;
3876 }
3877
3878 if (do_segments)
3879 putc ('\n', stdout);
3880 }
3881
c256ffe7 3882 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 3883 {
3884 printf (_("\n Section to Segment mapping:\n"));
3885 printf (_(" Segment Sections...\n"));
3886
252b5132
RH		 3887 for (i = 0; i < elf_header.e_phnum; i++)
3888 {
9ad5cbcf 3889 unsigned int j;
2cf0635d 3890 Elf_Internal_Shdr * section;
252b5132
RH		 3891
3892 segment = program_headers + i;
b391a3e3 3893 section = section_headers + 1;
252b5132
RH		 3894
3895 printf (" %2.2d ", i);
3896
b34976b6 3897 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 3898 {
f4638467
AM		 3899 if (!ELF_TBSS_SPECIAL (section, segment)
3900 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
252b5132
RH		 3901 printf ("%s ", SECTION_NAME (section));
3902 }
3903
3904 putc ('\n',stdout);
3905 }
3906 }
3907
252b5132
RH		 3908 return 1;
3909}
3910
3911
d93f0186
NC		 3912/* Find the file offset corresponding to VMA by using the program headers. */
3913
3914static long
2cf0635d 3915offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 3916{
2cf0635d 3917 Elf_Internal_Phdr * seg;
d93f0186
NC		 3918
3919 if (! get_program_headers (file))
3920 {
3921 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3922 return (long) vma;
3923 }
3924
3925 for (seg = program_headers;
3926 seg < program_headers + elf_header.e_phnum;
3927 ++seg)
3928 {
3929 if (seg->p_type != PT_LOAD)
3930 continue;
3931
3932 if (vma >= (seg->p_vaddr & -seg->p_align)
3933 && vma + size <= seg->p_vaddr + seg->p_filesz)
3934 return vma - seg->p_vaddr + seg->p_offset;
3935 }
3936
3937 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 3938 (unsigned long) vma);
d93f0186
NC		 3939 return (long) vma;
3940}
3941
3942
252b5132 3943static int
2cf0635d 3944get_32bit_section_headers (FILE * file, unsigned int num)
252b5132 3945{
2cf0635d
NC		 3946 Elf32_External_Shdr * shdrs;
3947 Elf_Internal_Shdr * internal;
b34976b6 3948 unsigned int i;
252b5132 3949
3f5e193b
NC		 3950 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
3951 elf_header.e_shentsize, num,
3952 _("section headers"));
a6e9f9df
AM		 3953 if (!shdrs)
3954 return 0;
252b5132 3955
3f5e193b
NC		 3956 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
3957 sizeof (Elf_Internal_Shdr));
252b5132
RH		 3958
3959 if (section_headers == NULL)
3960 {
3961 error (_("Out of memory\n"));
3962 return 0;
3963 }
3964
3965 for (i = 0, internal = section_headers;
560f3c1c 3966 i < num;
b34976b6 3967 i++, internal++)
252b5132
RH		 3968 {
3969 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3970 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3971 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3972 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3973 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3974 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3975 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3976 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3977 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3978 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3979 }
3980
3981 free (shdrs);
3982
3983 return 1;
3984}
3985
9ea033b2 3986static int
2cf0635d 3987get_64bit_section_headers (FILE * file, unsigned int num)
9ea033b2 3988{
2cf0635d
NC		 3989 Elf64_External_Shdr * shdrs;
3990 Elf_Internal_Shdr * internal;
b34976b6 3991 unsigned int i;
9ea033b2 3992
3f5e193b
NC		 3993 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
3994 elf_header.e_shentsize, num,
3995 _("section headers"));
a6e9f9df
AM		 3996 if (!shdrs)
3997 return 0;
9ea033b2 3998
3f5e193b
NC		 3999 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4000 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4001
4002 if (section_headers == NULL)
4003 {
4004 error (_("Out of memory\n"));
4005 return 0;
4006 }
4007
4008 for (i = 0, internal = section_headers;
560f3c1c 4009 i < num;
b34976b6 4010 i++, internal++)
9ea033b2
NC		 4011 {
4012 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4013 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4014 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4015 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4016 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4017 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4018 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4019 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4020 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4021 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4022 }
4023
4024 free (shdrs);
4025
4026 return 1;
4027}
4028
252b5132 4029static Elf_Internal_Sym *
2cf0635d 4030get_32bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
252b5132 4031{
9ad5cbcf 4032 unsigned long number;
2cf0635d
NC		 4033 Elf32_External_Sym * esyms;
4034 Elf_External_Sym_Shndx * shndx;
4035 Elf_Internal_Sym * isyms;
4036 Elf_Internal_Sym * psym;
b34976b6 4037 unsigned int j;
252b5132 4038
3f5e193b
NC		 4039 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4040 section->sh_size, _("symbols"));
a6e9f9df
AM		 4041 if (!esyms)
4042 return NULL;
252b5132 4043
9ad5cbcf
AM		 4044 shndx = NULL;
4045 if (symtab_shndx_hdr != NULL
4046 && (symtab_shndx_hdr->sh_link
4fbb74a6 4047 == (unsigned long) (section - section_headers)))
9ad5cbcf 4048 {
3f5e193b
NC		 4049 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4050 symtab_shndx_hdr->sh_offset,
4051 1, symtab_shndx_hdr->sh_size,
4052 _("symtab shndx"));
9ad5cbcf
AM		 4053 if (!shndx)
4054 {
4055 free (esyms);
4056 return NULL;
4057 }
4058 }
4059
4060 number = section->sh_size / section->sh_entsize;
3f5e193b 4061 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 4062
4063 if (isyms == NULL)
4064 {
4065 error (_("Out of memory\n"));
9ad5cbcf
AM		 4066 if (shndx)
4067 free (shndx);
252b5132 4068 free (esyms);
252b5132
RH		 4069 return NULL;
4070 }
4071
4072 for (j = 0, psym = isyms;
4073 j < number;
b34976b6 4074 j++, psym++)
252b5132
RH		 4075 {
4076 psym->st_name = BYTE_GET (esyms[j].st_name);
4077 psym->st_value = BYTE_GET (esyms[j].st_value);
4078 psym->st_size = BYTE_GET (esyms[j].st_size);
4079 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4080 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4081 psym->st_shndx
4082 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4083 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4084 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 4085 psym->st_info = BYTE_GET (esyms[j].st_info);
4086 psym->st_other = BYTE_GET (esyms[j].st_other);
4087 }
4088
9ad5cbcf
AM		 4089 if (shndx)
4090 free (shndx);
252b5132
RH		 4091 free (esyms);
4092
4093 return isyms;
4094}
4095
9ea033b2 4096static Elf_Internal_Sym *
2cf0635d 4097get_64bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
9ea033b2 4098{
9ad5cbcf 4099 unsigned long number;
2cf0635d
NC		 4100 Elf64_External_Sym * esyms;
4101 Elf_External_Sym_Shndx * shndx;
4102 Elf_Internal_Sym * isyms;
4103 Elf_Internal_Sym * psym;
b34976b6 4104 unsigned int j;
9ea033b2 4105
3f5e193b
NC		 4106 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4107 section->sh_size, _("symbols"));
a6e9f9df
AM		 4108 if (!esyms)
4109 return NULL;
9ea033b2 4110
9ad5cbcf
AM		 4111 shndx = NULL;
4112 if (symtab_shndx_hdr != NULL
4113 && (symtab_shndx_hdr->sh_link
4fbb74a6 4114 == (unsigned long) (section - section_headers)))
9ad5cbcf 4115 {
3f5e193b
NC		 4116 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4117 symtab_shndx_hdr->sh_offset,
4118 1, symtab_shndx_hdr->sh_size,
4119 _("symtab shndx"));
9ad5cbcf
AM		 4120 if (!shndx)
4121 {
4122 free (esyms);
4123 return NULL;
4124 }
4125 }
4126
4127 number = section->sh_size / section->sh_entsize;
3f5e193b 4128 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 4129
4130 if (isyms == NULL)
4131 {
4132 error (_("Out of memory\n"));
9ad5cbcf
AM		 4133 if (shndx)
4134 free (shndx);
9ea033b2 4135 free (esyms);
9ea033b2
NC		 4136 return NULL;
4137 }
4138
4139 for (j = 0, psym = isyms;
4140 j < number;
b34976b6 4141 j++, psym++)
9ea033b2
NC		 4142 {
4143 psym->st_name = BYTE_GET (esyms[j].st_name);
4144 psym->st_info = BYTE_GET (esyms[j].st_info);
4145 psym->st_other = BYTE_GET (esyms[j].st_other);
4146 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4147 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4148 psym->st_shndx
4149 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4150 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4151 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
66543521
AM		 4152 psym->st_value = BYTE_GET (esyms[j].st_value);
4153 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 4154 }
4155
9ad5cbcf
AM		 4156 if (shndx)
4157 free (shndx);
9ea033b2
NC		 4158 free (esyms);
4159
4160 return isyms;
4161}
4162
d1133906 4163static const char *
d3ba0551 4164get_elf_section_flags (bfd_vma sh_flags)
d1133906 4165{
5477e8a0 4166 static char buff[1024];
2cf0635d 4167 char * p = buff;
8d5ff12c 4168 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 4169 int sindex;
4170 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 4171 bfd_vma os_flags = 0;
4172 bfd_vma proc_flags = 0;
4173 bfd_vma unknown_flags = 0;
148b93f2 4174 static const struct
5477e8a0 4175 {
2cf0635d 4176 const char * str;
5477e8a0
L		 4177 int len;
4178 }
4179 flags [] =
4180 {
cfcac11d
NC		 4181 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4182 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4183 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4184 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4185 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4186 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4187 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4188 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4189 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4190 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4191 /* IA-64 specific. */
4192 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4193 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4194 /* IA-64 OpenVMS specific. */
4195 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4196 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4197 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4198 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4199 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4200 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 4201 /* Generic. */
cfcac11d 4202 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 4203 /* SPARC specific. */
cfcac11d 4204 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5477e8a0
L		 4205 };
4206
4207 if (do_section_details)
4208 {
8d5ff12c
L		 4209 sprintf (buff, "[%*.*lx]: ",
4210 field_size, field_size, (unsigned long) sh_flags);
4211 p += field_size + 4;
5477e8a0 4212 }
76da6bbe 4213
d1133906
NC		 4214 while (sh_flags)
4215 {
4216 bfd_vma flag;
4217
4218 flag = sh_flags & - sh_flags;
4219 sh_flags &= ~ flag;
76da6bbe 4220
5477e8a0 4221 if (do_section_details)
d1133906 4222 {
5477e8a0
L		 4223 switch (flag)
4224 {
91d6fa6a
NC		 4225 case SHF_WRITE: sindex = 0; break;
4226 case SHF_ALLOC: sindex = 1; break;
4227 case SHF_EXECINSTR: sindex = 2; break;
4228 case SHF_MERGE: sindex = 3; break;
4229 case SHF_STRINGS: sindex = 4; break;
4230 case SHF_INFO_LINK: sindex = 5; break;
4231 case SHF_LINK_ORDER: sindex = 6; break;
4232 case SHF_OS_NONCONFORMING: sindex = 7; break;
4233 case SHF_GROUP: sindex = 8; break;
4234 case SHF_TLS: sindex = 9; break;
18ae9cc1 4235 case SHF_EXCLUDE: sindex = 18; break;
76da6bbe 4236
5477e8a0 4237 default:
91d6fa6a 4238 sindex = -1;
cfcac11d 4239 switch (elf_header.e_machine)
148b93f2 4240 {
cfcac11d 4241 case EM_IA_64:
148b93f2 4242 if (flag == SHF_IA_64_SHORT)
91d6fa6a 4243 sindex = 10;
148b93f2 4244 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 4245 sindex = 11;
148b93f2
NC		 4246#ifdef BFD64
4247 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4248 switch (flag)
4249 {
91d6fa6a
NC		 4250 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4251 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4252 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4253 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4254 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4255 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 4256 default: break;
4257 }
4258#endif
cfcac11d
NC		 4259 break;
4260
caa83f8b
NC		 4261 case EM_386:
4262 case EM_486:
4263 case EM_X86_64:
7f502d6c 4264 case EM_L1OM:
cfcac11d
NC		 4265 case EM_OLD_SPARCV9:
4266 case EM_SPARC32PLUS:
4267 case EM_SPARCV9:
4268 case EM_SPARC:
18ae9cc1 4269 if (flag == SHF_ORDERED)
91d6fa6a 4270 sindex = 19;
cfcac11d
NC		 4271 break;
4272 default:
4273 break;
148b93f2 4274 }
5477e8a0
L		 4275 }
4276
91d6fa6a 4277 if (sindex != -1)
5477e8a0 4278 {
8d5ff12c
L		 4279 if (p != buff + field_size + 4)
4280 {
4281 if (size < (10 + 2))
4282 abort ();
4283 size -= 2;
4284 *p++ = ',';
4285 *p++ = ' ';
4286 }
4287
91d6fa6a
NC		 4288 size -= flags [sindex].len;
4289 p = stpcpy (p, flags [sindex].str);
5477e8a0 4290 }
3b22753a 4291 else if (flag & SHF_MASKOS)
8d5ff12c 4292 os_flags |= flag;
d1133906 4293 else if (flag & SHF_MASKPROC)
8d5ff12c 4294 proc_flags |= flag;
d1133906 4295 else
8d5ff12c 4296 unknown_flags |= flag;
5477e8a0
L		 4297 }
4298 else
4299 {
4300 switch (flag)
4301 {
4302 case SHF_WRITE: *p = 'W'; break;
4303 case SHF_ALLOC: *p = 'A'; break;
4304 case SHF_EXECINSTR: *p = 'X'; break;
4305 case SHF_MERGE: *p = 'M'; break;
4306 case SHF_STRINGS: *p = 'S'; break;
4307 case SHF_INFO_LINK: *p = 'I'; break;
4308 case SHF_LINK_ORDER: *p = 'L'; break;
4309 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4310 case SHF_GROUP: *p = 'G'; break;
4311 case SHF_TLS: *p = 'T'; break;
18ae9cc1 4312 case SHF_EXCLUDE: *p = 'E'; break;
5477e8a0
L		 4313
4314 default:
8a9036a4
L		 4315 if ((elf_header.e_machine == EM_X86_64
4316 || elf_header.e_machine == EM_L1OM)
5477e8a0
L		 4317 && flag == SHF_X86_64_LARGE)
4318 *p = 'l';
4319 else if (flag & SHF_MASKOS)
4320 {
4321 *p = 'o';
4322 sh_flags &= ~ SHF_MASKOS;
4323 }
4324 else if (flag & SHF_MASKPROC)
4325 {
4326 *p = 'p';
4327 sh_flags &= ~ SHF_MASKPROC;
4328 }
4329 else
4330 *p = 'x';
4331 break;
4332 }
4333 p++;
d1133906
NC		 4334 }
4335 }
76da6bbe 4336
8d5ff12c
L		 4337 if (do_section_details)
4338 {
4339 if (os_flags)
4340 {
4341 size -= 5 + field_size;
4342 if (p != buff + field_size + 4)
4343 {
4344 if (size < (2 + 1))
4345 abort ();
4346 size -= 2;
4347 *p++ = ',';
4348 *p++ = ' ';
4349 }
4350 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4351 (unsigned long) os_flags);
4352 p += 5 + field_size;
4353 }
4354 if (proc_flags)
4355 {
4356 size -= 7 + field_size;
4357 if (p != buff + field_size + 4)
4358 {
4359 if (size < (2 + 1))
4360 abort ();
4361 size -= 2;
4362 *p++ = ',';
4363 *p++ = ' ';
4364 }
4365 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4366 (unsigned long) proc_flags);
4367 p += 7 + field_size;
4368 }
4369 if (unknown_flags)
4370 {
4371 size -= 10 + field_size;
4372 if (p != buff + field_size + 4)
4373 {
4374 if (size < (2 + 1))
4375 abort ();
4376 size -= 2;
4377 *p++ = ',';
4378 *p++ = ' ';
4379 }
2b692964 4380 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 4381 (unsigned long) unknown_flags);
4382 p += 10 + field_size;
4383 }
4384 }
4385
e9e44622 4386 *p = '\0';
d1133906
NC		 4387 return buff;
4388}
4389
252b5132 4390static int
2cf0635d 4391process_section_headers (FILE * file)
252b5132 4392{
2cf0635d 4393 Elf_Internal_Shdr * section;
b34976b6 4394 unsigned int i;
252b5132
RH		 4395
4396 section_headers = NULL;
4397
4398 if (elf_header.e_shnum == 0)
4399 {
4400 if (do_sections)
4401 printf (_("\nThere are no sections in this file.\n"));
4402
4403 return 1;
4404 }
4405
4406 if (do_sections && !do_header)
9ea033b2 4407 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 4408 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4409
9ea033b2
NC		 4410 if (is_32bit_elf)
4411 {
560f3c1c 4412 if (! get_32bit_section_headers (file, elf_header.e_shnum))
9ea033b2
NC		 4413 return 0;
4414 }
560f3c1c 4415 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
252b5132
RH		 4416 return 0;
4417
4418 /* Read in the string table, so that we have names to display. */
0b49d371 4419 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 4420 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 4421 {
4fbb74a6 4422 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 4423
c256ffe7
JJ		 4424 if (section->sh_size != 0)
4425 {
3f5e193b
NC		 4426 string_table = (char *) get_data (NULL, file, section->sh_offset,
4427 1, section->sh_size,
4428 _("string table"));
0de14b54 4429
c256ffe7
JJ		 4430 string_table_length = string_table != NULL ? section->sh_size : 0;
4431 }
252b5132
RH		 4432 }
4433
4434 /* Scan the sections for the dynamic symbol table
e3c8793a 4435 and dynamic string table and debug sections. */
252b5132
RH		 4436 dynamic_symbols = NULL;
4437 dynamic_strings = NULL;
4438 dynamic_syminfo = NULL;
f1ef08cb 4439 symtab_shndx_hdr = NULL;
103f02d3 4440
89fac5e3
RS		 4441 eh_addr_size = is_32bit_elf ? 4 : 8;
4442 switch (elf_header.e_machine)
4443 {
4444 case EM_MIPS:
4445 case EM_MIPS_RS3_LE:
4446 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4447 FDE addresses. However, the ABI also has a semi-official ILP32
4448 variant for which the normal FDE address size rules apply.
4449
4450 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4451 section, where XX is the size of longs in bits. Unfortunately,
4452 earlier compilers provided no way of distinguishing ILP32 objects
4453 from LP64 objects, so if there's any doubt, we should assume that
4454 the official LP64 form is being used. */
4455 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4456 && find_section (".gcc_compiled_long32") == NULL)
4457 eh_addr_size = 8;
4458 break;
0f56a26a
DD		 4459
4460 case EM_H8_300:
4461 case EM_H8_300H:
4462 switch (elf_header.e_flags & EF_H8_MACH)
4463 {
4464 case E_H8_MACH_H8300:
4465 case E_H8_MACH_H8300HN:
4466 case E_H8_MACH_H8300SN:
4467 case E_H8_MACH_H8300SXN:
4468 eh_addr_size = 2;
4469 break;
4470 case E_H8_MACH_H8300H:
4471 case E_H8_MACH_H8300S:
4472 case E_H8_MACH_H8300SX:
4473 eh_addr_size = 4;
4474 break;
4475 }
f4236fe4
DD		 4476 break;
4477
ff7eeb89 4478 case EM_M32C_OLD:
f4236fe4
DD		 4479 case EM_M32C:
4480 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4481 {
4482 case EF_M32C_CPU_M16C:
4483 eh_addr_size = 2;
4484 break;
4485 }
4486 break;
89fac5e3
RS		 4487 }
4488
08d8fa11
JJ		 4489#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4490 do \
4491 { \
4492 size_t expected_entsize \
4493 = is_32bit_elf ? size32 : size64; \
4494 if (section->sh_entsize != expected_entsize) \
4495 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4496 i, (unsigned long int) section->sh_entsize, \
4497 (unsigned long int) expected_entsize); \
4498 section->sh_entsize = expected_entsize; \
4499 } \
4500 while (0)
4501#define CHECK_ENTSIZE(section, i, type) \
4502 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4503 sizeof (Elf64_External_##type))
4504
252b5132
RH		 4505 for (i = 0, section = section_headers;
4506 i < elf_header.e_shnum;
b34976b6 4507 i++, section++)
252b5132 4508 {
2cf0635d 4509 char * name = SECTION_NAME (section);
252b5132
RH		 4510
4511 if (section->sh_type == SHT_DYNSYM)
4512 {
4513 if (dynamic_symbols != NULL)
4514 {
4515 error (_("File contains multiple dynamic symbol tables\n"));
4516 continue;
4517 }
4518
08d8fa11 4519 CHECK_ENTSIZE (section, i, Sym);
19936277 4520 num_dynamic_syms = section->sh_size / section->sh_entsize;
9ad5cbcf 4521 dynamic_symbols = GET_ELF_SYMBOLS (file, section);
252b5132
RH		 4522 }
4523 else if (section->sh_type == SHT_STRTAB
18bd398b 4524 && streq (name, ".dynstr"))
252b5132
RH		 4525 {
4526 if (dynamic_strings != NULL)
4527 {
4528 error (_("File contains multiple dynamic string tables\n"));
4529 continue;
4530 }
4531
3f5e193b
NC		 4532 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4533 1, section->sh_size,
4534 _("dynamic strings"));
d79b3d50 4535 dynamic_strings_length = section->sh_size;
252b5132 4536 }
9ad5cbcf
AM		 4537 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4538 {
4539 if (symtab_shndx_hdr != NULL)
4540 {
4541 error (_("File contains multiple symtab shndx tables\n"));
4542 continue;
4543 }
4544 symtab_shndx_hdr = section;
4545 }
08d8fa11
JJ		 4546 else if (section->sh_type == SHT_SYMTAB)
4547 CHECK_ENTSIZE (section, i, Sym);
4548 else if (section->sh_type == SHT_GROUP)
4549 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4550 else if (section->sh_type == SHT_REL)
4551 CHECK_ENTSIZE (section, i, Rel);
4552 else if (section->sh_type == SHT_RELA)
4553 CHECK_ENTSIZE (section, i, Rela);
252b5132 4554 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 4555 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 4556 || do_debug_aranges || do_debug_frames || do_debug_macinfo
a262ae96 4557 || do_debug_str || do_debug_loc || do_debug_ranges)
1b315056
CS		 4558 && (const_strneq (name, ".debug_")
4559 || const_strneq (name, ".zdebug_")))
252b5132 4560 {
1b315056
CS		 4561 if (name[1] == 'z')
4562 name += sizeof (".zdebug_") - 1;
4563 else
4564 name += sizeof (".debug_") - 1;
252b5132
RH		 4565
4566 if (do_debugging
18bd398b 4567 || (do_debug_info && streq (name, "info"))
2b6f5997 4568 || (do_debug_info && streq (name, "types"))
18bd398b 4569 || (do_debug_abbrevs && streq (name, "abbrev"))
4cb93e3b 4570 || (do_debug_lines && streq (name, "line"))
18bd398b 4571 || (do_debug_pubnames && streq (name, "pubnames"))
f9f0e732 4572 || (do_debug_pubtypes && streq (name, "pubtypes"))
18bd398b
NC		 4573 || (do_debug_aranges && streq (name, "aranges"))
4574 || (do_debug_ranges && streq (name, "ranges"))
4575 || (do_debug_frames && streq (name, "frame"))
4576 || (do_debug_macinfo && streq (name, "macinfo"))
4577 || (do_debug_str && streq (name, "str"))
4578 || (do_debug_loc && streq (name, "loc"))
252b5132 4579 )
09c11c86 4580 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 4581 }
a262ae96 4582 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 4583 else if ((do_debugging || do_debug_info)
0112cd26 4584 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 4585 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 4586 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 4587 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 4588 /* Trace sections for Itanium VMS. */
4589 else if ((do_debugging || do_trace_info || do_trace_abbrevs
4590 || do_trace_aranges)
4591 && const_strneq (name, ".trace_"))
4592 {
4593 name += sizeof (".trace_") - 1;
4594
4595 if (do_debugging
4596 || (do_trace_info && streq (name, "info"))
4597 || (do_trace_abbrevs && streq (name, "abbrev"))
4598 || (do_trace_aranges && streq (name, "aranges"))
4599 )
4600 request_dump_bynumber (i, DEBUG_DUMP);
4601 }
4602
252b5132
RH		 4603 }
4604
4605 if (! do_sections)
4606 return 1;
4607
3a1a2036
NC		 4608 if (elf_header.e_shnum > 1)
4609 printf (_("\nSection Headers:\n"));
4610 else
4611 printf (_("\nSection Header:\n"));
76da6bbe 4612
f7a99963 4613 if (is_32bit_elf)
595cf52e 4614 {
5477e8a0 4615 if (do_section_details)
595cf52e
L		 4616 {
4617 printf (_(" [Nr] Name\n"));
5477e8a0 4618 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 4619 }
4620 else
4621 printf
4622 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4623 }
d974e256 4624 else if (do_wide)
595cf52e 4625 {
5477e8a0 4626 if (do_section_details)
595cf52e
L		 4627 {
4628 printf (_(" [Nr] Name\n"));
5477e8a0 4629 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 4630 }
4631 else
4632 printf
4633 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4634 }
f7a99963
NC		 4635 else
4636 {
5477e8a0 4637 if (do_section_details)
595cf52e
L		 4638 {
4639 printf (_(" [Nr] Name\n"));
5477e8a0
L		 4640 printf (_(" Type Address Offset Link\n"));
4641 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 4642 }
4643 else
4644 {
4645 printf (_(" [Nr] Name Type Address Offset\n"));
4646 printf (_(" Size EntSize Flags Link Info Align\n"));
4647 }
f7a99963 4648 }
252b5132 4649
5477e8a0
L		 4650 if (do_section_details)
4651 printf (_(" Flags\n"));
4652
252b5132
RH		 4653 for (i = 0, section = section_headers;
4654 i < elf_header.e_shnum;
b34976b6 4655 i++, section++)
252b5132 4656 {
5477e8a0 4657 if (do_section_details)
595cf52e
L		 4658 {
4659 printf (" [%2u] %s\n",
4fbb74a6 4660 i,
595cf52e
L		 4661 SECTION_NAME (section));
4662 if (is_32bit_elf || do_wide)
4663 printf (" %-15.15s ",
4664 get_section_type_name (section->sh_type));
4665 }
4666 else
b9eb56c1
NC		 4667 printf ((do_wide ? " [%2u] %-17s %-15s "
4668 : " [%2u] %-17.17s %-15.15s "),
4fbb74a6 4669 i,
595cf52e
L		 4670 SECTION_NAME (section),
4671 get_section_type_name (section->sh_type));
252b5132 4672
f7a99963
NC		 4673 if (is_32bit_elf)
4674 {
cfcac11d
NC		 4675 const char * link_too_big = NULL;
4676
f7a99963 4677 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 4678
f7a99963
NC		 4679 printf ( " %6.6lx %6.6lx %2.2lx",
4680 (unsigned long) section->sh_offset,
4681 (unsigned long) section->sh_size,
4682 (unsigned long) section->sh_entsize);
d1133906 4683
5477e8a0
L		 4684 if (do_section_details)
4685 fputs (" ", stdout);
4686 else
4687 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 4688
cfcac11d
NC		 4689 if (section->sh_link >= elf_header.e_shnum)
4690 {
4691 link_too_big = "";
4692 /* The sh_link value is out of range. Normally this indicates
caa83f8b 4693 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 4694 switch (elf_header.e_machine)
4695 {
caa83f8b
NC		 4696 case EM_386:
4697 case EM_486:
4698 case EM_X86_64:
7f502d6c 4699 case EM_L1OM:
cfcac11d
NC		 4700 case EM_OLD_SPARCV9:
4701 case EM_SPARC32PLUS:
4702 case EM_SPARCV9:
4703 case EM_SPARC:
4704 if (section->sh_link == (SHN_BEFORE & 0xffff))
4705 link_too_big = "BEFORE";
4706 else if (section->sh_link == (SHN_AFTER & 0xffff))
4707 link_too_big = "AFTER";
4708 break;
4709 default:
4710 break;
4711 }
4712 }
4713
4714 if (do_section_details)
4715 {
4716 if (link_too_big != NULL && * link_too_big)
4717 printf ("<%s> ", link_too_big);
4718 else
4719 printf ("%2u ", section->sh_link);
4720 printf ("%3u %2lu\n", section->sh_info,
4721 (unsigned long) section->sh_addralign);
4722 }
4723 else
4724 printf ("%2u %3u %2lu\n",
4725 section->sh_link,
4726 section->sh_info,
4727 (unsigned long) section->sh_addralign);
4728
4729 if (link_too_big && ! * link_too_big)
4730 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4731 i, section->sh_link);
f7a99963 4732 }
d974e256
JJ		 4733 else if (do_wide)
4734 {
4735 print_vma (section->sh_addr, LONG_HEX);
4736
4737 if ((long) section->sh_offset == section->sh_offset)
4738 printf (" %6.6lx", (unsigned long) section->sh_offset);
4739 else
4740 {
4741 putchar (' ');
4742 print_vma (section->sh_offset, LONG_HEX);
4743 }
4744
4745 if ((unsigned long) section->sh_size == section->sh_size)
4746 printf (" %6.6lx", (unsigned long) section->sh_size);
4747 else
4748 {
4749 putchar (' ');
4750 print_vma (section->sh_size, LONG_HEX);
4751 }
4752
4753 if ((unsigned long) section->sh_entsize == section->sh_entsize)
4754 printf (" %2.2lx", (unsigned long) section->sh_entsize);
4755 else
4756 {
4757 putchar (' ');
4758 print_vma (section->sh_entsize, LONG_HEX);
4759 }
4760
5477e8a0
L		 4761 if (do_section_details)
4762 fputs (" ", stdout);
4763 else
4764 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 4765
72de5009 4766 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 4767
4768 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 4769 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 4770 else
4771 {
4772 print_vma (section->sh_addralign, DEC);
4773 putchar ('\n');
4774 }
4775 }
5477e8a0 4776 else if (do_section_details)
595cf52e 4777 {
5477e8a0 4778 printf (" %-15.15s ",
595cf52e 4779 get_section_type_name (section->sh_type));
595cf52e
L		 4780 print_vma (section->sh_addr, LONG_HEX);
4781 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 4782 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 4783 else
4784 {
4785 printf (" ");
4786 print_vma (section->sh_offset, LONG_HEX);
4787 }
72de5009 4788 printf (" %u\n ", section->sh_link);
595cf52e 4789 print_vma (section->sh_size, LONG_HEX);
5477e8a0 4790 putchar (' ');
595cf52e
L		 4791 print_vma (section->sh_entsize, LONG_HEX);
4792
72de5009
AM		 4793 printf (" %-16u %lu\n",
4794 section->sh_info,
595cf52e
L		 4795 (unsigned long) section->sh_addralign);
4796 }
f7a99963
NC		 4797 else
4798 {
4799 putchar (' ');
4800 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 4801 if ((long) section->sh_offset == section->sh_offset)
4802 printf (" %8.8lx", (unsigned long) section->sh_offset);
4803 else
4804 {
4805 printf (" ");
4806 print_vma (section->sh_offset, LONG_HEX);
4807 }
f7a99963
NC		 4808 printf ("\n ");
4809 print_vma (section->sh_size, LONG_HEX);
4810 printf (" ");
4811 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 4812
d1133906 4813 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 4814
72de5009
AM		 4815 printf (" %2u %3u %lu\n",
4816 section->sh_link,
4817 section->sh_info,
f7a99963
NC		 4818 (unsigned long) section->sh_addralign);
4819 }
5477e8a0
L		 4820
4821 if (do_section_details)
4822 printf (" %s\n", get_elf_section_flags (section->sh_flags));
252b5132
RH		 4823 }
4824
5477e8a0
L		 4825 if (!do_section_details)
4826 printf (_("Key to Flags:\n\
e3c8793a 4827 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 4828 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 4829 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
d1133906 4830
252b5132
RH		 4831 return 1;
4832}
4833
f5842774
L		 4834static const char *
4835get_group_flags (unsigned int flags)
4836{
4837 static char buff[32];
4838 switch (flags)
4839 {
220453ec
AM		 4840 case 0:
4841 return "";
4842
f5842774 4843 case GRP_COMDAT:
220453ec 4844 return "COMDAT ";
f5842774
L		 4845
4846 default:
220453ec 4847 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 4848 break;
4849 }
4850 return buff;
4851}
4852
4853static int
2cf0635d 4854process_section_groups (FILE * file)
f5842774 4855{
2cf0635d 4856 Elf_Internal_Shdr * section;
f5842774 4857 unsigned int i;
2cf0635d
NC		 4858 struct group * group;
4859 Elf_Internal_Shdr * symtab_sec;
4860 Elf_Internal_Shdr * strtab_sec;
4861 Elf_Internal_Sym * symtab;
4862 char * strtab;
c256ffe7 4863 size_t strtab_size;
d1f5c6e3
L		 4864
4865 /* Don't process section groups unless needed. */
4866 if (!do_unwind && !do_section_groups)
4867 return 1;
f5842774
L		 4868
4869 if (elf_header.e_shnum == 0)
4870 {
4871 if (do_section_groups)
d1f5c6e3 4872 printf (_("\nThere are no sections in this file.\n"));
f5842774
L		 4873
4874 return 1;
4875 }
4876
4877 if (section_headers == NULL)
4878 {
4879 error (_("Section headers are not available!\n"));
4880 abort ();
4881 }
4882
3f5e193b
NC		 4883 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
4884 sizeof (struct group *));
e4b17d5c
L		 4885
4886 if (section_headers_groups == NULL)
4887 {
4888 error (_("Out of memory\n"));
4889 return 0;
4890 }
4891
f5842774 4892 /* Scan the sections for the group section. */
d1f5c6e3 4893 group_count = 0;
f5842774
L		 4894 for (i = 0, section = section_headers;
4895 i < elf_header.e_shnum;
4896 i++, section++)
e4b17d5c
L		 4897 if (section->sh_type == SHT_GROUP)
4898 group_count++;
4899
d1f5c6e3
L		 4900 if (group_count == 0)
4901 {
4902 if (do_section_groups)
4903 printf (_("\nThere are no section groups in this file.\n"));
4904
4905 return 1;
4906 }
4907
3f5e193b 4908 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 4909
4910 if (section_groups == NULL)
4911 {
4912 error (_("Out of memory\n"));
4913 return 0;
4914 }
4915
d1f5c6e3
L		 4916 symtab_sec = NULL;
4917 strtab_sec = NULL;
4918 symtab = NULL;
4919 strtab = NULL;
c256ffe7 4920 strtab_size = 0;
e4b17d5c
L		 4921 for (i = 0, section = section_headers, group = section_groups;
4922 i < elf_header.e_shnum;
4923 i++, section++)
f5842774
L		 4924 {
4925 if (section->sh_type == SHT_GROUP)
4926 {
2cf0635d
NC		 4927 char * name = SECTION_NAME (section);
4928 char * group_name;
4929 unsigned char * start;
4930 unsigned char * indices;
f5842774 4931 unsigned int entry, j, size;
2cf0635d
NC		 4932 Elf_Internal_Shdr * sec;
4933 Elf_Internal_Sym * sym;
f5842774
L		 4934
4935 /* Get the symbol table. */
4fbb74a6
AM		 4936 if (section->sh_link >= elf_header.e_shnum
4937 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 4938 != SHT_SYMTAB))
f5842774
L		 4939 {
4940 error (_("Bad sh_link in group section `%s'\n"), name);
4941 continue;
4942 }
d1f5c6e3
L		 4943
4944 if (symtab_sec != sec)
4945 {
4946 symtab_sec = sec;
4947 if (symtab)
4948 free (symtab);
4949 symtab = GET_ELF_SYMBOLS (file, symtab_sec);
4950 }
f5842774
L		 4951
4952 sym = symtab + section->sh_info;
4953
4954 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4955 {
4fbb74a6
AM		 4956 if (sym->st_shndx == 0
4957 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 4958 {
4959 error (_("Bad sh_info in group section `%s'\n"), name);
4960 continue;
4961 }
ba2685cc 4962
4fbb74a6 4963 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 4964 strtab_sec = NULL;
4965 if (strtab)
4966 free (strtab);
f5842774 4967 strtab = NULL;
c256ffe7 4968 strtab_size = 0;
f5842774
L		 4969 }
4970 else
4971 {
4972 /* Get the string table. */
4fbb74a6 4973 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 4974 {
4975 strtab_sec = NULL;
4976 if (strtab)
4977 free (strtab);
4978 strtab = NULL;
4979 strtab_size = 0;
4980 }
4981 else if (strtab_sec
4fbb74a6 4982 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 4983 {
4984 strtab_sec = sec;
4985 if (strtab)
4986 free (strtab);
3f5e193b
NC		 4987 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
4988 1, strtab_sec->sh_size,
4989 _("string table"));
c256ffe7 4990 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 4991 }
c256ffe7 4992 group_name = sym->st_name < strtab_size
2b692964 4993 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 4994 }
4995
3f5e193b
NC		 4996 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
4997 1, section->sh_size,
4998 _("section data"));
f5842774
L		 4999
5000 indices = start;
5001 size = (section->sh_size / section->sh_entsize) - 1;
5002 entry = byte_get (indices, 4);
5003 indices += 4;
e4b17d5c
L		 5004
5005 if (do_section_groups)
5006 {
2b692964 5007 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 5008 get_group_flags (entry), i, name, group_name, size);
ba2685cc 5009
e4b17d5c
L		 5010 printf (_(" [Index] Name\n"));
5011 }
5012
5013 group->group_index = i;
5014
f5842774
L		 5015 for (j = 0; j < size; j++)
5016 {
2cf0635d 5017 struct group_list * g;
e4b17d5c 5018
f5842774
L		 5019 entry = byte_get (indices, 4);
5020 indices += 4;
5021
4fbb74a6 5022 if (entry >= elf_header.e_shnum)
391cb864
L		 5023 {
5024 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5025 entry, i, elf_header.e_shnum - 1);
5026 continue;
5027 }
391cb864 5028
4fbb74a6 5029 if (section_headers_groups [entry] != NULL)
e4b17d5c 5030 {
d1f5c6e3
L		 5031 if (entry)
5032 {
391cb864
L		 5033 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5034 entry, i,
4fbb74a6 5035 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5036 continue;
5037 }
5038 else
5039 {
5040 /* Intel C/C++ compiler may put section 0 in a
5041 section group. We just warn it the first time
5042 and ignore it afterwards. */
5043 static int warned = 0;
5044 if (!warned)
5045 {
5046 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 5047 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5048 warned++;
5049 }
5050 }
e4b17d5c
L		 5051 }
5052
4fbb74a6 5053 section_headers_groups [entry] = group;
e4b17d5c
L		 5054
5055 if (do_section_groups)
5056 {
4fbb74a6 5057 sec = section_headers + entry;
c256ffe7 5058 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
ba2685cc
AM		 5059 }
5060
3f5e193b 5061 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 5062 g->section_index = entry;
5063 g->next = group->root;
5064 group->root = g;
f5842774
L		 5065 }
5066
f5842774
L		 5067 if (start)
5068 free (start);
e4b17d5c
L		 5069
5070 group++;
f5842774
L		 5071 }
5072 }
5073
d1f5c6e3
L		 5074 if (symtab)
5075 free (symtab);
5076 if (strtab)
5077 free (strtab);
f5842774
L		 5078 return 1;
5079}
5080
28f997cf
TG		 5081/* Data used to display dynamic fixups. */
5082
5083struct ia64_vms_dynfixup
5084{
5085 bfd_vma needed_ident; /* Library ident number. */
5086 bfd_vma needed; /* Index in the dstrtab of the library name. */
5087 bfd_vma fixup_needed; /* Index of the library. */
5088 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5089 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5090};
5091
5092/* Data used to display dynamic relocations. */
5093
5094struct ia64_vms_dynimgrela
5095{
5096 bfd_vma img_rela_cnt; /* Number of relocations. */
5097 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5098};
5099
5100/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5101 library). */
5102
5103static void
5104dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5105 const char *strtab, unsigned int strtab_sz)
5106{
5107 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5108 long i;
5109 const char *lib_name;
5110
5111 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5112 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5113 _("dynamic section image fixups"));
5114 if (!imfs)
5115 return;
5116
5117 if (fixup->needed < strtab_sz)
5118 lib_name = strtab + fixup->needed;
5119 else
5120 {
5121 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 5122 (unsigned long) fixup->needed);
28f997cf
TG		 5123 lib_name = "???";
5124 }
5125 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5126 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5127 printf
5128 (_("Seg Offset Type SymVec DataType\n"));
5129
5130 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5131 {
5132 unsigned int type;
5133 const char *rtype;
5134
5135 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5136 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5137 type = BYTE_GET (imfs [i].type);
5138 rtype = elf_ia64_reloc_type (type);
5139 if (rtype == NULL)
5140 printf (" 0x%08x ", type);
5141 else
5142 printf (" %-32s ", rtype);
5143 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5144 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5145 }
5146
5147 free (imfs);
5148}
5149
5150/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5151
5152static void
5153dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5154{
5155 Elf64_External_VMS_IMAGE_RELA *imrs;
5156 long i;
5157
5158 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5159 1, imgrela->img_rela_cnt * sizeof (*imrs),
5160 _("dynamic section image relas"));
5161 if (!imrs)
5162 return;
5163
5164 printf (_("\nImage relocs\n"));
5165 printf
5166 (_("Seg Offset Type Addend Seg Sym Off\n"));
5167
5168 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5169 {
5170 unsigned int type;
5171 const char *rtype;
5172
5173 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5174 printf ("%08" BFD_VMA_FMT "x ",
5175 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5176 type = BYTE_GET (imrs [i].type);
5177 rtype = elf_ia64_reloc_type (type);
5178 if (rtype == NULL)
5179 printf ("0x%08x ", type);
5180 else
5181 printf ("%-31s ", rtype);
5182 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5183 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5184 printf ("%08" BFD_VMA_FMT "x\n",
5185 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5186 }
5187
5188 free (imrs);
5189}
5190
5191/* Display IA-64 OpenVMS dynamic relocations and fixups. */
5192
5193static int
5194process_ia64_vms_dynamic_relocs (FILE *file)
5195{
5196 struct ia64_vms_dynfixup fixup;
5197 struct ia64_vms_dynimgrela imgrela;
5198 Elf_Internal_Dyn *entry;
5199 int res = 0;
5200 bfd_vma strtab_off = 0;
5201 bfd_vma strtab_sz = 0;
5202 char *strtab = NULL;
5203
5204 memset (&fixup, 0, sizeof (fixup));
5205 memset (&imgrela, 0, sizeof (imgrela));
5206
5207 /* Note: the order of the entries is specified by the OpenVMS specs. */
5208 for (entry = dynamic_section;
5209 entry < dynamic_section + dynamic_nent;
5210 entry++)
5211 {
5212 switch (entry->d_tag)
5213 {
5214 case DT_IA_64_VMS_STRTAB_OFFSET:
5215 strtab_off = entry->d_un.d_val;
5216 break;
5217 case DT_STRSZ:
5218 strtab_sz = entry->d_un.d_val;
5219 if (strtab == NULL)
5220 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5221 1, strtab_sz, _("dynamic string section"));
5222 break;
5223
5224 case DT_IA_64_VMS_NEEDED_IDENT:
5225 fixup.needed_ident = entry->d_un.d_val;
5226 break;
5227 case DT_NEEDED:
5228 fixup.needed = entry->d_un.d_val;
5229 break;
5230 case DT_IA_64_VMS_FIXUP_NEEDED:
5231 fixup.fixup_needed = entry->d_un.d_val;
5232 break;
5233 case DT_IA_64_VMS_FIXUP_RELA_CNT:
5234 fixup.fixup_rela_cnt = entry->d_un.d_val;
5235 break;
5236 case DT_IA_64_VMS_FIXUP_RELA_OFF:
5237 fixup.fixup_rela_off = entry->d_un.d_val;
5238 res++;
5239 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5240 break;
5241
5242 case DT_IA_64_VMS_IMG_RELA_CNT:
5243 imgrela.img_rela_cnt = entry->d_un.d_val;
5244 break;
5245 case DT_IA_64_VMS_IMG_RELA_OFF:
5246 imgrela.img_rela_off = entry->d_un.d_val;
5247 res++;
5248 dump_ia64_vms_dynamic_relocs (file, &imgrela);
5249 break;
5250
5251 default:
5252 break;
5253 }
5254 }
5255
5256 if (strtab != NULL)
5257 free (strtab);
5258
5259 return res;
5260}
5261
85b1c36d 5262static struct
566b0d53 5263{
2cf0635d 5264 const char * name;
566b0d53
L		 5265 int reloc;
5266 int size;
5267 int rela;
5268} dynamic_relocations [] =
5269{
5270 { "REL", DT_REL, DT_RELSZ, FALSE },
5271 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5272 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5273};
5274
252b5132 5275/* Process the reloc section. */
18bd398b 5276
252b5132 5277static int
2cf0635d 5278process_relocs (FILE * file)
252b5132 5279{
b34976b6
AM		 5280 unsigned long rel_size;
5281 unsigned long rel_offset;
252b5132
RH		 5282
5283
5284 if (!do_reloc)
5285 return 1;
5286
5287 if (do_using_dynamic)
5288 {
566b0d53 5289 int is_rela;
2cf0635d 5290 const char * name;
566b0d53
L		 5291 int has_dynamic_reloc;
5292 unsigned int i;
0de14b54 5293
566b0d53 5294 has_dynamic_reloc = 0;
252b5132 5295
566b0d53 5296 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 5297 {
566b0d53
L		 5298 is_rela = dynamic_relocations [i].rela;
5299 name = dynamic_relocations [i].name;
5300 rel_size = dynamic_info [dynamic_relocations [i].size];
5301 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 5302
566b0d53
L		 5303 has_dynamic_reloc |= rel_size;
5304
5305 if (is_rela == UNKNOWN)
aa903cfb 5306 {
566b0d53
L		 5307 if (dynamic_relocations [i].reloc == DT_JMPREL)
5308 switch (dynamic_info[DT_PLTREL])
5309 {
5310 case DT_REL:
5311 is_rela = FALSE;
5312 break;
5313 case DT_RELA:
5314 is_rela = TRUE;
5315 break;
5316 }
aa903cfb 5317 }
252b5132 5318
566b0d53
L		 5319 if (rel_size)
5320 {
5321 printf
5322 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5323 name, rel_offset, rel_size);
252b5132 5324
d93f0186
NC		 5325 dump_relocations (file,
5326 offset_from_vma (file, rel_offset, rel_size),
5327 rel_size,
566b0d53 5328 dynamic_symbols, num_dynamic_syms,
d79b3d50 5329 dynamic_strings, dynamic_strings_length, is_rela);
566b0d53 5330 }
252b5132 5331 }
566b0d53 5332
28f997cf
TG		 5333 if (is_ia64_vms ())
5334 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5335
566b0d53 5336 if (! has_dynamic_reloc)
252b5132
RH		 5337 printf (_("\nThere are no dynamic relocations in this file.\n"));
5338 }
5339 else
5340 {
2cf0635d 5341 Elf_Internal_Shdr * section;
b34976b6
AM		 5342 unsigned long i;
5343 int found = 0;
252b5132
RH		 5344
5345 for (i = 0, section = section_headers;
5346 i < elf_header.e_shnum;
b34976b6 5347 i++, section++)
252b5132
RH		 5348 {
5349 if ( section->sh_type != SHT_RELA
5350 && section->sh_type != SHT_REL)
5351 continue;
5352
5353 rel_offset = section->sh_offset;
5354 rel_size = section->sh_size;
5355
5356 if (rel_size)
5357 {
2cf0635d 5358 Elf_Internal_Shdr * strsec;
b34976b6 5359 int is_rela;
103f02d3 5360
252b5132
RH		 5361 printf (_("\nRelocation section "));
5362
5363 if (string_table == NULL)
19936277 5364 printf ("%d", section->sh_name);
252b5132 5365 else
3a1a2036 5366 printf (_("'%s'"), SECTION_NAME (section));
252b5132
RH		 5367
5368 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5369 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5370
d79b3d50
NC		 5371 is_rela = section->sh_type == SHT_RELA;
5372
4fbb74a6
AM		 5373 if (section->sh_link != 0
5374 && section->sh_link < elf_header.e_shnum)
af3fc3bc 5375 {
2cf0635d
NC		 5376 Elf_Internal_Shdr * symsec;
5377 Elf_Internal_Sym * symtab;
d79b3d50 5378 unsigned long nsyms;
c256ffe7 5379 unsigned long strtablen = 0;
2cf0635d 5380 char * strtab = NULL;
57346661 5381
4fbb74a6 5382 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 5383 if (symsec->sh_type != SHT_SYMTAB
5384 && symsec->sh_type != SHT_DYNSYM)
5385 continue;
5386
af3fc3bc 5387 nsyms = symsec->sh_size / symsec->sh_entsize;
9ad5cbcf 5388 symtab = GET_ELF_SYMBOLS (file, symsec);
252b5132 5389
af3fc3bc
AM		 5390 if (symtab == NULL)
5391 continue;
252b5132 5392
4fbb74a6
AM		 5393 if (symsec->sh_link != 0
5394 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 5395 {
4fbb74a6 5396 strsec = section_headers + symsec->sh_link;
103f02d3 5397
3f5e193b
NC		 5398 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5399 1, strsec->sh_size,
5400 _("string table"));
c256ffe7
JJ		 5401 strtablen = strtab == NULL ? 0 : strsec->sh_size;
5402 }
252b5132 5403
d79b3d50
NC		 5404 dump_relocations (file, rel_offset, rel_size,
5405 symtab, nsyms, strtab, strtablen, is_rela);
5406 if (strtab)
5407 free (strtab);
5408 free (symtab);
5409 }
5410 else
5411 dump_relocations (file, rel_offset, rel_size,
5412 NULL, 0, NULL, 0, is_rela);
252b5132
RH		 5413
5414 found = 1;
5415 }
5416 }
5417
5418 if (! found)
5419 printf (_("\nThere are no relocations in this file.\n"));
5420 }
5421
5422 return 1;
5423}
5424
57346661
AM		 5425/* Process the unwind section. */
5426
4d6ed7c8
NC		 5427#include "unwind-ia64.h"
5428
5429/* An absolute address consists of a section and an offset. If the
5430 section is NULL, the offset itself is the address, otherwise, the
5431 address equals to LOAD_ADDRESS(section) + offset. */
5432
5433struct absaddr
5434 {
5435 unsigned short section;
5436 bfd_vma offset;
5437 };
5438
1949de15
L		 5439#define ABSADDR(a) \
5440 ((a).section \
5441 ? section_headers [(a).section].sh_addr + (a).offset \
5442 : (a).offset)
5443
3f5e193b
NC		 5444struct ia64_unw_table_entry
5445 {
5446 struct absaddr start;
5447 struct absaddr end;
5448 struct absaddr info;
5449 };
5450
57346661 5451struct ia64_unw_aux_info
4d6ed7c8 5452 {
3f5e193b
NC		 5453
5454 struct ia64_unw_table_entry *table; /* Unwind table. */
b34976b6 5455 unsigned long table_len; /* Length of unwind table. */
2cf0635d 5456 unsigned char * info; /* Unwind info. */
b34976b6
AM		 5457 unsigned long info_size; /* Size of unwind info. */
5458 bfd_vma info_addr; /* starting address of unwind info. */
5459 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 5460 Elf_Internal_Sym * symtab; /* The symbol table. */
b34976b6 5461 unsigned long nsyms; /* Number of symbols. */
2cf0635d 5462 char * strtab; /* The string table. */
b34976b6 5463 unsigned long strtab_size; /* Size of string table. */
4d6ed7c8
NC		 5464 };
5465
4d6ed7c8 5466static void
2cf0635d 5467find_symbol_for_address (Elf_Internal_Sym * symtab,
57346661 5468 unsigned long nsyms,
2cf0635d 5469 const char * strtab,
57346661 5470 unsigned long strtab_size,
d3ba0551 5471 struct absaddr addr,
2cf0635d
NC		 5472 const char ** symname,
5473 bfd_vma * offset)
4d6ed7c8 5474{
d3ba0551 5475 bfd_vma dist = 0x100000;
2cf0635d
NC		 5476 Elf_Internal_Sym * sym;
5477 Elf_Internal_Sym * best = NULL;
4d6ed7c8
NC		 5478 unsigned long i;
5479
0b6ae522
DJ		 5480 REMOVE_ARCH_BITS (addr.offset);
5481
57346661 5482 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4d6ed7c8 5483 {
0b6ae522
DJ		 5484 bfd_vma value = sym->st_value;
5485
5486 REMOVE_ARCH_BITS (value);
5487
4d6ed7c8
NC		 5488 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5489 && sym->st_name != 0
5490 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 5491 && addr.offset >= value
5492 && addr.offset - value < dist)
4d6ed7c8
NC		 5493 {
5494 best = sym;
0b6ae522 5495 dist = addr.offset - value;
4d6ed7c8
NC		 5496 if (!dist)
5497 break;
5498 }
5499 }
5500 if (best)
5501 {
57346661 5502 *symname = (best->st_name >= strtab_size
2b692964 5503 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 5504 *offset = dist;
5505 return;
5506 }
5507 *symname = NULL;
5508 *offset = addr.offset;
5509}
5510
5511static void
2cf0635d 5512dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 5513{
2cf0635d 5514 struct ia64_unw_table_entry * tp;
4d6ed7c8 5515 int in_body;
7036c0e1 5516
4d6ed7c8
NC		 5517 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5518 {
5519 bfd_vma stamp;
5520 bfd_vma offset;
2cf0635d
NC		 5521 const unsigned char * dp;
5522 const unsigned char * head;
5523 const char * procname;
4d6ed7c8 5524
57346661
AM		 5525 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5526 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 5527
5528 fputs ("\n<", stdout);
5529
5530 if (procname)
5531 {
5532 fputs (procname, stdout);
5533
5534 if (offset)
5535 printf ("+%lx", (unsigned long) offset);
5536 }
5537
5538 fputs (">: [", stdout);
5539 print_vma (tp->start.offset, PREFIX_HEX);
5540 fputc ('-', stdout);
5541 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 5542 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 5543 (unsigned long) (tp->info.offset - aux->seg_base));
5544
1949de15 5545 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 5546 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 5547
86f55779 5548 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 5549 (unsigned) UNW_VER (stamp),
5550 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5551 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5552 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 5553 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 5554
5555 if (UNW_VER (stamp) != 1)
5556 {
2b692964 5557 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 5558 continue;
5559 }
5560
5561 in_body = 0;
89fac5e3 5562 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
4d6ed7c8
NC		 5563 dp = unw_decode (dp, in_body, & in_body);
5564 }
5565}
5566
5567static int
2cf0635d
NC		 5568slurp_ia64_unwind_table (FILE * file,
5569 struct ia64_unw_aux_info * aux,
5570 Elf_Internal_Shdr * sec)
4d6ed7c8 5571{
89fac5e3 5572 unsigned long size, nrelas, i;
2cf0635d
NC		 5573 Elf_Internal_Phdr * seg;
5574 struct ia64_unw_table_entry * tep;
5575 Elf_Internal_Shdr * relsec;
5576 Elf_Internal_Rela * rela;
5577 Elf_Internal_Rela * rp;
5578 unsigned char * table;
5579 unsigned char * tp;
5580 Elf_Internal_Sym * sym;
5581 const char * relname;
4d6ed7c8 5582
4d6ed7c8
NC		 5583 /* First, find the starting address of the segment that includes
5584 this section: */
5585
5586 if (elf_header.e_phnum)
5587 {
d93f0186 5588 if (! get_program_headers (file))
4d6ed7c8 5589 return 0;
4d6ed7c8 5590
d93f0186
NC		 5591 for (seg = program_headers;
5592 seg < program_headers + elf_header.e_phnum;
5593 ++seg)
4d6ed7c8
NC		 5594 {
5595 if (seg->p_type != PT_LOAD)
5596 continue;
5597
5598 if (sec->sh_addr >= seg->p_vaddr
5599 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5600 {
5601 aux->seg_base = seg->p_vaddr;
5602 break;
5603 }
5604 }
4d6ed7c8
NC		 5605 }
5606
5607 /* Second, build the unwind table from the contents of the unwind section: */
5608 size = sec->sh_size;
3f5e193b
NC		 5609 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5610 _("unwind table"));
a6e9f9df
AM		 5611 if (!table)
5612 return 0;
4d6ed7c8 5613
3f5e193b
NC		 5614 aux->table = (struct ia64_unw_table_entry *)
5615 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
89fac5e3 5616 tep = aux->table;
c6a0c689 5617 for (tp = table; tp < table + size; ++tep)
4d6ed7c8
NC		 5618 {
5619 tep->start.section = SHN_UNDEF;
5620 tep->end.section = SHN_UNDEF;
5621 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 5622 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5623 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5624 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 5625 tep->start.offset += aux->seg_base;
5626 tep->end.offset += aux->seg_base;
5627 tep->info.offset += aux->seg_base;
5628 }
5629 free (table);
5630
41e92641 5631 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 5632 for (relsec = section_headers;
5633 relsec < section_headers + elf_header.e_shnum;
5634 ++relsec)
5635 {
5636 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 5637 || relsec->sh_info >= elf_header.e_shnum
5638 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 5639 continue;
5640
5641 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5642 & rela, & nrelas))
5643 return 0;
5644
5645 for (rp = rela; rp < rela + nrelas; ++rp)
5646 {
aca88567
NC		 5647 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5648 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 5649
0112cd26 5650 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 5651 {
e5fb9629 5652 warn (_("Skipping unexpected relocation type %s\n"), relname);
4d6ed7c8
NC		 5653 continue;
5654 }
5655
89fac5e3 5656 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 5657
89fac5e3 5658 switch (rp->r_offset/eh_addr_size % 3)
4d6ed7c8
NC		 5659 {
5660 case 0:
5661 aux->table[i].start.section = sym->st_shndx;
e466bc6e 5662 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5663 break;
5664 case 1:
5665 aux->table[i].end.section = sym->st_shndx;
e466bc6e 5666 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5667 break;
5668 case 2:
5669 aux->table[i].info.section = sym->st_shndx;
e466bc6e 5670 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5671 break;
5672 default:
5673 break;
5674 }
5675 }
5676
5677 free (rela);
5678 }
5679
89fac5e3 5680 aux->table_len = size / (3 * eh_addr_size);
4d6ed7c8
NC		 5681 return 1;
5682}
5683
5684static int
2cf0635d 5685ia64_process_unwind (FILE * file)
4d6ed7c8 5686{
2cf0635d
NC		 5687 Elf_Internal_Shdr * sec;
5688 Elf_Internal_Shdr * unwsec = NULL;
5689 Elf_Internal_Shdr * strsec;
89fac5e3 5690 unsigned long i, unwcount = 0, unwstart = 0;
57346661 5691 struct ia64_unw_aux_info aux;
f1467e33 5692
4d6ed7c8
NC		 5693 memset (& aux, 0, sizeof (aux));
5694
4d6ed7c8
NC		 5695 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5696 {
c256ffe7 5697 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 5698 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8
NC		 5699 {
5700 aux.nsyms = sec->sh_size / sec->sh_entsize;
9ad5cbcf 5701 aux.symtab = GET_ELF_SYMBOLS (file, sec);
4d6ed7c8 5702
4fbb74a6 5703 strsec = section_headers + sec->sh_link;
3f5e193b
NC		 5704 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5705 1, strsec->sh_size,
5706 _("string table"));
c256ffe7 5707 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 5708 }
5709 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 5710 unwcount++;
5711 }
5712
5713 if (!unwcount)
5714 printf (_("\nThere are no unwind sections in this file.\n"));
5715
5716 while (unwcount-- > 0)
5717 {
2cf0635d 5718 char * suffix;
579f31ac
JJ		 5719 size_t len, len2;
5720
5721 for (i = unwstart, sec = section_headers + unwstart;
5722 i < elf_header.e_shnum; ++i, ++sec)
5723 if (sec->sh_type == SHT_IA_64_UNWIND)
5724 {
5725 unwsec = sec;
5726 break;
5727 }
5728
5729 unwstart = i + 1;
5730 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
5731
e4b17d5c
L		 5732 if ((unwsec->sh_flags & SHF_GROUP) != 0)
5733 {
5734 /* We need to find which section group it is in. */
2cf0635d 5735 struct group_list * g = section_headers_groups [i]->root;
e4b17d5c
L		 5736
5737 for (; g != NULL; g = g->next)
5738 {
4fbb74a6 5739 sec = section_headers + g->section_index;
18bd398b
NC		 5740
5741 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
57346661 5742 break;
e4b17d5c
L		 5743 }
5744
5745 if (g == NULL)
5746 i = elf_header.e_shnum;
5747 }
18bd398b 5748 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 5749 {
18bd398b 5750 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 5751 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
5752 suffix = SECTION_NAME (unwsec) + len;
5753 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5754 ++i, ++sec)
18bd398b
NC		 5755 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
5756 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 5757 break;
5758 }
5759 else
5760 {
5761 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 5762 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 5763 len = sizeof (ELF_STRING_ia64_unwind) - 1;
5764 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
5765 suffix = "";
18bd398b 5766 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 5767 suffix = SECTION_NAME (unwsec) + len;
5768 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5769 ++i, ++sec)
18bd398b
NC		 5770 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
5771 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 5772 break;
5773 }
5774
5775 if (i == elf_header.e_shnum)
5776 {
5777 printf (_("\nCould not find unwind info section for "));
5778
5779 if (string_table == NULL)
5780 printf ("%d", unwsec->sh_name);
5781 else
3a1a2036 5782 printf (_("'%s'"), SECTION_NAME (unwsec));
579f31ac
JJ		 5783 }
5784 else
4d6ed7c8
NC		 5785 {
5786 aux.info_size = sec->sh_size;
5787 aux.info_addr = sec->sh_addr;
3f5e193b
NC		 5788 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
5789 aux.info_size,
5790 _("unwind info"));
4d6ed7c8 5791
579f31ac 5792 printf (_("\nUnwind section "));
4d6ed7c8 5793
579f31ac
JJ		 5794 if (string_table == NULL)
5795 printf ("%d", unwsec->sh_name);
5796 else
3a1a2036 5797 printf (_("'%s'"), SECTION_NAME (unwsec));
4d6ed7c8 5798
579f31ac 5799 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 5800 (unsigned long) unwsec->sh_offset,
89fac5e3 5801 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 5802
579f31ac 5803 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4d6ed7c8 5804
579f31ac
JJ		 5805 if (aux.table_len > 0)
5806 dump_ia64_unwind (& aux);
5807
5808 if (aux.table)
5809 free ((char *) aux.table);
5810 if (aux.info)
5811 free ((char *) aux.info);
5812 aux.table = NULL;
5813 aux.info = NULL;
5814 }
4d6ed7c8 5815 }
4d6ed7c8 5816
4d6ed7c8
NC		 5817 if (aux.symtab)
5818 free (aux.symtab);
5819 if (aux.strtab)
5820 free ((char *) aux.strtab);
5821
5822 return 1;
5823}
5824
3f5e193b
NC		 5825struct hppa_unw_table_entry
5826 {
5827 struct absaddr start;
5828 struct absaddr end;
5829 unsigned int Cannot_unwind:1; /* 0 */
5830 unsigned int Millicode:1; /* 1 */
5831 unsigned int Millicode_save_sr0:1; /* 2 */
5832 unsigned int Region_description:2; /* 3..4 */
5833 unsigned int reserved1:1; /* 5 */
5834 unsigned int Entry_SR:1; /* 6 */
5835 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
5836 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
5837 unsigned int Args_stored:1; /* 16 */
5838 unsigned int Variable_Frame:1; /* 17 */
5839 unsigned int Separate_Package_Body:1; /* 18 */
5840 unsigned int Frame_Extension_Millicode:1; /* 19 */
5841 unsigned int Stack_Overflow_Check:1; /* 20 */
5842 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
5843 unsigned int Ada_Region:1; /* 22 */
5844 unsigned int cxx_info:1; /* 23 */
5845 unsigned int cxx_try_catch:1; /* 24 */
5846 unsigned int sched_entry_seq:1; /* 25 */
5847 unsigned int reserved2:1; /* 26 */
5848 unsigned int Save_SP:1; /* 27 */
5849 unsigned int Save_RP:1; /* 28 */
5850 unsigned int Save_MRP_in_frame:1; /* 29 */
5851 unsigned int extn_ptr_defined:1; /* 30 */
5852 unsigned int Cleanup_defined:1; /* 31 */
5853
5854 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
5855 unsigned int HP_UX_interrupt_marker:1; /* 1 */
5856 unsigned int Large_frame:1; /* 2 */
5857 unsigned int Pseudo_SP_Set:1; /* 3 */
5858 unsigned int reserved4:1; /* 4 */
5859 unsigned int Total_frame_size:27; /* 5..31 */
5860 };
5861
57346661
AM		 5862struct hppa_unw_aux_info
5863 {
3f5e193b 5864 struct hppa_unw_table_entry *table; /* Unwind table. */
57346661
AM		 5865 unsigned long table_len; /* Length of unwind table. */
5866 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 5867 Elf_Internal_Sym * symtab; /* The symbol table. */
57346661 5868 unsigned long nsyms; /* Number of symbols. */
2cf0635d 5869 char * strtab; /* The string table. */
57346661
AM		 5870 unsigned long strtab_size; /* Size of string table. */
5871 };
5872
5873static void
2cf0635d 5874dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 5875{
2cf0635d 5876 struct hppa_unw_table_entry * tp;
57346661 5877
57346661
AM		 5878 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5879 {
5880 bfd_vma offset;
2cf0635d 5881 const char * procname;
57346661
AM		 5882
5883 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5884 aux->strtab_size, tp->start, &procname,
5885 &offset);
5886
5887 fputs ("\n<", stdout);
5888
5889 if (procname)
5890 {
5891 fputs (procname, stdout);
5892
5893 if (offset)
5894 printf ("+%lx", (unsigned long) offset);
5895 }
5896
5897 fputs (">: [", stdout);
5898 print_vma (tp->start.offset, PREFIX_HEX);
5899 fputc ('-', stdout);
5900 print_vma (tp->end.offset, PREFIX_HEX);
5901 printf ("]\n\t");
5902
18bd398b
NC		 5903#define PF(_m) if (tp->_m) printf (#_m " ");
5904#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 5905 PF(Cannot_unwind);
5906 PF(Millicode);
5907 PF(Millicode_save_sr0);
18bd398b 5908 /* PV(Region_description); */
57346661
AM		 5909 PF(Entry_SR);
5910 PV(Entry_FR);
5911 PV(Entry_GR);
5912 PF(Args_stored);
5913 PF(Variable_Frame);
5914 PF(Separate_Package_Body);
5915 PF(Frame_Extension_Millicode);
5916 PF(Stack_Overflow_Check);
5917 PF(Two_Instruction_SP_Increment);
5918 PF(Ada_Region);
5919 PF(cxx_info);
5920 PF(cxx_try_catch);
5921 PF(sched_entry_seq);
5922 PF(Save_SP);
5923 PF(Save_RP);
5924 PF(Save_MRP_in_frame);
5925 PF(extn_ptr_defined);
5926 PF(Cleanup_defined);
5927 PF(MPE_XL_interrupt_marker);
5928 PF(HP_UX_interrupt_marker);
5929 PF(Large_frame);
5930 PF(Pseudo_SP_Set);
5931 PV(Total_frame_size);
5932#undef PF
5933#undef PV
5934 }
5935
18bd398b 5936 printf ("\n");
57346661
AM		 5937}
5938
5939static int
2cf0635d
NC		 5940slurp_hppa_unwind_table (FILE * file,
5941 struct hppa_unw_aux_info * aux,
5942 Elf_Internal_Shdr * sec)
57346661 5943{
1c0751b2 5944 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 5945 Elf_Internal_Phdr * seg;
5946 struct hppa_unw_table_entry * tep;
5947 Elf_Internal_Shdr * relsec;
5948 Elf_Internal_Rela * rela;
5949 Elf_Internal_Rela * rp;
5950 unsigned char * table;
5951 unsigned char * tp;
5952 Elf_Internal_Sym * sym;
5953 const char * relname;
57346661 5954
57346661
AM		 5955 /* First, find the starting address of the segment that includes
5956 this section. */
5957
5958 if (elf_header.e_phnum)
5959 {
5960 if (! get_program_headers (file))
5961 return 0;
5962
5963 for (seg = program_headers;
5964 seg < program_headers + elf_header.e_phnum;
5965 ++seg)
5966 {
5967 if (seg->p_type != PT_LOAD)
5968 continue;
5969
5970 if (sec->sh_addr >= seg->p_vaddr
5971 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5972 {
5973 aux->seg_base = seg->p_vaddr;
5974 break;
5975 }
5976 }
5977 }
5978
5979 /* Second, build the unwind table from the contents of the unwind
5980 section. */
5981 size = sec->sh_size;
3f5e193b
NC		 5982 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5983 _("unwind table"));
57346661
AM		 5984 if (!table)
5985 return 0;
5986
1c0751b2
DA		 5987 unw_ent_size = 16;
5988 nentries = size / unw_ent_size;
5989 size = unw_ent_size * nentries;
57346661 5990
3f5e193b
NC		 5991 tep = aux->table = (struct hppa_unw_table_entry *)
5992 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 5993
1c0751b2 5994 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 5995 {
5996 unsigned int tmp1, tmp2;
5997
5998 tep->start.section = SHN_UNDEF;
5999 tep->end.section = SHN_UNDEF;
6000
1c0751b2
DA		 6001 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6002 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6003 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6004 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6005
6006 tep->start.offset += aux->seg_base;
6007 tep->end.offset += aux->seg_base;
57346661
AM		 6008
6009 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6010 tep->Millicode = (tmp1 >> 30) & 0x1;
6011 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6012 tep->Region_description = (tmp1 >> 27) & 0x3;
6013 tep->reserved1 = (tmp1 >> 26) & 0x1;
6014 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6015 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6016 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6017 tep->Args_stored = (tmp1 >> 15) & 0x1;
6018 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6019 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6020 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6021 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6022 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6023 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6024 tep->cxx_info = (tmp1 >> 8) & 0x1;
6025 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6026 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6027 tep->reserved2 = (tmp1 >> 5) & 0x1;
6028 tep->Save_SP = (tmp1 >> 4) & 0x1;
6029 tep->Save_RP = (tmp1 >> 3) & 0x1;
6030 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6031 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6032 tep->Cleanup_defined = tmp1 & 0x1;
6033
6034 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6035 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6036 tep->Large_frame = (tmp2 >> 29) & 0x1;
6037 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6038 tep->reserved4 = (tmp2 >> 27) & 0x1;
6039 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 6040 }
6041 free (table);
6042
6043 /* Third, apply any relocations to the unwind table. */
57346661
AM		 6044 for (relsec = section_headers;
6045 relsec < section_headers + elf_header.e_shnum;
6046 ++relsec)
6047 {
6048 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6049 || relsec->sh_info >= elf_header.e_shnum
6050 || section_headers + relsec->sh_info != sec)
57346661
AM		 6051 continue;
6052
6053 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6054 & rela, & nrelas))
6055 return 0;
6056
6057 for (rp = rela; rp < rela + nrelas; ++rp)
6058 {
aca88567
NC		 6059 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6060 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 6061
6062 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 6063 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 6064 {
6065 warn (_("Skipping unexpected relocation type %s\n"), relname);
6066 continue;
6067 }
6068
6069 i = rp->r_offset / unw_ent_size;
6070
89fac5e3 6071 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 6072 {
6073 case 0:
6074 aux->table[i].start.section = sym->st_shndx;
1e456d54 6075 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 6076 break;
6077 case 1:
6078 aux->table[i].end.section = sym->st_shndx;
1e456d54 6079 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 6080 break;
6081 default:
6082 break;
6083 }
6084 }
6085
6086 free (rela);
6087 }
6088
1c0751b2 6089 aux->table_len = nentries;
57346661
AM		 6090
6091 return 1;
6092}
6093
6094static int
2cf0635d 6095hppa_process_unwind (FILE * file)
57346661 6096{
57346661 6097 struct hppa_unw_aux_info aux;
2cf0635d
NC		 6098 Elf_Internal_Shdr * unwsec = NULL;
6099 Elf_Internal_Shdr * strsec;
6100 Elf_Internal_Shdr * sec;
18bd398b 6101 unsigned long i;
57346661
AM		 6102
6103 memset (& aux, 0, sizeof (aux));
6104
c256ffe7
JJ		 6105 if (string_table == NULL)
6106 return 1;
57346661
AM		 6107
6108 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6109 {
c256ffe7 6110 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6111 && sec->sh_link < elf_header.e_shnum)
57346661
AM		 6112 {
6113 aux.nsyms = sec->sh_size / sec->sh_entsize;
6114 aux.symtab = GET_ELF_SYMBOLS (file, sec);
6115
4fbb74a6 6116 strsec = section_headers + sec->sh_link;
3f5e193b
NC		 6117 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6118 1, strsec->sh_size,
6119 _("string table"));
c256ffe7 6120 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 6121 }
18bd398b 6122 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 6123 unwsec = sec;
6124 }
6125
6126 if (!unwsec)
6127 printf (_("\nThere are no unwind sections in this file.\n"));
6128
6129 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6130 {
18bd398b 6131 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 6132 {
57346661
AM		 6133 printf (_("\nUnwind section "));
6134 printf (_("'%s'"), SECTION_NAME (sec));
6135
6136 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6137 (unsigned long) sec->sh_offset,
89fac5e3 6138 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 6139
6140 slurp_hppa_unwind_table (file, &aux, sec);
6141 if (aux.table_len > 0)
6142 dump_hppa_unwind (&aux);
6143
6144 if (aux.table)
6145 free ((char *) aux.table);
6146 aux.table = NULL;
6147 }
6148 }
6149
6150 if (aux.symtab)
6151 free (aux.symtab);
6152 if (aux.strtab)
6153 free ((char *) aux.strtab);
6154
6155 return 1;
6156}
6157
0b6ae522
DJ		 6158struct arm_section
6159{
6160 unsigned char *data;
6161
6162 Elf_Internal_Shdr *sec;
6163 Elf_Internal_Rela *rela;
6164 unsigned long nrelas;
6165 unsigned int rel_type;
6166
6167 Elf_Internal_Rela *next_rela;
6168};
6169
6170struct arm_unw_aux_info
6171{
6172 FILE *file;
6173
6174 Elf_Internal_Sym *symtab; /* The symbol table. */
6175 unsigned long nsyms; /* Number of symbols. */
6176 char *strtab; /* The string table. */
6177 unsigned long strtab_size; /* Size of string table. */
6178};
6179
6180static const char *
6181arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6182 bfd_vma fn, struct absaddr addr)
6183{
6184 const char *procname;
6185 bfd_vma sym_offset;
6186
6187 if (addr.section == SHN_UNDEF)
6188 addr.offset = fn;
6189
6190 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6191 aux->strtab_size, addr, &procname,
6192 &sym_offset);
6193
6194 print_vma (fn, PREFIX_HEX);
6195
6196 if (procname)
6197 {
6198 fputs (" <", stdout);
6199 fputs (procname, stdout);
6200
6201 if (sym_offset)
6202 printf ("+0x%lx", (unsigned long) sym_offset);
6203 fputc ('>', stdout);
6204 }
6205
6206 return procname;
6207}
6208
6209static void
6210arm_free_section (struct arm_section *arm_sec)
6211{
6212 if (arm_sec->data != NULL)
6213 free (arm_sec->data);
6214
6215 if (arm_sec->rela != NULL)
6216 free (arm_sec->rela);
6217}
6218
6219static int
6220arm_section_get_word (struct arm_unw_aux_info *aux,
6221 struct arm_section *arm_sec,
6222 Elf_Internal_Shdr *sec, bfd_vma word_offset,
6223 unsigned int *wordp, struct absaddr *addr)
6224{
6225 Elf_Internal_Rela *rp;
6226 Elf_Internal_Sym *sym;
6227 const char * relname;
6228 unsigned int word;
6229 bfd_boolean wrapped;
6230
6231 addr->section = SHN_UNDEF;
6232 addr->offset = 0;
6233
6234 if (sec != arm_sec->sec)
6235 {
6236 Elf_Internal_Shdr *relsec;
6237
6238 arm_free_section (arm_sec);
6239
6240 arm_sec->sec = sec;
6241 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6242 sec->sh_size, _("unwind data"));
6243
6244 arm_sec->rela = NULL;
6245 arm_sec->nrelas = 0;
6246
6247 for (relsec = section_headers;
6248 relsec < section_headers + elf_header.e_shnum;
6249 ++relsec)
6250 {
6251 if (relsec->sh_info >= elf_header.e_shnum
6252 || section_headers + relsec->sh_info != sec)
6253 continue;
6254
6255 if (relsec->sh_type == SHT_REL)
6256 {
6257 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6258 relsec->sh_size,
6259 & arm_sec->rela, & arm_sec->nrelas))
6260 return 0;
6261 break;
6262 }
6263 else if (relsec->sh_type == SHT_RELA)
6264 {
6265 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6266 relsec->sh_size,
6267 & arm_sec->rela, & arm_sec->nrelas))
6268 return 0;
6269 break;
6270 }
6271 }
6272
6273 arm_sec->next_rela = arm_sec->rela;
6274 }
6275
6276 if (arm_sec->data == NULL)
6277 return 0;
6278
6279 word = byte_get (arm_sec->data + word_offset, 4);
6280
6281 wrapped = FALSE;
6282 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6283 {
6284 bfd_vma prelval, offset;
6285
6286 if (rp->r_offset > word_offset && !wrapped)
6287 {
6288 rp = arm_sec->rela;
6289 wrapped = TRUE;
6290 }
6291 if (rp->r_offset > word_offset)
6292 break;
6293
6294 if (rp->r_offset & 3)
6295 {
6296 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6297 (unsigned long) rp->r_offset);
6298 continue;
6299 }
6300
6301 if (rp->r_offset < word_offset)
6302 continue;
6303
6304 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6305
6306 if (streq (relname, "R_ARM_NONE"))
6307 continue;
6308
6309 if (! streq (relname, "R_ARM_PREL31"))
6310 {
6311 warn (_("Skipping unexpected relocation type %s\n"), relname);
6312 continue;
6313 }
6314
6315 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6316
6317 if (arm_sec->rel_type == SHT_REL)
6318 {
6319 offset = word & 0x7fffffff;
6320 if (offset & 0x40000000)
6321 offset |= ~ (bfd_vma) 0x7fffffff;
6322 }
6323 else
6324 offset = rp->r_addend;
6325
6326 offset += sym->st_value;
6327 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6328
6329 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6330 addr->section = sym->st_shndx;
6331 addr->offset = offset;
6332 break;
6333 }
6334
6335 *wordp = word;
6336 arm_sec->next_rela = rp;
6337
6338 return 1;
6339}
6340
6341static void
6342decode_arm_unwind (struct arm_unw_aux_info *aux,
6343 unsigned int word, unsigned int remaining,
6344 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6345 struct arm_section *data_arm_sec)
6346{
6347 int per_index;
6348 unsigned int more_words;
6349 struct absaddr addr;
6350
6351#define ADVANCE \
6352 if (remaining == 0 && more_words) \
6353 { \
6354 data_offset += 4; \
6355 if (!arm_section_get_word (aux, data_arm_sec, data_sec, \
6356 data_offset, &word, &addr)) \
6357 return; \
6358 remaining = 4; \
6359 more_words--; \
6360 } \
6361
6362#define GET_OP(OP) \
6363 ADVANCE; \
6364 if (remaining) \
6365 { \
6366 remaining--; \
6367 (OP) = word >> 24; \
6368 word <<= 8; \
6369 } \
6370 else \
6371 { \
2b692964 6372 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 6373 return; \
6374 } \
6375 printf (_("0x%02x "), OP)
6376
6377 if (remaining == 0)
6378 {
6379 /* Fetch the first word. */
6380 if (!arm_section_get_word (aux, data_arm_sec, data_sec, data_offset,
6381 &word, &addr))
6382 return;
6383 remaining = 4;
6384 }
6385
6386 if ((word & 0x80000000) == 0)
6387 {
6388 /* Expand prel31 for personality routine. */
6389 bfd_vma fn;
6390 const char *procname;
6391
6392 fn = word;
6393 if (fn & 0x40000000)
6394 fn |= ~ (bfd_vma) 0x7fffffff;
6395 fn = fn + data_sec->sh_addr + data_offset;
6396
6397 printf (_(" Personality routine: "));
6398 procname = arm_print_vma_and_name (aux, fn, addr);
6399 fputc ('\n', stdout);
6400
6401 /* The GCC personality routines use the standard compact
6402 encoding, starting with one byte giving the number of
6403 words. */
6404 if (procname != NULL
6405 && (const_strneq (procname, "__gcc_personality_v0")
6406 || const_strneq (procname, "__gxx_personality_v0")
6407 || const_strneq (procname, "__gcj_personality_v0")
6408 || const_strneq (procname, "__gnu_objc_personality_v0")))
6409 {
6410 remaining = 0;
6411 more_words = 1;
6412 ADVANCE;
6413 if (!remaining)
6414 {
6415 printf (_(" [Truncated data]\n"));
6416 return;
6417 }
6418 more_words = word >> 24;
6419 word <<= 8;
6420 remaining--;
6421 }
6422 else
6423 return;
6424 }
6425 else
6426 {
6427
6428 per_index = (word >> 24) & 0x7f;
6429 if (per_index != 0 && per_index != 1 && per_index != 2)
6430 {
6431 printf (_(" [reserved compact index %d]\n"), per_index);
6432 return;
6433 }
6434
6435 printf (_(" Compact model %d\n"), per_index);
6436 if (per_index == 0)
6437 {
6438 more_words = 0;
6439 word <<= 8;
6440 remaining--;
6441 }
6442 else
6443 {
6444 more_words = (word >> 16) & 0xff;
6445 word <<= 16;
6446 remaining -= 2;
6447 }
6448 }
6449
6450 /* Decode the unwinding instructions. */
6451 while (1)
6452 {
6453 unsigned int op, op2;
6454
6455 ADVANCE;
6456 if (remaining == 0)
6457 break;
6458 remaining--;
6459 op = word >> 24;
6460 word <<= 8;
6461
6462 printf (_(" 0x%02x "), op);
6463
6464 if ((op & 0xc0) == 0x00)
6465 {
6466 int offset = ((op & 0x3f) << 2) + 4;
6467 printf (_(" vsp = vsp + %d"), offset);
6468 }
6469 else if ((op & 0xc0) == 0x40)
6470 {
6471 int offset = ((op & 0x3f) << 2) + 4;
6472 printf (_(" vsp = vsp - %d"), offset);
6473 }
6474 else if ((op & 0xf0) == 0x80)
6475 {
6476 GET_OP (op2);
6477 if (op == 0x80 && op2 == 0)
6478 printf (_("Refuse to unwind"));
6479 else
6480 {
6481 unsigned int mask = ((op & 0x0f) << 8) | op2;
6482 int first = 1;
6483 int i;
2b692964 6484
0b6ae522
DJ		 6485 printf ("pop {");
6486 for (i = 0; i < 12; i++)
6487 if (mask & (1 << i))
6488 {
6489 if (first)
6490 first = 0;
6491 else
6492 printf (", ");
6493 printf ("r%d", 4 + i);
6494 }
6495 printf ("}");
6496 }
6497 }
6498 else if ((op & 0xf0) == 0x90)
6499 {
6500 if (op == 0x9d || op == 0x9f)
6501 printf (_(" [Reserved]"));
6502 else
6503 printf (_(" vsp = r%d"), op & 0x0f);
6504 }
6505 else if ((op & 0xf0) == 0xa0)
6506 {
6507 int end = 4 + (op & 0x07);
6508 int first = 1;
6509 int i;
6510 printf (" pop {");
6511 for (i = 4; i <= end; i++)
6512 {
6513 if (first)
6514 first = 0;
6515 else
6516 printf (", ");
6517 printf ("r%d", i);
6518 }
6519 if (op & 0x08)
6520 {
6521 if (first)
6522 printf (", ");
6523 printf ("r14");
6524 }
6525 printf ("}");
6526 }
6527 else if (op == 0xb0)
6528 printf (_(" finish"));
6529 else if (op == 0xb1)
6530 {
6531 GET_OP (op2);
6532 if (op2 == 0 || (op2 & 0xf0) != 0)
6533 printf (_("[Spare]"));
6534 else
6535 {
6536 unsigned int mask = op2 & 0x0f;
6537 int first = 1;
6538 int i;
6539 printf ("pop {");
6540 for (i = 0; i < 12; i++)
6541 if (mask & (1 << i))
6542 {
6543 if (first)
6544 first = 0;
6545 else
6546 printf (", ");
6547 printf ("r%d", i);
6548 }
6549 printf ("}");
6550 }
6551 }
6552 else if (op == 0xb2)
6553 {
b115cf96 6554 unsigned char buf[9];
0b6ae522
DJ		 6555 unsigned int i, len;
6556 unsigned long offset;
b115cf96 6557 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 6558 {
6559 GET_OP (buf[i]);
6560 if ((buf[i] & 0x80) == 0)
6561 break;
6562 }
6563 assert (i < sizeof (buf));
6564 offset = read_uleb128 (buf, &len);
6565 assert (len == i + 1);
6566 offset = offset * 4 + 0x204;
6567 printf (_("vsp = vsp + %ld"), offset);
6568 }
6569 else
6570 {
6571 if (op == 0xb3 || op == 0xc6 || op == 0xc7 || op == 0xc8 || op == 0xc9)
6572 {
6573 GET_OP (op2);
6574 printf (_("[unsupported two-byte opcode]"));
6575 }
6576 else
6577 {
6578 printf (_(" [unsupported opcode]"));
6579 }
6580 }
6581 printf ("\n");
6582 }
6583
6584 /* Decode the descriptors. Not implemented. */
6585}
6586
6587static void
6588dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
6589{
6590 struct arm_section exidx_arm_sec, extab_arm_sec;
6591 unsigned int i, exidx_len;
6592
6593 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
6594 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
6595 exidx_len = exidx_sec->sh_size / 8;
6596
6597 for (i = 0; i < exidx_len; i++)
6598 {
6599 unsigned int exidx_fn, exidx_entry;
6600 struct absaddr fn_addr, entry_addr;
6601 bfd_vma fn;
6602
6603 fputc ('\n', stdout);
6604
6605 if (!arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6606 8 * i, &exidx_fn, &fn_addr)
6607 || !arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6608 8 * i + 4, &exidx_entry, &entry_addr))
6609 {
6610 arm_free_section (&exidx_arm_sec);
6611 arm_free_section (&extab_arm_sec);
6612 return;
6613 }
6614
6615 fn = exidx_fn & 0x7fffffff;
6616 if (fn & 0x40000000)
6617 fn |= ~ (bfd_vma) 0x7fffffff;
6618 fn = fn + exidx_sec->sh_addr + 8 * i;
6619
6620 arm_print_vma_and_name (aux, fn, entry_addr);
6621 fputs (": ", stdout);
6622
6623 if (exidx_entry == 1)
6624 {
6625 print_vma (exidx_entry, PREFIX_HEX);
6626 fputs (" [cantunwind]\n", stdout);
6627 }
6628 else if (exidx_entry & 0x80000000)
6629 {
6630 print_vma (exidx_entry, PREFIX_HEX);
6631 fputc ('\n', stdout);
6632 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
6633 }
6634 else
6635 {
8f73510c 6636 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 6637 Elf_Internal_Shdr *table_sec;
6638
6639 fputs ("@", stdout);
6640 table = exidx_entry;
6641 if (table & 0x40000000)
6642 table |= ~ (bfd_vma) 0x7fffffff;
6643 table = table + exidx_sec->sh_addr + 8 * i + 4;
6644 print_vma (table, PREFIX_HEX);
6645 printf ("\n");
6646
6647 /* Locate the matching .ARM.extab. */
6648 if (entry_addr.section != SHN_UNDEF
6649 && entry_addr.section < elf_header.e_shnum)
6650 {
6651 table_sec = section_headers + entry_addr.section;
6652 table_offset = entry_addr.offset;
6653 }
6654 else
6655 {
6656 table_sec = find_section_by_address (table);
6657 if (table_sec != NULL)
6658 table_offset = table - table_sec->sh_addr;
6659 }
6660 if (table_sec == NULL)
6661 {
6662 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
6663 (unsigned long) table);
6664 continue;
6665 }
6666 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
6667 &extab_arm_sec);
6668 }
6669 }
6670
6671 printf ("\n");
6672
6673 arm_free_section (&exidx_arm_sec);
6674 arm_free_section (&extab_arm_sec);
6675}
6676
6677static int
6678arm_process_unwind (FILE *file)
6679{
6680 struct arm_unw_aux_info aux;
6681 Elf_Internal_Shdr *unwsec = NULL;
6682 Elf_Internal_Shdr *strsec;
6683 Elf_Internal_Shdr *sec;
6684 unsigned long i;
6685
6686 memset (& aux, 0, sizeof (aux));
6687 aux.file = file;
6688
6689 if (string_table == NULL)
6690 return 1;
6691
6692 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6693 {
6694 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
6695 {
6696 aux.nsyms = sec->sh_size / sec->sh_entsize;
6697 aux.symtab = GET_ELF_SYMBOLS (file, sec);
6698
6699 strsec = section_headers + sec->sh_link;
6700 aux.strtab = get_data (NULL, file, strsec->sh_offset,
6701 1, strsec->sh_size, _("string table"));
6702 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6703 }
6704 else if (sec->sh_type == SHT_ARM_EXIDX)
6705 unwsec = sec;
6706 }
6707
6708 if (!unwsec)
6709 printf (_("\nThere are no unwind sections in this file.\n"));
6710
6711 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6712 {
6713 if (sec->sh_type == SHT_ARM_EXIDX)
6714 {
6715 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
6716 SECTION_NAME (sec),
6717 (unsigned long) sec->sh_offset,
6718 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
6719
6720 dump_arm_unwind (&aux, sec);
6721 }
6722 }
6723
6724 if (aux.symtab)
6725 free (aux.symtab);
6726 if (aux.strtab)
6727 free ((char *) aux.strtab);
6728
6729 return 1;
6730}
6731
57346661 6732static int
2cf0635d 6733process_unwind (FILE * file)
57346661 6734{
2cf0635d
NC		 6735 struct unwind_handler
6736 {
57346661 6737 int machtype;
2cf0635d
NC		 6738 int (* handler)(FILE *);
6739 } handlers[] =
6740 {
0b6ae522 6741 { EM_ARM, arm_process_unwind },
57346661
AM		 6742 { EM_IA_64, ia64_process_unwind },
6743 { EM_PARISC, hppa_process_unwind },
6744 { 0, 0 }
6745 };
6746 int i;
6747
6748 if (!do_unwind)
6749 return 1;
6750
6751 for (i = 0; handlers[i].handler != NULL; i++)
6752 if (elf_header.e_machine == handlers[i].machtype)
18bd398b 6753 return handlers[i].handler (file);
57346661
AM		 6754
6755 printf (_("\nThere are no unwind sections in this file.\n"));
6756 return 1;
6757}
6758
252b5132 6759static void
2cf0635d 6760dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 6761{
6762 switch (entry->d_tag)
6763 {
6764 case DT_MIPS_FLAGS:
6765 if (entry->d_un.d_val == 0)
2b692964 6766 printf (_("NONE\n"));
252b5132
RH		 6767 else
6768 {
6769 static const char * opts[] =
6770 {
6771 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
6772 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
6773 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
6774 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
6775 "RLD_ORDER_SAFE"
6776 };
6777 unsigned int cnt;
6778 int first = 1;
2b692964 6779
60bca95a 6780 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 6781 if (entry->d_un.d_val & (1 << cnt))
6782 {
6783 printf ("%s%s", first ? "" : " ", opts[cnt]);
6784 first = 0;
6785 }
6786 puts ("");
6787 }
6788 break;
103f02d3 6789
252b5132 6790 case DT_MIPS_IVERSION:
d79b3d50 6791 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
2b692964 6792 printf (_("Interface Version: %s\n"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 6793 else
2b692964 6794 printf (_("<corrupt: %ld>\n"), (long) entry->d_un.d_ptr);
252b5132 6795 break;
103f02d3 6796
252b5132
RH		 6797 case DT_MIPS_TIME_STAMP:
6798 {
6799 char timebuf[20];
2cf0635d 6800 struct tm * tmp;
50da7a9c 6801
91d6fa6a
NC		 6802 time_t atime = entry->d_un.d_val;
6803 tmp = gmtime (&atime);
e9e44622
JJ		 6804 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
6805 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
6806 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
2b692964 6807 printf (_("Time Stamp: %s\n"), timebuf);
252b5132
RH		 6808 }
6809 break;
103f02d3 6810
252b5132
RH		 6811 case DT_MIPS_RLD_VERSION:
6812 case DT_MIPS_LOCAL_GOTNO:
6813 case DT_MIPS_CONFLICTNO:
6814 case DT_MIPS_LIBLISTNO:
6815 case DT_MIPS_SYMTABNO:
6816 case DT_MIPS_UNREFEXTNO:
6817 case DT_MIPS_HIPAGENO:
6818 case DT_MIPS_DELTA_CLASS_NO:
6819 case DT_MIPS_DELTA_INSTANCE_NO:
6820 case DT_MIPS_DELTA_RELOC_NO:
6821 case DT_MIPS_DELTA_SYM_NO:
6822 case DT_MIPS_DELTA_CLASSSYM_NO:
6823 case DT_MIPS_COMPACT_SIZE:
6824 printf ("%ld\n", (long) entry->d_un.d_ptr);
6825 break;
103f02d3
UD		 6826
6827 default:
0af1713e 6828 printf ("%#lx\n", (unsigned long) entry->d_un.d_ptr);
103f02d3
UD		 6829 }
6830}
6831
103f02d3 6832static void
2cf0635d 6833dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 6834{
6835 switch (entry->d_tag)
6836 {
6837 case DT_HP_DLD_FLAGS:
6838 {
6839 static struct
6840 {
6841 long int bit;
2cf0635d 6842 const char * str;
5e220199
NC		 6843 }
6844 flags[] =
6845 {
6846 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
6847 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
6848 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
6849 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
6850 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
6851 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
6852 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
6853 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
6854 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
6855 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 6856 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
6857 { DT_HP_GST, "HP_GST" },
6858 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
6859 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
6860 { DT_HP_NODELETE, "HP_NODELETE" },
6861 { DT_HP_GROUP, "HP_GROUP" },
6862 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 6863 };
103f02d3 6864 int first = 1;
5e220199 6865 size_t cnt;
f7a99963 6866 bfd_vma val = entry->d_un.d_val;
103f02d3 6867
60bca95a 6868 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 6869 if (val & flags[cnt].bit)
30800947
NC		 6870 {
6871 if (! first)
6872 putchar (' ');
6873 fputs (flags[cnt].str, stdout);
6874 first = 0;
6875 val ^= flags[cnt].bit;
6876 }
76da6bbe 6877
103f02d3 6878 if (val != 0 || first)
f7a99963
NC		 6879 {
6880 if (! first)
6881 putchar (' ');
6882 print_vma (val, HEX);
6883 }
103f02d3
UD		 6884 }
6885 break;
76da6bbe 6886
252b5132 6887 default:
f7a99963
NC		 6888 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
6889 break;
252b5132 6890 }
35b1837e 6891 putchar ('\n');
252b5132
RH		 6892}
6893
28f997cf
TG		 6894#ifdef BFD64
6895
6896/* VMS vs Unix time offset and factor. */
6897
6898#define VMS_EPOCH_OFFSET 35067168000000000LL
6899#define VMS_GRANULARITY_FACTOR 10000000
6900
6901/* Display a VMS time in a human readable format. */
6902
6903static void
6904print_vms_time (bfd_int64_t vmstime)
6905{
6906 struct tm *tm;
6907 time_t unxtime;
6908
6909 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
6910 tm = gmtime (&unxtime);
6911 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
6912 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
6913 tm->tm_hour, tm->tm_min, tm->tm_sec);
6914}
6915#endif /* BFD64 */
6916
ecc51f48 6917static void
2cf0635d 6918dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 6919{
6920 switch (entry->d_tag)
6921 {
0de14b54 6922 case DT_IA_64_PLT_RESERVE:
bdf4d63a 6923 /* First 3 slots reserved. */
ecc51f48
NC		 6924 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
6925 printf (" -- ");
6926 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 6927 break;
6928
28f997cf
TG		 6929 case DT_IA_64_VMS_LINKTIME:
6930#ifdef BFD64
6931 print_vms_time (entry->d_un.d_val);
6932#endif
6933 break;
6934
6935 case DT_IA_64_VMS_LNKFLAGS:
6936 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
6937 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
6938 printf (" CALL_DEBUG");
6939 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
6940 printf (" NOP0BUFS");
6941 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
6942 printf (" P0IMAGE");
6943 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
6944 printf (" MKTHREADS");
6945 if (entry->d_un.d_val & VMS_LF_UPCALLS)
6946 printf (" UPCALLS");
6947 if (entry->d_un.d_val & VMS_LF_IMGSTA)
6948 printf (" IMGSTA");
6949 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
6950 printf (" INITIALIZE");
6951 if (entry->d_un.d_val & VMS_LF_MAIN)
6952 printf (" MAIN");
6953 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
6954 printf (" EXE_INIT");
6955 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
6956 printf (" TBK_IN_IMG");
6957 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
6958 printf (" DBG_IN_IMG");
6959 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
6960 printf (" TBK_IN_DSF");
6961 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
6962 printf (" DBG_IN_DSF");
6963 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
6964 printf (" SIGNATURES");
6965 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
6966 printf (" REL_SEG_OFF");
6967 break;
6968
bdf4d63a
JJ		 6969 default:
6970 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
6971 break;
ecc51f48 6972 }
bdf4d63a 6973 putchar ('\n');
ecc51f48
NC		 6974}
6975
252b5132 6976static int
2cf0635d 6977get_32bit_dynamic_section (FILE * file)
252b5132 6978{
2cf0635d
NC		 6979 Elf32_External_Dyn * edyn;
6980 Elf32_External_Dyn * ext;
6981 Elf_Internal_Dyn * entry;
103f02d3 6982
3f5e193b
NC		 6983 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
6984 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 6985 if (!edyn)
6986 return 0;
103f02d3 6987
ba2685cc
AM		 6988/* SGI's ELF has more than one section in the DYNAMIC segment, and we
6989 might not have the luxury of section headers. Look for the DT_NULL
6990 terminator to determine the number of entries. */
6991 for (ext = edyn, dynamic_nent = 0;
6992 (char *) ext < (char *) edyn + dynamic_size;
6993 ext++)
6994 {
6995 dynamic_nent++;
6996 if (BYTE_GET (ext->d_tag) == DT_NULL)
6997 break;
6998 }
252b5132 6999
3f5e193b
NC		 7000 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7001 sizeof (* entry));
b2d38a17 7002 if (dynamic_section == NULL)
252b5132 7003 {
9ea033b2
NC		 7004 error (_("Out of memory\n"));
7005 free (edyn);
7006 return 0;
7007 }
252b5132 7008
fb514b26 7009 for (ext = edyn, entry = dynamic_section;
ba2685cc 7010 entry < dynamic_section + dynamic_nent;
fb514b26 7011 ext++, entry++)
9ea033b2 7012 {
fb514b26
AM		 7013 entry->d_tag = BYTE_GET (ext->d_tag);
7014 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 7015 }
7016
9ea033b2
NC		 7017 free (edyn);
7018
7019 return 1;
7020}
7021
7022static int
2cf0635d 7023get_64bit_dynamic_section (FILE * file)
9ea033b2 7024{
2cf0635d
NC		 7025 Elf64_External_Dyn * edyn;
7026 Elf64_External_Dyn * ext;
7027 Elf_Internal_Dyn * entry;
103f02d3 7028
3f5e193b
NC		 7029 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7030 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 7031 if (!edyn)
7032 return 0;
103f02d3 7033
ba2685cc
AM		 7034/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7035 might not have the luxury of section headers. Look for the DT_NULL
7036 terminator to determine the number of entries. */
7037 for (ext = edyn, dynamic_nent = 0;
7038 (char *) ext < (char *) edyn + dynamic_size;
7039 ext++)
7040 {
7041 dynamic_nent++;
66543521 7042 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 7043 break;
7044 }
252b5132 7045
3f5e193b
NC		 7046 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7047 sizeof (* entry));
b2d38a17 7048 if (dynamic_section == NULL)
252b5132
RH		 7049 {
7050 error (_("Out of memory\n"));
7051 free (edyn);
7052 return 0;
7053 }
7054
fb514b26 7055 for (ext = edyn, entry = dynamic_section;
ba2685cc 7056 entry < dynamic_section + dynamic_nent;
fb514b26 7057 ext++, entry++)
252b5132 7058 {
66543521
AM		 7059 entry->d_tag = BYTE_GET (ext->d_tag);
7060 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 7061 }
7062
7063 free (edyn);
7064
9ea033b2
NC		 7065 return 1;
7066}
7067
e9e44622
JJ		 7068static void
7069print_dynamic_flags (bfd_vma flags)
d1133906 7070{
e9e44622 7071 int first = 1;
13ae64f3 7072
d1133906
NC		 7073 while (flags)
7074 {
7075 bfd_vma flag;
7076
7077 flag = flags & - flags;
7078 flags &= ~ flag;
7079
e9e44622
JJ		 7080 if (first)
7081 first = 0;
7082 else
7083 putc (' ', stdout);
13ae64f3 7084
d1133906
NC		 7085 switch (flag)
7086 {
e9e44622
JJ		 7087 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
7088 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
7089 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
7090 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
7091 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 7092 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 7093 }
7094 }
e9e44622 7095 puts ("");
d1133906
NC		 7096}
7097
b2d38a17
NC		 7098/* Parse and display the contents of the dynamic section. */
7099
9ea033b2 7100static int
2cf0635d 7101process_dynamic_section (FILE * file)
9ea033b2 7102{
2cf0635d 7103 Elf_Internal_Dyn * entry;
9ea033b2
NC		 7104
7105 if (dynamic_size == 0)
7106 {
7107 if (do_dynamic)
b2d38a17 7108 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 7109
7110 return 1;
7111 }
7112
7113 if (is_32bit_elf)
7114 {
b2d38a17 7115 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 7116 return 0;
7117 }
b2d38a17 7118 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 7119 return 0;
7120
252b5132
RH		 7121 /* Find the appropriate symbol table. */
7122 if (dynamic_symbols == NULL)
7123 {
86dba8ee
AM		 7124 for (entry = dynamic_section;
7125 entry < dynamic_section + dynamic_nent;
7126 ++entry)
252b5132 7127 {
c8286bd1 7128 Elf_Internal_Shdr section;
252b5132
RH		 7129
7130 if (entry->d_tag != DT_SYMTAB)
7131 continue;
7132
7133 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7134
7135 /* Since we do not know how big the symbol table is,
7136 we default to reading in the entire file (!) and
7137 processing that. This is overkill, I know, but it
e3c8793a 7138 should work. */
d93f0186 7139 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 7140
fb52b2f4
NC		 7141 if (archive_file_offset != 0)
7142 section.sh_size = archive_file_size - section.sh_offset;
7143 else
7144 {
7145 if (fseek (file, 0, SEEK_END))
591a748a 7146 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 7147
7148 section.sh_size = ftell (file) - section.sh_offset;
7149 }
252b5132 7150
9ea033b2 7151 if (is_32bit_elf)
9ad5cbcf 7152 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 7153 else
9ad5cbcf 7154 section.sh_entsize = sizeof (Elf64_External_Sym);
252b5132 7155
9ad5cbcf 7156 num_dynamic_syms = section.sh_size / section.sh_entsize;
19936277 7157 if (num_dynamic_syms < 1)
252b5132
RH		 7158 {
7159 error (_("Unable to determine the number of symbols to load\n"));
7160 continue;
7161 }
7162
9ad5cbcf 7163 dynamic_symbols = GET_ELF_SYMBOLS (file, &section);
252b5132
RH		 7164 }
7165 }
7166
7167 /* Similarly find a string table. */
7168 if (dynamic_strings == NULL)
7169 {
86dba8ee
AM		 7170 for (entry = dynamic_section;
7171 entry < dynamic_section + dynamic_nent;
7172 ++entry)
252b5132
RH		 7173 {
7174 unsigned long offset;
b34976b6 7175 long str_tab_len;
252b5132
RH		 7176
7177 if (entry->d_tag != DT_STRTAB)
7178 continue;
7179
7180 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7181
7182 /* Since we do not know how big the string table is,
7183 we default to reading in the entire file (!) and
7184 processing that. This is overkill, I know, but it
e3c8793a 7185 should work. */
252b5132 7186
d93f0186 7187 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 7188
7189 if (archive_file_offset != 0)
7190 str_tab_len = archive_file_size - offset;
7191 else
7192 {
7193 if (fseek (file, 0, SEEK_END))
7194 error (_("Unable to seek to end of file\n"));
7195 str_tab_len = ftell (file) - offset;
7196 }
252b5132
RH		 7197
7198 if (str_tab_len < 1)
7199 {
7200 error
7201 (_("Unable to determine the length of the dynamic string table\n"));
7202 continue;
7203 }
7204
3f5e193b
NC		 7205 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7206 str_tab_len,
7207 _("dynamic string table"));
d79b3d50 7208 dynamic_strings_length = str_tab_len;
252b5132
RH		 7209 break;
7210 }
7211 }
7212
7213 /* And find the syminfo section if available. */
7214 if (dynamic_syminfo == NULL)
7215 {
3e8bba36 7216 unsigned long syminsz = 0;
252b5132 7217
86dba8ee
AM		 7218 for (entry = dynamic_section;
7219 entry < dynamic_section + dynamic_nent;
7220 ++entry)
252b5132
RH		 7221 {
7222 if (entry->d_tag == DT_SYMINENT)
7223 {
7224 /* Note: these braces are necessary to avoid a syntax
7225 error from the SunOS4 C compiler. */
7226 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7227 }
7228 else if (entry->d_tag == DT_SYMINSZ)
7229 syminsz = entry->d_un.d_val;
7230 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 7231 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7232 syminsz);
252b5132
RH		 7233 }
7234
7235 if (dynamic_syminfo_offset != 0 && syminsz != 0)
7236 {
2cf0635d
NC		 7237 Elf_External_Syminfo * extsyminfo;
7238 Elf_External_Syminfo * extsym;
7239 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 7240
7241 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 7242 extsyminfo = (Elf_External_Syminfo *)
7243 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
7244 _("symbol information"));
a6e9f9df
AM		 7245 if (!extsyminfo)
7246 return 0;
252b5132 7247
3f5e193b 7248 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 7249 if (dynamic_syminfo == NULL)
7250 {
7251 error (_("Out of memory\n"));
7252 return 0;
7253 }
7254
7255 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 7256 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
7257 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
7258 ++syminfo, ++extsym)
252b5132 7259 {
86dba8ee
AM		 7260 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
7261 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 7262 }
7263
7264 free (extsyminfo);
7265 }
7266 }
7267
7268 if (do_dynamic && dynamic_addr)
86dba8ee
AM		 7269 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7270 dynamic_addr, dynamic_nent);
252b5132
RH		 7271 if (do_dynamic)
7272 printf (_(" Tag Type Name/Value\n"));
7273
86dba8ee
AM		 7274 for (entry = dynamic_section;
7275 entry < dynamic_section + dynamic_nent;
7276 entry++)
252b5132
RH		 7277 {
7278 if (do_dynamic)
f7a99963 7279 {
2cf0635d 7280 const char * dtype;
e699b9ff 7281
f7a99963
NC		 7282 putchar (' ');
7283 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 7284 dtype = get_dynamic_type (entry->d_tag);
7285 printf (" (%s)%*s", dtype,
7286 ((is_32bit_elf ? 27 : 19)
7287 - (int) strlen (dtype)),
f7a99963
NC		 7288 " ");
7289 }
252b5132
RH		 7290
7291 switch (entry->d_tag)
7292 {
d1133906
NC		 7293 case DT_FLAGS:
7294 if (do_dynamic)
e9e44622 7295 print_dynamic_flags (entry->d_un.d_val);
d1133906 7296 break;
76da6bbe 7297
252b5132
RH		 7298 case DT_AUXILIARY:
7299 case DT_FILTER:
019148e4
L		 7300 case DT_CONFIG:
7301 case DT_DEPAUDIT:
7302 case DT_AUDIT:
252b5132
RH		 7303 if (do_dynamic)
7304 {
019148e4 7305 switch (entry->d_tag)
b34976b6 7306 {
019148e4
L		 7307 case DT_AUXILIARY:
7308 printf (_("Auxiliary library"));
7309 break;
7310
7311 case DT_FILTER:
7312 printf (_("Filter library"));
7313 break;
7314
b34976b6 7315 case DT_CONFIG:
019148e4
L		 7316 printf (_("Configuration file"));
7317 break;
7318
7319 case DT_DEPAUDIT:
7320 printf (_("Dependency audit library"));
7321 break;
7322
7323 case DT_AUDIT:
7324 printf (_("Audit library"));
7325 break;
7326 }
252b5132 7327
d79b3d50
NC		 7328 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7329 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 7330 else
f7a99963
NC		 7331 {
7332 printf (": ");
7333 print_vma (entry->d_un.d_val, PREFIX_HEX);
7334 putchar ('\n');
7335 }
252b5132
RH		 7336 }
7337 break;
7338
dcefbbbd 7339 case DT_FEATURE:
252b5132
RH		 7340 if (do_dynamic)
7341 {
7342 printf (_("Flags:"));
86f55779 7343
252b5132
RH		 7344 if (entry->d_un.d_val == 0)
7345 printf (_(" None\n"));
7346 else
7347 {
7348 unsigned long int val = entry->d_un.d_val;
86f55779 7349
252b5132
RH		 7350 if (val & DTF_1_PARINIT)
7351 {
7352 printf (" PARINIT");
7353 val ^= DTF_1_PARINIT;
7354 }
dcefbbbd
L		 7355 if (val & DTF_1_CONFEXP)
7356 {
7357 printf (" CONFEXP");
7358 val ^= DTF_1_CONFEXP;
7359 }
252b5132
RH		 7360 if (val != 0)
7361 printf (" %lx", val);
7362 puts ("");
7363 }
7364 }
7365 break;
7366
7367 case DT_POSFLAG_1:
7368 if (do_dynamic)
7369 {
7370 printf (_("Flags:"));
86f55779 7371
252b5132
RH		 7372 if (entry->d_un.d_val == 0)
7373 printf (_(" None\n"));
7374 else
7375 {
7376 unsigned long int val = entry->d_un.d_val;
86f55779 7377
252b5132
RH		 7378 if (val & DF_P1_LAZYLOAD)
7379 {
7380 printf (" LAZYLOAD");
7381 val ^= DF_P1_LAZYLOAD;
7382 }
7383 if (val & DF_P1_GROUPPERM)
7384 {
7385 printf (" GROUPPERM");
7386 val ^= DF_P1_GROUPPERM;
7387 }
7388 if (val != 0)
7389 printf (" %lx", val);
7390 puts ("");
7391 }
7392 }
7393 break;
7394
7395 case DT_FLAGS_1:
7396 if (do_dynamic)
7397 {
7398 printf (_("Flags:"));
7399 if (entry->d_un.d_val == 0)
7400 printf (_(" None\n"));
7401 else
7402 {
7403 unsigned long int val = entry->d_un.d_val;
86f55779 7404
252b5132
RH		 7405 if (val & DF_1_NOW)
7406 {
7407 printf (" NOW");
7408 val ^= DF_1_NOW;
7409 }
7410 if (val & DF_1_GLOBAL)
7411 {
7412 printf (" GLOBAL");
7413 val ^= DF_1_GLOBAL;
7414 }
7415 if (val & DF_1_GROUP)
7416 {
7417 printf (" GROUP");
7418 val ^= DF_1_GROUP;
7419 }
7420 if (val & DF_1_NODELETE)
7421 {
7422 printf (" NODELETE");
7423 val ^= DF_1_NODELETE;
7424 }
7425 if (val & DF_1_LOADFLTR)
7426 {
7427 printf (" LOADFLTR");
7428 val ^= DF_1_LOADFLTR;
7429 }
7430 if (val & DF_1_INITFIRST)
7431 {
7432 printf (" INITFIRST");
7433 val ^= DF_1_INITFIRST;
7434 }
7435 if (val & DF_1_NOOPEN)
7436 {
7437 printf (" NOOPEN");
7438 val ^= DF_1_NOOPEN;
7439 }
7440 if (val & DF_1_ORIGIN)
7441 {
7442 printf (" ORIGIN");
7443 val ^= DF_1_ORIGIN;
7444 }
7445 if (val & DF_1_DIRECT)
7446 {
7447 printf (" DIRECT");
7448 val ^= DF_1_DIRECT;
7449 }
7450 if (val & DF_1_TRANS)
7451 {
7452 printf (" TRANS");
7453 val ^= DF_1_TRANS;
7454 }
7455 if (val & DF_1_INTERPOSE)
7456 {
7457 printf (" INTERPOSE");
7458 val ^= DF_1_INTERPOSE;
7459 }
f7db6139 7460 if (val & DF_1_NODEFLIB)
dcefbbbd 7461 {
f7db6139
L		 7462 printf (" NODEFLIB");
7463 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 7464 }
7465 if (val & DF_1_NODUMP)
7466 {
7467 printf (" NODUMP");
7468 val ^= DF_1_NODUMP;
7469 }
7470 if (val & DF_1_CONLFAT)
7471 {
7472 printf (" CONLFAT");
7473 val ^= DF_1_CONLFAT;
7474 }
252b5132
RH		 7475 if (val != 0)
7476 printf (" %lx", val);
7477 puts ("");
7478 }
7479 }
7480 break;
7481
7482 case DT_PLTREL:
566b0d53 7483 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 7484 if (do_dynamic)
7485 puts (get_dynamic_type (entry->d_un.d_val));
7486 break;
7487
7488 case DT_NULL :
7489 case DT_NEEDED :
7490 case DT_PLTGOT :
7491 case DT_HASH :
7492 case DT_STRTAB :
7493 case DT_SYMTAB :
7494 case DT_RELA :
7495 case DT_INIT :
7496 case DT_FINI :
7497 case DT_SONAME :
7498 case DT_RPATH :
7499 case DT_SYMBOLIC:
7500 case DT_REL :
7501 case DT_DEBUG :
7502 case DT_TEXTREL :
7503 case DT_JMPREL :
019148e4 7504 case DT_RUNPATH :
252b5132
RH		 7505 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7506
7507 if (do_dynamic)
7508 {
2cf0635d 7509 char * name;
252b5132 7510
d79b3d50
NC		 7511 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7512 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 7513 else
d79b3d50 7514 name = NULL;
252b5132
RH		 7515
7516 if (name)
7517 {
7518 switch (entry->d_tag)
7519 {
7520 case DT_NEEDED:
7521 printf (_("Shared library: [%s]"), name);
7522
18bd398b 7523 if (streq (name, program_interpreter))
f7a99963 7524 printf (_(" program interpreter"));
252b5132
RH		 7525 break;
7526
7527 case DT_SONAME:
f7a99963 7528 printf (_("Library soname: [%s]"), name);
252b5132
RH		 7529 break;
7530
7531 case DT_RPATH:
f7a99963 7532 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 7533 break;
7534
019148e4
L		 7535 case DT_RUNPATH:
7536 printf (_("Library runpath: [%s]"), name);
7537 break;
7538
252b5132 7539 default:
f7a99963
NC		 7540 print_vma (entry->d_un.d_val, PREFIX_HEX);
7541 break;
252b5132
RH		 7542 }
7543 }
7544 else
f7a99963
NC		 7545 print_vma (entry->d_un.d_val, PREFIX_HEX);
7546
7547 putchar ('\n');
252b5132
RH		 7548 }
7549 break;
7550
7551 case DT_PLTRELSZ:
7552 case DT_RELASZ :
7553 case DT_STRSZ :
7554 case DT_RELSZ :
7555 case DT_RELAENT :
7556 case DT_SYMENT :
7557 case DT_RELENT :
566b0d53 7558 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 7559 case DT_PLTPADSZ:
7560 case DT_MOVEENT :
7561 case DT_MOVESZ :
7562 case DT_INIT_ARRAYSZ:
7563 case DT_FINI_ARRAYSZ:
047b2264
JJ		 7564 case DT_GNU_CONFLICTSZ:
7565 case DT_GNU_LIBLISTSZ:
252b5132 7566 if (do_dynamic)
f7a99963
NC		 7567 {
7568 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 7569 printf (_(" (bytes)\n"));
f7a99963 7570 }
252b5132
RH		 7571 break;
7572
7573 case DT_VERDEFNUM:
7574 case DT_VERNEEDNUM:
7575 case DT_RELACOUNT:
7576 case DT_RELCOUNT:
7577 if (do_dynamic)
f7a99963
NC		 7578 {
7579 print_vma (entry->d_un.d_val, UNSIGNED);
7580 putchar ('\n');
7581 }
252b5132
RH		 7582 break;
7583
7584 case DT_SYMINSZ:
7585 case DT_SYMINENT:
7586 case DT_SYMINFO:
7587 case DT_USED:
7588 case DT_INIT_ARRAY:
7589 case DT_FINI_ARRAY:
7590 if (do_dynamic)
7591 {
d79b3d50
NC		 7592 if (entry->d_tag == DT_USED
7593 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 7594 {
2cf0635d 7595 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 7596
b34976b6 7597 if (*name)
252b5132
RH		 7598 {
7599 printf (_("Not needed object: [%s]\n"), name);
7600 break;
7601 }
7602 }
103f02d3 7603
f7a99963
NC		 7604 print_vma (entry->d_un.d_val, PREFIX_HEX);
7605 putchar ('\n');
252b5132
RH		 7606 }
7607 break;
7608
7609 case DT_BIND_NOW:
7610 /* The value of this entry is ignored. */
35b1837e
AM		 7611 if (do_dynamic)
7612 putchar ('\n');
252b5132 7613 break;
103f02d3 7614
047b2264
JJ		 7615 case DT_GNU_PRELINKED:
7616 if (do_dynamic)
7617 {
2cf0635d 7618 struct tm * tmp;
91d6fa6a 7619 time_t atime = entry->d_un.d_val;
047b2264 7620
91d6fa6a 7621 tmp = gmtime (&atime);
047b2264
JJ		 7622 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
7623 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7624 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7625
7626 }
7627 break;
7628
fdc90cb4
JJ		 7629 case DT_GNU_HASH:
7630 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
7631 if (do_dynamic)
7632 {
7633 print_vma (entry->d_un.d_val, PREFIX_HEX);
7634 putchar ('\n');
7635 }
7636 break;
7637
252b5132
RH		 7638 default:
7639 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 7640 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 7641 entry->d_un.d_val;
7642
7643 if (do_dynamic)
7644 {
7645 switch (elf_header.e_machine)
7646 {
7647 case EM_MIPS:
4fe85591 7648 case EM_MIPS_RS3_LE:
b2d38a17 7649 dynamic_section_mips_val (entry);
252b5132 7650 break;
103f02d3 7651 case EM_PARISC:
b2d38a17 7652 dynamic_section_parisc_val (entry);
103f02d3 7653 break;
ecc51f48 7654 case EM_IA_64:
b2d38a17 7655 dynamic_section_ia64_val (entry);
ecc51f48 7656 break;
252b5132 7657 default:
f7a99963
NC		 7658 print_vma (entry->d_un.d_val, PREFIX_HEX);
7659 putchar ('\n');
252b5132
RH		 7660 }
7661 }
7662 break;
7663 }
7664 }
7665
7666 return 1;
7667}
7668
7669static char *
d3ba0551 7670get_ver_flags (unsigned int flags)
252b5132 7671{
b34976b6 7672 static char buff[32];
252b5132
RH		 7673
7674 buff[0] = 0;
7675
7676 if (flags == 0)
7677 return _("none");
7678
7679 if (flags & VER_FLG_BASE)
7680 strcat (buff, "BASE ");
7681
7682 if (flags & VER_FLG_WEAK)
7683 {
7684 if (flags & VER_FLG_BASE)
7685 strcat (buff, "| ");
7686
7687 strcat (buff, "WEAK ");
7688 }
7689
44ec90b9
RO		 7690 if (flags & VER_FLG_INFO)
7691 {
7692 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
7693 strcat (buff, "| ");
7694
7695 strcat (buff, "INFO ");
7696 }
7697
7698 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 7699 strcat (buff, _("| <unknown>"));
252b5132
RH		 7700
7701 return buff;
7702}
7703
7704/* Display the contents of the version sections. */
98fb390a 7705
252b5132 7706static int
2cf0635d 7707process_version_sections (FILE * file)
252b5132 7708{
2cf0635d 7709 Elf_Internal_Shdr * section;
b34976b6
AM		 7710 unsigned i;
7711 int found = 0;
252b5132
RH		 7712
7713 if (! do_version)
7714 return 1;
7715
7716 for (i = 0, section = section_headers;
7717 i < elf_header.e_shnum;
b34976b6 7718 i++, section++)
252b5132
RH		 7719 {
7720 switch (section->sh_type)
7721 {
7722 case SHT_GNU_verdef:
7723 {
2cf0635d 7724 Elf_External_Verdef * edefs;
b34976b6
AM		 7725 unsigned int idx;
7726 unsigned int cnt;
2cf0635d 7727 char * endbuf;
252b5132
RH		 7728
7729 found = 1;
7730
7731 printf
72de5009 7732 (_("\nVersion definition section '%s' contains %u entries:\n"),
252b5132
RH		 7733 SECTION_NAME (section), section->sh_info);
7734
7735 printf (_(" Addr: 0x"));
7736 printf_vma (section->sh_addr);
72de5009 7737 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 7738 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 7739 section->sh_link < elf_header.e_shnum
7740 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 7741 : _("<corrupt>"));
252b5132 7742
3f5e193b
NC		 7743 edefs = (Elf_External_Verdef *)
7744 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
7745 _("version definition section"));
54806181 7746 endbuf = (char *) edefs + section->sh_size;
a6e9f9df
AM		 7747 if (!edefs)
7748 break;
252b5132 7749
b34976b6 7750 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 7751 {
2cf0635d
NC		 7752 char * vstart;
7753 Elf_External_Verdef * edef;
b34976b6 7754 Elf_Internal_Verdef ent;
2cf0635d 7755 Elf_External_Verdaux * eaux;
b34976b6
AM		 7756 Elf_Internal_Verdaux aux;
7757 int j;
7758 int isum;
103f02d3 7759
252b5132 7760 vstart = ((char *) edefs) + idx;
54806181
AM		 7761 if (vstart + sizeof (*edef) > endbuf)
7762 break;
252b5132
RH		 7763
7764 edef = (Elf_External_Verdef *) vstart;
7765
7766 ent.vd_version = BYTE_GET (edef->vd_version);
7767 ent.vd_flags = BYTE_GET (edef->vd_flags);
7768 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
7769 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
7770 ent.vd_hash = BYTE_GET (edef->vd_hash);
7771 ent.vd_aux = BYTE_GET (edef->vd_aux);
7772 ent.vd_next = BYTE_GET (edef->vd_next);
7773
7774 printf (_(" %#06x: Rev: %d Flags: %s"),
7775 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
7776
7777 printf (_(" Index: %d Cnt: %d "),
7778 ent.vd_ndx, ent.vd_cnt);
7779
7780 vstart += ent.vd_aux;
7781
7782 eaux = (Elf_External_Verdaux *) vstart;
7783
7784 aux.vda_name = BYTE_GET (eaux->vda_name);
7785 aux.vda_next = BYTE_GET (eaux->vda_next);
7786
d79b3d50
NC		 7787 if (VALID_DYNAMIC_NAME (aux.vda_name))
7788 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 7789 else
7790 printf (_("Name index: %ld\n"), aux.vda_name);
7791
7792 isum = idx + ent.vd_aux;
7793
b34976b6 7794 for (j = 1; j < ent.vd_cnt; j++)
252b5132
RH		 7795 {
7796 isum += aux.vda_next;
7797 vstart += aux.vda_next;
7798
7799 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 7800 if (vstart + sizeof (*eaux) > endbuf)
7801 break;
252b5132
RH		 7802
7803 aux.vda_name = BYTE_GET (eaux->vda_name);
7804 aux.vda_next = BYTE_GET (eaux->vda_next);
7805
d79b3d50 7806 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 7807 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 7808 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 7809 else
7810 printf (_(" %#06x: Parent %d, name index: %ld\n"),
7811 isum, j, aux.vda_name);
7812 }
54806181
AM		 7813 if (j < ent.vd_cnt)
7814 printf (_(" Version def aux past end of section\n"));
252b5132
RH		 7815
7816 idx += ent.vd_next;
7817 }
54806181
AM		 7818 if (cnt < section->sh_info)
7819 printf (_(" Version definition past end of section\n"));
252b5132
RH		 7820
7821 free (edefs);
7822 }
7823 break;
103f02d3 7824
252b5132
RH		 7825 case SHT_GNU_verneed:
7826 {
2cf0635d 7827 Elf_External_Verneed * eneed;
b34976b6
AM		 7828 unsigned int idx;
7829 unsigned int cnt;
2cf0635d 7830 char * endbuf;
252b5132
RH		 7831
7832 found = 1;
7833
72de5009 7834 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
252b5132
RH		 7835 SECTION_NAME (section), section->sh_info);
7836
7837 printf (_(" Addr: 0x"));
7838 printf_vma (section->sh_addr);
72de5009 7839 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 7840 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 7841 section->sh_link < elf_header.e_shnum
7842 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 7843 : _("<corrupt>"));
252b5132 7844
3f5e193b
NC		 7845 eneed = (Elf_External_Verneed *) get_data (NULL, file,
7846 section->sh_offset, 1,
7847 section->sh_size,
7848 _("version need section"));
54806181 7849 endbuf = (char *) eneed + section->sh_size;
a6e9f9df
AM		 7850 if (!eneed)
7851 break;
252b5132
RH		 7852
7853 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
7854 {
2cf0635d 7855 Elf_External_Verneed * entry;
b34976b6
AM		 7856 Elf_Internal_Verneed ent;
7857 int j;
7858 int isum;
2cf0635d 7859 char * vstart;
252b5132
RH		 7860
7861 vstart = ((char *) eneed) + idx;
54806181
AM		 7862 if (vstart + sizeof (*entry) > endbuf)
7863 break;
252b5132
RH		 7864
7865 entry = (Elf_External_Verneed *) vstart;
7866
7867 ent.vn_version = BYTE_GET (entry->vn_version);
7868 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
7869 ent.vn_file = BYTE_GET (entry->vn_file);
7870 ent.vn_aux = BYTE_GET (entry->vn_aux);
7871 ent.vn_next = BYTE_GET (entry->vn_next);
7872
7873 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
7874
d79b3d50
NC		 7875 if (VALID_DYNAMIC_NAME (ent.vn_file))
7876 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 7877 else
7878 printf (_(" File: %lx"), ent.vn_file);
7879
7880 printf (_(" Cnt: %d\n"), ent.vn_cnt);
7881
7882 vstart += ent.vn_aux;
7883
7884 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
7885 {
2cf0635d 7886 Elf_External_Vernaux * eaux;
b34976b6 7887 Elf_Internal_Vernaux aux;
252b5132 7888
54806181
AM		 7889 if (vstart + sizeof (*eaux) > endbuf)
7890 break;
252b5132
RH		 7891 eaux = (Elf_External_Vernaux *) vstart;
7892
7893 aux.vna_hash = BYTE_GET (eaux->vna_hash);
7894 aux.vna_flags = BYTE_GET (eaux->vna_flags);
7895 aux.vna_other = BYTE_GET (eaux->vna_other);
7896 aux.vna_name = BYTE_GET (eaux->vna_name);
7897 aux.vna_next = BYTE_GET (eaux->vna_next);
7898
d79b3d50 7899 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 7900 printf (_(" %#06x: Name: %s"),
d79b3d50 7901 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 7902 else
ecc2063b 7903 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 7904 isum, aux.vna_name);
7905
7906 printf (_(" Flags: %s Version: %d\n"),
7907 get_ver_flags (aux.vna_flags), aux.vna_other);
7908
7909 isum += aux.vna_next;
7910 vstart += aux.vna_next;
7911 }
54806181
AM		 7912 if (j < ent.vn_cnt)
7913 printf (_(" Version need aux past end of section\n"));
252b5132
RH		 7914
7915 idx += ent.vn_next;
7916 }
54806181
AM		 7917 if (cnt < section->sh_info)
7918 printf (_(" Version need past end of section\n"));
103f02d3 7919
252b5132
RH		 7920 free (eneed);
7921 }
7922 break;
7923
7924 case SHT_GNU_versym:
7925 {
2cf0635d 7926 Elf_Internal_Shdr * link_section;
b34976b6
AM		 7927 int total;
7928 int cnt;
2cf0635d
NC		 7929 unsigned char * edata;
7930 unsigned short * data;
7931 char * strtab;
7932 Elf_Internal_Sym * symbols;
7933 Elf_Internal_Shdr * string_sec;
d3ba0551 7934 long off;
252b5132 7935
4fbb74a6 7936 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 7937 break;
7938
4fbb74a6 7939 link_section = section_headers + section->sh_link;
08d8fa11 7940 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 7941
4fbb74a6 7942 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 7943 break;
7944
252b5132
RH		 7945 found = 1;
7946
9ad5cbcf 7947 symbols = GET_ELF_SYMBOLS (file, link_section);
252b5132 7948
4fbb74a6 7949 string_sec = section_headers + link_section->sh_link;
252b5132 7950
3f5e193b
NC		 7951 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
7952 string_sec->sh_size,
7953 _("version string table"));
a6e9f9df
AM		 7954 if (!strtab)
7955 break;
252b5132
RH		 7956
7957 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
7958 SECTION_NAME (section), total);
7959
7960 printf (_(" Addr: "));
7961 printf_vma (section->sh_addr);
72de5009 7962 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 7963 (unsigned long) section->sh_offset, section->sh_link,
252b5132
RH		 7964 SECTION_NAME (link_section));
7965
d3ba0551
AM		 7966 off = offset_from_vma (file,
7967 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
7968 total * sizeof (short));
3f5e193b
NC		 7969 edata = (unsigned char *) get_data (NULL, file, off, total,
7970 sizeof (short),
7971 _("version symbol data"));
a6e9f9df
AM		 7972 if (!edata)
7973 {
7974 free (strtab);
7975 break;
7976 }
252b5132 7977
3f5e193b 7978 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 7979
7980 for (cnt = total; cnt --;)
b34976b6
AM		 7981 data[cnt] = byte_get (edata + cnt * sizeof (short),
7982 sizeof (short));
252b5132
RH		 7983
7984 free (edata);
7985
7986 for (cnt = 0; cnt < total; cnt += 4)
7987 {
7988 int j, nn;
00d93f34 7989 int check_def, check_need;
2cf0635d 7990 char * name;
252b5132
RH		 7991
7992 printf (" %03x:", cnt);
7993
7994 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 7995 switch (data[cnt + j])
252b5132
RH		 7996 {
7997 case 0:
7998 fputs (_(" 0 (*local*) "), stdout);
7999 break;
8000
8001 case 1:
8002 fputs (_(" 1 (*global*) "), stdout);
8003 break;
8004
8005 default:
c244d050
NC		 8006 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8007 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 8008
00d93f34
JJ		 8009 check_def = 1;
8010 check_need = 1;
4fbb74a6
AM		 8011 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8012 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 8013 != SHT_NOBITS)
252b5132 8014 {
b34976b6 8015 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 8016 check_def = 0;
8017 else
8018 check_need = 0;
252b5132 8019 }
00d93f34
JJ		 8020
8021 if (check_need
b34976b6 8022 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 8023 {
b34976b6
AM		 8024 Elf_Internal_Verneed ivn;
8025 unsigned long offset;
252b5132 8026
d93f0186
NC		 8027 offset = offset_from_vma
8028 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8029 sizeof (Elf_External_Verneed));
252b5132 8030
b34976b6 8031 do
252b5132 8032 {
b34976b6
AM		 8033 Elf_Internal_Vernaux ivna;
8034 Elf_External_Verneed evn;
8035 Elf_External_Vernaux evna;
8036 unsigned long a_off;
252b5132 8037
c256ffe7 8038 get_data (&evn, file, offset, sizeof (evn), 1,
a6e9f9df 8039 _("version need"));
252b5132
RH		 8040
8041 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8042 ivn.vn_next = BYTE_GET (evn.vn_next);
8043
8044 a_off = offset + ivn.vn_aux;
8045
8046 do
8047 {
a6e9f9df 8048 get_data (&evna, file, a_off, sizeof (evna),
c256ffe7 8049 1, _("version need aux (2)"));
252b5132
RH		 8050
8051 ivna.vna_next = BYTE_GET (evna.vna_next);
8052 ivna.vna_other = BYTE_GET (evna.vna_other);
8053
8054 a_off += ivna.vna_next;
8055 }
b34976b6 8056 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 8057 && ivna.vna_next != 0);
8058
b34976b6 8059 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 8060 {
8061 ivna.vna_name = BYTE_GET (evna.vna_name);
8062
54806181
AM		 8063 if (ivna.vna_name >= string_sec->sh_size)
8064 name = _("*invalid*");
8065 else
8066 name = strtab + ivna.vna_name;
252b5132 8067 nn += printf ("(%s%-*s",
16062207
ILT		 8068 name,
8069 12 - (int) strlen (name),
252b5132 8070 ")");
00d93f34 8071 check_def = 0;
252b5132
RH		 8072 break;
8073 }
8074
8075 offset += ivn.vn_next;
8076 }
8077 while (ivn.vn_next);
8078 }
00d93f34 8079
b34976b6
AM		 8080 if (check_def && data[cnt + j] != 0x8001
8081 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 8082 {
b34976b6
AM		 8083 Elf_Internal_Verdef ivd;
8084 Elf_External_Verdef evd;
8085 unsigned long offset;
252b5132 8086
d93f0186
NC		 8087 offset = offset_from_vma
8088 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8089 sizeof evd);
252b5132
RH		 8090
8091 do
8092 {
c256ffe7 8093 get_data (&evd, file, offset, sizeof (evd), 1,
a6e9f9df 8094 _("version def"));
252b5132
RH		 8095
8096 ivd.vd_next = BYTE_GET (evd.vd_next);
8097 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8098
8099 offset += ivd.vd_next;
8100 }
c244d050 8101 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 8102 && ivd.vd_next != 0);
8103
c244d050 8104 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 8105 {
b34976b6
AM		 8106 Elf_External_Verdaux evda;
8107 Elf_Internal_Verdaux ivda;
252b5132
RH		 8108
8109 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8110
a6e9f9df
AM		 8111 get_data (&evda, file,
8112 offset - ivd.vd_next + ivd.vd_aux,
c256ffe7
JJ		 8113 sizeof (evda), 1,
8114 _("version def aux"));
252b5132
RH		 8115
8116 ivda.vda_name = BYTE_GET (evda.vda_name);
8117
54806181
AM		 8118 if (ivda.vda_name >= string_sec->sh_size)
8119 name = _("*invalid*");
8120 else
8121 name = strtab + ivda.vda_name;
252b5132 8122 nn += printf ("(%s%-*s",
16062207
ILT		 8123 name,
8124 12 - (int) strlen (name),
252b5132
RH		 8125 ")");
8126 }
8127 }
8128
8129 if (nn < 18)
8130 printf ("%*c", 18 - nn, ' ');
8131 }
8132
8133 putchar ('\n');
8134 }
8135
8136 free (data);
8137 free (strtab);
8138 free (symbols);
8139 }
8140 break;
103f02d3 8141
252b5132
RH		 8142 default:
8143 break;
8144 }
8145 }
8146
8147 if (! found)
8148 printf (_("\nNo version information found in this file.\n"));
8149
8150 return 1;
8151}
8152
d1133906 8153static const char *
d3ba0551 8154get_symbol_binding (unsigned int binding)
252b5132 8155{
b34976b6 8156 static char buff[32];
252b5132
RH		 8157
8158 switch (binding)
8159 {
b34976b6
AM		 8160 case STB_LOCAL: return "LOCAL";
8161 case STB_GLOBAL: return "GLOBAL";
8162 case STB_WEAK: return "WEAK";
252b5132
RH		 8163 default:
8164 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 8165 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
8166 binding);
252b5132 8167 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 8168 {
8169 if (binding == STB_GNU_UNIQUE
8170 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
8171 /* GNU/Linux is still using the default value 0. */
8172 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8173 return "UNIQUE";
8174 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
8175 }
252b5132 8176 else
e9e44622 8177 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 8178 return buff;
8179 }
8180}
8181
d1133906 8182static const char *
d3ba0551 8183get_symbol_type (unsigned int type)
252b5132 8184{
b34976b6 8185 static char buff[32];
252b5132
RH		 8186
8187 switch (type)
8188 {
b34976b6
AM		 8189 case STT_NOTYPE: return "NOTYPE";
8190 case STT_OBJECT: return "OBJECT";
8191 case STT_FUNC: return "FUNC";
8192 case STT_SECTION: return "SECTION";
8193 case STT_FILE: return "FILE";
8194 case STT_COMMON: return "COMMON";
8195 case STT_TLS: return "TLS";
15ab5209
DB		 8196 case STT_RELC: return "RELC";
8197 case STT_SRELC: return "SRELC";
252b5132
RH		 8198 default:
8199 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af
NC		 8200 {
8201 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
103f02d3
UD		 8202 return "THUMB_FUNC";
8203
351b4b40 8204 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 8205 return "REGISTER";
8206
8207 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
8208 return "PARISC_MILLI";
8209
e9e44622 8210 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 8211 }
252b5132 8212 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 8213 {
8214 if (elf_header.e_machine == EM_PARISC)
8215 {
8216 if (type == STT_HP_OPAQUE)
8217 return "HP_OPAQUE";
8218 if (type == STT_HP_STUB)
8219 return "HP_STUB";
8220 }
8221
d8045f23
NC		 8222 if (type == STT_GNU_IFUNC
8223 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
8224 /* GNU/Linux is still using the default value 0. */
8225 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8226 return "IFUNC";
8227
e9e44622 8228 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 8229 }
252b5132 8230 else
e9e44622 8231 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 8232 return buff;
8233 }
8234}
8235
d1133906 8236static const char *
d3ba0551 8237get_symbol_visibility (unsigned int visibility)
d1133906
NC		 8238{
8239 switch (visibility)
8240 {
b34976b6
AM		 8241 case STV_DEFAULT: return "DEFAULT";
8242 case STV_INTERNAL: return "INTERNAL";
8243 case STV_HIDDEN: return "HIDDEN";
d1133906
NC		 8244 case STV_PROTECTED: return "PROTECTED";
8245 default: abort ();
8246 }
8247}
8248
5e2b0d47
NC		 8249static const char *
8250get_mips_symbol_other (unsigned int other)
8251{
8252 switch (other)
8253 {
8254 case STO_OPTIONAL: return "OPTIONAL";
8255 case STO_MIPS16: return "MIPS16";
861fb55a
DJ		 8256 case STO_MIPS_PLT: return "MIPS PLT";
8257 case STO_MIPS_PIC: return "MIPS PIC";
5e2b0d47
NC		 8258 default: return NULL;
8259 }
8260}
8261
28f997cf
TG		 8262static const char *
8263get_ia64_symbol_other (unsigned int other)
8264{
8265 if (is_ia64_vms ())
8266 {
8267 static char res[32];
8268
8269 res[0] = 0;
8270
8271 /* Function types is for images and .STB files only. */
8272 switch (elf_header.e_type)
8273 {
8274 case ET_DYN:
8275 case ET_EXEC:
8276 switch (VMS_ST_FUNC_TYPE (other))
8277 {
8278 case VMS_SFT_CODE_ADDR:
8279 strcat (res, " CA");
8280 break;
8281 case VMS_SFT_SYMV_IDX:
8282 strcat (res, " VEC");
8283 break;
8284 case VMS_SFT_FD:
8285 strcat (res, " FD");
8286 break;
8287 case VMS_SFT_RESERVE:
8288 strcat (res, " RSV");
8289 break;
8290 default:
8291 abort ();
8292 }
8293 break;
8294 default:
8295 break;
8296 }
8297 switch (VMS_ST_LINKAGE (other))
8298 {
8299 case VMS_STL_IGNORE:
8300 strcat (res, " IGN");
8301 break;
8302 case VMS_STL_RESERVE:
8303 strcat (res, " RSV");
8304 break;
8305 case VMS_STL_STD:
8306 strcat (res, " STD");
8307 break;
8308 case VMS_STL_LNK:
8309 strcat (res, " LNK");
8310 break;
8311 default:
8312 abort ();
8313 }
8314
8315 if (res[0] != 0)
8316 return res + 1;
8317 else
8318 return res;
8319 }
8320 return NULL;
8321}
8322
5e2b0d47
NC		 8323static const char *
8324get_symbol_other (unsigned int other)
8325{
8326 const char * result = NULL;
8327 static char buff [32];
8328
8329 if (other == 0)
8330 return "";
8331
8332 switch (elf_header.e_machine)
8333 {
8334 case EM_MIPS:
8335 result = get_mips_symbol_other (other);
28f997cf
TG		 8336 break;
8337 case EM_IA_64:
8338 result = get_ia64_symbol_other (other);
8339 break;
5e2b0d47
NC		 8340 default:
8341 break;
8342 }
8343
8344 if (result)
8345 return result;
8346
8347 snprintf (buff, sizeof buff, _("<other>: %x"), other);
8348 return buff;
8349}
8350
d1133906 8351static const char *
d3ba0551 8352get_symbol_index_type (unsigned int type)
252b5132 8353{
b34976b6 8354 static char buff[32];
5cf1065c 8355
252b5132
RH		 8356 switch (type)
8357 {
b34976b6
AM		 8358 case SHN_UNDEF: return "UND";
8359 case SHN_ABS: return "ABS";
8360 case SHN_COMMON: return "COM";
252b5132 8361 default:
9ce701e2
L		 8362 if (type == SHN_IA_64_ANSI_COMMON
8363 && elf_header.e_machine == EM_IA_64
8364 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
8365 return "ANSI_COM";
8a9036a4
L		 8366 else if ((elf_header.e_machine == EM_X86_64
8367 || elf_header.e_machine == EM_L1OM)
3b22753a
L		 8368 && type == SHN_X86_64_LCOMMON)
8369 return "LARGE_COM";
172553c7
TS		 8370 else if (type == SHN_MIPS_SCOMMON
8371 && elf_header.e_machine == EM_MIPS)
8372 return "SCOM";
8373 else if (type == SHN_MIPS_SUNDEFINED
8374 && elf_header.e_machine == EM_MIPS)
8375 return "SUND";
9ce701e2 8376 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 8377 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 8378 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 8379 sprintf (buff, "OS [0x%04x]", type & 0xffff);
8380 else if (type >= SHN_LORESERVE)
8381 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
252b5132 8382 else
232e7cb8 8383 sprintf (buff, "%3d", type);
5cf1065c 8384 break;
252b5132 8385 }
5cf1065c
NC		 8386
8387 return buff;
252b5132
RH		 8388}
8389
66543521 8390static bfd_vma *
2cf0635d 8391get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
252b5132 8392{
2cf0635d
NC		 8393 unsigned char * e_data;
8394 bfd_vma * i_data;
252b5132 8395
3f5e193b 8396 e_data = (unsigned char *) cmalloc (number, ent_size);
252b5132
RH		 8397
8398 if (e_data == NULL)
8399 {
8400 error (_("Out of memory\n"));
8401 return NULL;
8402 }
8403
66543521 8404 if (fread (e_data, ent_size, number, file) != number)
252b5132
RH		 8405 {
8406 error (_("Unable to read in dynamic data\n"));
8407 return NULL;
8408 }
8409
3f5e193b 8410 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
252b5132
RH		 8411
8412 if (i_data == NULL)
8413 {
8414 error (_("Out of memory\n"));
8415 free (e_data);
8416 return NULL;
8417 }
8418
8419 while (number--)
66543521 8420 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 8421
8422 free (e_data);
8423
8424 return i_data;
8425}
8426
6bd1a22c
L		 8427static void
8428print_dynamic_symbol (bfd_vma si, unsigned long hn)
8429{
2cf0635d 8430 Elf_Internal_Sym * psym;
6bd1a22c
L		 8431 int n;
8432
8433 psym = dynamic_symbols + si;
8434
8435 n = print_vma (si, DEC_5);
8436 if (n < 5)
8437 fputs (" " + n, stdout);
8438 printf (" %3lu: ", hn);
8439 print_vma (psym->st_value, LONG_HEX);
8440 putchar (' ');
8441 print_vma (psym->st_size, DEC_5);
8442
f4be36b3
AM		 8443 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
8444 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
8445 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 8446 /* Check to see if any other bits in the st_other field are set.
8447 Note - displaying this information disrupts the layout of the
8448 table being generated, but for the moment this case is very
8449 rare. */
8450 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
8451 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
8452 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
8453 if (VALID_DYNAMIC_NAME (psym->st_name))
8454 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
8455 else
2b692964 8456 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 8457 putchar ('\n');
8458}
8459
e3c8793a 8460/* Dump the symbol table. */
252b5132 8461static int
2cf0635d 8462process_symbol_table (FILE * file)
252b5132 8463{
2cf0635d 8464 Elf_Internal_Shdr * section;
66543521
AM		 8465 bfd_vma nbuckets = 0;
8466 bfd_vma nchains = 0;
2cf0635d
NC		 8467 bfd_vma * buckets = NULL;
8468 bfd_vma * chains = NULL;
fdc90cb4 8469 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 8470 bfd_vma * gnubuckets = NULL;
8471 bfd_vma * gnuchains = NULL;
6bd1a22c 8472 bfd_vma gnusymidx = 0;
252b5132 8473
2c610e4b 8474 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 8475 return 1;
8476
6bd1a22c
L		 8477 if (dynamic_info[DT_HASH]
8478 && (do_histogram
2c610e4b
L		 8479 || (do_using_dynamic
8480 && !do_dyn_syms
8481 && dynamic_strings != NULL)))
252b5132 8482 {
66543521
AM		 8483 unsigned char nb[8];
8484 unsigned char nc[8];
8485 int hash_ent_size = 4;
8486
8487 if ((elf_header.e_machine == EM_ALPHA
8488 || elf_header.e_machine == EM_S390
8489 || elf_header.e_machine == EM_S390_OLD)
8490 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
8491 hash_ent_size = 8;
8492
fb52b2f4
NC		 8493 if (fseek (file,
8494 (archive_file_offset
8495 + offset_from_vma (file, dynamic_info[DT_HASH],
8496 sizeof nb + sizeof nc)),
d93f0186 8497 SEEK_SET))
252b5132 8498 {
591a748a 8499 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 8500 goto no_hash;
252b5132
RH		 8501 }
8502
66543521 8503 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 8504 {
8505 error (_("Failed to read in number of buckets\n"));
d3a44ec6 8506 goto no_hash;
252b5132
RH		 8507 }
8508
66543521 8509 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 8510 {
8511 error (_("Failed to read in number of chains\n"));
d3a44ec6 8512 goto no_hash;
252b5132
RH		 8513 }
8514
66543521
AM		 8515 nbuckets = byte_get (nb, hash_ent_size);
8516 nchains = byte_get (nc, hash_ent_size);
252b5132 8517
66543521
AM		 8518 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
8519 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 8520
d3a44ec6 8521 no_hash:
252b5132 8522 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 8523 {
8524 if (do_using_dynamic)
8525 return 0;
8526 free (buckets);
8527 free (chains);
8528 buckets = NULL;
8529 chains = NULL;
8530 nbuckets = 0;
8531 nchains = 0;
8532 }
252b5132
RH		 8533 }
8534
6bd1a22c
L		 8535 if (dynamic_info_DT_GNU_HASH
8536 && (do_histogram
2c610e4b
L		 8537 || (do_using_dynamic
8538 && !do_dyn_syms
8539 && dynamic_strings != NULL)))
252b5132 8540 {
6bd1a22c
L		 8541 unsigned char nb[16];
8542 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
8543 bfd_vma buckets_vma;
8544
8545 if (fseek (file,
8546 (archive_file_offset
8547 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
8548 sizeof nb)),
8549 SEEK_SET))
8550 {
8551 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 8552 goto no_gnu_hash;
6bd1a22c 8553 }
252b5132 8554
6bd1a22c
L		 8555 if (fread (nb, 16, 1, file) != 1)
8556 {
8557 error (_("Failed to read in number of buckets\n"));
d3a44ec6 8558 goto no_gnu_hash;
6bd1a22c
L		 8559 }
8560
8561 ngnubuckets = byte_get (nb, 4);
8562 gnusymidx = byte_get (nb + 4, 4);
8563 bitmaskwords = byte_get (nb + 8, 4);
8564 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 8565 if (is_32bit_elf)
6bd1a22c 8566 buckets_vma += bitmaskwords * 4;
f7a99963 8567 else
6bd1a22c 8568 buckets_vma += bitmaskwords * 8;
252b5132 8569
6bd1a22c
L		 8570 if (fseek (file,
8571 (archive_file_offset
8572 + offset_from_vma (file, buckets_vma, 4)),
8573 SEEK_SET))
252b5132 8574 {
6bd1a22c 8575 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 8576 goto no_gnu_hash;
6bd1a22c
L		 8577 }
8578
8579 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 8580
6bd1a22c 8581 if (gnubuckets == NULL)
d3a44ec6 8582 goto no_gnu_hash;
6bd1a22c
L		 8583
8584 for (i = 0; i < ngnubuckets; i++)
8585 if (gnubuckets[i] != 0)
8586 {
8587 if (gnubuckets[i] < gnusymidx)
8588 return 0;
8589
8590 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
8591 maxchain = gnubuckets[i];
8592 }
8593
8594 if (maxchain == 0xffffffff)
d3a44ec6 8595 goto no_gnu_hash;
6bd1a22c
L		 8596
8597 maxchain -= gnusymidx;
8598
8599 if (fseek (file,
8600 (archive_file_offset
8601 + offset_from_vma (file, buckets_vma
8602 + 4 * (ngnubuckets + maxchain), 4)),
8603 SEEK_SET))
8604 {
8605 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 8606 goto no_gnu_hash;
6bd1a22c
L		 8607 }
8608
8609 do
8610 {
8611 if (fread (nb, 4, 1, file) != 1)
252b5132 8612 {
6bd1a22c 8613 error (_("Failed to determine last chain length\n"));
d3a44ec6 8614 goto no_gnu_hash;
6bd1a22c 8615 }
252b5132 8616
6bd1a22c 8617 if (maxchain + 1 == 0)
d3a44ec6 8618 goto no_gnu_hash;
252b5132 8619
6bd1a22c
L		 8620 ++maxchain;
8621 }
8622 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 8623
6bd1a22c
L		 8624 if (fseek (file,
8625 (archive_file_offset
8626 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
8627 SEEK_SET))
8628 {
8629 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 8630 goto no_gnu_hash;
6bd1a22c
L		 8631 }
8632
8633 gnuchains = get_dynamic_data (file, maxchain, 4);
8634
d3a44ec6 8635 no_gnu_hash:
6bd1a22c 8636 if (gnuchains == NULL)
d3a44ec6
JJ		 8637 {
8638 free (gnubuckets);
d3a44ec6
JJ		 8639 gnubuckets = NULL;
8640 ngnubuckets = 0;
f64fddf1
NC		 8641 if (do_using_dynamic)
8642 return 0;
d3a44ec6 8643 }
6bd1a22c
L		 8644 }
8645
8646 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
8647 && do_syms
8648 && do_using_dynamic
8649 && dynamic_strings != NULL)
8650 {
8651 unsigned long hn;
8652
8653 if (dynamic_info[DT_HASH])
8654 {
8655 bfd_vma si;
8656
8657 printf (_("\nSymbol table for image:\n"));
8658 if (is_32bit_elf)
8659 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8660 else
8661 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8662
8663 for (hn = 0; hn < nbuckets; hn++)
8664 {
8665 if (! buckets[hn])
8666 continue;
8667
8668 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
8669 print_dynamic_symbol (si, hn);
252b5132
RH		 8670 }
8671 }
6bd1a22c
L		 8672
8673 if (dynamic_info_DT_GNU_HASH)
8674 {
8675 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
8676 if (is_32bit_elf)
8677 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8678 else
8679 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8680
8681 for (hn = 0; hn < ngnubuckets; ++hn)
8682 if (gnubuckets[hn] != 0)
8683 {
8684 bfd_vma si = gnubuckets[hn];
8685 bfd_vma off = si - gnusymidx;
8686
8687 do
8688 {
8689 print_dynamic_symbol (si, hn);
8690 si++;
8691 }
8692 while ((gnuchains[off++] & 1) == 0);
8693 }
8694 }
252b5132 8695 }
2c610e4b 8696 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
252b5132 8697 {
b34976b6 8698 unsigned int i;
252b5132
RH		 8699
8700 for (i = 0, section = section_headers;
8701 i < elf_header.e_shnum;
8702 i++, section++)
8703 {
b34976b6 8704 unsigned int si;
2cf0635d 8705 char * strtab = NULL;
c256ffe7 8706 unsigned long int strtab_size = 0;
2cf0635d
NC		 8707 Elf_Internal_Sym * symtab;
8708 Elf_Internal_Sym * psym;
252b5132 8709
2c610e4b
L		 8710 if ((section->sh_type != SHT_SYMTAB
8711 && section->sh_type != SHT_DYNSYM)
8712 || (!do_syms
8713 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 8714 continue;
8715
8716 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
8717 SECTION_NAME (section),
8718 (unsigned long) (section->sh_size / section->sh_entsize));
f7a99963 8719 if (is_32bit_elf)
ca47b30c 8720 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 8721 else
ca47b30c 8722 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 8723
9ad5cbcf 8724 symtab = GET_ELF_SYMBOLS (file, section);
252b5132
RH		 8725 if (symtab == NULL)
8726 continue;
8727
8728 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 8729 {
8730 strtab = string_table;
8731 strtab_size = string_table_length;
8732 }
4fbb74a6 8733 else if (section->sh_link < elf_header.e_shnum)
252b5132 8734 {
2cf0635d 8735 Elf_Internal_Shdr * string_sec;
252b5132 8736
4fbb74a6 8737 string_sec = section_headers + section->sh_link;
252b5132 8738
3f5e193b
NC		 8739 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
8740 1, string_sec->sh_size,
8741 _("string table"));
c256ffe7 8742 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 8743 }
8744
8745 for (si = 0, psym = symtab;
8746 si < section->sh_size / section->sh_entsize;
b34976b6 8747 si++, psym++)
252b5132 8748 {
5e220199 8749 printf ("%6d: ", si);
f7a99963
NC		 8750 print_vma (psym->st_value, LONG_HEX);
8751 putchar (' ');
8752 print_vma (psym->st_size, DEC_5);
d1133906
NC		 8753 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
8754 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 8755 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 8756 /* Check to see if any other bits in the st_other field are set.
8757 Note - displaying this information disrupts the layout of the
8758 table being generated, but for the moment this case is very rare. */
8759 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
8760 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 8761 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 8762 print_symbol (25, psym->st_name < strtab_size
2b692964 8763 ? strtab + psym->st_name : _("<corrupt>"));
252b5132
RH		 8764
8765 if (section->sh_type == SHT_DYNSYM &&
b34976b6 8766 version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
252b5132 8767 {
b34976b6
AM		 8768 unsigned char data[2];
8769 unsigned short vers_data;
8770 unsigned long offset;
8771 int is_nobits;
8772 int check_def;
252b5132 8773
d93f0186
NC		 8774 offset = offset_from_vma
8775 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8776 sizeof data + si * sizeof (vers_data));
252b5132 8777
a6e9f9df 8778 get_data (&data, file, offset + si * sizeof (vers_data),
c256ffe7 8779 sizeof (data), 1, _("version data"));
252b5132
RH		 8780
8781 vers_data = byte_get (data, 2);
8782
4fbb74a6
AM		 8783 is_nobits = (psym->st_shndx < elf_header.e_shnum
8784 && section_headers[psym->st_shndx].sh_type
c256ffe7 8785 == SHT_NOBITS);
252b5132
RH		 8786
8787 check_def = (psym->st_shndx != SHN_UNDEF);
8788
c244d050 8789 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
252b5132 8790 {
b34976b6 8791 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
00d93f34 8792 && (is_nobits || ! check_def))
252b5132 8793 {
b34976b6
AM		 8794 Elf_External_Verneed evn;
8795 Elf_Internal_Verneed ivn;
8796 Elf_Internal_Vernaux ivna;
252b5132
RH		 8797
8798 /* We must test both. */
d93f0186
NC		 8799 offset = offset_from_vma
8800 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8801 sizeof evn);
252b5132 8802
252b5132
RH		 8803 do
8804 {
b34976b6 8805 unsigned long vna_off;
252b5132 8806
c256ffe7 8807 get_data (&evn, file, offset, sizeof (evn), 1,
a6e9f9df 8808 _("version need"));
dd27201e
L		 8809
8810 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8811 ivn.vn_next = BYTE_GET (evn.vn_next);
8812
252b5132
RH		 8813 vna_off = offset + ivn.vn_aux;
8814
8815 do
8816 {
b34976b6 8817 Elf_External_Vernaux evna;
252b5132 8818
a6e9f9df 8819 get_data (&evna, file, vna_off,
c256ffe7 8820 sizeof (evna), 1,
a6e9f9df 8821 _("version need aux (3)"));
252b5132
RH		 8822
8823 ivna.vna_other = BYTE_GET (evna.vna_other);
8824 ivna.vna_next = BYTE_GET (evna.vna_next);
8825 ivna.vna_name = BYTE_GET (evna.vna_name);
8826
8827 vna_off += ivna.vna_next;
8828 }
8829 while (ivna.vna_other != vers_data
8830 && ivna.vna_next != 0);
8831
8832 if (ivna.vna_other == vers_data)
8833 break;
8834
8835 offset += ivn.vn_next;
8836 }
8837 while (ivn.vn_next != 0);
8838
8839 if (ivna.vna_other == vers_data)
8840 {
8841 printf ("@%s (%d)",
c256ffe7 8842 ivna.vna_name < strtab_size
2b692964 8843 ? strtab + ivna.vna_name : _("<corrupt>"),
c256ffe7 8844 ivna.vna_other);
252b5132
RH		 8845 check_def = 0;
8846 }
8847 else if (! is_nobits)
591a748a 8848 error (_("bad dynamic symbol\n"));
252b5132
RH		 8849 else
8850 check_def = 1;
8851 }
8852
8853 if (check_def)
8854 {
00d93f34 8855 if (vers_data != 0x8001
b34976b6 8856 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 8857 {
b34976b6
AM		 8858 Elf_Internal_Verdef ivd;
8859 Elf_Internal_Verdaux ivda;
8860 Elf_External_Verdaux evda;
91d6fa6a 8861 unsigned long off;
252b5132 8862
91d6fa6a 8863 off = offset_from_vma
d93f0186
NC		 8864 (file,
8865 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8866 sizeof (Elf_External_Verdef));
252b5132
RH		 8867
8868 do
8869 {
b34976b6 8870 Elf_External_Verdef evd;
252b5132 8871
91d6fa6a 8872 get_data (&evd, file, off, sizeof (evd),
c256ffe7 8873 1, _("version def"));
252b5132 8874
b34976b6
AM		 8875 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8876 ivd.vd_aux = BYTE_GET (evd.vd_aux);
252b5132
RH		 8877 ivd.vd_next = BYTE_GET (evd.vd_next);
8878
91d6fa6a 8879 off += ivd.vd_next;
252b5132 8880 }
c244d050 8881 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
252b5132
RH		 8882 && ivd.vd_next != 0);
8883
91d6fa6a
NC		 8884 off -= ivd.vd_next;
8885 off += ivd.vd_aux;
252b5132 8886
91d6fa6a 8887 get_data (&evda, file, off, sizeof (evda),
c256ffe7 8888 1, _("version def aux"));
252b5132
RH		 8889
8890 ivda.vda_name = BYTE_GET (evda.vda_name);
8891
8892 if (psym->st_name != ivda.vda_name)
c244d050 8893 printf ((vers_data & VERSYM_HIDDEN)
252b5132 8894 ? "@%s" : "@@%s",
c256ffe7 8895 ivda.vda_name < strtab_size
2b692964 8896 ? strtab + ivda.vda_name : _("<corrupt>"));
252b5132
RH		 8897 }
8898 }
8899 }
8900 }
8901
8902 putchar ('\n');
8903 }
8904
8905 free (symtab);
8906 if (strtab != string_table)
8907 free (strtab);
8908 }
8909 }
8910 else if (do_syms)
8911 printf
8912 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
8913
8914 if (do_histogram && buckets != NULL)
8915 {
2cf0635d
NC		 8916 unsigned long * lengths;
8917 unsigned long * counts;
66543521
AM		 8918 unsigned long hn;
8919 bfd_vma si;
8920 unsigned long maxlength = 0;
8921 unsigned long nzero_counts = 0;
8922 unsigned long nsyms = 0;
252b5132 8923
66543521
AM		 8924 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
8925 (unsigned long) nbuckets);
252b5132
RH		 8926 printf (_(" Length Number %% of total Coverage\n"));
8927
3f5e193b 8928 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 8929 if (lengths == NULL)
8930 {
591a748a 8931 error (_("Out of memory\n"));
252b5132
RH		 8932 return 0;
8933 }
8934 for (hn = 0; hn < nbuckets; ++hn)
8935 {
f7a99963 8936 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
252b5132 8937 {
b34976b6 8938 ++nsyms;
252b5132 8939 if (maxlength < ++lengths[hn])
b34976b6 8940 ++maxlength;
252b5132
RH		 8941 }
8942 }
8943
3f5e193b 8944 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 8945 if (counts == NULL)
8946 {
591a748a 8947 error (_("Out of memory\n"));
252b5132
RH		 8948 return 0;
8949 }
8950
8951 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 8952 ++counts[lengths[hn]];
252b5132 8953
103f02d3 8954 if (nbuckets > 0)
252b5132 8955 {
66543521
AM		 8956 unsigned long i;
8957 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 8958 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 8959 for (i = 1; i <= maxlength; ++i)
103f02d3 8960 {
66543521
AM		 8961 nzero_counts += counts[i] * i;
8962 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
8963 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 8964 (nzero_counts * 100.0) / nsyms);
8965 }
252b5132
RH		 8966 }
8967
8968 free (counts);
8969 free (lengths);
8970 }
8971
8972 if (buckets != NULL)
8973 {
8974 free (buckets);
8975 free (chains);
8976 }
8977
d3a44ec6 8978 if (do_histogram && gnubuckets != NULL)
fdc90cb4 8979 {
2cf0635d
NC		 8980 unsigned long * lengths;
8981 unsigned long * counts;
fdc90cb4
JJ		 8982 unsigned long hn;
8983 unsigned long maxlength = 0;
8984 unsigned long nzero_counts = 0;
8985 unsigned long nsyms = 0;
fdc90cb4 8986
3f5e193b 8987 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 8988 if (lengths == NULL)
8989 {
591a748a 8990 error (_("Out of memory\n"));
fdc90cb4
JJ		 8991 return 0;
8992 }
8993
8994 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
8995 (unsigned long) ngnubuckets);
8996 printf (_(" Length Number %% of total Coverage\n"));
8997
8998 for (hn = 0; hn < ngnubuckets; ++hn)
8999 if (gnubuckets[hn] != 0)
9000 {
9001 bfd_vma off, length = 1;
9002
6bd1a22c 9003 for (off = gnubuckets[hn] - gnusymidx;
fdc90cb4
JJ		 9004 (gnuchains[off] & 1) == 0; ++off)
9005 ++length;
9006 lengths[hn] = length;
9007 if (length > maxlength)
9008 maxlength = length;
9009 nsyms += length;
9010 }
9011
3f5e193b 9012 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 9013 if (counts == NULL)
9014 {
591a748a 9015 error (_("Out of memory\n"));
fdc90cb4
JJ		 9016 return 0;
9017 }
9018
9019 for (hn = 0; hn < ngnubuckets; ++hn)
9020 ++counts[lengths[hn]];
9021
9022 if (ngnubuckets > 0)
9023 {
9024 unsigned long j;
9025 printf (" 0 %-10lu (%5.1f%%)\n",
9026 counts[0], (counts[0] * 100.0) / ngnubuckets);
9027 for (j = 1; j <= maxlength; ++j)
9028 {
9029 nzero_counts += counts[j] * j;
9030 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9031 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9032 (nzero_counts * 100.0) / nsyms);
9033 }
9034 }
9035
9036 free (counts);
9037 free (lengths);
9038 free (gnubuckets);
9039 free (gnuchains);
9040 }
9041
252b5132
RH		 9042 return 1;
9043}
9044
9045static int
2cf0635d 9046process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 9047{
b4c96d0d 9048 unsigned int i;
252b5132
RH		 9049
9050 if (dynamic_syminfo == NULL
9051 || !do_dynamic)
9052 /* No syminfo, this is ok. */
9053 return 1;
9054
9055 /* There better should be a dynamic symbol section. */
9056 if (dynamic_symbols == NULL || dynamic_strings == NULL)
9057 return 0;
9058
9059 if (dynamic_addr)
9060 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9061 dynamic_syminfo_offset, dynamic_syminfo_nent);
9062
9063 printf (_(" Num: Name BoundTo Flags\n"));
9064 for (i = 0; i < dynamic_syminfo_nent; ++i)
9065 {
9066 unsigned short int flags = dynamic_syminfo[i].si_flags;
9067
31104126 9068 printf ("%4d: ", i);
d79b3d50
NC		 9069 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9070 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9071 else
2b692964 9072 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 9073 putchar (' ');
252b5132
RH		 9074
9075 switch (dynamic_syminfo[i].si_boundto)
9076 {
9077 case SYMINFO_BT_SELF:
9078 fputs ("SELF ", stdout);
9079 break;
9080 case SYMINFO_BT_PARENT:
9081 fputs ("PARENT ", stdout);
9082 break;
9083 default:
9084 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 9085 && dynamic_syminfo[i].si_boundto < dynamic_nent
9086 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 9087 {
d79b3d50 9088 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 9089 putchar (' ' );
9090 }
252b5132
RH		 9091 else
9092 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
9093 break;
9094 }
9095
9096 if (flags & SYMINFO_FLG_DIRECT)
9097 printf (" DIRECT");
9098 if (flags & SYMINFO_FLG_PASSTHRU)
9099 printf (" PASSTHRU");
9100 if (flags & SYMINFO_FLG_COPY)
9101 printf (" COPY");
9102 if (flags & SYMINFO_FLG_LAZYLOAD)
9103 printf (" LAZYLOAD");
9104
9105 puts ("");
9106 }
9107
9108 return 1;
9109}
9110
cf13d699
NC		 9111/* Check to see if the given reloc needs to be handled in a target specific
9112 manner. If so then process the reloc and return TRUE otherwise return
9113 FALSE. */
09c11c86 9114
cf13d699
NC		 9115static bfd_boolean
9116target_specific_reloc_handling (Elf_Internal_Rela * reloc,
9117 unsigned char * start,
9118 Elf_Internal_Sym * symtab)
252b5132 9119{
cf13d699 9120 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 9121
cf13d699 9122 switch (elf_header.e_machine)
252b5132 9123 {
cf13d699
NC		 9124 case EM_MN10300:
9125 case EM_CYGNUS_MN10300:
9126 {
9127 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 9128
cf13d699
NC		 9129 switch (reloc_type)
9130 {
9131 case 34: /* R_MN10300_ALIGN */
9132 return TRUE;
9133 case 33: /* R_MN10300_SYM_DIFF */
9134 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
9135 return TRUE;
9136 case 1: /* R_MN10300_32 */
9137 case 2: /* R_MN10300_16 */
9138 if (saved_sym != NULL)
9139 {
9140 bfd_vma value;
252b5132 9141
cf13d699
NC		 9142 value = reloc->r_addend
9143 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
9144 - saved_sym->st_value);
252b5132 9145
cf13d699 9146 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 9147
cf13d699
NC		 9148 saved_sym = NULL;
9149 return TRUE;
9150 }
9151 break;
9152 default:
9153 if (saved_sym != NULL)
9154 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9155 break;
9156 }
9157 break;
9158 }
252b5132
RH		 9159 }
9160
cf13d699 9161 return FALSE;
252b5132
RH		 9162}
9163
aca88567
NC		 9164/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9165 DWARF debug sections. This is a target specific test. Note - we do not
9166 go through the whole including-target-headers-multiple-times route, (as
9167 we have already done with <elf/h8.h>) because this would become very
9168 messy and even then this function would have to contain target specific
9169 information (the names of the relocs instead of their numeric values).
9170 FIXME: This is not the correct way to solve this problem. The proper way
9171 is to have target specific reloc sizing and typing functions created by
9172 the reloc-macros.h header, in the same way that it already creates the
9173 reloc naming functions. */
9174
9175static bfd_boolean
9176is_32bit_abs_reloc (unsigned int reloc_type)
9177{
9178 switch (elf_header.e_machine)
9179 {
41e92641
NC		 9180 case EM_386:
9181 case EM_486:
9182 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 9183 case EM_68K:
9184 return reloc_type == 1; /* R_68K_32. */
9185 case EM_860:
9186 return reloc_type == 1; /* R_860_32. */
9187 case EM_ALPHA:
9188 return reloc_type == 1; /* XXX Is this right ? */
41e92641
NC		 9189 case EM_ARC:
9190 return reloc_type == 1; /* R_ARC_32. */
9191 case EM_ARM:
9192 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 9193 case EM_AVR_OLD:
aca88567
NC		 9194 case EM_AVR:
9195 return reloc_type == 1;
9196 case EM_BLACKFIN:
9197 return reloc_type == 0x12; /* R_byte4_data. */
9198 case EM_CRIS:
9199 return reloc_type == 3; /* R_CRIS_32. */
9200 case EM_CR16:
6c03b1ed 9201 case EM_CR16_OLD:
aca88567
NC		 9202 return reloc_type == 3; /* R_CR16_NUM32. */
9203 case EM_CRX:
9204 return reloc_type == 15; /* R_CRX_NUM32. */
9205 case EM_CYGNUS_FRV:
9206 return reloc_type == 1;
41e92641
NC		 9207 case EM_CYGNUS_D10V:
9208 case EM_D10V:
9209 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 9210 case EM_CYGNUS_D30V:
9211 case EM_D30V:
9212 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 9213 case EM_DLX:
9214 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 9215 case EM_CYGNUS_FR30:
9216 case EM_FR30:
9217 return reloc_type == 3; /* R_FR30_32. */
9218 case EM_H8S:
9219 case EM_H8_300:
9220 case EM_H8_300H:
9221 return reloc_type == 1; /* R_H8_DIR32. */
3730236a
NC		 9222 case EM_IA_64:
9223 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
aca88567
NC		 9224 case EM_IP2K_OLD:
9225 case EM_IP2K:
9226 return reloc_type == 2; /* R_IP2K_32. */
9227 case EM_IQ2000:
9228 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 9229 case EM_LATTICEMICO32:
9230 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 9231 case EM_M32C_OLD:
aca88567
NC		 9232 case EM_M32C:
9233 return reloc_type == 3; /* R_M32C_32. */
9234 case EM_M32R:
9235 return reloc_type == 34; /* R_M32R_32_RELA. */
9236 case EM_MCORE:
9237 return reloc_type == 1; /* R_MCORE_ADDR32. */
9238 case EM_CYGNUS_MEP:
9239 return reloc_type == 4; /* R_MEP_32. */
9240 case EM_MIPS:
9241 return reloc_type == 2; /* R_MIPS_32. */
9242 case EM_MMIX:
9243 return reloc_type == 4; /* R_MMIX_32. */
9244 case EM_CYGNUS_MN10200:
9245 case EM_MN10200:
9246 return reloc_type == 1; /* R_MN10200_32. */
9247 case EM_CYGNUS_MN10300:
9248 case EM_MN10300:
9249 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 9250 case EM_MOXIE:
9251 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 9252 case EM_MSP430_OLD:
9253 case EM_MSP430:
9254 return reloc_type == 1; /* R_MSP43_32. */
9255 case EM_MT:
9256 return reloc_type == 2; /* R_MT_32. */
3e0873ac
NC		 9257 case EM_ALTERA_NIOS2:
9258 case EM_NIOS32:
9259 return reloc_type == 1; /* R_NIOS_32. */
41e92641
NC		 9260 case EM_OPENRISC:
9261 case EM_OR32:
9262 return reloc_type == 1; /* R_OR32_32. */
aca88567 9263 case EM_PARISC:
5fda8eca
NC		 9264 return (reloc_type == 1 /* R_PARISC_DIR32. */
9265 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 9266 case EM_PJ:
9267 case EM_PJ_OLD:
9268 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
9269 case EM_PPC64:
9270 return reloc_type == 1; /* R_PPC64_ADDR32. */
9271 case EM_PPC:
9272 return reloc_type == 1; /* R_PPC_ADDR32. */
c7927a3c
NC		 9273 case EM_RX:
9274 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 9275 case EM_S370:
9276 return reloc_type == 1; /* R_I370_ADDR31. */
9277 case EM_S390_OLD:
9278 case EM_S390:
9279 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 9280 case EM_SCORE:
9281 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 9282 case EM_SH:
9283 return reloc_type == 1; /* R_SH_DIR32. */
9284 case EM_SPARC32PLUS:
9285 case EM_SPARCV9:
9286 case EM_SPARC:
9287 return reloc_type == 3 /* R_SPARC_32. */
9288 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 9289 case EM_SPU:
9290 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 9291 case EM_TI_C6000:
9292 return reloc_type == 1; /* R_C6000_ABS32. */
aca88567
NC		 9293 case EM_CYGNUS_V850:
9294 case EM_V850:
9295 return reloc_type == 6; /* R_V850_ABS32. */
9296 case EM_VAX:
9297 return reloc_type == 1; /* R_VAX_32. */
9298 case EM_X86_64:
8a9036a4 9299 case EM_L1OM:
aca88567 9300 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 9301 case EM_XC16X:
9302 case EM_C166:
9303 return reloc_type == 3; /* R_XC16C_ABS_32. */
aca88567
NC		 9304 case EM_XSTORMY16:
9305 return reloc_type == 1; /* R_XSTROMY16_32. */
9306 case EM_XTENSA_OLD:
9307 case EM_XTENSA:
9308 return reloc_type == 1; /* R_XTENSA_32. */
aca88567
NC		 9309 default:
9310 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
9311 elf_header.e_machine);
9312 abort ();
9313 }
9314}
9315
9316/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9317 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
9318
9319static bfd_boolean
9320is_32bit_pcrel_reloc (unsigned int reloc_type)
9321{
9322 switch (elf_header.e_machine)
9323 {
41e92641
NC		 9324 case EM_386:
9325 case EM_486:
3e0873ac 9326 return reloc_type == 2; /* R_386_PC32. */
aca88567 9327 case EM_68K:
3e0873ac 9328 return reloc_type == 4; /* R_68K_PC32. */
aca88567
NC		 9329 case EM_ALPHA:
9330 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 9331 case EM_ARM:
3e0873ac 9332 return reloc_type == 3; /* R_ARM_REL32 */
aca88567 9333 case EM_PARISC:
85acf597 9334 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 9335 case EM_PPC:
9336 return reloc_type == 26; /* R_PPC_REL32. */
9337 case EM_PPC64:
3e0873ac 9338 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 9339 case EM_S390_OLD:
9340 case EM_S390:
3e0873ac 9341 return reloc_type == 5; /* R_390_PC32. */
aca88567 9342 case EM_SH:
3e0873ac 9343 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 9344 case EM_SPARC32PLUS:
9345 case EM_SPARCV9:
9346 case EM_SPARC:
3e0873ac 9347 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 9348 case EM_SPU:
9349 return reloc_type == 13; /* R_SPU_REL32. */
aca88567 9350 case EM_X86_64:
8a9036a4 9351 case EM_L1OM:
3e0873ac 9352 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 9353 case EM_XTENSA_OLD:
9354 case EM_XTENSA:
9355 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 9356 default:
9357 /* Do not abort or issue an error message here. Not all targets use
9358 pc-relative 32-bit relocs in their DWARF debug information and we
9359 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 9360 more helpful warning message will be generated by apply_relocations
9361 anyway, so just return. */
aca88567
NC		 9362 return FALSE;
9363 }
9364}
9365
9366/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9367 a 64-bit absolute RELA relocation used in DWARF debug sections. */
9368
9369static bfd_boolean
9370is_64bit_abs_reloc (unsigned int reloc_type)
9371{
9372 switch (elf_header.e_machine)
9373 {
9374 case EM_ALPHA:
9375 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 9376 case EM_IA_64:
9377 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 9378 case EM_PARISC:
9379 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 9380 case EM_PPC64:
9381 return reloc_type == 38; /* R_PPC64_ADDR64. */
9382 case EM_SPARC32PLUS:
9383 case EM_SPARCV9:
9384 case EM_SPARC:
9385 return reloc_type == 54; /* R_SPARC_UA64. */
9386 case EM_X86_64:
8a9036a4 9387 case EM_L1OM:
aca88567 9388 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 9389 case EM_S390_OLD:
9390 case EM_S390:
9391 return reloc_type == 22; /* R_S390_64 */
85a82265
AM		 9392 case EM_MIPS:
9393 return reloc_type == 18; /* R_MIPS_64 */
aca88567
NC		 9394 default:
9395 return FALSE;
9396 }
9397}
9398
85acf597
RH		 9399/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
9400 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
9401
9402static bfd_boolean
9403is_64bit_pcrel_reloc (unsigned int reloc_type)
9404{
9405 switch (elf_header.e_machine)
9406 {
9407 case EM_ALPHA:
9408 return reloc_type == 11; /* R_ALPHA_SREL64 */
9409 case EM_IA_64:
9410 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB */
9411 case EM_PARISC:
9412 return reloc_type == 72; /* R_PARISC_PCREL64 */
9413 case EM_PPC64:
9414 return reloc_type == 44; /* R_PPC64_REL64 */
9415 case EM_SPARC32PLUS:
9416 case EM_SPARCV9:
9417 case EM_SPARC:
9418 return reloc_type == 46; /* R_SPARC_DISP64 */
9419 case EM_X86_64:
8a9036a4 9420 case EM_L1OM:
85acf597
RH		 9421 return reloc_type == 24; /* R_X86_64_PC64 */
9422 case EM_S390_OLD:
9423 case EM_S390:
9424 return reloc_type == 23; /* R_S390_PC64 */
9425 default:
9426 return FALSE;
9427 }
9428}
9429
4dc3c23d
AM		 9430/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9431 a 24-bit absolute RELA relocation used in DWARF debug sections. */
9432
9433static bfd_boolean
9434is_24bit_abs_reloc (unsigned int reloc_type)
9435{
9436 switch (elf_header.e_machine)
9437 {
9438 case EM_CYGNUS_MN10200:
9439 case EM_MN10200:
9440 return reloc_type == 4; /* R_MN10200_24. */
9441 default:
9442 return FALSE;
9443 }
9444}
9445
aca88567
NC		 9446/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9447 a 16-bit absolute RELA relocation used in DWARF debug sections. */
9448
9449static bfd_boolean
9450is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 9451{
9452 switch (elf_header.e_machine)
9453 {
aca88567
NC		 9454 case EM_AVR_OLD:
9455 case EM_AVR:
9456 return reloc_type == 4; /* R_AVR_16. */
41e92641
NC		 9457 case EM_CYGNUS_D10V:
9458 case EM_D10V:
9459 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 9460 case EM_H8S:
9461 case EM_H8_300:
9462 case EM_H8_300H:
aca88567
NC		 9463 return reloc_type == R_H8_DIR16;
9464 case EM_IP2K_OLD:
9465 case EM_IP2K:
9466 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 9467 case EM_M32C_OLD:
f4236fe4
DD		 9468 case EM_M32C:
9469 return reloc_type == 1; /* R_M32C_16 */
aca88567
NC		 9470 case EM_MSP430_OLD:
9471 case EM_MSP430:
9472 return reloc_type == 5; /* R_MSP430_16_BYTE. */
3e0873ac
NC		 9473 case EM_ALTERA_NIOS2:
9474 case EM_NIOS32:
9475 return reloc_type == 9; /* R_NIOS_16. */
40b36596
JM		 9476 case EM_TI_C6000:
9477 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 9478 case EM_XC16X:
9479 case EM_C166:
9480 return reloc_type == 2; /* R_XC16C_ABS_16. */
4b78141a 9481 default:
aca88567 9482 return FALSE;
4b78141a
NC		 9483 }
9484}
9485
2a7b2e88
JK		 9486/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
9487 relocation entries (possibly formerly used for SHT_GROUP sections). */
9488
9489static bfd_boolean
9490is_none_reloc (unsigned int reloc_type)
9491{
9492 switch (elf_header.e_machine)
9493 {
cb8f3167
NC		 9494 case EM_68K: /* R_68K_NONE. */
9495 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 9496 case EM_SPARC32PLUS:
9497 case EM_SPARCV9:
cb8f3167
NC		 9498 case EM_SPARC: /* R_SPARC_NONE. */
9499 case EM_MIPS: /* R_MIPS_NONE. */
9500 case EM_PARISC: /* R_PARISC_NONE. */
9501 case EM_ALPHA: /* R_ALPHA_NONE. */
9502 case EM_PPC: /* R_PPC_NONE. */
9503 case EM_PPC64: /* R_PPC64_NONE. */
9504 case EM_ARM: /* R_ARM_NONE. */
9505 case EM_IA_64: /* R_IA64_NONE. */
9506 case EM_SH: /* R_SH_NONE. */
2a7b2e88 9507 case EM_S390_OLD:
cb8f3167
NC		 9508 case EM_S390: /* R_390_NONE. */
9509 case EM_CRIS: /* R_CRIS_NONE. */
9510 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 9511 case EM_L1OM: /* R_X86_64_NONE. */
cb8f3167 9512 case EM_MN10300: /* R_MN10300_NONE. */
5506d11a 9513 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 9514 case EM_M32R: /* R_M32R_NONE. */
40b36596 9515 case EM_TI_C6000:/* R_C6000_NONE. */
c29aca4a
NC		 9516 case EM_XC16X:
9517 case EM_C166: /* R_XC16X_NONE. */
cb8f3167 9518 return reloc_type == 0;
58332dda
JK		 9519 case EM_XTENSA_OLD:
9520 case EM_XTENSA:
4dc3c23d
AM		 9521 return (reloc_type == 0 /* R_XTENSA_NONE. */
9522 || reloc_type == 17 /* R_XTENSA_DIFF8. */
9523 || reloc_type == 18 /* R_XTENSA_DIFF16. */
9524 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
2a7b2e88
JK		 9525 }
9526 return FALSE;
9527}
9528
cf13d699
NC		 9529/* Apply relocations to a section.
9530 Note: So far support has been added only for those relocations
9531 which can be found in debug sections.
9532 FIXME: Add support for more relocations ? */
1b315056 9533
cf13d699
NC		 9534static void
9535apply_relocations (void * file,
9536 Elf_Internal_Shdr * section,
9537 unsigned char * start)
1b315056 9538{
cf13d699
NC		 9539 Elf_Internal_Shdr * relsec;
9540 unsigned char * end = start + section->sh_size;
cb8f3167 9541
cf13d699
NC		 9542 if (elf_header.e_type != ET_REL)
9543 return;
1b315056 9544
cf13d699 9545 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 9546 for (relsec = section_headers;
9547 relsec < section_headers + elf_header.e_shnum;
9548 ++relsec)
252b5132 9549 {
41e92641
NC		 9550 bfd_boolean is_rela;
9551 unsigned long num_relocs;
2cf0635d
NC		 9552 Elf_Internal_Rela * relocs;
9553 Elf_Internal_Rela * rp;
9554 Elf_Internal_Shdr * symsec;
9555 Elf_Internal_Sym * symtab;
9556 Elf_Internal_Sym * sym;
252b5132 9557
41e92641 9558 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 9559 || relsec->sh_info >= elf_header.e_shnum
9560 || section_headers + relsec->sh_info != section
c256ffe7 9561 || relsec->sh_size == 0
4fbb74a6 9562 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 9563 continue;
428409d5 9564
41e92641
NC		 9565 is_rela = relsec->sh_type == SHT_RELA;
9566
9567 if (is_rela)
9568 {
3f5e193b
NC		 9569 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
9570 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 9571 return;
9572 }
9573 else
9574 {
3f5e193b
NC		 9575 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
9576 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 9577 return;
9578 }
9579
9580 /* SH uses RELA but uses in place value instead of the addend field. */
9581 if (elf_header.e_machine == EM_SH)
9582 is_rela = FALSE;
428409d5 9583
4fbb74a6 9584 symsec = section_headers + relsec->sh_link;
3f5e193b 9585 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec);
103f02d3 9586
41e92641 9587 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 9588 {
41e92641
NC		 9589 bfd_vma addend;
9590 unsigned int reloc_type;
9591 unsigned int reloc_size;
91d6fa6a 9592 unsigned char * rloc;
4b78141a 9593
aca88567 9594 reloc_type = get_reloc_type (rp->r_info);
41e92641 9595
98fb390a 9596 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 9597 continue;
98fb390a
NC		 9598 else if (is_none_reloc (reloc_type))
9599 continue;
9600 else if (is_32bit_abs_reloc (reloc_type)
9601 || is_32bit_pcrel_reloc (reloc_type))
aca88567 9602 reloc_size = 4;
85acf597
RH		 9603 else if (is_64bit_abs_reloc (reloc_type)
9604 || is_64bit_pcrel_reloc (reloc_type))
aca88567 9605 reloc_size = 8;
4dc3c23d
AM		 9606 else if (is_24bit_abs_reloc (reloc_type))
9607 reloc_size = 3;
aca88567
NC		 9608 else if (is_16bit_abs_reloc (reloc_type))
9609 reloc_size = 2;
9610 else
4b78141a 9611 {
41e92641 9612 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
aca88567 9613 reloc_type, SECTION_NAME (section));
4b78141a
NC		 9614 continue;
9615 }
103f02d3 9616
91d6fa6a
NC		 9617 rloc = start + rp->r_offset;
9618 if ((rloc + reloc_size) > end)
700dd8b7
L		 9619 {
9620 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
9621 (unsigned long) rp->r_offset,
9622 SECTION_NAME (section));
9623 continue;
9624 }
103f02d3 9625
41e92641
NC		 9626 sym = symtab + get_reloc_symindex (rp->r_info);
9627
9628 /* If the reloc has a symbol associated with it,
55f25fc3
L		 9629 make sure that it is of an appropriate type.
9630
9631 Relocations against symbols without type can happen.
9632 Gcc -feliminate-dwarf2-dups may generate symbols
9633 without type for debug info.
9634
9635 Icc generates relocations against function symbols
9636 instead of local labels.
9637
9638 Relocations against object symbols can happen, eg when
9639 referencing a global array. For an example of this see
9640 the _clz.o binary in libgcc.a. */
aca88567 9641 if (sym != symtab
55f25fc3 9642 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 9643 {
41e92641 9644 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 9645 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 9646 (long int)(rp - relocs),
41e92641 9647 SECTION_NAME (relsec));
aca88567 9648 continue;
5b18a4bc 9649 }
252b5132 9650
4dc3c23d
AM		 9651 addend = 0;
9652 if (is_rela)
9653 addend += rp->r_addend;
9654 /* R_XTENSA_32 and R_PJ_DATA_DIR32 are partial_inplace. */
9655 if (!is_rela
9656 || (elf_header.e_machine == EM_XTENSA
9657 && reloc_type == 1)
9658 || ((elf_header.e_machine == EM_PJ
9659 || elf_header.e_machine == EM_PJ_OLD)
9660 && reloc_type == 1))
91d6fa6a 9661 addend += byte_get (rloc, reloc_size);
cb8f3167 9662
85acf597
RH		 9663 if (is_32bit_pcrel_reloc (reloc_type)
9664 || is_64bit_pcrel_reloc (reloc_type))
9665 {
9666 /* On HPPA, all pc-relative relocations are biased by 8. */
9667 if (elf_header.e_machine == EM_PARISC)
9668 addend -= 8;
91d6fa6a 9669 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 9670 reloc_size);
9671 }
41e92641 9672 else
91d6fa6a 9673 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 9674 }
252b5132 9675
5b18a4bc 9676 free (symtab);
41e92641 9677 free (relocs);
5b18a4bc
NC		 9678 break;
9679 }
5b18a4bc 9680}
103f02d3 9681
cf13d699
NC		 9682#ifdef SUPPORT_DISASSEMBLY
9683static int
9684disassemble_section (Elf_Internal_Shdr * section, FILE * file)
9685{
9686 printf (_("\nAssembly dump of section %s\n"),
9687 SECTION_NAME (section));
9688
9689 /* XXX -- to be done --- XXX */
9690
9691 return 1;
9692}
9693#endif
9694
9695/* Reads in the contents of SECTION from FILE, returning a pointer
9696 to a malloc'ed buffer or NULL if something went wrong. */
9697
9698static char *
9699get_section_contents (Elf_Internal_Shdr * section, FILE * file)
9700{
9701 bfd_size_type num_bytes;
9702
9703 num_bytes = section->sh_size;
9704
9705 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
9706 {
9707 printf (_("\nSection '%s' has no data to dump.\n"),
9708 SECTION_NAME (section));
9709 return NULL;
9710 }
9711
3f5e193b
NC		 9712 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
9713 _("section contents"));
cf13d699
NC		 9714}
9715
9716
9717static void
9718dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
9719{
9720 Elf_Internal_Shdr * relsec;
9721 bfd_size_type num_bytes;
cf13d699
NC		 9722 char * data;
9723 char * end;
9724 char * start;
9725 char * name = SECTION_NAME (section);
9726 bfd_boolean some_strings_shown;
9727
9728 start = get_section_contents (section, file);
9729 if (start == NULL)
9730 return;
9731
9732 printf (_("\nString dump of section '%s':\n"), name);
9733
9734 /* If the section being dumped has relocations against it the user might
9735 be expecting these relocations to have been applied. Check for this
9736 case and issue a warning message in order to avoid confusion.
9737 FIXME: Maybe we ought to have an option that dumps a section with
9738 relocs applied ? */
9739 for (relsec = section_headers;
9740 relsec < section_headers + elf_header.e_shnum;
9741 ++relsec)
9742 {
9743 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
9744 || relsec->sh_info >= elf_header.e_shnum
9745 || section_headers + relsec->sh_info != section
9746 || relsec->sh_size == 0
9747 || relsec->sh_link >= elf_header.e_shnum)
9748 continue;
9749
9750 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9751 break;
9752 }
9753
9754 num_bytes = section->sh_size;
cf13d699
NC		 9755 data = start;
9756 end = start + num_bytes;
9757 some_strings_shown = FALSE;
9758
9759 while (data < end)
9760 {
9761 while (!ISPRINT (* data))
9762 if (++ data >= end)
9763 break;
9764
9765 if (data < end)
9766 {
9767#ifndef __MSVCRT__
c975cc98
NC		 9768 /* PR 11128: Use two separate invocations in order to work
9769 around bugs in the Solaris 8 implementation of printf. */
9770 printf (" [%6tx] ", data - start);
9771 printf ("%s\n", data);
cf13d699
NC		 9772#else
9773 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
9774#endif
9775 data += strlen (data);
9776 some_strings_shown = TRUE;
9777 }
9778 }
9779
9780 if (! some_strings_shown)
9781 printf (_(" No strings found in this section."));
9782
9783 free (start);
9784
9785 putchar ('\n');
9786}
9787
9788static void
9789dump_section_as_bytes (Elf_Internal_Shdr * section,
9790 FILE * file,
9791 bfd_boolean relocate)
9792{
9793 Elf_Internal_Shdr * relsec;
9794 bfd_size_type bytes;
9795 bfd_vma addr;
9796 unsigned char * data;
9797 unsigned char * start;
9798
9799 start = (unsigned char *) get_section_contents (section, file);
9800 if (start == NULL)
9801 return;
9802
9803 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
9804
9805 if (relocate)
9806 {
9807 apply_relocations (file, section, start);
9808 }
9809 else
9810 {
9811 /* If the section being dumped has relocations against it the user might
9812 be expecting these relocations to have been applied. Check for this
9813 case and issue a warning message in order to avoid confusion.
9814 FIXME: Maybe we ought to have an option that dumps a section with
9815 relocs applied ? */
9816 for (relsec = section_headers;
9817 relsec < section_headers + elf_header.e_shnum;
9818 ++relsec)
9819 {
9820 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
9821 || relsec->sh_info >= elf_header.e_shnum
9822 || section_headers + relsec->sh_info != section
9823 || relsec->sh_size == 0
9824 || relsec->sh_link >= elf_header.e_shnum)
9825 continue;
9826
9827 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9828 break;
9829 }
9830 }
9831
9832 addr = section->sh_addr;
9833 bytes = section->sh_size;
9834 data = start;
9835
9836 while (bytes)
9837 {
9838 int j;
9839 int k;
9840 int lbytes;
9841
9842 lbytes = (bytes > 16 ? 16 : bytes);
9843
9844 printf (" 0x%8.8lx ", (unsigned long) addr);
9845
9846 for (j = 0; j < 16; j++)
9847 {
9848 if (j < lbytes)
9849 printf ("%2.2x", data[j]);
9850 else
9851 printf (" ");
9852
9853 if ((j & 3) == 3)
9854 printf (" ");
9855 }
9856
9857 for (j = 0; j < lbytes; j++)
9858 {
9859 k = data[j];
9860 if (k >= ' ' && k < 0x7f)
9861 printf ("%c", k);
9862 else
9863 printf (".");
9864 }
9865
9866 putchar ('\n');
9867
9868 data += lbytes;
9869 addr += lbytes;
9870 bytes -= lbytes;
9871 }
9872
9873 free (start);
9874
9875 putchar ('\n');
9876}
9877
9878/* Uncompresses a section that was compressed using zlib, in place.
9879 This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
9880
9881static int
d3dbc530
AM		 9882uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
9883 dwarf_size_type *size ATTRIBUTE_UNUSED)
cf13d699
NC		 9884{
9885#ifndef HAVE_ZLIB_H
cf13d699
NC		 9886 return FALSE;
9887#else
9888 dwarf_size_type compressed_size = *size;
9889 unsigned char * compressed_buffer = *buffer;
9890 dwarf_size_type uncompressed_size;
9891 unsigned char * uncompressed_buffer;
9892 z_stream strm;
9893 int rc;
9894 dwarf_size_type header_size = 12;
9895
9896 /* Read the zlib header. In this case, it should be "ZLIB" followed
9897 by the uncompressed section size, 8 bytes in big-endian order. */
9898 if (compressed_size < header_size
9899 || ! streq ((char *) compressed_buffer, "ZLIB"))
9900 return 0;
9901
9902 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
9903 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
9904 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
9905 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
9906 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
9907 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
9908 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
9909 uncompressed_size += compressed_buffer[11];
9910
9911 /* It is possible the section consists of several compressed
9912 buffers concatenated together, so we uncompress in a loop. */
9913 strm.zalloc = NULL;
9914 strm.zfree = NULL;
9915 strm.opaque = NULL;
9916 strm.avail_in = compressed_size - header_size;
9917 strm.next_in = (Bytef *) compressed_buffer + header_size;
9918 strm.avail_out = uncompressed_size;
3f5e193b 9919 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
cf13d699
NC		 9920
9921 rc = inflateInit (& strm);
9922 while (strm.avail_in > 0)
9923 {
9924 if (rc != Z_OK)
9925 goto fail;
9926 strm.next_out = ((Bytef *) uncompressed_buffer
9927 + (uncompressed_size - strm.avail_out));
9928 rc = inflate (&strm, Z_FINISH);
9929 if (rc != Z_STREAM_END)
9930 goto fail;
9931 rc = inflateReset (& strm);
9932 }
9933 rc = inflateEnd (& strm);
9934 if (rc != Z_OK
9935 || strm.avail_out != 0)
9936 goto fail;
9937
9938 free (compressed_buffer);
9939 *buffer = uncompressed_buffer;
9940 *size = uncompressed_size;
9941 return 1;
9942
9943 fail:
9944 free (uncompressed_buffer);
9945 return 0;
9946#endif /* HAVE_ZLIB_H */
9947}
9948
d966045b
DJ		 9949static int
9950load_specific_debug_section (enum dwarf_section_display_enum debug,
2cf0635d 9951 Elf_Internal_Shdr * sec, void * file)
1007acb3 9952{
2cf0635d 9953 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 9954 char buf [64];
1b315056 9955 int section_is_compressed;
1007acb3 9956
19e6b90e
L		 9957 /* If it is already loaded, do nothing. */
9958 if (section->start != NULL)
9959 return 1;
1007acb3 9960
a71cc8e0 9961 section_is_compressed = section->name == section->compressed_name;
1007acb3 9962
19e6b90e
L		 9963 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
9964 section->address = sec->sh_addr;
9965 section->size = sec->sh_size;
3f5e193b
NC		 9966 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
9967 sec->sh_offset, 1,
9968 sec->sh_size, buf);
1b315056
CS		 9969 if (section->start == NULL)
9970 return 0;
9971
9972 if (section_is_compressed)
0acf065b
CC		 9973 {
9974 if (! uncompress_section_contents (&section->start, &section->size))
9975 return 0;
9976 sec->sh_size = section->size;
9977 }
1007acb3 9978
19e6b90e 9979 if (debug_displays [debug].relocate)
3f5e193b 9980 apply_relocations ((FILE *) file, sec, section->start);
1007acb3 9981
1b315056 9982 return 1;
1007acb3
L		 9983}
9984
d966045b 9985int
2cf0635d 9986load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 9987{
2cf0635d
NC		 9988 struct dwarf_section * section = &debug_displays [debug].section;
9989 Elf_Internal_Shdr * sec;
d966045b
DJ		 9990
9991 /* Locate the debug section. */
9992 sec = find_section (section->uncompressed_name);
9993 if (sec != NULL)
9994 section->name = section->uncompressed_name;
9995 else
9996 {
9997 sec = find_section (section->compressed_name);
9998 if (sec != NULL)
9999 section->name = section->compressed_name;
10000 }
10001 if (sec == NULL)
10002 return 0;
10003
3f5e193b 10004 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 10005}
10006
19e6b90e
L		 10007void
10008free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 10009{
2cf0635d 10010 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 10011
19e6b90e
L		 10012 if (section->start == NULL)
10013 return;
1007acb3 10014
19e6b90e
L		 10015 free ((char *) section->start);
10016 section->start = NULL;
10017 section->address = 0;
10018 section->size = 0;
1007acb3
L		 10019}
10020
1007acb3 10021static int
2cf0635d 10022display_debug_section (Elf_Internal_Shdr * section, FILE * file)
1007acb3 10023{
2cf0635d 10024 char * name = SECTION_NAME (section);
19e6b90e
L		 10025 bfd_size_type length;
10026 int result = 1;
3f5e193b 10027 int i;
1007acb3 10028
19e6b90e
L		 10029 length = section->sh_size;
10030 if (length == 0)
1007acb3 10031 {
19e6b90e
L		 10032 printf (_("\nSection '%s' has no debugging data.\n"), name);
10033 return 0;
1007acb3 10034 }
5dff79d8
NC		 10035 if (section->sh_type == SHT_NOBITS)
10036 {
10037 /* There is no point in dumping the contents of a debugging section
10038 which has the NOBITS type - the bits in the file will be random.
10039 This can happen when a file containing a .eh_frame section is
10040 stripped with the --only-keep-debug command line option. */
10041 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
10042 return 0;
10043 }
1007acb3 10044
0112cd26 10045 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 10046 name = ".debug_info";
1007acb3 10047
19e6b90e
L		 10048 /* See if we know how to display the contents of this section. */
10049 for (i = 0; i < max; i++)
1b315056
CS		 10050 if (streq (debug_displays[i].section.uncompressed_name, name)
10051 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 10052 {
2cf0635d 10053 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 10054 int secondary = (section != find_section (name));
10055
10056 if (secondary)
3f5e193b 10057 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 10058
2b6f5997 10059 if (streq (sec->uncompressed_name, name))
d966045b
DJ		 10060 sec->name = sec->uncompressed_name;
10061 else
10062 sec->name = sec->compressed_name;
3f5e193b
NC		 10063 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
10064 section, file))
19e6b90e
L		 10065 {
10066 result &= debug_displays[i].display (sec, file);
1007acb3 10067
d966045b 10068 if (secondary || (i != info && i != abbrev))
3f5e193b 10069 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 10070 }
1007acb3 10071
19e6b90e
L		 10072 break;
10073 }
1007acb3 10074
19e6b90e 10075 if (i == max)
1007acb3 10076 {
19e6b90e
L		 10077 printf (_("Unrecognized debug section: %s\n"), name);
10078 result = 0;
1007acb3
L		 10079 }
10080
19e6b90e 10081 return result;
5b18a4bc 10082}
103f02d3 10083
aef1f6d0
DJ		 10084/* Set DUMP_SECTS for all sections where dumps were requested
10085 based on section name. */
10086
10087static void
10088initialise_dumps_byname (void)
10089{
2cf0635d 10090 struct dump_list_entry * cur;
aef1f6d0
DJ		 10091
10092 for (cur = dump_sects_byname; cur; cur = cur->next)
10093 {
10094 unsigned int i;
10095 int any;
10096
10097 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
10098 if (streq (SECTION_NAME (section_headers + i), cur->name))
10099 {
09c11c86 10100 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 10101 any = 1;
10102 }
10103
10104 if (!any)
10105 warn (_("Section '%s' was not dumped because it does not exist!\n"),
10106 cur->name);
10107 }
10108}
10109
5b18a4bc 10110static void
2cf0635d 10111process_section_contents (FILE * file)
5b18a4bc 10112{
2cf0635d 10113 Elf_Internal_Shdr * section;
19e6b90e 10114 unsigned int i;
103f02d3 10115
19e6b90e
L		 10116 if (! do_dump)
10117 return;
103f02d3 10118
aef1f6d0
DJ		 10119 initialise_dumps_byname ();
10120
19e6b90e
L		 10121 for (i = 0, section = section_headers;
10122 i < elf_header.e_shnum && i < num_dump_sects;
10123 i++, section++)
10124 {
10125#ifdef SUPPORT_DISASSEMBLY
10126 if (dump_sects[i] & DISASS_DUMP)
10127 disassemble_section (section, file);
10128#endif
10129 if (dump_sects[i] & HEX_DUMP)
cf13d699 10130 dump_section_as_bytes (section, file, FALSE);
103f02d3 10131
cf13d699
NC		 10132 if (dump_sects[i] & RELOC_DUMP)
10133 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 10134
10135 if (dump_sects[i] & STRING_DUMP)
10136 dump_section_as_strings (section, file);
cf13d699
NC		 10137
10138 if (dump_sects[i] & DEBUG_DUMP)
10139 display_debug_section (section, file);
5b18a4bc 10140 }
103f02d3 10141
19e6b90e
L		 10142 /* Check to see if the user requested a
10143 dump of a section that does not exist. */
10144 while (i++ < num_dump_sects)
10145 if (dump_sects[i])
10146 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 10147}
103f02d3 10148
5b18a4bc 10149static void
19e6b90e 10150process_mips_fpe_exception (int mask)
5b18a4bc 10151{
19e6b90e
L		 10152 if (mask)
10153 {
10154 int first = 1;
10155 if (mask & OEX_FPU_INEX)
10156 fputs ("INEX", stdout), first = 0;
10157 if (mask & OEX_FPU_UFLO)
10158 printf ("%sUFLO", first ? "" : "|"), first = 0;
10159 if (mask & OEX_FPU_OFLO)
10160 printf ("%sOFLO", first ? "" : "|"), first = 0;
10161 if (mask & OEX_FPU_DIV0)
10162 printf ("%sDIV0", first ? "" : "|"), first = 0;
10163 if (mask & OEX_FPU_INVAL)
10164 printf ("%sINVAL", first ? "" : "|");
10165 }
5b18a4bc 10166 else
19e6b90e 10167 fputs ("0", stdout);
5b18a4bc 10168}
103f02d3 10169
11c1ff18
PB		 10170/* ARM EABI attributes section. */
10171typedef struct
10172{
10173 int tag;
2cf0635d 10174 const char * name;
11c1ff18
PB		 10175 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
10176 int type;
2cf0635d 10177 const char ** table;
11c1ff18
PB		 10178} arm_attr_public_tag;
10179
2cf0635d 10180static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 10181 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
9e3c6df6 10182 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
2cf0635d
NC		 10183static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
10184static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 10185 {"No", "Thumb-1", "Thumb-2"};
75375b3e 10186static const char * arm_attr_tag_FP_arch[] =
62f3b8c8 10187 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
2cf0635d 10188static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
cd21e546
MGD		 10189static const char * arm_attr_tag_Advanced_SIMD_arch[] =
10190 {"No", "NEONv1", "NEONv1 with Fused-MAC"};
2cf0635d 10191static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 10192 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
10193 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 10194static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 10195 {"V6", "SB", "TLS", "Unused"};
2cf0635d 10196static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 10197 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 10198static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 10199 {"Absolute", "PC-relative", "None"};
2cf0635d 10200static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 10201 {"None", "direct", "GOT-indirect"};
2cf0635d 10202static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 10203 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 10204static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
10205static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 10206 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 10207static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
10208static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
10209static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 10210 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 10211static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 10212 {"Unused", "small", "int", "forced to int"};
2cf0635d 10213static const char * arm_attr_tag_ABI_HardFP_use[] =
75375b3e 10214 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
2cf0635d 10215static const char * arm_attr_tag_ABI_VFP_args[] =
11c1ff18 10216 {"AAPCS", "VFP registers", "custom"};
2cf0635d 10217static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 10218 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 10219static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 10220 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10221 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 10222static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 10223 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10224 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 10225static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 10226static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 10227 {"Not Allowed", "Allowed"};
2cf0635d 10228static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 10229 {"None", "IEEE 754", "Alternative Format"};
cd21e546
MGD		 10230static const char * arm_attr_tag_MPextension_use[] =
10231 {"Not Allowed", "Allowed"};
10232static const char * arm_attr_tag_DIV_use[] =
10233 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
10234 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 10235static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
10236static const char * arm_attr_tag_Virtualization_use[] =
cd21e546
MGD		 10237 {"Not Allowed", "TrustZone", "Virtualization Extensions",
10238 "TrustZone and Virtualization Extensions"};
10239static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 10240 {"Not Allowed", "Allowed"};
11c1ff18
PB		 10241
10242#define LOOKUP(id, name) \
10243 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 10244static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 10245{
10246 {4, "CPU_raw_name", 1, NULL},
10247 {5, "CPU_name", 1, NULL},
10248 LOOKUP(6, CPU_arch),
10249 {7, "CPU_arch_profile", 0, NULL},
10250 LOOKUP(8, ARM_ISA_use),
10251 LOOKUP(9, THUMB_ISA_use),
75375b3e 10252 LOOKUP(10, FP_arch),
11c1ff18 10253 LOOKUP(11, WMMX_arch),
f5f53991
AS		 10254 LOOKUP(12, Advanced_SIMD_arch),
10255 LOOKUP(13, PCS_config),
11c1ff18
PB		 10256 LOOKUP(14, ABI_PCS_R9_use),
10257 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 10258 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 10259 LOOKUP(17, ABI_PCS_GOT_use),
10260 LOOKUP(18, ABI_PCS_wchar_t),
10261 LOOKUP(19, ABI_FP_rounding),
10262 LOOKUP(20, ABI_FP_denormal),
10263 LOOKUP(21, ABI_FP_exceptions),
10264 LOOKUP(22, ABI_FP_user_exceptions),
10265 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 10266 {24, "ABI_align_needed", 0, NULL},
10267 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 10268 LOOKUP(26, ABI_enum_size),
10269 LOOKUP(27, ABI_HardFP_use),
10270 LOOKUP(28, ABI_VFP_args),
10271 LOOKUP(29, ABI_WMMX_args),
10272 LOOKUP(30, ABI_optimization_goals),
10273 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 10274 {32, "compatibility", 0, NULL},
f5f53991 10275 LOOKUP(34, CPU_unaligned_access),
75375b3e 10276 LOOKUP(36, FP_HP_extension),
8e79c3df 10277 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 10278 LOOKUP(42, MPextension_use),
10279 LOOKUP(44, DIV_use),
f5f53991
AS		 10280 {64, "nodefaults", 0, NULL},
10281 {65, "also_compatible_with", 0, NULL},
10282 LOOKUP(66, T2EE_use),
10283 {67, "conformance", 1, NULL},
10284 LOOKUP(68, Virtualization_use),
cd21e546 10285 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 10286};
10287#undef LOOKUP
10288
11c1ff18 10289static unsigned char *
2cf0635d 10290display_arm_attribute (unsigned char * p)
11c1ff18
PB		 10291{
10292 int tag;
10293 unsigned int len;
10294 int val;
2cf0635d 10295 arm_attr_public_tag * attr;
11c1ff18
PB		 10296 unsigned i;
10297 int type;
10298
10299 tag = read_uleb128 (p, &len);
10300 p += len;
10301 attr = NULL;
2cf0635d 10302 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 10303 {
10304 if (arm_attr_public_tags[i].tag == tag)
10305 {
10306 attr = &arm_attr_public_tags[i];
10307 break;
10308 }
10309 }
10310
10311 if (attr)
10312 {
10313 printf (" Tag_%s: ", attr->name);
10314 switch (attr->type)
10315 {
10316 case 0:
10317 switch (tag)
10318 {
10319 case 7: /* Tag_CPU_arch_profile. */
10320 val = read_uleb128 (p, &len);
10321 p += len;
10322 switch (val)
10323 {
2b692964
NC		 10324 case 0: printf (_("None\n")); break;
10325 case 'A': printf (_("Application\n")); break;
10326 case 'R': printf (_("Realtime\n")); break;
10327 case 'M': printf (_("Microcontroller\n")); break;
10328 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 10329 default: printf ("??? (%d)\n", val); break;
10330 }
10331 break;
10332
75375b3e
MGD		 10333 case 24: /* Tag_align_needed. */
10334 val = read_uleb128 (p, &len);
10335 p += len;
10336 switch (val)
10337 {
2b692964
NC		 10338 case 0: printf (_("None\n")); break;
10339 case 1: printf (_("8-byte\n")); break;
10340 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 10341 case 3: printf ("??? 3\n"); break;
10342 default:
10343 if (val <= 12)
2b692964 10344 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 10345 1 << val);
10346 else
10347 printf ("??? (%d)\n", val);
10348 break;
10349 }
10350 break;
10351
10352 case 25: /* Tag_align_preserved. */
10353 val = read_uleb128 (p, &len);
10354 p += len;
10355 switch (val)
10356 {
2b692964
NC		 10357 case 0: printf (_("None\n")); break;
10358 case 1: printf (_("8-byte, except leaf SP\n")); break;
10359 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 10360 case 3: printf ("??? 3\n"); break;
10361 default:
10362 if (val <= 12)
2b692964 10363 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 10364 1 << val);
10365 else
10366 printf ("??? (%d)\n", val);
10367 break;
10368 }
10369 break;
10370
11c1ff18
PB		 10371 case 32: /* Tag_compatibility. */
10372 val = read_uleb128 (p, &len);
10373 p += len;
2b692964 10374 printf (_("flag = %d, vendor = %s\n"), val, p);
2cf0635d 10375 p += strlen ((char *) p) + 1;
11c1ff18
PB		 10376 break;
10377
f5f53991
AS		 10378 case 64: /* Tag_nodefaults. */
10379 p++;
2b692964 10380 printf (_("True\n"));
f5f53991
AS		 10381 break;
10382
10383 case 65: /* Tag_also_compatible_with. */
10384 val = read_uleb128 (p, &len);
10385 p += len;
10386 if (val == 6 /* Tag_CPU_arch. */)
10387 {
10388 val = read_uleb128 (p, &len);
10389 p += len;
2cf0635d 10390 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 10391 printf ("??? (%d)\n", val);
10392 else
10393 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
10394 }
10395 else
10396 printf ("???\n");
10397 while (*(p++) != '\0' /* NUL terminator. */);
10398 break;
10399
11c1ff18 10400 default:
2cf0635d 10401 abort ();
11c1ff18
PB		 10402 }
10403 return p;
10404
10405 case 1:
10406 case 2:
10407 type = attr->type;
10408 break;
10409
10410 default:
10411 assert (attr->type & 0x80);
10412 val = read_uleb128 (p, &len);
10413 p += len;
10414 type = attr->type & 0x7f;
10415 if (val >= type)
10416 printf ("??? (%d)\n", val);
10417 else
10418 printf ("%s\n", attr->table[val]);
10419 return p;
10420 }
10421 }
10422 else
10423 {
10424 if (tag & 1)
10425 type = 1; /* String. */
10426 else
10427 type = 2; /* uleb128. */
10428 printf (" Tag_unknown_%d: ", tag);
10429 }
10430
10431 if (type == 1)
10432 {
10433 printf ("\"%s\"\n", p);
2cf0635d 10434 p += strlen ((char *) p) + 1;
11c1ff18
PB		 10435 }
10436 else
10437 {
10438 val = read_uleb128 (p, &len);
10439 p += len;
10440 printf ("%d (0x%x)\n", val, val);
10441 }
10442
10443 return p;
10444}
10445
104d59d1 10446static unsigned char *
60bca95a
NC		 10447display_gnu_attribute (unsigned char * p,
10448 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
104d59d1
JM		 10449{
10450 int tag;
10451 unsigned int len;
10452 int val;
10453 int type;
10454
10455 tag = read_uleb128 (p, &len);
10456 p += len;
10457
10458 /* Tag_compatibility is the only generic GNU attribute defined at
10459 present. */
10460 if (tag == 32)
10461 {
10462 val = read_uleb128 (p, &len);
10463 p += len;
2b692964 10464 printf (_("flag = %d, vendor = %s\n"), val, p);
60bca95a 10465 p += strlen ((char *) p) + 1;
104d59d1
JM		 10466 return p;
10467 }
10468
10469 if ((tag & 2) == 0 && display_proc_gnu_attribute)
10470 return display_proc_gnu_attribute (p, tag);
10471
10472 if (tag & 1)
10473 type = 1; /* String. */
10474 else
10475 type = 2; /* uleb128. */
10476 printf (" Tag_unknown_%d: ", tag);
10477
10478 if (type == 1)
10479 {
10480 printf ("\"%s\"\n", p);
60bca95a 10481 p += strlen ((char *) p) + 1;
104d59d1
JM		 10482 }
10483 else
10484 {
10485 val = read_uleb128 (p, &len);
10486 p += len;
10487 printf ("%d (0x%x)\n", val, val);
10488 }
10489
10490 return p;
10491}
10492
34c8bcba 10493static unsigned char *
2cf0635d 10494display_power_gnu_attribute (unsigned char * p, int tag)
34c8bcba
JM		 10495{
10496 int type;
10497 unsigned int len;
10498 int val;
10499
10500 if (tag == Tag_GNU_Power_ABI_FP)
10501 {
10502 val = read_uleb128 (p, &len);
10503 p += len;
10504 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 10505
34c8bcba
JM		 10506 switch (val)
10507 {
10508 case 0:
2b692964 10509 printf (_("Hard or soft float\n"));
34c8bcba
JM		 10510 break;
10511 case 1:
2b692964 10512 printf (_("Hard float\n"));
34c8bcba
JM		 10513 break;
10514 case 2:
2b692964 10515 printf (_("Soft float\n"));
34c8bcba 10516 break;
3c7b9897 10517 case 3:
2b692964 10518 printf (_("Single-precision hard float\n"));
3c7b9897 10519 break;
34c8bcba
JM		 10520 default:
10521 printf ("??? (%d)\n", val);
10522 break;
10523 }
10524 return p;
10525 }
10526
c6e65352
DJ		 10527 if (tag == Tag_GNU_Power_ABI_Vector)
10528 {
10529 val = read_uleb128 (p, &len);
10530 p += len;
10531 printf (" Tag_GNU_Power_ABI_Vector: ");
10532 switch (val)
10533 {
10534 case 0:
2b692964 10535 printf (_("Any\n"));
c6e65352
DJ		 10536 break;
10537 case 1:
2b692964 10538 printf (_("Generic\n"));
c6e65352
DJ		 10539 break;
10540 case 2:
10541 printf ("AltiVec\n");
10542 break;
10543 case 3:
10544 printf ("SPE\n");
10545 break;
10546 default:
10547 printf ("??? (%d)\n", val);
10548 break;
10549 }
10550 return p;
10551 }
10552
f82e0623
NF		 10553 if (tag == Tag_GNU_Power_ABI_Struct_Return)
10554 {
10555 val = read_uleb128 (p, &len);
10556 p += len;
10557 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
10558 switch (val)
10559 {
10560 case 0:
2b692964 10561 printf (_("Any\n"));
f82e0623
NF		 10562 break;
10563 case 1:
10564 printf ("r3/r4\n");
10565 break;
10566 case 2:
2b692964 10567 printf (_("Memory\n"));
f82e0623
NF		 10568 break;
10569 default:
10570 printf ("??? (%d)\n", val);
10571 break;
10572 }
10573 return p;
10574 }
10575
34c8bcba
JM		 10576 if (tag & 1)
10577 type = 1; /* String. */
10578 else
10579 type = 2; /* uleb128. */
10580 printf (" Tag_unknown_%d: ", tag);
10581
10582 if (type == 1)
10583 {
10584 printf ("\"%s\"\n", p);
60bca95a 10585 p += strlen ((char *) p) + 1;
34c8bcba
JM		 10586 }
10587 else
10588 {
10589 val = read_uleb128 (p, &len);
10590 p += len;
10591 printf ("%d (0x%x)\n", val, val);
10592 }
10593
10594 return p;
10595}
10596
2cf19d5c 10597static unsigned char *
2cf0635d 10598display_mips_gnu_attribute (unsigned char * p, int tag)
2cf19d5c
JM		 10599{
10600 int type;
10601 unsigned int len;
10602 int val;
10603
10604 if (tag == Tag_GNU_MIPS_ABI_FP)
10605 {
10606 val = read_uleb128 (p, &len);
10607 p += len;
10608 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 10609
2cf19d5c
JM		 10610 switch (val)
10611 {
10612 case 0:
2b692964 10613 printf (_("Hard or soft float\n"));
2cf19d5c
JM		 10614 break;
10615 case 1:
2b692964 10616 printf (_("Hard float (double precision)\n"));
2cf19d5c
JM		 10617 break;
10618 case 2:
2b692964 10619 printf (_("Hard float (single precision)\n"));
2cf19d5c
JM		 10620 break;
10621 case 3:
2b692964 10622 printf (_("Soft float\n"));
2cf19d5c 10623 break;
42554f6a 10624 case 4:
2b692964 10625 printf (_("64-bit float (-mips32r2 -mfp64)\n"));
42554f6a 10626 break;
2cf19d5c
JM		 10627 default:
10628 printf ("??? (%d)\n", val);
10629 break;
10630 }
10631 return p;
10632 }
10633
10634 if (tag & 1)
10635 type = 1; /* String. */
10636 else
10637 type = 2; /* uleb128. */
10638 printf (" Tag_unknown_%d: ", tag);
10639
10640 if (type == 1)
10641 {
10642 printf ("\"%s\"\n", p);
60bca95a 10643 p += strlen ((char *) p) + 1;
2cf19d5c
JM		 10644 }
10645 else
10646 {
10647 val = read_uleb128 (p, &len);
10648 p += len;
10649 printf ("%d (0x%x)\n", val, val);
10650 }
10651
10652 return p;
10653}
10654
59e6276b
JM		 10655static unsigned char *
10656display_tic6x_attribute (unsigned char * p)
10657{
10658 int tag;
10659 unsigned int len;
10660 int val;
10661
10662 tag = read_uleb128 (p, &len);
10663 p += len;
10664
10665 switch (tag)
10666 {
10667 case Tag_C6XABI_Tag_CPU_arch:
10668 val = read_uleb128 (p, &len);
10669 p += len;
10670 printf (" Tag_C6XABI_Tag_CPU_arch: ");
10671
10672 switch (val)
10673 {
10674 case C6XABI_Tag_CPU_arch_none:
10675 printf (_("None\n"));
10676 break;
10677 case C6XABI_Tag_CPU_arch_C62X:
10678 printf ("C62x\n");
10679 break;
10680 case C6XABI_Tag_CPU_arch_C67X:
10681 printf ("C67x\n");
10682 break;
10683 case C6XABI_Tag_CPU_arch_C67XP:
10684 printf ("C67x+\n");
10685 break;
10686 case C6XABI_Tag_CPU_arch_C64X:
10687 printf ("C64x\n");
10688 break;
10689 case C6XABI_Tag_CPU_arch_C64XP:
10690 printf ("C64x+\n");
10691 break;
10692 case C6XABI_Tag_CPU_arch_C674X:
10693 printf ("C674x\n");
10694 break;
10695 default:
10696 printf ("??? (%d)\n", val);
10697 break;
10698 }
10699 return p;
10700
10701 case 32:
10702 /* Tag_compatibility - treated as generic by binutils for now
10703 although not currently specified for C6X. */
10704 val = read_uleb128 (p, &len);
10705 p += len;
10706 printf (_("flag = %d, vendor = %s\n"), val, p);
10707 p += strlen ((char *) p) + 1;
10708 return p;
10709 }
10710
10711 printf (" Tag_unknown_%d: ", tag);
10712
10713 /* No general documentation of handling unknown attributes, treat as
10714 ULEB128 for now. */
10715 val = read_uleb128 (p, &len);
10716 p += len;
10717 printf ("%d (0x%x)\n", val, val);
10718
10719 return p;
10720}
10721
11c1ff18 10722static int
60bca95a
NC		 10723process_attributes (FILE * file,
10724 const char * public_name,
104d59d1 10725 unsigned int proc_type,
60bca95a
NC		 10726 unsigned char * (* display_pub_attribute) (unsigned char *),
10727 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11c1ff18 10728{
2cf0635d
NC		 10729 Elf_Internal_Shdr * sect;
10730 unsigned char * contents;
10731 unsigned char * p;
10732 unsigned char * end;
11c1ff18
PB		 10733 bfd_vma section_len;
10734 bfd_vma len;
10735 unsigned i;
10736
10737 /* Find the section header so that we get the size. */
10738 for (i = 0, sect = section_headers;
10739 i < elf_header.e_shnum;
10740 i++, sect++)
10741 {
104d59d1 10742 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 10743 continue;
10744
3f5e193b
NC		 10745 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
10746 sect->sh_size, _("attributes"));
60bca95a 10747 if (contents == NULL)
11c1ff18 10748 continue;
60bca95a 10749
11c1ff18
PB		 10750 p = contents;
10751 if (*p == 'A')
10752 {
10753 len = sect->sh_size - 1;
10754 p++;
60bca95a 10755
11c1ff18
PB		 10756 while (len > 0)
10757 {
10758 int namelen;
10759 bfd_boolean public_section;
104d59d1 10760 bfd_boolean gnu_section;
11c1ff18
PB		 10761
10762 section_len = byte_get (p, 4);
10763 p += 4;
60bca95a 10764
11c1ff18
PB		 10765 if (section_len > len)
10766 {
10767 printf (_("ERROR: Bad section length (%d > %d)\n"),
60bca95a 10768 (int) section_len, (int) len);
11c1ff18
PB		 10769 section_len = len;
10770 }
60bca95a 10771
11c1ff18 10772 len -= section_len;
2b692964 10773 printf (_("Attribute Section: %s\n"), p);
60bca95a
NC		 10774
10775 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 10776 public_section = TRUE;
10777 else
10778 public_section = FALSE;
60bca95a
NC		 10779
10780 if (streq ((char *) p, "gnu"))
104d59d1
JM		 10781 gnu_section = TRUE;
10782 else
10783 gnu_section = FALSE;
60bca95a
NC		 10784
10785 namelen = strlen ((char *) p) + 1;
11c1ff18
PB		 10786 p += namelen;
10787 section_len -= namelen + 4;
60bca95a 10788
11c1ff18
PB		 10789 while (section_len > 0)
10790 {
10791 int tag = *(p++);
10792 int val;
10793 bfd_vma size;
60bca95a 10794
11c1ff18
PB		 10795 size = byte_get (p, 4);
10796 if (size > section_len)
10797 {
10798 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
60bca95a 10799 (int) size, (int) section_len);
11c1ff18
PB		 10800 size = section_len;
10801 }
60bca95a 10802
11c1ff18
PB		 10803 section_len -= size;
10804 end = p + size - 1;
10805 p += 4;
60bca95a 10806
11c1ff18
PB		 10807 switch (tag)
10808 {
10809 case 1:
2b692964 10810 printf (_("File Attributes\n"));
11c1ff18
PB		 10811 break;
10812 case 2:
2b692964 10813 printf (_("Section Attributes:"));
11c1ff18
PB		 10814 goto do_numlist;
10815 case 3:
2b692964 10816 printf (_("Symbol Attributes:"));
11c1ff18
PB		 10817 do_numlist:
10818 for (;;)
10819 {
91d6fa6a 10820 unsigned int j;
60bca95a 10821
91d6fa6a
NC		 10822 val = read_uleb128 (p, &j);
10823 p += j;
11c1ff18
PB		 10824 if (val == 0)
10825 break;
10826 printf (" %d", val);
10827 }
10828 printf ("\n");
10829 break;
10830 default:
2b692964 10831 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 10832 public_section = FALSE;
10833 break;
10834 }
60bca95a 10835
11c1ff18
PB		 10836 if (public_section)
10837 {
10838 while (p < end)
104d59d1
JM		 10839 p = display_pub_attribute (p);
10840 }
10841 else if (gnu_section)
10842 {
10843 while (p < end)
10844 p = display_gnu_attribute (p,
10845 display_proc_gnu_attribute);
11c1ff18
PB		 10846 }
10847 else
10848 {
10849 /* ??? Do something sensible, like dump hex. */
2b692964 10850 printf (_(" Unknown section contexts\n"));
11c1ff18
PB		 10851 p = end;
10852 }
10853 }
10854 }
10855 }
10856 else
60bca95a 10857 printf (_("Unknown format '%c'\n"), *p);
d70c5fc7 10858
60bca95a 10859 free (contents);
11c1ff18
PB		 10860 }
10861 return 1;
10862}
10863
104d59d1 10864static int
2cf0635d 10865process_arm_specific (FILE * file)
104d59d1
JM		 10866{
10867 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
10868 display_arm_attribute, NULL);
10869}
10870
34c8bcba 10871static int
2cf0635d 10872process_power_specific (FILE * file)
34c8bcba
JM		 10873{
10874 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
10875 display_power_gnu_attribute);
10876}
10877
59e6276b
JM		 10878static int
10879process_tic6x_specific (FILE * file)
10880{
10881 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
10882 display_tic6x_attribute, NULL);
10883}
10884
ccb4c951
RS		 10885/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
10886 Print the Address, Access and Initial fields of an entry at VMA ADDR
10887 and return the VMA of the next entry. */
10888
10889static bfd_vma
2cf0635d 10890print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
ccb4c951
RS		 10891{
10892 printf (" ");
10893 print_vma (addr, LONG_HEX);
10894 printf (" ");
10895 if (addr < pltgot + 0xfff0)
10896 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
10897 else
10898 printf ("%10s", "");
10899 printf (" ");
10900 if (data == NULL)
2b692964 10901 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 10902 else
10903 {
10904 bfd_vma entry;
10905
10906 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
10907 print_vma (entry, LONG_HEX);
10908 }
10909 return addr + (is_32bit_elf ? 4 : 8);
10910}
10911
861fb55a
DJ		 10912/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
10913 PLTGOT. Print the Address and Initial fields of an entry at VMA
10914 ADDR and return the VMA of the next entry. */
10915
10916static bfd_vma
2cf0635d 10917print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 10918{
10919 printf (" ");
10920 print_vma (addr, LONG_HEX);
10921 printf (" ");
10922 if (data == NULL)
2b692964 10923 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 10924 else
10925 {
10926 bfd_vma entry;
10927
10928 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
10929 print_vma (entry, LONG_HEX);
10930 }
10931 return addr + (is_32bit_elf ? 4 : 8);
10932}
10933
19e6b90e 10934static int
2cf0635d 10935process_mips_specific (FILE * file)
5b18a4bc 10936{
2cf0635d 10937 Elf_Internal_Dyn * entry;
19e6b90e
L		 10938 size_t liblist_offset = 0;
10939 size_t liblistno = 0;
10940 size_t conflictsno = 0;
10941 size_t options_offset = 0;
10942 size_t conflicts_offset = 0;
861fb55a
DJ		 10943 size_t pltrelsz = 0;
10944 size_t pltrel = 0;
ccb4c951 10945 bfd_vma pltgot = 0;
861fb55a
DJ		 10946 bfd_vma mips_pltgot = 0;
10947 bfd_vma jmprel = 0;
ccb4c951
RS		 10948 bfd_vma local_gotno = 0;
10949 bfd_vma gotsym = 0;
10950 bfd_vma symtabno = 0;
103f02d3 10951
2cf19d5c
JM		 10952 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
10953 display_mips_gnu_attribute);
10954
19e6b90e
L		 10955 /* We have a lot of special sections. Thanks SGI! */
10956 if (dynamic_section == NULL)
10957 /* No information available. */
10958 return 0;
252b5132 10959
b2d38a17 10960 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
252b5132
RH		 10961 switch (entry->d_tag)
10962 {
10963 case DT_MIPS_LIBLIST:
d93f0186
NC		 10964 liblist_offset
10965 = offset_from_vma (file, entry->d_un.d_val,
10966 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 10967 break;
10968 case DT_MIPS_LIBLISTNO:
10969 liblistno = entry->d_un.d_val;
10970 break;
10971 case DT_MIPS_OPTIONS:
d93f0186 10972 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 10973 break;
10974 case DT_MIPS_CONFLICT:
d93f0186
NC		 10975 conflicts_offset
10976 = offset_from_vma (file, entry->d_un.d_val,
10977 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 10978 break;
10979 case DT_MIPS_CONFLICTNO:
10980 conflictsno = entry->d_un.d_val;
10981 break;
ccb4c951 10982 case DT_PLTGOT:
861fb55a
DJ		 10983 pltgot = entry->d_un.d_ptr;
10984 break;
ccb4c951
RS		 10985 case DT_MIPS_LOCAL_GOTNO:
10986 local_gotno = entry->d_un.d_val;
10987 break;
10988 case DT_MIPS_GOTSYM:
10989 gotsym = entry->d_un.d_val;
10990 break;
10991 case DT_MIPS_SYMTABNO:
10992 symtabno = entry->d_un.d_val;
10993 break;
861fb55a
DJ		 10994 case DT_MIPS_PLTGOT:
10995 mips_pltgot = entry->d_un.d_ptr;
10996 break;
10997 case DT_PLTREL:
10998 pltrel = entry->d_un.d_val;
10999 break;
11000 case DT_PLTRELSZ:
11001 pltrelsz = entry->d_un.d_val;
11002 break;
11003 case DT_JMPREL:
11004 jmprel = entry->d_un.d_ptr;
11005 break;
252b5132
RH		 11006 default:
11007 break;
11008 }
11009
11010 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
11011 {
2cf0635d 11012 Elf32_External_Lib * elib;
252b5132
RH		 11013 size_t cnt;
11014
3f5e193b
NC		 11015 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
11016 liblistno,
11017 sizeof (Elf32_External_Lib),
11018 _("liblist"));
a6e9f9df 11019 if (elib)
252b5132 11020 {
2b692964 11021 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 11022 (unsigned long) liblistno);
2b692964 11023 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 11024 stdout);
11025
11026 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 11027 {
a6e9f9df 11028 Elf32_Lib liblist;
91d6fa6a 11029 time_t atime;
a6e9f9df 11030 char timebuf[20];
2cf0635d 11031 struct tm * tmp;
a6e9f9df
AM		 11032
11033 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 11034 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 11035 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
11036 liblist.l_version = BYTE_GET (elib[cnt].l_version);
11037 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
11038
91d6fa6a 11039 tmp = gmtime (&atime);
e9e44622
JJ		 11040 snprintf (timebuf, sizeof (timebuf),
11041 "%04u-%02u-%02uT%02u:%02u:%02u",
11042 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
11043 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 11044
31104126 11045 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 11046 if (VALID_DYNAMIC_NAME (liblist.l_name))
11047 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
11048 else
2b692964 11049 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 11050 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
11051 liblist.l_version);
a6e9f9df
AM		 11052
11053 if (liblist.l_flags == 0)
2b692964 11054 puts (_(" NONE"));
a6e9f9df
AM		 11055 else
11056 {
11057 static const struct
252b5132 11058 {
2cf0635d 11059 const char * name;
a6e9f9df 11060 int bit;
252b5132 11061 }
a6e9f9df
AM		 11062 l_flags_vals[] =
11063 {
11064 { " EXACT_MATCH", LL_EXACT_MATCH },
11065 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
11066 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
11067 { " EXPORTS", LL_EXPORTS },
11068 { " DELAY_LOAD", LL_DELAY_LOAD },
11069 { " DELTA", LL_DELTA }
11070 };
11071 int flags = liblist.l_flags;
11072 size_t fcnt;
11073
60bca95a 11074 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 11075 if ((flags & l_flags_vals[fcnt].bit) != 0)
11076 {
11077 fputs (l_flags_vals[fcnt].name, stdout);
11078 flags ^= l_flags_vals[fcnt].bit;
11079 }
11080 if (flags != 0)
11081 printf (" %#x", (unsigned int) flags);
252b5132 11082
a6e9f9df
AM		 11083 puts ("");
11084 }
252b5132 11085 }
252b5132 11086
a6e9f9df
AM		 11087 free (elib);
11088 }
252b5132
RH		 11089 }
11090
11091 if (options_offset != 0)
11092 {
2cf0635d
NC		 11093 Elf_External_Options * eopt;
11094 Elf_Internal_Shdr * sect = section_headers;
11095 Elf_Internal_Options * iopt;
11096 Elf_Internal_Options * option;
252b5132
RH		 11097 size_t offset;
11098 int cnt;
11099
11100 /* Find the section header so that we get the size. */
11101 while (sect->sh_type != SHT_MIPS_OPTIONS)
b34976b6 11102 ++sect;
252b5132 11103
3f5e193b
NC		 11104 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
11105 sect->sh_size, _("options"));
a6e9f9df 11106 if (eopt)
252b5132 11107 {
3f5e193b
NC		 11108 iopt = (Elf_Internal_Options *)
11109 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 11110 if (iopt == NULL)
11111 {
591a748a 11112 error (_("Out of memory\n"));
a6e9f9df
AM		 11113 return 0;
11114 }
76da6bbe 11115
a6e9f9df
AM		 11116 offset = cnt = 0;
11117 option = iopt;
252b5132 11118
a6e9f9df
AM		 11119 while (offset < sect->sh_size)
11120 {
2cf0635d 11121 Elf_External_Options * eoption;
252b5132 11122
a6e9f9df 11123 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 11124
a6e9f9df
AM		 11125 option->kind = BYTE_GET (eoption->kind);
11126 option->size = BYTE_GET (eoption->size);
11127 option->section = BYTE_GET (eoption->section);
11128 option->info = BYTE_GET (eoption->info);
76da6bbe 11129
a6e9f9df 11130 offset += option->size;
252b5132 11131
a6e9f9df
AM		 11132 ++option;
11133 ++cnt;
11134 }
252b5132 11135
a6e9f9df
AM		 11136 printf (_("\nSection '%s' contains %d entries:\n"),
11137 SECTION_NAME (sect), cnt);
76da6bbe 11138
a6e9f9df 11139 option = iopt;
252b5132 11140
a6e9f9df 11141 while (cnt-- > 0)
252b5132 11142 {
a6e9f9df
AM		 11143 size_t len;
11144
11145 switch (option->kind)
252b5132 11146 {
a6e9f9df
AM		 11147 case ODK_NULL:
11148 /* This shouldn't happen. */
11149 printf (" NULL %d %lx", option->section, option->info);
11150 break;
11151 case ODK_REGINFO:
11152 printf (" REGINFO ");
11153 if (elf_header.e_machine == EM_MIPS)
11154 {
11155 /* 32bit form. */
2cf0635d 11156 Elf32_External_RegInfo * ereg;
b34976b6 11157 Elf32_RegInfo reginfo;
a6e9f9df
AM		 11158
11159 ereg = (Elf32_External_RegInfo *) (option + 1);
11160 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
11161 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11162 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11163 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11164 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
11165 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
11166
11167 printf ("GPR %08lx GP 0x%lx\n",
11168 reginfo.ri_gprmask,
11169 (unsigned long) reginfo.ri_gp_value);
11170 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11171 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11172 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11173 }
11174 else
11175 {
11176 /* 64 bit form. */
2cf0635d 11177 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 11178 Elf64_Internal_RegInfo reginfo;
11179
11180 ereg = (Elf64_External_RegInfo *) (option + 1);
11181 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
11182 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11183 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11184 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11185 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 11186 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 11187
11188 printf ("GPR %08lx GP 0x",
11189 reginfo.ri_gprmask);
11190 printf_vma (reginfo.ri_gp_value);
11191 printf ("\n");
11192
11193 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11194 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11195 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11196 }
11197 ++option;
11198 continue;
11199 case ODK_EXCEPTIONS:
11200 fputs (" EXCEPTIONS fpe_min(", stdout);
11201 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
11202 fputs (") fpe_max(", stdout);
11203 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
11204 fputs (")", stdout);
11205
11206 if (option->info & OEX_PAGE0)
11207 fputs (" PAGE0", stdout);
11208 if (option->info & OEX_SMM)
11209 fputs (" SMM", stdout);
11210 if (option->info & OEX_FPDBUG)
11211 fputs (" FPDBUG", stdout);
11212 if (option->info & OEX_DISMISS)
11213 fputs (" DISMISS", stdout);
11214 break;
11215 case ODK_PAD:
11216 fputs (" PAD ", stdout);
11217 if (option->info & OPAD_PREFIX)
11218 fputs (" PREFIX", stdout);
11219 if (option->info & OPAD_POSTFIX)
11220 fputs (" POSTFIX", stdout);
11221 if (option->info & OPAD_SYMBOL)
11222 fputs (" SYMBOL", stdout);
11223 break;
11224 case ODK_HWPATCH:
11225 fputs (" HWPATCH ", stdout);
11226 if (option->info & OHW_R4KEOP)
11227 fputs (" R4KEOP", stdout);
11228 if (option->info & OHW_R8KPFETCH)
11229 fputs (" R8KPFETCH", stdout);
11230 if (option->info & OHW_R5KEOP)
11231 fputs (" R5KEOP", stdout);
11232 if (option->info & OHW_R5KCVTL)
11233 fputs (" R5KCVTL", stdout);
11234 break;
11235 case ODK_FILL:
11236 fputs (" FILL ", stdout);
11237 /* XXX Print content of info word? */
11238 break;
11239 case ODK_TAGS:
11240 fputs (" TAGS ", stdout);
11241 /* XXX Print content of info word? */
11242 break;
11243 case ODK_HWAND:
11244 fputs (" HWAND ", stdout);
11245 if (option->info & OHWA0_R4KEOP_CHECKED)
11246 fputs (" R4KEOP_CHECKED", stdout);
11247 if (option->info & OHWA0_R4KEOP_CLEAN)
11248 fputs (" R4KEOP_CLEAN", stdout);
11249 break;
11250 case ODK_HWOR:
11251 fputs (" HWOR ", stdout);
11252 if (option->info & OHWA0_R4KEOP_CHECKED)
11253 fputs (" R4KEOP_CHECKED", stdout);
11254 if (option->info & OHWA0_R4KEOP_CLEAN)
11255 fputs (" R4KEOP_CLEAN", stdout);
11256 break;
11257 case ODK_GP_GROUP:
11258 printf (" GP_GROUP %#06lx self-contained %#06lx",
11259 option->info & OGP_GROUP,
11260 (option->info & OGP_SELF) >> 16);
11261 break;
11262 case ODK_IDENT:
11263 printf (" IDENT %#06lx self-contained %#06lx",
11264 option->info & OGP_GROUP,
11265 (option->info & OGP_SELF) >> 16);
11266 break;
11267 default:
11268 /* This shouldn't happen. */
11269 printf (" %3d ??? %d %lx",
11270 option->kind, option->section, option->info);
11271 break;
252b5132 11272 }
a6e9f9df 11273
2cf0635d 11274 len = sizeof (* eopt);
a6e9f9df
AM		 11275 while (len < option->size)
11276 if (((char *) option)[len] >= ' '
11277 && ((char *) option)[len] < 0x7f)
11278 printf ("%c", ((char *) option)[len++]);
11279 else
11280 printf ("\\%03o", ((char *) option)[len++]);
11281
11282 fputs ("\n", stdout);
252b5132 11283 ++option;
252b5132
RH		 11284 }
11285
a6e9f9df 11286 free (eopt);
252b5132 11287 }
252b5132
RH		 11288 }
11289
11290 if (conflicts_offset != 0 && conflictsno != 0)
11291 {
2cf0635d 11292 Elf32_Conflict * iconf;
252b5132
RH		 11293 size_t cnt;
11294
11295 if (dynamic_symbols == NULL)
11296 {
591a748a 11297 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 11298 return 0;
11299 }
11300
3f5e193b 11301 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 11302 if (iconf == NULL)
11303 {
591a748a 11304 error (_("Out of memory\n"));
252b5132
RH		 11305 return 0;
11306 }
11307
9ea033b2 11308 if (is_32bit_elf)
252b5132 11309 {
2cf0635d 11310 Elf32_External_Conflict * econf32;
a6e9f9df 11311
3f5e193b
NC		 11312 econf32 = (Elf32_External_Conflict *)
11313 get_data (NULL, file, conflicts_offset, conflictsno,
11314 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 11315 if (!econf32)
11316 return 0;
252b5132
RH		 11317
11318 for (cnt = 0; cnt < conflictsno; ++cnt)
11319 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 11320
11321 free (econf32);
252b5132
RH		 11322 }
11323 else
11324 {
2cf0635d 11325 Elf64_External_Conflict * econf64;
a6e9f9df 11326
3f5e193b
NC		 11327 econf64 = (Elf64_External_Conflict *)
11328 get_data (NULL, file, conflicts_offset, conflictsno,
11329 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 11330 if (!econf64)
11331 return 0;
252b5132
RH		 11332
11333 for (cnt = 0; cnt < conflictsno; ++cnt)
11334 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 11335
11336 free (econf64);
252b5132
RH		 11337 }
11338
c7e7ca54
NC		 11339 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11340 (unsigned long) conflictsno);
252b5132
RH		 11341 puts (_(" Num: Index Value Name"));
11342
11343 for (cnt = 0; cnt < conflictsno; ++cnt)
11344 {
2cf0635d 11345 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
252b5132 11346
b34976b6 11347 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
f7a99963 11348 print_vma (psym->st_value, FULL_HEX);
31104126 11349 putchar (' ');
d79b3d50
NC		 11350 if (VALID_DYNAMIC_NAME (psym->st_name))
11351 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11352 else
2b692964 11353 printf (_("<corrupt: %14ld>"), psym->st_name);
31104126 11354 putchar ('\n');
252b5132
RH		 11355 }
11356
252b5132
RH		 11357 free (iconf);
11358 }
11359
ccb4c951
RS		 11360 if (pltgot != 0 && local_gotno != 0)
11361 {
91d6fa6a 11362 bfd_vma ent, local_end, global_end;
bbeee7ea 11363 size_t i, offset;
2cf0635d 11364 unsigned char * data;
bbeee7ea 11365 int addr_size;
ccb4c951 11366
91d6fa6a 11367 ent = pltgot;
ccb4c951
RS		 11368 addr_size = (is_32bit_elf ? 4 : 8);
11369 local_end = pltgot + local_gotno * addr_size;
11370 global_end = local_end + (symtabno - gotsym) * addr_size;
11371
11372 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b
NC		 11373 data = (unsigned char *) get_data (NULL, file, offset,
11374 global_end - pltgot, 1, _("GOT"));
ccb4c951
RS		 11375 printf (_("\nPrimary GOT:\n"));
11376 printf (_(" Canonical gp value: "));
11377 print_vma (pltgot + 0x7ff0, LONG_HEX);
11378 printf ("\n\n");
11379
11380 printf (_(" Reserved entries:\n"));
11381 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 11382 addr_size * 2, _("Address"), _("Access"),
11383 addr_size * 2, _("Initial"));
91d6fa6a 11384 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 11385 printf (_(" Lazy resolver\n"));
ccb4c951 11386 if (data
91d6fa6a 11387 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 11388 >> (addr_size * 8 - 1)) != 0)
11389 {
91d6fa6a 11390 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 11391 printf (_(" Module pointer (GNU extension)\n"));
ccb4c951
RS		 11392 }
11393 printf ("\n");
11394
91d6fa6a 11395 if (ent < local_end)
ccb4c951
RS		 11396 {
11397 printf (_(" Local entries:\n"));
11398 printf (_(" %*s %10s %*s\n"),
2b692964
NC		 11399 addr_size * 2, _("Address"), _("Access"),
11400 addr_size * 2, _("Initial"));
91d6fa6a 11401 while (ent < local_end)
ccb4c951 11402 {
91d6fa6a 11403 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 11404 printf ("\n");
11405 }
11406 printf ("\n");
11407 }
11408
11409 if (gotsym < symtabno)
11410 {
11411 int sym_width;
11412
11413 printf (_(" Global entries:\n"));
11414 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
2b692964
NC		 11415 addr_size * 2, _("Address"), _("Access"),
11416 addr_size * 2, _("Initial"),
11417 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
ccb4c951
RS		 11418 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
11419 for (i = gotsym; i < symtabno; i++)
11420 {
2cf0635d 11421 Elf_Internal_Sym * psym;
ccb4c951
RS		 11422
11423 psym = dynamic_symbols + i;
91d6fa6a 11424 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 11425 printf (" ");
11426 print_vma (psym->st_value, LONG_HEX);
11427 printf (" %-7s %3s ",
11428 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
11429 get_symbol_index_type (psym->st_shndx));
11430 if (VALID_DYNAMIC_NAME (psym->st_name))
11431 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
11432 else
2b692964 11433 printf (_("<corrupt: %14ld>"), psym->st_name);
ccb4c951
RS		 11434 printf ("\n");
11435 }
11436 printf ("\n");
11437 }
11438
11439 if (data)
11440 free (data);
11441 }
11442
861fb55a
DJ		 11443 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
11444 {
91d6fa6a 11445 bfd_vma ent, end;
861fb55a
DJ		 11446 size_t offset, rel_offset;
11447 unsigned long count, i;
2cf0635d 11448 unsigned char * data;
861fb55a 11449 int addr_size, sym_width;
2cf0635d 11450 Elf_Internal_Rela * rels;
861fb55a
DJ		 11451
11452 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
11453 if (pltrel == DT_RELA)
11454 {
11455 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
11456 return 0;
11457 }
11458 else
11459 {
11460 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
11461 return 0;
11462 }
11463
91d6fa6a 11464 ent = mips_pltgot;
861fb55a
DJ		 11465 addr_size = (is_32bit_elf ? 4 : 8);
11466 end = mips_pltgot + (2 + count) * addr_size;
11467
11468 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b
NC		 11469 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
11470 1, _("PLT GOT"));
861fb55a
DJ		 11471 printf (_("\nPLT GOT:\n\n"));
11472 printf (_(" Reserved entries:\n"));
11473 printf (_(" %*s %*s Purpose\n"),
2b692964 11474 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 11475 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 11476 printf (_(" PLT lazy resolver\n"));
91d6fa6a 11477 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 11478 printf (_(" Module pointer\n"));
861fb55a
DJ		 11479 printf ("\n");
11480
11481 printf (_(" Entries:\n"));
11482 printf (_(" %*s %*s %*s %-7s %3s %s\n"),
2b692964
NC		 11483 addr_size * 2, _("Address"),
11484 addr_size * 2, _("Initial"),
11485 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 11486 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
11487 for (i = 0; i < count; i++)
11488 {
2cf0635d 11489 Elf_Internal_Sym * psym;
861fb55a
DJ		 11490
11491 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
91d6fa6a 11492 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a
DJ		 11493 printf (" ");
11494 print_vma (psym->st_value, LONG_HEX);
11495 printf (" %-7s %3s ",
11496 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
11497 get_symbol_index_type (psym->st_shndx));
11498 if (VALID_DYNAMIC_NAME (psym->st_name))
11499 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
11500 else
2b692964 11501 printf (_("<corrupt: %14ld>"), psym->st_name);
861fb55a
DJ		 11502 printf ("\n");
11503 }
11504 printf ("\n");
11505
11506 if (data)
11507 free (data);
11508 free (rels);
11509 }
11510
252b5132
RH		 11511 return 1;
11512}
11513
047b2264 11514static int
2cf0635d 11515process_gnu_liblist (FILE * file)
047b2264 11516{
2cf0635d
NC		 11517 Elf_Internal_Shdr * section;
11518 Elf_Internal_Shdr * string_sec;
11519 Elf32_External_Lib * elib;
11520 char * strtab;
c256ffe7 11521 size_t strtab_size;
047b2264
JJ		 11522 size_t cnt;
11523 unsigned i;
11524
11525 if (! do_arch)
11526 return 0;
11527
11528 for (i = 0, section = section_headers;
11529 i < elf_header.e_shnum;
b34976b6 11530 i++, section++)
047b2264
JJ		 11531 {
11532 switch (section->sh_type)
11533 {
11534 case SHT_GNU_LIBLIST:
4fbb74a6 11535 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 11536 break;
11537
3f5e193b
NC		 11538 elib = (Elf32_External_Lib *)
11539 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
11540 _("liblist"));
047b2264
JJ		 11541
11542 if (elib == NULL)
11543 break;
4fbb74a6 11544 string_sec = section_headers + section->sh_link;
047b2264 11545
3f5e193b
NC		 11546 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
11547 string_sec->sh_size,
11548 _("liblist string table"));
c256ffe7 11549 strtab_size = string_sec->sh_size;
047b2264
JJ		 11550
11551 if (strtab == NULL
11552 || section->sh_entsize != sizeof (Elf32_External_Lib))
11553 {
11554 free (elib);
11555 break;
11556 }
11557
11558 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11559 SECTION_NAME (section),
0af1713e 11560 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 11561
2b692964 11562 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 11563
11564 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
11565 ++cnt)
11566 {
11567 Elf32_Lib liblist;
91d6fa6a 11568 time_t atime;
047b2264 11569 char timebuf[20];
2cf0635d 11570 struct tm * tmp;
047b2264
JJ		 11571
11572 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 11573 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 11574 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
11575 liblist.l_version = BYTE_GET (elib[cnt].l_version);
11576 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
11577
91d6fa6a 11578 tmp = gmtime (&atime);
e9e44622
JJ		 11579 snprintf (timebuf, sizeof (timebuf),
11580 "%04u-%02u-%02uT%02u:%02u:%02u",
11581 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
11582 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 11583
11584 printf ("%3lu: ", (unsigned long) cnt);
11585 if (do_wide)
c256ffe7 11586 printf ("%-20s", liblist.l_name < strtab_size
2b692964 11587 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 11588 else
c256ffe7 11589 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 11590 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 11591 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
11592 liblist.l_version, liblist.l_flags);
11593 }
11594
11595 free (elib);
11596 }
11597 }
11598
11599 return 1;
11600}
11601
9437c45b 11602static const char *
d3ba0551 11603get_note_type (unsigned e_type)
779fe533
NC		 11604{
11605 static char buff[64];
103f02d3 11606
1ec5cd37
NC		 11607 if (elf_header.e_type == ET_CORE)
11608 switch (e_type)
11609 {
57346661 11610 case NT_AUXV:
1ec5cd37 11611 return _("NT_AUXV (auxiliary vector)");
57346661 11612 case NT_PRSTATUS:
1ec5cd37 11613 return _("NT_PRSTATUS (prstatus structure)");
57346661 11614 case NT_FPREGSET:
1ec5cd37 11615 return _("NT_FPREGSET (floating point registers)");
57346661 11616 case NT_PRPSINFO:
1ec5cd37 11617 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 11618 case NT_TASKSTRUCT:
1ec5cd37 11619 return _("NT_TASKSTRUCT (task structure)");
57346661 11620 case NT_PRXFPREG:
1ec5cd37 11621 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 11622 case NT_PPC_VMX:
11623 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 11624 case NT_PPC_VSX:
11625 return _("NT_PPC_VSX (ppc VSX registers)");
4339cae0
L		 11626 case NT_X86_XSTATE:
11627 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 11628 case NT_S390_HIGH_GPRS:
11629 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 11630 case NT_S390_TIMER:
11631 return _("NT_S390_TIMER (s390 timer register)");
11632 case NT_S390_TODCMP:
11633 return _("NT_S390_TODCMP (s390 TOD comparator register)");
11634 case NT_S390_TODPREG:
11635 return _("NT_S390_TODPREG (s390 TOD programmable register)");
11636 case NT_S390_CTRS:
11637 return _("NT_S390_CTRS (s390 control registers)");
11638 case NT_S390_PREFIX:
11639 return _("NT_S390_PREFIX (s390 prefix register)");
57346661 11640 case NT_PSTATUS:
1ec5cd37 11641 return _("NT_PSTATUS (pstatus structure)");
57346661 11642 case NT_FPREGS:
1ec5cd37 11643 return _("NT_FPREGS (floating point registers)");
57346661 11644 case NT_PSINFO:
1ec5cd37 11645 return _("NT_PSINFO (psinfo structure)");
57346661 11646 case NT_LWPSTATUS:
1ec5cd37 11647 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 11648 case NT_LWPSINFO:
1ec5cd37 11649 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 11650 case NT_WIN32PSTATUS:
1ec5cd37
NC		 11651 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11652 default:
11653 break;
11654 }
11655 else
11656 switch (e_type)
11657 {
11658 case NT_VERSION:
11659 return _("NT_VERSION (version)");
11660 case NT_ARCH:
11661 return _("NT_ARCH (architecture)");
11662 default:
11663 break;
11664 }
11665
e9e44622 11666 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 11667 return buff;
779fe533
NC		 11668}
11669
1118d252
RM		 11670static const char *
11671get_gnu_elf_note_type (unsigned e_type)
11672{
11673 static char buff[64];
11674
11675 switch (e_type)
11676 {
11677 case NT_GNU_ABI_TAG:
11678 return _("NT_GNU_ABI_TAG (ABI version tag)");
11679 case NT_GNU_HWCAP:
11680 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
11681 case NT_GNU_BUILD_ID:
11682 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 11683 case NT_GNU_GOLD_VERSION:
11684 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 11685 default:
11686 break;
11687 }
11688
11689 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
11690 return buff;
11691}
11692
9437c45b 11693static const char *
d3ba0551 11694get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 11695{
11696 static char buff[64];
11697
b4db1224 11698 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 11699 {
11700 /* NetBSD core "procinfo" structure. */
11701 return _("NetBSD procinfo structure");
11702 }
11703
11704 /* As of Jan 2002 there are no other machine-independent notes
11705 defined for NetBSD core files. If the note type is less
11706 than the start of the machine-dependent note types, we don't
11707 understand it. */
11708
b4db1224 11709 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 11710 {
e9e44622 11711 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 11712 return buff;
11713 }
11714
11715 switch (elf_header.e_machine)
11716 {
11717 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11718 and PT_GETFPREGS == mach+2. */
11719
11720 case EM_OLD_ALPHA:
11721 case EM_ALPHA:
11722 case EM_SPARC:
11723 case EM_SPARC32PLUS:
11724 case EM_SPARCV9:
11725 switch (e_type)
11726 {
2b692964 11727 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 11728 return _("PT_GETREGS (reg structure)");
2b692964 11729 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 11730 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 11731 default:
11732 break;
11733 }
11734 break;
11735
11736 /* On all other arch's, PT_GETREGS == mach+1 and
11737 PT_GETFPREGS == mach+3. */
11738 default:
11739 switch (e_type)
11740 {
2b692964 11741 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 11742 return _("PT_GETREGS (reg structure)");
2b692964 11743 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 11744 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 11745 default:
11746 break;
11747 }
11748 }
11749
e9e44622
JJ		 11750 snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
11751 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 11752 return buff;
11753}
11754
6d118b09
NC		 11755/* Note that by the ELF standard, the name field is already null byte
11756 terminated, and namesz includes the terminating null byte.
11757 I.E. the value of namesz for the name "FSF" is 4.
11758
e3c8793a 11759 If the value of namesz is zero, there is no name present. */
779fe533 11760static int
2cf0635d 11761process_note (Elf_Internal_Note * pnote)
779fe533 11762{
2cf0635d
NC		 11763 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
11764 const char * nt;
9437c45b
JT		 11765
11766 if (pnote->namesz == 0)
1ec5cd37
NC		 11767 /* If there is no note name, then use the default set of
11768 note type strings. */
11769 nt = get_note_type (pnote->type);
11770
1118d252
RM		 11771 else if (const_strneq (pnote->namedata, "GNU"))
11772 /* GNU-specific object file notes. */
11773 nt = get_gnu_elf_note_type (pnote->type);
11774
0112cd26 11775 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 11776 /* NetBSD-specific core file notes. */
11777 nt = get_netbsd_elfcore_note_type (pnote->type);
11778
b15fa79e
AM		 11779 else if (strneq (pnote->namedata, "SPU/", 4))
11780 {
11781 /* SPU-specific core file notes. */
11782 nt = pnote->namedata + 4;
11783 name = "SPU";
11784 }
11785
9437c45b 11786 else
1ec5cd37
NC		 11787 /* Don't recognize this note name; just use the default set of
11788 note type strings. */
9437c45b 11789 nt = get_note_type (pnote->type);
9437c45b 11790
b15fa79e 11791 printf (" %s\t\t0x%08lx\t%s\n", name, pnote->descsz, nt);
779fe533
NC		 11792 return 1;
11793}
11794
6d118b09 11795
779fe533 11796static int
2cf0635d 11797process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 11798{
2cf0635d
NC		 11799 Elf_External_Note * pnotes;
11800 Elf_External_Note * external;
b34976b6 11801 int res = 1;
103f02d3 11802
779fe533
NC		 11803 if (length <= 0)
11804 return 0;
103f02d3 11805
3f5e193b
NC		 11806 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
11807 _("notes"));
a6e9f9df
AM		 11808 if (!pnotes)
11809 return 0;
779fe533 11810
103f02d3 11811 external = pnotes;
103f02d3 11812
305c7206 11813 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 11814 (unsigned long) offset, (unsigned long) length);
779fe533 11815 printf (_(" Owner\t\tData size\tDescription\n"));
103f02d3 11816
2cf0635d 11817 while (external < (Elf_External_Note *) ((char *) pnotes + length))
779fe533 11818 {
2cf0635d 11819 Elf_External_Note * next;
b34976b6 11820 Elf_Internal_Note inote;
2cf0635d 11821 char * temp = NULL;
6d118b09
NC		 11822
11823 inote.type = BYTE_GET (external->type);
11824 inote.namesz = BYTE_GET (external->namesz);
11825 inote.namedata = external->name;
11826 inote.descsz = BYTE_GET (external->descsz);
11827 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
11828 inote.descpos = offset + (inote.descdata - (char *) pnotes);
76da6bbe 11829
2cf0635d 11830 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
3e55a963
NC		 11831
11832 if (((char *) next) > (((char *) pnotes) + length))
11833 {
0fd3a477 11834 warn (_("corrupt note found at offset %lx into core notes\n"),
0af1713e 11835 (unsigned long) ((char *) external - (char *) pnotes));
0fd3a477 11836 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
3e55a963
NC		 11837 inote.type, inote.namesz, inote.descsz);
11838 break;
11839 }
11840
11841 external = next;
6d118b09
NC		 11842
11843 /* Verify that name is null terminated. It appears that at least
11844 one version of Linux (RedHat 6.0) generates corefiles that don't
11845 comply with the ELF spec by failing to include the null byte in
11846 namesz. */
11847 if (inote.namedata[inote.namesz] != '\0')
11848 {
3f5e193b 11849 temp = (char *) malloc (inote.namesz + 1);
76da6bbe 11850
6d118b09
NC		 11851 if (temp == NULL)
11852 {
11853 error (_("Out of memory\n"));
11854 res = 0;
11855 break;
11856 }
76da6bbe 11857
6d118b09
NC		 11858 strncpy (temp, inote.namedata, inote.namesz);
11859 temp[inote.namesz] = 0;
76da6bbe 11860
6d118b09
NC		 11861 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
11862 inote.namedata = temp;
11863 }
11864
11865 res &= process_note (& inote);
103f02d3 11866
6d118b09
NC		 11867 if (temp != NULL)
11868 {
11869 free (temp);
11870 temp = NULL;
11871 }
779fe533
NC		 11872 }
11873
11874 free (pnotes);
103f02d3 11875
779fe533
NC		 11876 return res;
11877}
11878
11879static int
2cf0635d 11880process_corefile_note_segments (FILE * file)
779fe533 11881{
2cf0635d 11882 Elf_Internal_Phdr * segment;
b34976b6
AM		 11883 unsigned int i;
11884 int res = 1;
103f02d3 11885
d93f0186 11886 if (! get_program_headers (file))
779fe533 11887 return 0;
103f02d3 11888
779fe533
NC		 11889 for (i = 0, segment = program_headers;
11890 i < elf_header.e_phnum;
b34976b6 11891 i++, segment++)
779fe533
NC		 11892 {
11893 if (segment->p_type == PT_NOTE)
103f02d3 11894 res &= process_corefile_note_segment (file,
30800947
NC		 11895 (bfd_vma) segment->p_offset,
11896 (bfd_vma) segment->p_filesz);
779fe533 11897 }
103f02d3 11898
779fe533
NC		 11899 return res;
11900}
11901
11902static int
2cf0635d 11903process_note_sections (FILE * file)
1ec5cd37 11904{
2cf0635d 11905 Elf_Internal_Shdr * section;
1ec5cd37
NC		 11906 unsigned long i;
11907 int res = 1;
11908
11909 for (i = 0, section = section_headers;
11910 i < elf_header.e_shnum;
11911 i++, section++)
11912 if (section->sh_type == SHT_NOTE)
11913 res &= process_corefile_note_segment (file,
11914 (bfd_vma) section->sh_offset,
11915 (bfd_vma) section->sh_size);
11916
11917 return res;
11918}
11919
11920static int
2cf0635d 11921process_notes (FILE * file)
779fe533
NC		 11922{
11923 /* If we have not been asked to display the notes then do nothing. */
11924 if (! do_notes)
11925 return 1;
103f02d3 11926
779fe533 11927 if (elf_header.e_type != ET_CORE)
1ec5cd37 11928 return process_note_sections (file);
103f02d3 11929
779fe533 11930 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 11931 if (elf_header.e_phnum > 0)
11932 return process_corefile_note_segments (file);
779fe533 11933
1ec5cd37
NC		 11934 printf (_("No note segments present in the core file.\n"));
11935 return 1;
779fe533
NC		 11936}
11937
252b5132 11938static int
2cf0635d 11939process_arch_specific (FILE * file)
252b5132 11940{
a952a375
NC		 11941 if (! do_arch)
11942 return 1;
11943
252b5132
RH		 11944 switch (elf_header.e_machine)
11945 {
11c1ff18
PB		 11946 case EM_ARM:
11947 return process_arm_specific (file);
252b5132 11948 case EM_MIPS:
4fe85591 11949 case EM_MIPS_RS3_LE:
252b5132
RH		 11950 return process_mips_specific (file);
11951 break;
34c8bcba
JM		 11952 case EM_PPC:
11953 return process_power_specific (file);
11954 break;
59e6276b
JM		 11955 case EM_TI_C6000:
11956 return process_tic6x_specific (file);
11957 break;
252b5132
RH		 11958 default:
11959 break;
11960 }
11961 return 1;
11962}
11963
11964static int
2cf0635d 11965get_file_header (FILE * file)
252b5132 11966{
9ea033b2
NC		 11967 /* Read in the identity array. */
11968 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 11969 return 0;
11970
9ea033b2 11971 /* Determine how to read the rest of the header. */
b34976b6 11972 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 11973 {
11974 default: /* fall through */
11975 case ELFDATANONE: /* fall through */
adab8cdc
AO		 11976 case ELFDATA2LSB:
11977 byte_get = byte_get_little_endian;
11978 byte_put = byte_put_little_endian;
11979 break;
11980 case ELFDATA2MSB:
11981 byte_get = byte_get_big_endian;
11982 byte_put = byte_put_big_endian;
11983 break;
9ea033b2
NC		 11984 }
11985
11986 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 11987 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 11988
11989 /* Read in the rest of the header. */
11990 if (is_32bit_elf)
11991 {
11992 Elf32_External_Ehdr ehdr32;
252b5132 11993
9ea033b2
NC		 11994 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
11995 return 0;
103f02d3 11996
9ea033b2
NC		 11997 elf_header.e_type = BYTE_GET (ehdr32.e_type);
11998 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
11999 elf_header.e_version = BYTE_GET (ehdr32.e_version);
12000 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
12001 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
12002 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
12003 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
12004 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
12005 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
12006 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
12007 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
12008 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
12009 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
12010 }
252b5132 12011 else
9ea033b2
NC		 12012 {
12013 Elf64_External_Ehdr ehdr64;
a952a375
NC		 12014
12015 /* If we have been compiled with sizeof (bfd_vma) == 4, then
12016 we will not be able to cope with the 64bit data found in
12017 64 ELF files. Detect this now and abort before we start
50c2245b 12018 overwriting things. */
a952a375
NC		 12019 if (sizeof (bfd_vma) < 8)
12020 {
e3c8793a
NC		 12021 error (_("This instance of readelf has been built without support for a\n\
1202264 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 12023 return 0;
12024 }
103f02d3 12025
9ea033b2
NC		 12026 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
12027 return 0;
103f02d3 12028
9ea033b2
NC		 12029 elf_header.e_type = BYTE_GET (ehdr64.e_type);
12030 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
12031 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 12032 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
12033 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
12034 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 12035 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
12036 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
12037 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
12038 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
12039 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
12040 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
12041 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
12042 }
252b5132 12043
7ece0d85
JJ		 12044 if (elf_header.e_shoff)
12045 {
12046 /* There may be some extensions in the first section header. Don't
12047 bomb if we can't read it. */
12048 if (is_32bit_elf)
12049 get_32bit_section_headers (file, 1);
12050 else
12051 get_64bit_section_headers (file, 1);
12052 }
560f3c1c 12053
252b5132
RH		 12054 return 1;
12055}
12056
fb52b2f4
NC		 12057/* Process one ELF object file according to the command line options.
12058 This file may actually be stored in an archive. The file is
12059 positioned at the start of the ELF object. */
12060
ff78d6d6 12061static int
2cf0635d 12062process_object (char * file_name, FILE * file)
252b5132 12063{
252b5132
RH		 12064 unsigned int i;
12065
252b5132
RH		 12066 if (! get_file_header (file))
12067 {
12068 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 12069 return 1;
252b5132
RH		 12070 }
12071
12072 /* Initialise per file variables. */
60bca95a 12073 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 12074 version_info[i] = 0;
12075
60bca95a 12076 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132
RH		 12077 dynamic_info[i] = 0;
12078
12079 /* Process the file. */
12080 if (show_name)
12081 printf (_("\nFile: %s\n"), file_name);
12082
18bd398b
NC		 12083 /* Initialise the dump_sects array from the cmdline_dump_sects array.
12084 Note we do this even if cmdline_dump_sects is empty because we
12085 must make sure that the dump_sets array is zeroed out before each
12086 object file is processed. */
12087 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 12088 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 12089
12090 if (num_cmdline_dump_sects > 0)
12091 {
12092 if (num_dump_sects == 0)
12093 /* A sneaky way of allocating the dump_sects array. */
09c11c86 12094 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 12095
12096 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 12097 memcpy (dump_sects, cmdline_dump_sects,
12098 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 12099 }
d70c5fc7 12100
252b5132 12101 if (! process_file_header ())
fb52b2f4 12102 return 1;
252b5132 12103
d1f5c6e3 12104 if (! process_section_headers (file))
2f62977e 12105 {
d1f5c6e3
L		 12106 /* Without loaded section headers we cannot process lots of
12107 things. */
2f62977e 12108 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 12109
2f62977e 12110 if (! do_using_dynamic)
2c610e4b 12111 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 12112 }
252b5132 12113
d1f5c6e3
L		 12114 if (! process_section_groups (file))
12115 {
12116 /* Without loaded section groups we cannot process unwind. */
12117 do_unwind = 0;
12118 }
12119
2f62977e 12120 if (process_program_headers (file))
b2d38a17 12121 process_dynamic_section (file);
252b5132
RH		 12122
12123 process_relocs (file);
12124
4d6ed7c8
NC		 12125 process_unwind (file);
12126
252b5132
RH		 12127 process_symbol_table (file);
12128
12129 process_syminfo (file);
12130
12131 process_version_sections (file);
12132
12133 process_section_contents (file);
f5842774 12134
1ec5cd37 12135 process_notes (file);
103f02d3 12136
047b2264
JJ		 12137 process_gnu_liblist (file);
12138
252b5132
RH		 12139 process_arch_specific (file);
12140
d93f0186
NC		 12141 if (program_headers)
12142 {
12143 free (program_headers);
12144 program_headers = NULL;
12145 }
12146
252b5132
RH		 12147 if (section_headers)
12148 {
12149 free (section_headers);
12150 section_headers = NULL;
12151 }
12152
12153 if (string_table)
12154 {
12155 free (string_table);
12156 string_table = NULL;
d40ac9bd 12157 string_table_length = 0;
252b5132
RH		 12158 }
12159
12160 if (dynamic_strings)
12161 {
12162 free (dynamic_strings);
12163 dynamic_strings = NULL;
d79b3d50 12164 dynamic_strings_length = 0;
252b5132
RH		 12165 }
12166
12167 if (dynamic_symbols)
12168 {
12169 free (dynamic_symbols);
12170 dynamic_symbols = NULL;
19936277 12171 num_dynamic_syms = 0;
252b5132
RH		 12172 }
12173
12174 if (dynamic_syminfo)
12175 {
12176 free (dynamic_syminfo);
12177 dynamic_syminfo = NULL;
12178 }
ff78d6d6 12179
e4b17d5c
L		 12180 if (section_headers_groups)
12181 {
12182 free (section_headers_groups);
12183 section_headers_groups = NULL;
12184 }
12185
12186 if (section_groups)
12187 {
2cf0635d
NC		 12188 struct group_list * g;
12189 struct group_list * next;
e4b17d5c
L		 12190
12191 for (i = 0; i < group_count; i++)
12192 {
12193 for (g = section_groups [i].root; g != NULL; g = next)
12194 {
12195 next = g->next;
12196 free (g);
12197 }
12198 }
12199
12200 free (section_groups);
12201 section_groups = NULL;
12202 }
12203
19e6b90e 12204 free_debug_memory ();
18bd398b 12205
ff78d6d6 12206 return 0;
252b5132
RH		 12207}
12208
2cf0635d
NC		 12209/* Return the path name for a proxy entry in a thin archive, adjusted relative
12210 to the path name of the thin archive itself if necessary. Always returns
12211 a pointer to malloc'ed memory. */
12212
12213static char *
12214adjust_relative_path (char * file_name, char * name, int name_len)
12215{
12216 char * member_file_name;
12217 const char * base_name = lbasename (file_name);
12218
12219 /* This is a proxy entry for a thin archive member.
12220 If the extended name table contains an absolute path
12221 name, or if the archive is in the current directory,
12222 use the path name as given. Otherwise, we need to
12223 find the member relative to the directory where the
12224 archive is located. */
12225 if (IS_ABSOLUTE_PATH (name) || base_name == file_name)
12226 {
3f5e193b 12227 member_file_name = (char *) malloc (name_len + 1);
2cf0635d
NC		 12228 if (member_file_name == NULL)
12229 {
12230 error (_("Out of memory\n"));
12231 return NULL;
12232 }
12233 memcpy (member_file_name, name, name_len);
12234 member_file_name[name_len] = '\0';
12235 }
12236 else
12237 {
12238 /* Concatenate the path components of the archive file name
12239 to the relative path name from the extended name table. */
12240 size_t prefix_len = base_name - file_name;
3f5e193b 12241 member_file_name = (char *) malloc (prefix_len + name_len + 1);
2cf0635d
NC		 12242 if (member_file_name == NULL)
12243 {
12244 error (_("Out of memory\n"));
12245 return NULL;
12246 }
12247 memcpy (member_file_name, file_name, prefix_len);
12248 memcpy (member_file_name + prefix_len, name, name_len);
12249 member_file_name[prefix_len + name_len] = '\0';
12250 }
12251 return member_file_name;
12252}
12253
12254/* Structure to hold information about an archive file. */
12255
12256struct archive_info
12257{
12258 char * file_name; /* Archive file name. */
12259 FILE * file; /* Open file descriptor. */
12260 unsigned long index_num; /* Number of symbols in table. */
12261 unsigned long * index_array; /* The array of member offsets. */
12262 char * sym_table; /* The symbol table. */
12263 unsigned long sym_size; /* Size of the symbol table. */
12264 char * longnames; /* The long file names table. */
12265 unsigned long longnames_size; /* Size of the long file names table. */
12266 unsigned long nested_member_origin; /* Origin in the nested archive of the current member. */
12267 unsigned long next_arhdr_offset; /* Offset of the next archive header. */
12268 bfd_boolean is_thin_archive; /* TRUE if this is a thin archive. */
12269 struct ar_hdr arhdr; /* Current archive header. */
12270};
12271
12272/* Read the symbol table and long-name table from an archive. */
fb52b2f4
NC		 12273
12274static int
2cf0635d
NC		 12275setup_archive (struct archive_info * arch, char * file_name, FILE * file,
12276 bfd_boolean is_thin_archive, bfd_boolean read_symbols)
fb52b2f4 12277{
fb52b2f4
NC		 12278 size_t got;
12279 unsigned long size;
fb52b2f4 12280
2cf0635d
NC		 12281 arch->file_name = strdup (file_name);
12282 arch->file = file;
12283 arch->index_num = 0;
12284 arch->index_array = NULL;
12285 arch->sym_table = NULL;
12286 arch->sym_size = 0;
12287 arch->longnames = NULL;
12288 arch->longnames_size = 0;
12289 arch->nested_member_origin = 0;
12290 arch->is_thin_archive = is_thin_archive;
12291 arch->next_arhdr_offset = SARMAG;
12292
12293 /* Read the first archive member header. */
12294 if (fseek (file, SARMAG, SEEK_SET) != 0)
12295 {
12296 error (_("%s: failed to seek to first archive header\n"), file_name);
12297 return 1;
12298 }
12299 got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
12300 if (got != sizeof arch->arhdr)
fb52b2f4
NC		 12301 {
12302 if (got == 0)
12303 return 0;
12304
12305 error (_("%s: failed to read archive header\n"), file_name);
12306 return 1;
12307 }
12308
4145f1d5 12309 /* See if this is the archive symbol table. */
2cf0635d
NC		 12310 if (const_strneq (arch->arhdr.ar_name, "/ ")
12311 || const_strneq (arch->arhdr.ar_name, "/SYM64/ "))
fb52b2f4 12312 {
2cf0635d 12313 size = strtoul (arch->arhdr.ar_size, NULL, 10);
4145f1d5
NC		 12314 size = size + (size & 1);
12315
2cf0635d
NC		 12316 arch->next_arhdr_offset += sizeof arch->arhdr + size;
12317
12318 if (read_symbols)
fb52b2f4 12319 {
4145f1d5
NC		 12320 unsigned long i;
12321 /* A buffer used to hold numbers read in from an archive index.
12322 These are always 4 bytes long and stored in big-endian format. */
12323#define SIZEOF_AR_INDEX_NUMBERS 4
12324 unsigned char integer_buffer[SIZEOF_AR_INDEX_NUMBERS];
12325 unsigned char * index_buffer;
12326
12327 /* Check the size of the archive index. */
12328 if (size < SIZEOF_AR_INDEX_NUMBERS)
12329 {
12330 error (_("%s: the archive index is empty\n"), file_name);
12331 return 1;
12332 }
12333
12334 /* Read the numer of entries in the archive index. */
12335 got = fread (integer_buffer, 1, sizeof integer_buffer, file);
12336 if (got != sizeof (integer_buffer))
12337 {
12338 error (_("%s: failed to read archive index\n"), file_name);
12339 return 1;
12340 }
2cf0635d 12341 arch->index_num = byte_get_big_endian (integer_buffer, sizeof integer_buffer);
4145f1d5
NC		 12342 size -= SIZEOF_AR_INDEX_NUMBERS;
12343
12344 /* Read in the archive index. */
2cf0635d 12345 if (size < arch->index_num * SIZEOF_AR_INDEX_NUMBERS)
4145f1d5
NC		 12346 {
12347 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
2cf0635d 12348 file_name, arch->index_num);
4145f1d5
NC		 12349 return 1;
12350 }
3f5e193b
NC		 12351 index_buffer = (unsigned char *)
12352 malloc (arch->index_num * SIZEOF_AR_INDEX_NUMBERS);
4145f1d5
NC		 12353 if (index_buffer == NULL)
12354 {
12355 error (_("Out of memory whilst trying to read archive symbol index\n"));
12356 return 1;
12357 }
2cf0635d
NC		 12358 got = fread (index_buffer, SIZEOF_AR_INDEX_NUMBERS, arch->index_num, file);
12359 if (got != arch->index_num)
4145f1d5
NC		 12360 {
12361 free (index_buffer);
12362 error (_("%s: failed to read archive index\n"), file_name);
2cf0635d 12363 return 1;
4145f1d5 12364 }
2cf0635d 12365 size -= arch->index_num * SIZEOF_AR_INDEX_NUMBERS;
4145f1d5
NC		 12366
12367 /* Convert the index numbers into the host's numeric format. */
3f5e193b
NC		 12368 arch->index_array = (long unsigned int *)
12369 malloc (arch->index_num * sizeof (* arch->index_array));
2cf0635d 12370 if (arch->index_array == NULL)
4145f1d5
NC		 12371 {
12372 free (index_buffer);
12373 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
12374 return 1;
12375 }
12376
2cf0635d
NC		 12377 for (i = 0; i < arch->index_num; i++)
12378 arch->index_array[i] = byte_get_big_endian ((unsigned char *) (index_buffer + (i * SIZEOF_AR_INDEX_NUMBERS)),
12379 SIZEOF_AR_INDEX_NUMBERS);
4145f1d5
NC		 12380 free (index_buffer);
12381
12382 /* The remaining space in the header is taken up by the symbol table. */
12383 if (size < 1)
12384 {
12385 error (_("%s: the archive has an index but no symbols\n"), file_name);
2cf0635d 12386 return 1;
4145f1d5 12387 }
3f5e193b 12388 arch->sym_table = (char *) malloc (size);
2cf0635d
NC		 12389 arch->sym_size = size;
12390 if (arch->sym_table == NULL)
4145f1d5
NC		 12391 {
12392 error (_("Out of memory whilst trying to read archive index symbol table\n"));
2cf0635d 12393 return 1;
4145f1d5 12394 }
2cf0635d 12395 got = fread (arch->sym_table, 1, size, file);
4145f1d5
NC		 12396 if (got != size)
12397 {
12398 error (_("%s: failed to read archive index symbol table\n"), file_name);
2cf0635d 12399 return 1;
cb8f3167 12400 }
4145f1d5
NC		 12401 }
12402 else
12403 {
12404 if (fseek (file, size, SEEK_CUR) != 0)
12405 {
12406 error (_("%s: failed to skip archive symbol table\n"), file_name);
12407 return 1;
12408 }
fb52b2f4
NC		 12409 }
12410
2cf0635d
NC		 12411 /* Read the next archive header. */
12412 got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
12413 if (got != sizeof arch->arhdr)
fb52b2f4
NC		 12414 {
12415 if (got == 0)
2cf0635d 12416 return 0;
4145f1d5 12417 error (_("%s: failed to read archive header following archive index\n"), file_name);
2cf0635d 12418 return 1;
fb52b2f4
NC		 12419 }
12420 }
2cf0635d 12421 else if (read_symbols)
4145f1d5 12422 printf (_("%s has no archive index\n"), file_name);
fb52b2f4 12423
2cf0635d 12424 if (const_strneq (arch->arhdr.ar_name, "// "))
fb52b2f4 12425 {
2cf0635d
NC		 12426 /* This is the archive string table holding long member names. */
12427 arch->longnames_size = strtoul (arch->arhdr.ar_size, NULL, 10);
12428 arch->next_arhdr_offset += sizeof arch->arhdr + arch->longnames_size;
fb52b2f4 12429
3f5e193b 12430 arch->longnames = (char *) malloc (arch->longnames_size);
2cf0635d 12431 if (arch->longnames == NULL)
fb52b2f4 12432 {
4145f1d5 12433 error (_("Out of memory reading long symbol names in archive\n"));
2cf0635d 12434 return 1;
fb52b2f4
NC		 12435 }
12436
2cf0635d 12437 if (fread (arch->longnames, arch->longnames_size, 1, file) != 1)
fb52b2f4 12438 {
2cf0635d
NC		 12439 free (arch->longnames);
12440 arch->longnames = NULL;
4145f1d5 12441 error (_("%s: failed to read long symbol name string table\n"), file_name);
2cf0635d 12442 return 1;
fb52b2f4
NC		 12443 }
12444
2cf0635d 12445 if ((arch->longnames_size & 1) != 0)
fb52b2f4 12446 getc (file);
2cf0635d 12447 }
fb52b2f4 12448
2cf0635d
NC		 12449 return 0;
12450}
12451
12452/* Release the memory used for the archive information. */
12453
12454static void
12455release_archive (struct archive_info * arch)
12456{
12457 if (arch->file_name != NULL)
12458 free (arch->file_name);
12459 if (arch->index_array != NULL)
12460 free (arch->index_array);
12461 if (arch->sym_table != NULL)
12462 free (arch->sym_table);
12463 if (arch->longnames != NULL)
12464 free (arch->longnames);
12465}
12466
12467/* Open and setup a nested archive, if not already open. */
12468
12469static int
12470setup_nested_archive (struct archive_info * nested_arch, char * member_file_name)
12471{
12472 FILE * member_file;
12473
12474 /* Have we already setup this archive? */
12475 if (nested_arch->file_name != NULL
12476 && streq (nested_arch->file_name, member_file_name))
12477 return 0;
12478
12479 /* Close previous file and discard cached information. */
12480 if (nested_arch->file != NULL)
12481 fclose (nested_arch->file);
12482 release_archive (nested_arch);
12483
12484 member_file = fopen (member_file_name, "rb");
12485 if (member_file == NULL)
12486 return 1;
12487 return setup_archive (nested_arch, member_file_name, member_file, FALSE, FALSE);
12488}
12489
12490static char *
12491get_archive_member_name_at (struct archive_info * arch,
12492 unsigned long offset,
12493 struct archive_info * nested_arch);
12494
12495/* Get the name of an archive member from the current archive header.
12496 For simple names, this will modify the ar_name field of the current
12497 archive header. For long names, it will return a pointer to the
12498 longnames table. For nested archives, it will open the nested archive
12499 and get the name recursively. NESTED_ARCH is a single-entry cache so
12500 we don't keep rereading the same information from a nested archive. */
12501
12502static char *
12503get_archive_member_name (struct archive_info * arch,
12504 struct archive_info * nested_arch)
12505{
12506 unsigned long j, k;
12507
12508 if (arch->arhdr.ar_name[0] == '/')
12509 {
12510 /* We have a long name. */
12511 char * endp;
12512 char * member_file_name;
12513 char * member_name;
12514
12515 arch->nested_member_origin = 0;
12516 k = j = strtoul (arch->arhdr.ar_name + 1, &endp, 10);
12517 if (arch->is_thin_archive && endp != NULL && * endp == ':')
12518 arch->nested_member_origin = strtoul (endp + 1, NULL, 10);
12519
12520 while ((j < arch->longnames_size)
12521 && (arch->longnames[j] != '\n')
12522 && (arch->longnames[j] != '\0'))
12523 j++;
12524 if (arch->longnames[j-1] == '/')
12525 j--;
12526 arch->longnames[j] = '\0';
12527
12528 if (!arch->is_thin_archive || arch->nested_member_origin == 0)
12529 return arch->longnames + k;
12530
12531 /* This is a proxy for a member of a nested archive.
12532 Find the name of the member in that archive. */
12533 member_file_name = adjust_relative_path (arch->file_name, arch->longnames + k, j - k);
12534 if (member_file_name != NULL
12535 && setup_nested_archive (nested_arch, member_file_name) == 0
12536 && (member_name = get_archive_member_name_at (nested_arch, arch->nested_member_origin, NULL)) != NULL)
12537 {
12538 free (member_file_name);
12539 return member_name;
12540 }
12541 free (member_file_name);
12542
12543 /* Last resort: just return the name of the nested archive. */
12544 return arch->longnames + k;
12545 }
12546
12547 /* We have a normal (short) name. */
12548 j = 0;
12549 while ((arch->arhdr.ar_name[j] != '/') && (j < 16))
12550 j++;
12551 arch->arhdr.ar_name[j] = '\0';
12552 return arch->arhdr.ar_name;
12553}
12554
12555/* Get the name of an archive member at a given OFFSET within an archive ARCH. */
12556
12557static char *
12558get_archive_member_name_at (struct archive_info * arch,
12559 unsigned long offset,
12560 struct archive_info * nested_arch)
12561{
12562 size_t got;
12563
12564 if (fseek (arch->file, offset, SEEK_SET) != 0)
12565 {
12566 error (_("%s: failed to seek to next file name\n"), arch->file_name);
12567 return NULL;
12568 }
12569 got = fread (&arch->arhdr, 1, sizeof arch->arhdr, arch->file);
12570 if (got != sizeof arch->arhdr)
12571 {
12572 error (_("%s: failed to read archive header\n"), arch->file_name);
12573 return NULL;
12574 }
12575 if (memcmp (arch->arhdr.ar_fmag, ARFMAG, 2) != 0)
12576 {
12577 error (_("%s: did not find a valid archive header\n"), arch->file_name);
12578 return NULL;
12579 }
12580
12581 return get_archive_member_name (arch, nested_arch);
12582}
12583
12584/* Construct a string showing the name of the archive member, qualified
12585 with the name of the containing archive file. For thin archives, we
12586 use square brackets to denote the indirection. For nested archives,
12587 we show the qualified name of the external member inside the square
12588 brackets (e.g., "thin.a[normal.a(foo.o)]"). */
12589
12590static char *
12591make_qualified_name (struct archive_info * arch,
12592 struct archive_info * nested_arch,
12593 char * member_name)
12594{
12595 size_t len;
12596 char * name;
12597
12598 len = strlen (arch->file_name) + strlen (member_name) + 3;
12599 if (arch->is_thin_archive && arch->nested_member_origin != 0)
12600 len += strlen (nested_arch->file_name) + 2;
12601
3f5e193b 12602 name = (char *) malloc (len);
2cf0635d
NC		 12603 if (name == NULL)
12604 {
12605 error (_("Out of memory\n"));
12606 return NULL;
12607 }
12608
12609 if (arch->is_thin_archive && arch->nested_member_origin != 0)
12610 snprintf (name, len, "%s[%s(%s)]", arch->file_name, nested_arch->file_name, member_name);
12611 else if (arch->is_thin_archive)
12612 snprintf (name, len, "%s[%s]", arch->file_name, member_name);
12613 else
12614 snprintf (name, len, "%s(%s)", arch->file_name, member_name);
12615
12616 return name;
12617}
12618
12619/* Process an ELF archive.
12620 On entry the file is positioned just after the ARMAG string. */
12621
12622static int
12623process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
12624{
12625 struct archive_info arch;
12626 struct archive_info nested_arch;
12627 size_t got;
2cf0635d
NC		 12628 int ret;
12629
12630 show_name = 1;
12631
12632 /* The ARCH structure is used to hold information about this archive. */
12633 arch.file_name = NULL;
12634 arch.file = NULL;
12635 arch.index_array = NULL;
12636 arch.sym_table = NULL;
12637 arch.longnames = NULL;
12638
12639 /* The NESTED_ARCH structure is used as a single-item cache of information
12640 about a nested archive (when members of a thin archive reside within
12641 another regular archive file). */
12642 nested_arch.file_name = NULL;
12643 nested_arch.file = NULL;
12644 nested_arch.index_array = NULL;
12645 nested_arch.sym_table = NULL;
12646 nested_arch.longnames = NULL;
12647
12648 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
12649 {
12650 ret = 1;
12651 goto out;
4145f1d5 12652 }
fb52b2f4 12653
4145f1d5
NC		 12654 if (do_archive_index)
12655 {
2cf0635d 12656 if (arch.sym_table == NULL)
4145f1d5
NC		 12657 error (_("%s: unable to dump the index as none was found\n"), file_name);
12658 else
12659 {
2cf0635d 12660 unsigned int i, l;
4145f1d5
NC		 12661 unsigned long current_pos;
12662
12663 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
2cf0635d 12664 file_name, arch.index_num, arch.sym_size);
4145f1d5
NC		 12665 current_pos = ftell (file);
12666
2cf0635d 12667 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 12668 {
2cf0635d
NC		 12669 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
12670 {
12671 char * member_name;
4145f1d5 12672
2cf0635d
NC		 12673 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
12674
12675 if (member_name != NULL)
12676 {
12677 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
12678
12679 if (qualified_name != NULL)
12680 {
12681 printf (_("Binary %s contains:\n"), qualified_name);
12682 free (qualified_name);
12683 }
4145f1d5
NC		 12684 }
12685 }
2cf0635d
NC		 12686
12687 if (l >= arch.sym_size)
4145f1d5
NC		 12688 {
12689 error (_("%s: end of the symbol table reached before the end of the index\n"),
12690 file_name);
cb8f3167 12691 break;
4145f1d5 12692 }
2cf0635d
NC		 12693 printf ("\t%s\n", arch.sym_table + l);
12694 l += strlen (arch.sym_table + l) + 1;
4145f1d5
NC		 12695 }
12696
2cf0635d
NC		 12697 if (l & 01)
12698 ++l;
12699 if (l < arch.sym_size)
4145f1d5
NC		 12700 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
12701 file_name);
12702
4145f1d5
NC		 12703 if (fseek (file, current_pos, SEEK_SET) != 0)
12704 {
12705 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 12706 ret = 1;
12707 goto out;
4145f1d5 12708 }
fb52b2f4 12709 }
4145f1d5
NC		 12710
12711 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
12712 && !do_segments && !do_header && !do_dump && !do_version
12713 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 12714 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 12715 {
12716 ret = 0; /* Archive index only. */
12717 goto out;
12718 }
fb52b2f4
NC		 12719 }
12720
d989285c 12721 ret = 0;
fb52b2f4
NC		 12722
12723 while (1)
12724 {
2cf0635d
NC		 12725 char * name;
12726 size_t namelen;
12727 char * qualified_name;
12728
12729 /* Read the next archive header. */
12730 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
12731 {
12732 error (_("%s: failed to seek to next archive header\n"), file_name);
12733 return 1;
12734 }
12735 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
12736 if (got != sizeof arch.arhdr)
12737 {
12738 if (got == 0)
12739 break;
12740 error (_("%s: failed to read archive header\n"), file_name);
12741 ret = 1;
12742 break;
12743 }
12744 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
12745 {
12746 error (_("%s: did not find a valid archive header\n"), arch.file_name);
12747 ret = 1;
12748 break;
12749 }
12750
12751 arch.next_arhdr_offset += sizeof arch.arhdr;
12752
12753 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
12754 if (archive_file_size & 01)
12755 ++archive_file_size;
12756
12757 name = get_archive_member_name (&arch, &nested_arch);
12758 if (name == NULL)
fb52b2f4 12759 {
0fd3a477 12760 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 12761 ret = 1;
12762 break;
fb52b2f4 12763 }
2cf0635d 12764 namelen = strlen (name);
fb52b2f4 12765
2cf0635d
NC		 12766 qualified_name = make_qualified_name (&arch, &nested_arch, name);
12767 if (qualified_name == NULL)
fb52b2f4 12768 {
2cf0635d 12769 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 12770 ret = 1;
12771 break;
fb52b2f4
NC		 12772 }
12773
2cf0635d
NC		 12774 if (is_thin_archive && arch.nested_member_origin == 0)
12775 {
12776 /* This is a proxy for an external member of a thin archive. */
12777 FILE * member_file;
12778 char * member_file_name = adjust_relative_path (file_name, name, namelen);
12779 if (member_file_name == NULL)
12780 {
12781 ret = 1;
12782 break;
12783 }
12784
12785 member_file = fopen (member_file_name, "rb");
12786 if (member_file == NULL)
12787 {
12788 error (_("Input file '%s' is not readable.\n"), member_file_name);
12789 free (member_file_name);
12790 ret = 1;
12791 break;
12792 }
12793
12794 archive_file_offset = arch.nested_member_origin;
12795
12796 ret |= process_object (qualified_name, member_file);
12797
12798 fclose (member_file);
12799 free (member_file_name);
12800 }
12801 else if (is_thin_archive)
12802 {
12803 /* This is a proxy for a member of a nested archive. */
12804 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
12805
12806 /* The nested archive file will have been opened and setup by
12807 get_archive_member_name. */
12808 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
12809 {
12810 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
12811 ret = 1;
12812 break;
12813 }
12814
12815 ret |= process_object (qualified_name, nested_arch.file);
12816 }
12817 else
12818 {
12819 archive_file_offset = arch.next_arhdr_offset;
12820 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 12821
2cf0635d
NC		 12822 ret |= process_object (qualified_name, file);
12823 }
fb52b2f4 12824
2cf0635d 12825 free (qualified_name);
fb52b2f4
NC		 12826 }
12827
4145f1d5 12828 out:
2cf0635d
NC		 12829 if (nested_arch.file != NULL)
12830 fclose (nested_arch.file);
12831 release_archive (&nested_arch);
12832 release_archive (&arch);
fb52b2f4 12833
d989285c 12834 return ret;
fb52b2f4
NC		 12835}
12836
12837static int
2cf0635d 12838process_file (char * file_name)
fb52b2f4 12839{
2cf0635d 12840 FILE * file;
fb52b2f4
NC		 12841 struct stat statbuf;
12842 char armag[SARMAG];
12843 int ret;
12844
12845 if (stat (file_name, &statbuf) < 0)
12846 {
f24ddbdd
NC		 12847 if (errno == ENOENT)
12848 error (_("'%s': No such file\n"), file_name);
12849 else
12850 error (_("Could not locate '%s'. System error message: %s\n"),
12851 file_name, strerror (errno));
12852 return 1;
12853 }
12854
12855 if (! S_ISREG (statbuf.st_mode))
12856 {
12857 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 12858 return 1;
12859 }
12860
12861 file = fopen (file_name, "rb");
12862 if (file == NULL)
12863 {
f24ddbdd 12864 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 12865 return 1;
12866 }
12867
12868 if (fread (armag, SARMAG, 1, file) != 1)
12869 {
4145f1d5 12870 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 12871 fclose (file);
12872 return 1;
12873 }
12874
12875 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 12876 ret = process_archive (file_name, file, FALSE);
12877 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
12878 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 12879 else
12880 {
4145f1d5
NC		 12881 if (do_archive_index)
12882 error (_("File %s is not an archive so its index cannot be displayed.\n"),
12883 file_name);
12884
fb52b2f4
NC		 12885 rewind (file);
12886 archive_file_size = archive_file_offset = 0;
12887 ret = process_object (file_name, file);
12888 }
12889
12890 fclose (file);
12891
12892 return ret;
12893}
12894
252b5132
RH		 12895#ifdef SUPPORT_DISASSEMBLY
12896/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 12897 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 12898 symbols. */
252b5132
RH		 12899
12900void
2cf0635d 12901print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 12902{
12903 fprintf (outfile,"0x%8.8x", addr);
12904}
12905
e3c8793a 12906/* Needed by the i386 disassembler. */
252b5132
RH		 12907void
12908db_task_printsym (unsigned int addr)
12909{
12910 print_address (addr, stderr);
12911}
12912#endif
12913
12914int
2cf0635d 12915main (int argc, char ** argv)
252b5132 12916{
ff78d6d6
L		 12917 int err;
12918
252b5132
RH		 12919#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12920 setlocale (LC_MESSAGES, "");
3882b010
L		 12921#endif
12922#if defined (HAVE_SETLOCALE)
12923 setlocale (LC_CTYPE, "");
252b5132
RH		 12924#endif
12925 bindtextdomain (PACKAGE, LOCALEDIR);
12926 textdomain (PACKAGE);
12927
869b9d07
MM		 12928 expandargv (&argc, &argv);
12929
252b5132
RH		 12930 parse_args (argc, argv);
12931
18bd398b 12932 if (num_dump_sects > 0)
59f14fc0 12933 {
18bd398b 12934 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 12935 cmdline_dump_sects = (dump_type *)
12936 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 12937 if (cmdline_dump_sects == NULL)
591a748a 12938 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 12939 else
12940 {
09c11c86
NC		 12941 memcpy (cmdline_dump_sects, dump_sects,
12942 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 12943 num_cmdline_dump_sects = num_dump_sects;
12944 }
12945 }
12946
18bd398b
NC		 12947 if (optind < (argc - 1))
12948 show_name = 1;
12949
ff78d6d6 12950 err = 0;
252b5132 12951 while (optind < argc)
18bd398b 12952 err |= process_file (argv[optind++]);
252b5132
RH		 12953
12954 if (dump_sects != NULL)
12955 free (dump_sects);
59f14fc0
AS		 12956 if (cmdline_dump_sects != NULL)
12957 free (cmdline_dump_sects);
252b5132 12958
ff78d6d6 12959 return err;
252b5132 12960}
Empty description
This page took 3.322053 seconds and 4 git commands to generate.