]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - binutils/readelf.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
opcodes/
[thirdparty/binutils-gdb.git] / binutils / readelf.c
CommitLineData
252b5132 1/* readelf.c -- display contents of an ELF format file
6e3d6dc1 2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
7a88bc9c 3 2008, 2009, 2010, 2011
a0f19280 4 Free Software Foundation, Inc.
252b5132
RH		 5
6 Originally developed by Eric Youngdale <eric@andante.jic.com>
12ab83a9 7 Modifications by Nick Clifton <nickc@redhat.com>
252b5132
RH		 8
9 This file is part of GNU Binutils.
10
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
32866df7 13 the Free Software Foundation; either version 3 of the License, or
252b5132
RH		 14 (at your option) any later version.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
b43b5d5f
NC		 23 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 02110-1301, USA. */
252b5132 25\f
9eb20dd8 26/* The difference between readelf and objdump:
252b5132 27
74013231 28 Both programs are capable of displaying the contents of ELF format files,
9eb20dd8 29 so why does the binutils project have two file dumpers ?
0de14b54 30
9eb20dd8
NC		 31 The reason is that objdump sees an ELF file through a BFD filter of the
32 world; if BFD has a bug where, say, it disagrees about a machine constant
33 in e_flags, then the odds are good that it will remain internally
34 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
35 GAS sees it the BFD way. There was need for a tool to go find out what
36 the file actually says.
37
38 This is why the readelf program does not link against the BFD library - it
39 exists as an independent program to help verify the correct working of BFD.
40
41 There is also the case that readelf can provide more information about an
42 ELF file than is provided by objdump. In particular it can display DWARF
43 debugging information which (at the moment) objdump cannot. */
44\f
1b315056 45#include "config.h"
3db64b00 46#include "sysdep.h"
252b5132
RH		 47#include <assert.h>
48#include <sys/stat.h>
252b5132 49#include <time.h>
1b315056
CS		 50#ifdef HAVE_ZLIB_H
51#include <zlib.h>
52#endif
252b5132 53
a952a375 54#if __GNUC__ >= 2
19936277 55/* Define BFD64 here, even if our default architecture is 32 bit ELF
a952a375 56 as this will allow us to read in and parse 64bit and 32bit ELF files.
b34976b6 57 Only do this if we believe that the compiler can support a 64 bit
a952a375 58 data type. For now we only rely on GCC being able to do this. */
19936277 59#define BFD64
a952a375
NC		 60#endif
61
3db64b00
AM		 62#include "bfd.h"
63#include "bucomm.h"
3284fe0c 64#include "elfcomm.h"
19e6b90e 65#include "dwarf.h"
252b5132
RH		 66
67#include "elf/common.h"
68#include "elf/external.h"
69#include "elf/internal.h"
252b5132 70
4b78141a
NC		 71
72/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
73 we can obtain the H8 reloc numbers. We need these for the
74 get_reloc_size() function. We include h8.h again after defining
75 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
76
77#include "elf/h8.h"
78#undef _ELF_H8_H
79
80/* Undo the effects of #including reloc-macros.h. */
81
82#undef START_RELOC_NUMBERS
83#undef RELOC_NUMBER
84#undef FAKE_RELOC
85#undef EMPTY_RELOC
86#undef END_RELOC_NUMBERS
87#undef _RELOC_MACROS_H
88
252b5132
RH		 89/* The following headers use the elf/reloc-macros.h file to
90 automatically generate relocation recognition functions
91 such as elf_mips_reloc_type() */
92
93#define RELOC_MACROS_GEN_FUNC
94
252b5132 95#include "elf/alpha.h"
3b16e843 96#include "elf/arc.h"
252b5132 97#include "elf/arm.h"
3b16e843 98#include "elf/avr.h"
1d65ded4 99#include "elf/bfin.h"
60bca95a 100#include "elf/cr16.h"
3b16e843 101#include "elf/cris.h"
1c0d3aa6 102#include "elf/crx.h"
252b5132
RH		 103#include "elf/d10v.h"
104#include "elf/d30v.h"
d172d4ba 105#include "elf/dlx.h"
252b5132 106#include "elf/fr30.h"
5c70f934 107#include "elf/frv.h"
3b16e843
NC		 108#include "elf/h8.h"
109#include "elf/hppa.h"
110#include "elf/i386.h"
35b1837e 111#include "elf/i370.h"
3b16e843
NC		 112#include "elf/i860.h"
113#include "elf/i960.h"
114#include "elf/ia64.h"
1e4cf259 115#include "elf/ip2k.h"
84e94c90 116#include "elf/lm32.h"
1c0d3aa6 117#include "elf/iq2000.h"
49f58d10 118#include "elf/m32c.h"
3b16e843
NC		 119#include "elf/m32r.h"
120#include "elf/m68k.h"
75751cd9 121#include "elf/m68hc11.h"
252b5132 122#include "elf/mcore.h"
15ab5209 123#include "elf/mep.h"
7ba29e2a 124#include "elf/microblaze.h"
3b16e843 125#include "elf/mips.h"
3c3bdf30 126#include "elf/mmix.h"
3b16e843
NC		 127#include "elf/mn10200.h"
128#include "elf/mn10300.h"
5506d11a 129#include "elf/moxie.h"
4970f871 130#include "elf/mt.h"
2469cfa2 131#include "elf/msp430.h"
3b16e843 132#include "elf/or32.h"
7d466069 133#include "elf/pj.h"
3b16e843 134#include "elf/ppc.h"
c833c019 135#include "elf/ppc64.h"
c7927a3c 136#include "elf/rx.h"
a85d7ed0 137#include "elf/s390.h"
1c0d3aa6 138#include "elf/score.h"
3b16e843
NC		 139#include "elf/sh.h"
140#include "elf/sparc.h"
e9f53129 141#include "elf/spu.h"
40b36596 142#include "elf/tic6x.h"
aa137e4d
NC		 143#include "elf/tilegx.h"
144#include "elf/tilepro.h"
3b16e843 145#include "elf/v850.h"
179d3252 146#include "elf/vax.h"
3b16e843 147#include "elf/x86-64.h"
c29aca4a 148#include "elf/xc16x.h"
93fbbb04 149#include "elf/xstormy16.h"
88da6820 150#include "elf/xtensa.h"
252b5132 151
252b5132 152#include "getopt.h"
566b0d53 153#include "libiberty.h"
09c11c86 154#include "safe-ctype.h"
2cf0635d 155#include "filenames.h"
252b5132 156
2cf0635d 157char * program_name = "readelf";
85b1c36d
BE		 158static long archive_file_offset;
159static unsigned long archive_file_size;
160static unsigned long dynamic_addr;
161static bfd_size_type dynamic_size;
162static unsigned int dynamic_nent;
2cf0635d 163static char * dynamic_strings;
85b1c36d 164static unsigned long dynamic_strings_length;
2cf0635d 165static char * string_table;
85b1c36d
BE		 166static unsigned long string_table_length;
167static unsigned long num_dynamic_syms;
2cf0635d
NC		 168static Elf_Internal_Sym * dynamic_symbols;
169static Elf_Internal_Syminfo * dynamic_syminfo;
85b1c36d
BE		 170static unsigned long dynamic_syminfo_offset;
171static unsigned int dynamic_syminfo_nent;
f8eae8b2 172static char program_interpreter[PATH_MAX];
bb8a0291 173static bfd_vma dynamic_info[DT_ENCODING];
fdc90cb4 174static bfd_vma dynamic_info_DT_GNU_HASH;
85b1c36d
BE		 175static bfd_vma version_info[16];
176static Elf_Internal_Ehdr elf_header;
2cf0635d
NC		 177static Elf_Internal_Shdr * section_headers;
178static Elf_Internal_Phdr * program_headers;
179static Elf_Internal_Dyn * dynamic_section;
180static Elf_Internal_Shdr * symtab_shndx_hdr;
85b1c36d
BE		 181static int show_name;
182static int do_dynamic;
183static int do_syms;
2c610e4b 184static int do_dyn_syms;
85b1c36d
BE		 185static int do_reloc;
186static int do_sections;
187static int do_section_groups;
5477e8a0 188static int do_section_details;
85b1c36d
BE		 189static int do_segments;
190static int do_unwind;
191static int do_using_dynamic;
192static int do_header;
193static int do_dump;
194static int do_version;
85b1c36d
BE		 195static int do_histogram;
196static int do_debugging;
85b1c36d
BE		 197static int do_arch;
198static int do_notes;
4145f1d5 199static int do_archive_index;
85b1c36d 200static int is_32bit_elf;
252b5132 201
e4b17d5c
L		 202struct group_list
203{
2cf0635d 204 struct group_list * next;
e4b17d5c
L		 205 unsigned int section_index;
206};
207
208struct group
209{
2cf0635d 210 struct group_list * root;
e4b17d5c
L		 211 unsigned int group_index;
212};
213
85b1c36d 214static size_t group_count;
2cf0635d
NC		 215static struct group * section_groups;
216static struct group ** section_headers_groups;
e4b17d5c 217
09c11c86
NC		 218
219/* Flag bits indicating particular types of dump. */
220#define HEX_DUMP (1 << 0) /* The -x command line switch. */
221#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
222#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
223#define STRING_DUMP (1 << 3) /* The -p command line switch. */
cf13d699 224#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
09c11c86
NC		 225
226typedef unsigned char dump_type;
227
228/* A linked list of the section names for which dumps were requested. */
aef1f6d0
DJ		 229struct dump_list_entry
230{
2cf0635d 231 char * name;
09c11c86 232 dump_type type;
2cf0635d 233 struct dump_list_entry * next;
aef1f6d0 234};
2cf0635d 235static struct dump_list_entry * dump_sects_byname;
aef1f6d0 236
09c11c86
NC		 237/* A dynamic array of flags indicating for which sections a dump
238 has been requested via command line switches. */
239static dump_type * cmdline_dump_sects = NULL;
240static unsigned int num_cmdline_dump_sects = 0;
18bd398b
NC		 241
242/* A dynamic array of flags indicating for which sections a dump of
243 some kind has been requested. It is reset on a per-object file
aef1f6d0
DJ		 244 basis and then initialised from the cmdline_dump_sects array,
245 the results of interpreting the -w switch, and the
246 dump_sects_byname list. */
09c11c86
NC		 247static dump_type * dump_sects = NULL;
248static unsigned int num_dump_sects = 0;
252b5132 249
252b5132 250
c256ffe7 251/* How to print a vma value. */
843dd992
NC		 252typedef enum print_mode
253{
254 HEX,
255 DEC,
256 DEC_5,
257 UNSIGNED,
258 PREFIX_HEX,
259 FULL_HEX,
260 LONG_HEX
261}
262print_mode;
263
9c19a809
NC		 264#define UNKNOWN -1
265
2b692964
NC		 266#define SECTION_NAME(X) \
267 ((X) == NULL ? _("<none>") \
268 : string_table == NULL ? _("<no-name>") \
269 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
0b49d371 270 : string_table + (X)->sh_name))
252b5132 271
ee42cf8c 272#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
252b5132 273
9ad5cbcf
AM		 274#define GET_ELF_SYMBOLS(file, section) \
275 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
276 : get_64bit_elf_symbols (file, section))
9ea033b2 277
d79b3d50
NC		 278#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
279/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
280 already been called and verified that the string exists. */
281#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
18bd398b 282
61865e30
NC		 283#define REMOVE_ARCH_BITS(ADDR) \
284 do \
285 { \
286 if (elf_header.e_machine == EM_ARM) \
287 (ADDR) &= ~1; \
288 } \
289 while (0)
d79b3d50 290\f
59245841
NC		 291/* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
292 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
293 using malloc and fill that. In either case return the pointer to the start of
294 the retrieved data or NULL if something went wrong. If something does go wrong
295 emit an error message using REASON as part of the context. */
296
c256ffe7 297static void *
2cf0635d
NC		 298get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
299 const char * reason)
a6e9f9df 300{
2cf0635d 301 void * mvar;
a6e9f9df 302
c256ffe7 303 if (size == 0 || nmemb == 0)
a6e9f9df
AM		 304 return NULL;
305
fb52b2f4 306 if (fseek (file, archive_file_offset + offset, SEEK_SET))
a6e9f9df 307 {
0fd3a477 308 error (_("Unable to seek to 0x%lx for %s\n"),
0af1713e 309 (unsigned long) archive_file_offset + offset, reason);
a6e9f9df
AM		 310 return NULL;
311 }
312
313 mvar = var;
314 if (mvar == NULL)
315 {
c256ffe7
JJ		 316 /* Check for overflow. */
317 if (nmemb < (~(size_t) 0 - 1) / size)
318 /* + 1 so that we can '\0' terminate invalid string table sections. */
319 mvar = malloc (size * nmemb + 1);
a6e9f9df
AM		 320
321 if (mvar == NULL)
322 {
0fd3a477
JW		 323 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
324 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM		 325 return NULL;
326 }
c256ffe7
JJ		 327
328 ((char *) mvar)[size * nmemb] = '\0';
a6e9f9df
AM		 329 }
330
c256ffe7 331 if (fread (mvar, size, nmemb, file) != nmemb)
a6e9f9df 332 {
0fd3a477
JW		 333 error (_("Unable to read in 0x%lx bytes of %s\n"),
334 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM		 335 if (mvar != var)
336 free (mvar);
337 return NULL;
338 }
339
340 return mvar;
341}
342
14a91970 343/* Print a VMA value. */
cb8f3167 344
66543521 345static int
14a91970 346print_vma (bfd_vma vma, print_mode mode)
66543521 347{
66543521
AM		 348 int nc = 0;
349
14a91970 350 switch (mode)
66543521 351 {
14a91970
AM		 352 case FULL_HEX:
353 nc = printf ("0x");
354 /* Drop through. */
66543521 355
14a91970 356 case LONG_HEX:
f7a99963 357#ifdef BFD64
14a91970 358 if (is_32bit_elf)
437c2fb7 359 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
f7a99963 360#endif
14a91970
AM		 361 printf_vma (vma);
362 return nc + 16;
b19aac67 363
14a91970
AM		 364 case DEC_5:
365 if (vma <= 99999)
366 return printf ("%5" BFD_VMA_FMT "d", vma);
367 /* Drop through. */
66543521 368
14a91970
AM		 369 case PREFIX_HEX:
370 nc = printf ("0x");
371 /* Drop through. */
66543521 372
14a91970
AM		 373 case HEX:
374 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 375
14a91970
AM		 376 case DEC:
377 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 378
14a91970
AM		 379 case UNSIGNED:
380 return printf ("%" BFD_VMA_FMT "u", vma);
f7a99963 381 }
66543521 382 return 0;
f7a99963
NC		 383}
384
171191ba 385/* Display a symbol on stdout. Handles the display of non-printing characters.
31104126 386
171191ba
NC		 387 If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
388 truncating as necessary. If WIDTH is negative then format the string to be
389 exactly - WIDTH characters, truncating or padding as necessary.
390
391 Returns the number of emitted characters. */
392
393static unsigned int
7a88bc9c 394print_symbol (int width, const char *symbol)
31104126 395{
7a88bc9c 396 const char *c;
171191ba
NC		 397 bfd_boolean extra_padding = FALSE;
398 unsigned int num_printed = 0;
961c521f 399
31104126 400 if (do_wide)
961c521f 401 {
7a88bc9c
AS		 402 /* Set the width to a very large value. This simplifies the
403 code below. */
961c521f
NC		 404 width = INT_MAX;
405 }
31104126 406 else if (width < 0)
961c521f 407 {
961c521f
NC		 408 /* Keep the width positive. This also helps. */
409 width = - width;
171191ba 410 extra_padding = TRUE;
961c521f
NC		 411 }
412
413 while (width)
414 {
415 int len;
416
417 c = symbol;
418
419 /* Look for non-printing symbols inside the symbol's name.
420 This test is triggered in particular by the names generated
421 by the assembler for local labels. */
7a88bc9c 422 while (ISPRINT (*c))
961c521f
NC		 423 c++;
424
425 len = c - symbol;
426
427 if (len)
428 {
429 if (len > width)
430 len = width;
cb8f3167 431
171191ba 432 printf ("%.*s", len, symbol);
961c521f
NC		 433
434 width -= len;
171191ba 435 num_printed += len;
961c521f
NC		 436 }
437
7a88bc9c 438 if (*c == 0 || width == 0)
961c521f
NC		 439 break;
440
441 /* Now display the non-printing character, if
442 there is room left in which to dipslay it. */
7a88bc9c 443 if ((unsigned char) *c < 32)
961c521f
NC		 444 {
445 if (width < 2)
446 break;
447
448 printf ("^%c", *c + 0x40);
449
450 width -= 2;
171191ba 451 num_printed += 2;
961c521f
NC		 452 }
453 else
454 {
455 if (width < 6)
456 break;
cb8f3167 457
7a88bc9c 458 printf ("<0x%.2x>", (unsigned char) *c);
961c521f
NC		 459
460 width -= 6;
171191ba 461 num_printed += 6;
961c521f
NC		 462 }
463
464 symbol = c + 1;
465 }
171191ba
NC		 466
467 if (extra_padding && width > 0)
468 {
469 /* Fill in the remaining spaces. */
470 printf ("%-*s", width, " ");
471 num_printed += 2;
472 }
473
474 return num_printed;
31104126
NC		 475}
476
89fac5e3
RS		 477/* Return a pointer to section NAME, or NULL if no such section exists. */
478
479static Elf_Internal_Shdr *
2cf0635d 480find_section (const char * name)
89fac5e3
RS		 481{
482 unsigned int i;
483
484 for (i = 0; i < elf_header.e_shnum; i++)
485 if (streq (SECTION_NAME (section_headers + i), name))
486 return section_headers + i;
487
488 return NULL;
489}
490
0b6ae522
DJ		 491/* Return a pointer to a section containing ADDR, or NULL if no such
492 section exists. */
493
494static Elf_Internal_Shdr *
495find_section_by_address (bfd_vma addr)
496{
497 unsigned int i;
498
499 for (i = 0; i < elf_header.e_shnum; i++)
500 {
501 Elf_Internal_Shdr *sec = section_headers + i;
502 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
503 return sec;
504 }
505
506 return NULL;
507}
508
509/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
510 bytes read. */
511
512static unsigned long
513read_uleb128 (unsigned char *data, unsigned int *length_return)
514{
515 return read_leb128 (data, length_return, 0);
516}
517
28f997cf
TG		 518/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
519 This OS has so many departures from the ELF standard that we test it at
520 many places. */
521
522static inline int
523is_ia64_vms (void)
524{
525 return elf_header.e_machine == EM_IA_64
526 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
527}
528
bcedfee6 529/* Guess the relocation size commonly used by the specific machines. */
252b5132 530
252b5132 531static int
2dc4cec1 532guess_is_rela (unsigned int e_machine)
252b5132 533{
9c19a809 534 switch (e_machine)
252b5132
RH		 535 {
536 /* Targets that use REL relocations. */
252b5132
RH		 537 case EM_386:
538 case EM_486:
63fcb9e9 539 case EM_960:
e9f53129 540 case EM_ARM:
2b0337b0 541 case EM_D10V:
252b5132 542 case EM_CYGNUS_D10V:
e9f53129 543 case EM_DLX:
252b5132 544 case EM_MIPS:
4fe85591 545 case EM_MIPS_RS3_LE:
e9f53129
AM		 546 case EM_CYGNUS_M32R:
547 case EM_OPENRISC:
548 case EM_OR32:
1c0d3aa6 549 case EM_SCORE:
9c19a809 550 return FALSE;
103f02d3 551
252b5132
RH		 552 /* Targets that use RELA relocations. */
553 case EM_68K:
e9f53129
AM		 554 case EM_860:
555 case EM_ALPHA:
556 case EM_ALTERA_NIOS2:
557 case EM_AVR:
558 case EM_AVR_OLD:
559 case EM_BLACKFIN:
60bca95a 560 case EM_CR16:
6c03b1ed 561 case EM_CR16_OLD:
e9f53129
AM		 562 case EM_CRIS:
563 case EM_CRX:
2b0337b0 564 case EM_D30V:
252b5132 565 case EM_CYGNUS_D30V:
2b0337b0 566 case EM_FR30:
252b5132 567 case EM_CYGNUS_FR30:
5c70f934 568 case EM_CYGNUS_FRV:
e9f53129
AM		 569 case EM_H8S:
570 case EM_H8_300:
571 case EM_H8_300H:
800eeca4 572 case EM_IA_64:
1e4cf259
NC		 573 case EM_IP2K:
574 case EM_IP2K_OLD:
3b36097d 575 case EM_IQ2000:
84e94c90 576 case EM_LATTICEMICO32:
ff7eeb89 577 case EM_M32C_OLD:
49f58d10 578 case EM_M32C:
e9f53129
AM		 579 case EM_M32R:
580 case EM_MCORE:
15ab5209 581 case EM_CYGNUS_MEP:
e9f53129
AM		 582 case EM_MMIX:
583 case EM_MN10200:
584 case EM_CYGNUS_MN10200:
585 case EM_MN10300:
586 case EM_CYGNUS_MN10300:
5506d11a 587 case EM_MOXIE:
e9f53129
AM		 588 case EM_MSP430:
589 case EM_MSP430_OLD:
d031aafb 590 case EM_MT:
64fd6348 591 case EM_NIOS32:
e9f53129
AM		 592 case EM_PPC64:
593 case EM_PPC:
c7927a3c 594 case EM_RX:
e9f53129
AM		 595 case EM_S390:
596 case EM_S390_OLD:
597 case EM_SH:
598 case EM_SPARC:
599 case EM_SPARC32PLUS:
600 case EM_SPARCV9:
601 case EM_SPU:
40b36596 602 case EM_TI_C6000:
aa137e4d
NC		 603 case EM_TILEGX:
604 case EM_TILEPRO:
e9f53129
AM		 605 case EM_V850:
606 case EM_CYGNUS_V850:
607 case EM_VAX:
608 case EM_X86_64:
8a9036a4 609 case EM_L1OM:
7a9068fe 610 case EM_K1OM:
e9f53129
AM		 611 case EM_XSTORMY16:
612 case EM_XTENSA:
613 case EM_XTENSA_OLD:
7ba29e2a
NC		 614 case EM_MICROBLAZE:
615 case EM_MICROBLAZE_OLD:
9c19a809 616 return TRUE;
103f02d3 617
e9f53129
AM		 618 case EM_68HC05:
619 case EM_68HC08:
620 case EM_68HC11:
621 case EM_68HC16:
622 case EM_FX66:
623 case EM_ME16:
d1133906 624 case EM_MMA:
d1133906
NC		 625 case EM_NCPU:
626 case EM_NDR1:
e9f53129 627 case EM_PCP:
d1133906 628 case EM_ST100:
e9f53129 629 case EM_ST19:
d1133906 630 case EM_ST7:
e9f53129
AM		 631 case EM_ST9PLUS:
632 case EM_STARCORE:
d1133906 633 case EM_SVX:
e9f53129 634 case EM_TINYJ:
9c19a809
NC		 635 default:
636 warn (_("Don't know about relocations on this machine architecture\n"));
637 return FALSE;
638 }
639}
252b5132 640
9c19a809 641static int
2cf0635d 642slurp_rela_relocs (FILE * file,
d3ba0551
AM		 643 unsigned long rel_offset,
644 unsigned long rel_size,
2cf0635d
NC		 645 Elf_Internal_Rela ** relasp,
646 unsigned long * nrelasp)
9c19a809 647{
2cf0635d 648 Elf_Internal_Rela * relas;
4d6ed7c8
NC		 649 unsigned long nrelas;
650 unsigned int i;
252b5132 651
4d6ed7c8
NC		 652 if (is_32bit_elf)
653 {
2cf0635d 654 Elf32_External_Rela * erelas;
103f02d3 655
3f5e193b
NC		 656 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
657 rel_size, _("relocs"));
a6e9f9df
AM		 658 if (!erelas)
659 return 0;
252b5132 660
4d6ed7c8 661 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 662
3f5e193b
NC		 663 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
664 sizeof (Elf_Internal_Rela));
103f02d3 665
4d6ed7c8
NC		 666 if (relas == NULL)
667 {
c256ffe7 668 free (erelas);
591a748a 669 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 670 return 0;
671 }
103f02d3 672
4d6ed7c8
NC		 673 for (i = 0; i < nrelas; i++)
674 {
675 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
676 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 677 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 678 }
103f02d3 679
4d6ed7c8
NC		 680 free (erelas);
681 }
682 else
683 {
2cf0635d 684 Elf64_External_Rela * erelas;
103f02d3 685
3f5e193b
NC		 686 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
687 rel_size, _("relocs"));
a6e9f9df
AM		 688 if (!erelas)
689 return 0;
4d6ed7c8
NC		 690
691 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 692
3f5e193b
NC		 693 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
694 sizeof (Elf_Internal_Rela));
103f02d3 695
4d6ed7c8
NC		 696 if (relas == NULL)
697 {
c256ffe7 698 free (erelas);
591a748a 699 error (_("out of memory parsing relocs\n"));
4d6ed7c8 700 return 0;
9c19a809 701 }
4d6ed7c8
NC		 702
703 for (i = 0; i < nrelas; i++)
9c19a809 704 {
66543521
AM		 705 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
706 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 707 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 708
709 /* The #ifdef BFD64 below is to prevent a compile time
710 warning. We know that if we do not have a 64 bit data
711 type that we will never execute this code anyway. */
712#ifdef BFD64
713 if (elf_header.e_machine == EM_MIPS
714 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
715 {
716 /* In little-endian objects, r_info isn't really a
717 64-bit little-endian value: it has a 32-bit
718 little-endian symbol index followed by four
719 individual byte fields. Reorder INFO
720 accordingly. */
91d6fa6a
NC		 721 bfd_vma inf = relas[i].r_info;
722 inf = (((inf & 0xffffffff) << 32)
723 | ((inf >> 56) & 0xff)
724 | ((inf >> 40) & 0xff00)
725 | ((inf >> 24) & 0xff0000)
726 | ((inf >> 8) & 0xff000000));
727 relas[i].r_info = inf;
861fb55a
DJ		 728 }
729#endif /* BFD64 */
4d6ed7c8 730 }
103f02d3 731
4d6ed7c8
NC		 732 free (erelas);
733 }
734 *relasp = relas;
735 *nrelasp = nrelas;
736 return 1;
737}
103f02d3 738
4d6ed7c8 739static int
2cf0635d 740slurp_rel_relocs (FILE * file,
d3ba0551
AM		 741 unsigned long rel_offset,
742 unsigned long rel_size,
2cf0635d
NC		 743 Elf_Internal_Rela ** relsp,
744 unsigned long * nrelsp)
4d6ed7c8 745{
2cf0635d 746 Elf_Internal_Rela * rels;
4d6ed7c8
NC		 747 unsigned long nrels;
748 unsigned int i;
103f02d3 749
4d6ed7c8
NC		 750 if (is_32bit_elf)
751 {
2cf0635d 752 Elf32_External_Rel * erels;
103f02d3 753
3f5e193b
NC		 754 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
755 rel_size, _("relocs"));
a6e9f9df
AM		 756 if (!erels)
757 return 0;
103f02d3 758
4d6ed7c8 759 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 760
3f5e193b 761 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 762
4d6ed7c8
NC		 763 if (rels == NULL)
764 {
c256ffe7 765 free (erels);
591a748a 766 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 767 return 0;
768 }
769
770 for (i = 0; i < nrels; i++)
771 {
772 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
773 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 774 rels[i].r_addend = 0;
9ea033b2 775 }
4d6ed7c8
NC		 776
777 free (erels);
9c19a809
NC		 778 }
779 else
780 {
2cf0635d 781 Elf64_External_Rel * erels;
9ea033b2 782
3f5e193b
NC		 783 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
784 rel_size, _("relocs"));
a6e9f9df
AM		 785 if (!erels)
786 return 0;
103f02d3 787
4d6ed7c8 788 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 789
3f5e193b 790 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 791
4d6ed7c8 792 if (rels == NULL)
9c19a809 793 {
c256ffe7 794 free (erels);
591a748a 795 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 796 return 0;
797 }
103f02d3 798
4d6ed7c8
NC		 799 for (i = 0; i < nrels; i++)
800 {
66543521
AM		 801 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
802 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 803 rels[i].r_addend = 0;
861fb55a
DJ		 804
805 /* The #ifdef BFD64 below is to prevent a compile time
806 warning. We know that if we do not have a 64 bit data
807 type that we will never execute this code anyway. */
808#ifdef BFD64
809 if (elf_header.e_machine == EM_MIPS
810 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
811 {
812 /* In little-endian objects, r_info isn't really a
813 64-bit little-endian value: it has a 32-bit
814 little-endian symbol index followed by four
815 individual byte fields. Reorder INFO
816 accordingly. */
91d6fa6a
NC		 817 bfd_vma inf = rels[i].r_info;
818 inf = (((inf & 0xffffffff) << 32)
819 | ((inf >> 56) & 0xff)
820 | ((inf >> 40) & 0xff00)
821 | ((inf >> 24) & 0xff0000)
822 | ((inf >> 8) & 0xff000000));
823 rels[i].r_info = inf;
861fb55a
DJ		 824 }
825#endif /* BFD64 */
4d6ed7c8 826 }
103f02d3 827
4d6ed7c8
NC		 828 free (erels);
829 }
830 *relsp = rels;
831 *nrelsp = nrels;
832 return 1;
833}
103f02d3 834
aca88567
NC		 835/* Returns the reloc type extracted from the reloc info field. */
836
837static unsigned int
838get_reloc_type (bfd_vma reloc_info)
839{
840 if (is_32bit_elf)
841 return ELF32_R_TYPE (reloc_info);
842
843 switch (elf_header.e_machine)
844 {
845 case EM_MIPS:
846 /* Note: We assume that reloc_info has already been adjusted for us. */
847 return ELF64_MIPS_R_TYPE (reloc_info);
848
849 case EM_SPARCV9:
850 return ELF64_R_TYPE_ID (reloc_info);
851
852 default:
853 return ELF64_R_TYPE (reloc_info);
854 }
855}
856
857/* Return the symbol index extracted from the reloc info field. */
858
859static bfd_vma
860get_reloc_symindex (bfd_vma reloc_info)
861{
862 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
863}
864
d3ba0551
AM		 865/* Display the contents of the relocation data found at the specified
866 offset. */
ee42cf8c 867
41e92641 868static void
2cf0635d 869dump_relocations (FILE * file,
d3ba0551
AM		 870 unsigned long rel_offset,
871 unsigned long rel_size,
2cf0635d 872 Elf_Internal_Sym * symtab,
d3ba0551 873 unsigned long nsyms,
2cf0635d 874 char * strtab,
d79b3d50 875 unsigned long strtablen,
d3ba0551 876 int is_rela)
4d6ed7c8 877{
b34976b6 878 unsigned int i;
2cf0635d 879 Elf_Internal_Rela * rels;
103f02d3 880
4d6ed7c8
NC		 881 if (is_rela == UNKNOWN)
882 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 883
4d6ed7c8
NC		 884 if (is_rela)
885 {
c8286bd1 886 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 887 return;
4d6ed7c8
NC		 888 }
889 else
890 {
891 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 892 return;
252b5132
RH		 893 }
894
410f7a12
L		 895 if (is_32bit_elf)
896 {
897 if (is_rela)
2c71103e
NC		 898 {
899 if (do_wide)
900 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
901 else
902 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
903 }
410f7a12 904 else
2c71103e
NC		 905 {
906 if (do_wide)
907 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
908 else
909 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
910 }
410f7a12 911 }
252b5132 912 else
410f7a12
L		 913 {
914 if (is_rela)
2c71103e
NC		 915 {
916 if (do_wide)
8beeaeb7 917 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 918 else
919 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
920 }
410f7a12 921 else
2c71103e
NC		 922 {
923 if (do_wide)
8beeaeb7 924 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 925 else
926 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
927 }
410f7a12 928 }
252b5132
RH		 929
930 for (i = 0; i < rel_size; i++)
931 {
2cf0635d 932 const char * rtype;
b34976b6 933 bfd_vma offset;
91d6fa6a 934 bfd_vma inf;
b34976b6
AM		 935 bfd_vma symtab_index;
936 bfd_vma type;
103f02d3 937
b34976b6 938 offset = rels[i].r_offset;
91d6fa6a 939 inf = rels[i].r_info;
103f02d3 940
91d6fa6a
NC		 941 type = get_reloc_type (inf);
942 symtab_index = get_reloc_symindex (inf);
252b5132 943
410f7a12
L		 944 if (is_32bit_elf)
945 {
39dbeff8
AM		 946 printf ("%8.8lx %8.8lx ",
947 (unsigned long) offset & 0xffffffff,
91d6fa6a 948 (unsigned long) inf & 0xffffffff);
410f7a12
L		 949 }
950 else
951 {
39dbeff8
AM		 952#if BFD_HOST_64BIT_LONG
953 printf (do_wide
954 ? "%16.16lx %16.16lx "
955 : "%12.12lx %12.12lx ",
91d6fa6a 956 offset, inf);
39dbeff8 957#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 958#ifndef __MSVCRT__
39dbeff8
AM		 959 printf (do_wide
960 ? "%16.16llx %16.16llx "
961 : "%12.12llx %12.12llx ",
91d6fa6a 962 offset, inf);
6e3d6dc1
NC		 963#else
964 printf (do_wide
965 ? "%16.16I64x %16.16I64x "
966 : "%12.12I64x %12.12I64x ",
91d6fa6a 967 offset, inf);
6e3d6dc1 968#endif
39dbeff8 969#else
2c71103e
NC		 970 printf (do_wide
971 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
972 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 973 _bfd_int64_high (offset),
974 _bfd_int64_low (offset),
91d6fa6a
NC		 975 _bfd_int64_high (inf),
976 _bfd_int64_low (inf));
9ea033b2 977#endif
410f7a12 978 }
103f02d3 979
252b5132
RH		 980 switch (elf_header.e_machine)
981 {
982 default:
983 rtype = NULL;
984 break;
985
2b0337b0 986 case EM_M32R:
252b5132 987 case EM_CYGNUS_M32R:
9ea033b2 988 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 989 break;
990
991 case EM_386:
992 case EM_486:
9ea033b2 993 rtype = elf_i386_reloc_type (type);
252b5132
RH		 994 break;
995
ba2685cc
AM		 996 case EM_68HC11:
997 case EM_68HC12:
998 rtype = elf_m68hc11_reloc_type (type);
999 break;
75751cd9 1000
252b5132 1001 case EM_68K:
9ea033b2 1002 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1003 break;
1004
63fcb9e9 1005 case EM_960:
9ea033b2 1006 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1007 break;
1008
adde6300 1009 case EM_AVR:
2b0337b0 1010 case EM_AVR_OLD:
adde6300
AM		 1011 rtype = elf_avr_reloc_type (type);
1012 break;
1013
9ea033b2
NC		 1014 case EM_OLD_SPARCV9:
1015 case EM_SPARC32PLUS:
1016 case EM_SPARCV9:
252b5132 1017 case EM_SPARC:
9ea033b2 1018 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1019 break;
1020
e9f53129
AM		 1021 case EM_SPU:
1022 rtype = elf_spu_reloc_type (type);
1023 break;
1024
2b0337b0 1025 case EM_V850:
252b5132 1026 case EM_CYGNUS_V850:
9ea033b2 1027 rtype = v850_reloc_type (type);
252b5132
RH		 1028 break;
1029
2b0337b0 1030 case EM_D10V:
252b5132 1031 case EM_CYGNUS_D10V:
9ea033b2 1032 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1033 break;
1034
2b0337b0 1035 case EM_D30V:
252b5132 1036 case EM_CYGNUS_D30V:
9ea033b2 1037 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1038 break;
1039
d172d4ba
NC		 1040 case EM_DLX:
1041 rtype = elf_dlx_reloc_type (type);
1042 break;
1043
252b5132 1044 case EM_SH:
9ea033b2 1045 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1046 break;
1047
2b0337b0 1048 case EM_MN10300:
252b5132 1049 case EM_CYGNUS_MN10300:
9ea033b2 1050 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1051 break;
1052
2b0337b0 1053 case EM_MN10200:
252b5132 1054 case EM_CYGNUS_MN10200:
9ea033b2 1055 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1056 break;
1057
2b0337b0 1058 case EM_FR30:
252b5132 1059 case EM_CYGNUS_FR30:
9ea033b2 1060 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1061 break;
1062
ba2685cc
AM		 1063 case EM_CYGNUS_FRV:
1064 rtype = elf_frv_reloc_type (type);
1065 break;
5c70f934 1066
252b5132 1067 case EM_MCORE:
9ea033b2 1068 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1069 break;
1070
3c3bdf30
NC		 1071 case EM_MMIX:
1072 rtype = elf_mmix_reloc_type (type);
1073 break;
1074
5506d11a
AM		 1075 case EM_MOXIE:
1076 rtype = elf_moxie_reloc_type (type);
1077 break;
1078
2469cfa2
NC		 1079 case EM_MSP430:
1080 case EM_MSP430_OLD:
1081 rtype = elf_msp430_reloc_type (type);
1082 break;
1083
252b5132 1084 case EM_PPC:
9ea033b2 1085 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1086 break;
1087
c833c019
AM		 1088 case EM_PPC64:
1089 rtype = elf_ppc64_reloc_type (type);
1090 break;
1091
252b5132 1092 case EM_MIPS:
4fe85591 1093 case EM_MIPS_RS3_LE:
9ea033b2 1094 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1095 break;
1096
1097 case EM_ALPHA:
9ea033b2 1098 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1099 break;
1100
1101 case EM_ARM:
9ea033b2 1102 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1103 break;
1104
584da044 1105 case EM_ARC:
9ea033b2 1106 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1107 break;
1108
1109 case EM_PARISC:
69e617ca 1110 rtype = elf_hppa_reloc_type (type);
252b5132 1111 break;
7d466069 1112
b8720f9d
JL		 1113 case EM_H8_300:
1114 case EM_H8_300H:
1115 case EM_H8S:
1116 rtype = elf_h8_reloc_type (type);
1117 break;
1118
3b16e843
NC		 1119 case EM_OPENRISC:
1120 case EM_OR32:
1121 rtype = elf_or32_reloc_type (type);
1122 break;
1123
7d466069 1124 case EM_PJ:
2b0337b0 1125 case EM_PJ_OLD:
7d466069
ILT		 1126 rtype = elf_pj_reloc_type (type);
1127 break;
800eeca4
JW		 1128 case EM_IA_64:
1129 rtype = elf_ia64_reloc_type (type);
1130 break;
1b61cf92
HPN		 1131
1132 case EM_CRIS:
1133 rtype = elf_cris_reloc_type (type);
1134 break;
535c37ff
JE		 1135
1136 case EM_860:
1137 rtype = elf_i860_reloc_type (type);
1138 break;
bcedfee6
NC		 1139
1140 case EM_X86_64:
8a9036a4 1141 case EM_L1OM:
7a9068fe 1142 case EM_K1OM:
bcedfee6
NC		 1143 rtype = elf_x86_64_reloc_type (type);
1144 break;
a85d7ed0 1145
35b1837e
AM		 1146 case EM_S370:
1147 rtype = i370_reloc_type (type);
1148 break;
1149
53c7db4b
KH		 1150 case EM_S390_OLD:
1151 case EM_S390:
1152 rtype = elf_s390_reloc_type (type);
1153 break;
93fbbb04 1154
1c0d3aa6
NC		 1155 case EM_SCORE:
1156 rtype = elf_score_reloc_type (type);
1157 break;
1158
93fbbb04
GK		 1159 case EM_XSTORMY16:
1160 rtype = elf_xstormy16_reloc_type (type);
1161 break;
179d3252 1162
1fe1f39c
NC		 1163 case EM_CRX:
1164 rtype = elf_crx_reloc_type (type);
1165 break;
1166
179d3252
JT		 1167 case EM_VAX:
1168 rtype = elf_vax_reloc_type (type);
1169 break;
1e4cf259
NC		 1170
1171 case EM_IP2K:
1172 case EM_IP2K_OLD:
1173 rtype = elf_ip2k_reloc_type (type);
1174 break;
3b36097d
SC		 1175
1176 case EM_IQ2000:
1177 rtype = elf_iq2000_reloc_type (type);
1178 break;
88da6820
NC		 1179
1180 case EM_XTENSA_OLD:
1181 case EM_XTENSA:
1182 rtype = elf_xtensa_reloc_type (type);
1183 break;
a34e3ecb 1184
84e94c90
NC		 1185 case EM_LATTICEMICO32:
1186 rtype = elf_lm32_reloc_type (type);
1187 break;
1188
ff7eeb89 1189 case EM_M32C_OLD:
49f58d10
JB		 1190 case EM_M32C:
1191 rtype = elf_m32c_reloc_type (type);
1192 break;
1193
d031aafb
NS		 1194 case EM_MT:
1195 rtype = elf_mt_reloc_type (type);
a34e3ecb 1196 break;
1d65ded4
CM		 1197
1198 case EM_BLACKFIN:
1199 rtype = elf_bfin_reloc_type (type);
1200 break;
15ab5209
DB		 1201
1202 case EM_CYGNUS_MEP:
1203 rtype = elf_mep_reloc_type (type);
1204 break;
60bca95a
NC		 1205
1206 case EM_CR16:
6c03b1ed 1207 case EM_CR16_OLD:
60bca95a
NC		 1208 rtype = elf_cr16_reloc_type (type);
1209 break;
dd24e3da 1210
7ba29e2a
NC		 1211 case EM_MICROBLAZE:
1212 case EM_MICROBLAZE_OLD:
1213 rtype = elf_microblaze_reloc_type (type);
1214 break;
c7927a3c
NC		 1215
1216 case EM_RX:
1217 rtype = elf_rx_reloc_type (type);
1218 break;
c29aca4a
NC		 1219
1220 case EM_XC16X:
1221 case EM_C166:
1222 rtype = elf_xc16x_reloc_type (type);
1223 break;
40b36596
JM		 1224
1225 case EM_TI_C6000:
1226 rtype = elf_tic6x_reloc_type (type);
1227 break;
aa137e4d
NC		 1228
1229 case EM_TILEGX:
1230 rtype = elf_tilegx_reloc_type (type);
1231 break;
1232
1233 case EM_TILEPRO:
1234 rtype = elf_tilepro_reloc_type (type);
1235 break;
252b5132
RH		 1236 }
1237
1238 if (rtype == NULL)
39dbeff8 1239 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1240 else
8beeaeb7 1241 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1242
7ace3541 1243 if (elf_header.e_machine == EM_ALPHA
157c2599 1244 && rtype != NULL
7ace3541
RH		 1245 && streq (rtype, "R_ALPHA_LITUSE")
1246 && is_rela)
1247 {
1248 switch (rels[i].r_addend)
1249 {
1250 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1251 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1252 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1253 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1254 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1255 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1256 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1257 default: rtype = NULL;
1258 }
1259 if (rtype)
1260 printf (" (%s)", rtype);
1261 else
1262 {
1263 putchar (' ');
1264 printf (_("<unknown addend: %lx>"),
1265 (unsigned long) rels[i].r_addend);
1266 }
1267 }
1268 else if (symtab_index)
252b5132 1269 {
af3fc3bc 1270 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1271 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1272 else
19936277 1273 {
2cf0635d 1274 Elf_Internal_Sym * psym;
19936277 1275
af3fc3bc 1276 psym = symtab + symtab_index;
103f02d3 1277
af3fc3bc 1278 printf (" ");
171191ba 1279
d8045f23
NC		 1280 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1281 {
1282 const char * name;
1283 unsigned int len;
1284 unsigned int width = is_32bit_elf ? 8 : 14;
1285
1286 /* Relocations against GNU_IFUNC symbols do not use the value
1287 of the symbol as the address to relocate against. Instead
1288 they invoke the function named by the symbol and use its
1289 result as the address for relocation.
1290
1291 To indicate this to the user, do not display the value of
1292 the symbol in the "Symbols's Value" field. Instead show
1293 its name followed by () as a hint that the symbol is
1294 invoked. */
1295
1296 if (strtab == NULL
1297 || psym->st_name == 0
1298 || psym->st_name >= strtablen)
1299 name = "??";
1300 else
1301 name = strtab + psym->st_name;
1302
1303 len = print_symbol (width, name);
1304 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1305 }
1306 else
1307 {
1308 print_vma (psym->st_value, LONG_HEX);
171191ba 1309
d8045f23
NC		 1310 printf (is_32bit_elf ? " " : " ");
1311 }
103f02d3 1312
af3fc3bc 1313 if (psym->st_name == 0)
f1ef08cb 1314 {
2cf0635d 1315 const char * sec_name = "<null>";
f1ef08cb
AM		 1316 char name_buf[40];
1317
1318 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1319 {
4fbb74a6
AM		 1320 if (psym->st_shndx < elf_header.e_shnum)
1321 sec_name
1322 = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1323 else if (psym->st_shndx == SHN_ABS)
1324 sec_name = "ABS";
1325 else if (psym->st_shndx == SHN_COMMON)
1326 sec_name = "COMMON";
ac145307
BS		 1327 else if ((elf_header.e_machine == EM_MIPS
1328 && psym->st_shndx == SHN_MIPS_SCOMMON)
1329 || (elf_header.e_machine == EM_TI_C6000
1330 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1331 sec_name = "SCOMMON";
1332 else if (elf_header.e_machine == EM_MIPS
1333 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1334 sec_name = "SUNDEF";
8a9036a4 1335 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1336 || elf_header.e_machine == EM_L1OM
1337 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1338 && psym->st_shndx == SHN_X86_64_LCOMMON)
1339 sec_name = "LARGE_COMMON";
9ce701e2
L		 1340 else if (elf_header.e_machine == EM_IA_64
1341 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1342 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1343 sec_name = "ANSI_COM";
28f997cf 1344 else if (is_ia64_vms ()
148b93f2
NC		 1345 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1346 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1347 else
1348 {
1349 sprintf (name_buf, "<section 0x%x>",
1350 (unsigned int) psym->st_shndx);
1351 sec_name = name_buf;
1352 }
1353 }
1354 print_symbol (22, sec_name);
1355 }
af3fc3bc 1356 else if (strtab == NULL)
d79b3d50 1357 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1358 else if (psym->st_name >= strtablen)
d79b3d50 1359 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1360 else
2c71103e 1361 print_symbol (22, strtab + psym->st_name);
103f02d3 1362
af3fc3bc 1363 if (is_rela)
171191ba 1364 {
598aaa76 1365 bfd_signed_vma off = rels[i].r_addend;
171191ba 1366
91d6fa6a 1367 if (off < 0)
598aaa76 1368 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1369 else
598aaa76 1370 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1371 }
19936277 1372 }
252b5132 1373 }
1b228002 1374 else if (is_rela)
f7a99963 1375 {
18bd398b
NC		 1376 printf ("%*c", is_32bit_elf ?
1377 (do_wide ? 34 : 28) : (do_wide ? 26 : 20), ' ');
c8286bd1 1378 print_vma (rels[i].r_addend, LONG_HEX);
f7a99963 1379 }
252b5132 1380
157c2599
NC		 1381 if (elf_header.e_machine == EM_SPARCV9
1382 && rtype != NULL
1383 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1384 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1385
252b5132 1386 putchar ('\n');
2c71103e 1387
aca88567 1388#ifdef BFD64
53c7db4b 1389 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1390 {
91d6fa6a
NC		 1391 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1392 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1393 const char * rtype2 = elf_mips_reloc_type (type2);
1394 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1395
2c71103e
NC		 1396 printf (" Type2: ");
1397
1398 if (rtype2 == NULL)
39dbeff8
AM		 1399 printf (_("unrecognized: %-7lx"),
1400 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1401 else
1402 printf ("%-17.17s", rtype2);
1403
18bd398b 1404 printf ("\n Type3: ");
2c71103e
NC		 1405
1406 if (rtype3 == NULL)
39dbeff8
AM		 1407 printf (_("unrecognized: %-7lx"),
1408 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1409 else
1410 printf ("%-17.17s", rtype3);
1411
53c7db4b 1412 putchar ('\n');
2c71103e 1413 }
aca88567 1414#endif /* BFD64 */
252b5132
RH		 1415 }
1416
c8286bd1 1417 free (rels);
252b5132
RH		 1418}
1419
1420static const char *
d3ba0551 1421get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1422{
1423 switch (type)
1424 {
1425 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1426 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1427 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1428 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1429 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1430 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1431 case DT_MIPS_MSYM: return "MIPS_MSYM";
1432 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1433 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1434 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1435 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1436 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1437 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1438 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1439 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1440 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1441 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1442 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1443 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1444 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1445 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1446 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1447 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1448 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1449 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1450 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1451 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1452 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1453 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1454 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1455 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1456 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1457 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1458 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1459 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1460 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1461 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1462 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1463 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1464 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1465 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1466 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1467 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1468 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1469 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1470 default:
1471 return NULL;
1472 }
1473}
1474
9a097730 1475static const char *
d3ba0551 1476get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1477{
1478 switch (type)
1479 {
1480 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1481 default:
1482 return NULL;
1483 }
103f02d3
UD		 1484}
1485
7490d522
AM		 1486static const char *
1487get_ppc_dynamic_type (unsigned long type)
1488{
1489 switch (type)
1490 {
a7f2871e
AM		 1491 case DT_PPC_GOT: return "PPC_GOT";
1492 case DT_PPC_TLSOPT: return "PPC_TLSOPT";
7490d522
AM		 1493 default:
1494 return NULL;
1495 }
1496}
1497
f1cb7e17 1498static const char *
d3ba0551 1499get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1500{
1501 switch (type)
1502 {
a7f2871e
AM		 1503 case DT_PPC64_GLINK: return "PPC64_GLINK";
1504 case DT_PPC64_OPD: return "PPC64_OPD";
1505 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1506 case DT_PPC64_TLSOPT: return "PPC64_TLSOPT";
f1cb7e17
AM		 1507 default:
1508 return NULL;
1509 }
1510}
1511
103f02d3 1512static const char *
d3ba0551 1513get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1514{
1515 switch (type)
1516 {
1517 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1518 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1519 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1520 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1521 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1522 case DT_HP_PREINIT: return "HP_PREINIT";
1523 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1524 case DT_HP_NEEDED: return "HP_NEEDED";
1525 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1526 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1527 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1528 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1529 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1530 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1531 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1532 case DT_HP_FILTERED: return "HP_FILTERED";
1533 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1534 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1535 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1536 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1537 case DT_PLT: return "PLT";
1538 case DT_PLT_SIZE: return "PLT_SIZE";
1539 case DT_DLT: return "DLT";
1540 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1541 default:
1542 return NULL;
1543 }
1544}
9a097730 1545
ecc51f48 1546static const char *
d3ba0551 1547get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1548{
1549 switch (type)
1550 {
148b93f2
NC		 1551 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1552 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1553 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1554 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1555 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1556 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1557 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1558 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1559 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1560 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1561 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1562 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1563 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1564 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1565 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1566 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1567 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1568 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1569 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1570 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1571 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1572 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1573 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1574 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1575 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1576 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1577 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1578 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1579 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1580 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1581 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1582 default:
1583 return NULL;
1584 }
1585}
1586
fabcb361
RH		 1587static const char *
1588get_alpha_dynamic_type (unsigned long type)
1589{
1590 switch (type)
1591 {
1592 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1593 default:
1594 return NULL;
1595 }
1596}
1597
1c0d3aa6
NC		 1598static const char *
1599get_score_dynamic_type (unsigned long type)
1600{
1601 switch (type)
1602 {
1603 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1604 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1605 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1606 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1607 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1608 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1609 default:
1610 return NULL;
1611 }
1612}
1613
40b36596
JM		 1614static const char *
1615get_tic6x_dynamic_type (unsigned long type)
1616{
1617 switch (type)
1618 {
1619 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1620 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1621 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1622 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1623 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1624 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1625 default:
1626 return NULL;
1627 }
1628}
1c0d3aa6 1629
252b5132 1630static const char *
d3ba0551 1631get_dynamic_type (unsigned long type)
252b5132 1632{
e9e44622 1633 static char buff[64];
252b5132
RH		 1634
1635 switch (type)
1636 {
1637 case DT_NULL: return "NULL";
1638 case DT_NEEDED: return "NEEDED";
1639 case DT_PLTRELSZ: return "PLTRELSZ";
1640 case DT_PLTGOT: return "PLTGOT";
1641 case DT_HASH: return "HASH";
1642 case DT_STRTAB: return "STRTAB";
1643 case DT_SYMTAB: return "SYMTAB";
1644 case DT_RELA: return "RELA";
1645 case DT_RELASZ: return "RELASZ";
1646 case DT_RELAENT: return "RELAENT";
1647 case DT_STRSZ: return "STRSZ";
1648 case DT_SYMENT: return "SYMENT";
1649 case DT_INIT: return "INIT";
1650 case DT_FINI: return "FINI";
1651 case DT_SONAME: return "SONAME";
1652 case DT_RPATH: return "RPATH";
1653 case DT_SYMBOLIC: return "SYMBOLIC";
1654 case DT_REL: return "REL";
1655 case DT_RELSZ: return "RELSZ";
1656 case DT_RELENT: return "RELENT";
1657 case DT_PLTREL: return "PLTREL";
1658 case DT_DEBUG: return "DEBUG";
1659 case DT_TEXTREL: return "TEXTREL";
1660 case DT_JMPREL: return "JMPREL";
1661 case DT_BIND_NOW: return "BIND_NOW";
1662 case DT_INIT_ARRAY: return "INIT_ARRAY";
1663 case DT_FINI_ARRAY: return "FINI_ARRAY";
1664 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1665 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1666 case DT_RUNPATH: return "RUNPATH";
1667 case DT_FLAGS: return "FLAGS";
2d0e6f43 1668
d1133906
NC		 1669 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1670 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1671
05107a46 1672 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1673 case DT_PLTPADSZ: return "PLTPADSZ";
1674 case DT_MOVEENT: return "MOVEENT";
1675 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1676 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1677 case DT_POSFLAG_1: return "POSFLAG_1";
1678 case DT_SYMINSZ: return "SYMINSZ";
1679 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1680
252b5132 1681 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1682 case DT_CONFIG: return "CONFIG";
1683 case DT_DEPAUDIT: return "DEPAUDIT";
1684 case DT_AUDIT: return "AUDIT";
1685 case DT_PLTPAD: return "PLTPAD";
1686 case DT_MOVETAB: return "MOVETAB";
252b5132 1687 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1688
252b5132 1689 case DT_VERSYM: return "VERSYM";
103f02d3 1690
67a4f2b7
AO		 1691 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1692 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1693 case DT_RELACOUNT: return "RELACOUNT";
1694 case DT_RELCOUNT: return "RELCOUNT";
1695 case DT_FLAGS_1: return "FLAGS_1";
1696 case DT_VERDEF: return "VERDEF";
1697 case DT_VERDEFNUM: return "VERDEFNUM";
1698 case DT_VERNEED: return "VERNEED";
1699 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1700
019148e4 1701 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1702 case DT_USED: return "USED";
1703 case DT_FILTER: return "FILTER";
103f02d3 1704
047b2264
JJ		 1705 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1706 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1707 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1708 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1709 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1710 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1711
252b5132
RH		 1712 default:
1713 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1714 {
2cf0635d 1715 const char * result;
103f02d3 1716
252b5132
RH		 1717 switch (elf_header.e_machine)
1718 {
1719 case EM_MIPS:
4fe85591 1720 case EM_MIPS_RS3_LE:
252b5132
RH		 1721 result = get_mips_dynamic_type (type);
1722 break;
9a097730
RH		 1723 case EM_SPARCV9:
1724 result = get_sparc64_dynamic_type (type);
1725 break;
7490d522
AM		 1726 case EM_PPC:
1727 result = get_ppc_dynamic_type (type);
1728 break;
f1cb7e17
AM		 1729 case EM_PPC64:
1730 result = get_ppc64_dynamic_type (type);
1731 break;
ecc51f48
NC		 1732 case EM_IA_64:
1733 result = get_ia64_dynamic_type (type);
1734 break;
fabcb361
RH		 1735 case EM_ALPHA:
1736 result = get_alpha_dynamic_type (type);
1737 break;
1c0d3aa6
NC		 1738 case EM_SCORE:
1739 result = get_score_dynamic_type (type);
1740 break;
40b36596
JM		 1741 case EM_TI_C6000:
1742 result = get_tic6x_dynamic_type (type);
1743 break;
252b5132
RH		 1744 default:
1745 result = NULL;
1746 break;
1747 }
1748
1749 if (result != NULL)
1750 return result;
1751
e9e44622 1752 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 1753 }
eec8f817
DA		 1754 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1755 || (elf_header.e_machine == EM_PARISC
1756 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 1757 {
2cf0635d 1758 const char * result;
103f02d3
UD		 1759
1760 switch (elf_header.e_machine)
1761 {
1762 case EM_PARISC:
1763 result = get_parisc_dynamic_type (type);
1764 break;
148b93f2
NC		 1765 case EM_IA_64:
1766 result = get_ia64_dynamic_type (type);
1767 break;
103f02d3
UD		 1768 default:
1769 result = NULL;
1770 break;
1771 }
1772
1773 if (result != NULL)
1774 return result;
1775
e9e44622
JJ		 1776 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1777 type);
103f02d3 1778 }
252b5132 1779 else
e9e44622 1780 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 1781
252b5132
RH		 1782 return buff;
1783 }
1784}
1785
1786static char *
d3ba0551 1787get_file_type (unsigned e_type)
252b5132 1788{
b34976b6 1789 static char buff[32];
252b5132
RH		 1790
1791 switch (e_type)
1792 {
1793 case ET_NONE: return _("NONE (None)");
1794 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 1795 case ET_EXEC: return _("EXEC (Executable file)");
1796 case ET_DYN: return _("DYN (Shared object file)");
1797 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 1798
1799 default:
1800 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 1801 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 1802 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 1803 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 1804 else
e9e44622 1805 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 1806 return buff;
1807 }
1808}
1809
1810static char *
d3ba0551 1811get_machine_name (unsigned e_machine)
252b5132 1812{
b34976b6 1813 static char buff[64]; /* XXX */
252b5132
RH		 1814
1815 switch (e_machine)
1816 {
c45021f2
NC		 1817 case EM_NONE: return _("None");
1818 case EM_M32: return "WE32100";
1819 case EM_SPARC: return "Sparc";
e9f53129 1820 case EM_SPU: return "SPU";
c45021f2
NC		 1821 case EM_386: return "Intel 80386";
1822 case EM_68K: return "MC68000";
1823 case EM_88K: return "MC88000";
1824 case EM_486: return "Intel 80486";
1825 case EM_860: return "Intel 80860";
1826 case EM_MIPS: return "MIPS R3000";
1827 case EM_S370: return "IBM System/370";
7036c0e1 1828 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 1829 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 1830 case EM_PARISC: return "HPPA";
252b5132 1831 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 1832 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 1833 case EM_960: return "Intel 90860";
1834 case EM_PPC: return "PowerPC";
285d1771 1835 case EM_PPC64: return "PowerPC64";
c45021f2
NC		 1836 case EM_V800: return "NEC V800";
1837 case EM_FR20: return "Fujitsu FR20";
1838 case EM_RH32: return "TRW RH32";
b34976b6 1839 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 1840 case EM_ARM: return "ARM";
1841 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 1842 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 1843 case EM_SPARCV9: return "Sparc v9";
1844 case EM_TRICORE: return "Siemens Tricore";
584da044 1845 case EM_ARC: return "ARC";
c2dcd04e
NC		 1846 case EM_H8_300: return "Renesas H8/300";
1847 case EM_H8_300H: return "Renesas H8/300H";
1848 case EM_H8S: return "Renesas H8S";
1849 case EM_H8_500: return "Renesas H8/500";
30800947 1850 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 1851 case EM_MIPS_X: return "Stanford MIPS-X";
1852 case EM_COLDFIRE: return "Motorola Coldfire";
1853 case EM_68HC12: return "Motorola M68HC12";
c45021f2 1854 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 1855 case EM_CYGNUS_D10V:
1856 case EM_D10V: return "d10v";
1857 case EM_CYGNUS_D30V:
b34976b6 1858 case EM_D30V: return "d30v";
2b0337b0 1859 case EM_CYGNUS_M32R:
26597c86 1860 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 1861 case EM_CYGNUS_V850:
8f7e76d0 1862 case EM_V850: return "Renesas v850";
2b0337b0
AO		 1863 case EM_CYGNUS_MN10300:
1864 case EM_MN10300: return "mn10300";
1865 case EM_CYGNUS_MN10200:
1866 case EM_MN10200: return "mn10200";
5506d11a 1867 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 1868 case EM_CYGNUS_FR30:
1869 case EM_FR30: return "Fujitsu FR30";
b34976b6 1870 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 1871 case EM_PJ_OLD:
b34976b6 1872 case EM_PJ: return "picoJava";
7036c0e1
AJ		 1873 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1874 case EM_PCP: return "Siemens PCP";
1875 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1876 case EM_NDR1: return "Denso NDR1 microprocesspr";
1877 case EM_STARCORE: return "Motorola Star*Core processor";
1878 case EM_ME16: return "Toyota ME16 processor";
1879 case EM_ST100: return "STMicroelectronics ST100 processor";
1880 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 1881 case EM_PDSP: return "Sony DSP processor";
1882 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
1883 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 1884 case EM_FX66: return "Siemens FX66 microcontroller";
1885 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1886 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1887 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1888 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1889 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1890 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1891 case EM_SVX: return "Silicon Graphics SVx";
1892 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1893 case EM_VAX: return "Digital VAX";
2b0337b0 1894 case EM_AVR_OLD:
b34976b6 1895 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 1896 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 1897 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1898 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1899 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 1900 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 1901 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 1902 case EM_PRISM: return "Vitesse Prism";
bcedfee6 1903 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 1904 case EM_L1OM: return "Intel L1OM";
7a9068fe 1905 case EM_K1OM: return "Intel K1OM";
b7498e0e 1906 case EM_S390_OLD:
b34976b6 1907 case EM_S390: return "IBM S/390";
1c0d3aa6 1908 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 1909 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
3b16e843
NC		 1910 case EM_OPENRISC:
1911 case EM_OR32: return "OpenRISC";
11636f9e 1912 case EM_ARC_A5: return "ARC International ARCompact processor";
1fe1f39c 1913 case EM_CRX: return "National Semiconductor CRX microprocessor";
d172d4ba 1914 case EM_DLX: return "OpenDLX";
1e4cf259 1915 case EM_IP2K_OLD:
b34976b6 1916 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 1917 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 1918 case EM_XTENSA_OLD:
1919 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 1920 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
1921 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
1922 case EM_NS32K: return "National Semiconductor 32000 series";
1923 case EM_TPC: return "Tenor Network TPC processor";
1924 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
1925 case EM_MAX: return "MAX Processor";
1926 case EM_CR: return "National Semiconductor CompactRISC";
1927 case EM_F2MC16: return "Fujitsu F2MC16";
1928 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 1929 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 1930 case EM_M32C_OLD:
49f58d10 1931 case EM_M32C: return "Renesas M32c";
d031aafb 1932 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 1933 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 1934 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
1935 case EM_SEP: return "Sharp embedded microprocessor";
1936 case EM_ARCA: return "Arca RISC microprocessor";
1937 case EM_UNICORE: return "Unicore";
1938 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
1939 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 1940 case EM_NIOS32: return "Altera Nios";
1941 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 1942 case EM_C166:
d70c5fc7 1943 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 1944 case EM_M16C: return "Renesas M16C series microprocessors";
1945 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
1946 case EM_CE: return "Freescale Communication Engine RISC core";
1947 case EM_TSK3000: return "Altium TSK3000 core";
1948 case EM_RS08: return "Freescale RS08 embedded processor";
1949 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
1950 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
1951 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
1952 case EM_SE_C17: return "Seiko Epson C17 family";
1953 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
1954 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
1955 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
1956 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
1957 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
1958 case EM_R32C: return "Renesas R32C series microprocessors";
1959 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
1960 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
1961 case EM_8051: return "Intel 8051 and variants";
1962 case EM_STXP7X: return "STMicroelectronics STxP7x family";
1963 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
1964 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
1965 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
1966 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
1967 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
1968 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 1969 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 1970 case EM_CR16:
6c03b1ed 1971 case EM_CR16_OLD: return "National Semiconductor's CR16";
7ba29e2a
NC		 1972 case EM_MICROBLAZE: return "Xilinx MicroBlaze";
1973 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
c7927a3c 1974 case EM_RX: return "Renesas RX";
11636f9e
JM		 1975 case EM_METAG: return "Imagination Technologies META processor architecture";
1976 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
1977 case EM_ECOG16: return "Cyan Technology eCOG16 family";
1978 case EM_ETPU: return "Freescale Extended Time Processing Unit";
1979 case EM_SLE9X: return "Infineon Technologies SLE9X core";
1980 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
1981 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
1982 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
1983 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 1984 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 1985 case EM_CUDA: return "NVIDIA CUDA architecture";
252b5132 1986 default:
35d9dd2f 1987 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 1988 return buff;
1989 }
1990}
1991
f3485b74 1992static void
d3ba0551 1993decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 1994{
1995 unsigned eabi;
1996 int unknown = 0;
1997
1998 eabi = EF_ARM_EABI_VERSION (e_flags);
1999 e_flags &= ~ EF_ARM_EABIMASK;
2000
2001 /* Handle "generic" ARM flags. */
2002 if (e_flags & EF_ARM_RELEXEC)
2003 {
2004 strcat (buf, ", relocatable executable");
2005 e_flags &= ~ EF_ARM_RELEXEC;
2006 }
76da6bbe 2007
f3485b74
NC		 2008 if (e_flags & EF_ARM_HASENTRY)
2009 {
2010 strcat (buf, ", has entry point");
2011 e_flags &= ~ EF_ARM_HASENTRY;
2012 }
76da6bbe 2013
f3485b74
NC		 2014 /* Now handle EABI specific flags. */
2015 switch (eabi)
2016 {
2017 default:
2c71103e 2018 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2019 if (e_flags)
2020 unknown = 1;
2021 break;
2022
2023 case EF_ARM_EABI_VER1:
a5bcd848 2024 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2025 while (e_flags)
2026 {
2027 unsigned flag;
76da6bbe 2028
f3485b74
NC		 2029 /* Process flags one bit at a time. */
2030 flag = e_flags & - e_flags;
2031 e_flags &= ~ flag;
76da6bbe 2032
f3485b74
NC		 2033 switch (flag)
2034 {
a5bcd848 2035 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2036 strcat (buf, ", sorted symbol tables");
2037 break;
76da6bbe 2038
f3485b74
NC		 2039 default:
2040 unknown = 1;
2041 break;
2042 }
2043 }
2044 break;
76da6bbe 2045
a5bcd848
PB		 2046 case EF_ARM_EABI_VER2:
2047 strcat (buf, ", Version2 EABI");
2048 while (e_flags)
2049 {
2050 unsigned flag;
2051
2052 /* Process flags one bit at a time. */
2053 flag = e_flags & - e_flags;
2054 e_flags &= ~ flag;
2055
2056 switch (flag)
2057 {
2058 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2059 strcat (buf, ", sorted symbol tables");
2060 break;
2061
2062 case EF_ARM_DYNSYMSUSESEGIDX:
2063 strcat (buf, ", dynamic symbols use segment index");
2064 break;
2065
2066 case EF_ARM_MAPSYMSFIRST:
2067 strcat (buf, ", mapping symbols precede others");
2068 break;
2069
2070 default:
2071 unknown = 1;
2072 break;
2073 }
2074 }
2075 break;
2076
d507cf36
PB		 2077 case EF_ARM_EABI_VER3:
2078 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2079 break;
2080
2081 case EF_ARM_EABI_VER4:
2082 strcat (buf, ", Version4 EABI");
3a4a14e9
PB		 2083 goto eabi;
2084
2085 case EF_ARM_EABI_VER5:
2086 strcat (buf, ", Version5 EABI");
2087 eabi:
d507cf36
PB		 2088 while (e_flags)
2089 {
2090 unsigned flag;
2091
2092 /* Process flags one bit at a time. */
2093 flag = e_flags & - e_flags;
2094 e_flags &= ~ flag;
2095
2096 switch (flag)
2097 {
2098 case EF_ARM_BE8:
2099 strcat (buf, ", BE8");
2100 break;
2101
2102 case EF_ARM_LE8:
2103 strcat (buf, ", LE8");
2104 break;
2105
2106 default:
2107 unknown = 1;
2108 break;
2109 }
2110 }
2111 break;
2112
f3485b74 2113 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2114 strcat (buf, ", GNU EABI");
f3485b74
NC		 2115 while (e_flags)
2116 {
2117 unsigned flag;
76da6bbe 2118
f3485b74
NC		 2119 /* Process flags one bit at a time. */
2120 flag = e_flags & - e_flags;
2121 e_flags &= ~ flag;
76da6bbe 2122
f3485b74
NC		 2123 switch (flag)
2124 {
a5bcd848 2125 case EF_ARM_INTERWORK:
f3485b74
NC		 2126 strcat (buf, ", interworking enabled");
2127 break;
76da6bbe 2128
a5bcd848 2129 case EF_ARM_APCS_26:
f3485b74
NC		 2130 strcat (buf, ", uses APCS/26");
2131 break;
76da6bbe 2132
a5bcd848 2133 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2134 strcat (buf, ", uses APCS/float");
2135 break;
76da6bbe 2136
a5bcd848 2137 case EF_ARM_PIC:
f3485b74
NC		 2138 strcat (buf, ", position independent");
2139 break;
76da6bbe 2140
a5bcd848 2141 case EF_ARM_ALIGN8:
f3485b74
NC		 2142 strcat (buf, ", 8 bit structure alignment");
2143 break;
76da6bbe 2144
a5bcd848 2145 case EF_ARM_NEW_ABI:
f3485b74
NC		 2146 strcat (buf, ", uses new ABI");
2147 break;
76da6bbe 2148
a5bcd848 2149 case EF_ARM_OLD_ABI:
f3485b74
NC		 2150 strcat (buf, ", uses old ABI");
2151 break;
76da6bbe 2152
a5bcd848 2153 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2154 strcat (buf, ", software FP");
2155 break;
76da6bbe 2156
90e01f86
ILT		 2157 case EF_ARM_VFP_FLOAT:
2158 strcat (buf, ", VFP");
2159 break;
2160
fde78edd
NC		 2161 case EF_ARM_MAVERICK_FLOAT:
2162 strcat (buf, ", Maverick FP");
2163 break;
2164
f3485b74
NC		 2165 default:
2166 unknown = 1;
2167 break;
2168 }
2169 }
2170 }
f3485b74
NC		 2171
2172 if (unknown)
2b692964 2173 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2174}
2175
252b5132 2176static char *
d3ba0551 2177get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2178{
b34976b6 2179 static char buf[1024];
252b5132
RH		 2180
2181 buf[0] = '\0';
76da6bbe 2182
252b5132
RH		 2183 if (e_flags)
2184 {
2185 switch (e_machine)
2186 {
2187 default:
2188 break;
2189
f3485b74
NC		 2190 case EM_ARM:
2191 decode_ARM_machine_flags (e_flags, buf);
2192 break;
76da6bbe 2193
781303ce
MF		 2194 case EM_BLACKFIN:
2195 if (e_flags & EF_BFIN_PIC)
2196 strcat (buf, ", PIC");
2197
2198 if (e_flags & EF_BFIN_FDPIC)
2199 strcat (buf, ", FDPIC");
2200
2201 if (e_flags & EF_BFIN_CODE_IN_L1)
2202 strcat (buf, ", code in L1");
2203
2204 if (e_flags & EF_BFIN_DATA_IN_L1)
2205 strcat (buf, ", data in L1");
2206
2207 break;
2208
ec2dfb42
AO		 2209 case EM_CYGNUS_FRV:
2210 switch (e_flags & EF_FRV_CPU_MASK)
2211 {
2212 case EF_FRV_CPU_GENERIC:
2213 break;
2214
2215 default:
2216 strcat (buf, ", fr???");
2217 break;
57346661 2218
ec2dfb42
AO		 2219 case EF_FRV_CPU_FR300:
2220 strcat (buf, ", fr300");
2221 break;
2222
2223 case EF_FRV_CPU_FR400:
2224 strcat (buf, ", fr400");
2225 break;
2226 case EF_FRV_CPU_FR405:
2227 strcat (buf, ", fr405");
2228 break;
2229
2230 case EF_FRV_CPU_FR450:
2231 strcat (buf, ", fr450");
2232 break;
2233
2234 case EF_FRV_CPU_FR500:
2235 strcat (buf, ", fr500");
2236 break;
2237 case EF_FRV_CPU_FR550:
2238 strcat (buf, ", fr550");
2239 break;
2240
2241 case EF_FRV_CPU_SIMPLE:
2242 strcat (buf, ", simple");
2243 break;
2244 case EF_FRV_CPU_TOMCAT:
2245 strcat (buf, ", tomcat");
2246 break;
2247 }
1c877e87 2248 break;
ec2dfb42 2249
53c7db4b 2250 case EM_68K:
425c6cb0 2251 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2252 strcat (buf, ", m68000");
425c6cb0 2253 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2254 strcat (buf, ", cpu32");
2255 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2256 strcat (buf, ", fido_a");
425c6cb0 2257 else
266abb8f 2258 {
2cf0635d
NC		 2259 char const * isa = _("unknown");
2260 char const * mac = _("unknown mac");
2261 char const * additional = NULL;
0112cd26 2262
c694fd50 2263 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2264 {
c694fd50 2265 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2266 isa = "A";
2267 additional = ", nodiv";
2268 break;
c694fd50 2269 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2270 isa = "A";
2271 break;
c694fd50 2272 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2273 isa = "A+";
2274 break;
c694fd50 2275 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2276 isa = "B";
2277 additional = ", nousp";
2278 break;
c694fd50 2279 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2280 isa = "B";
2281 break;
f608cd77
NS		 2282 case EF_M68K_CF_ISA_C:
2283 isa = "C";
2284 break;
2285 case EF_M68K_CF_ISA_C_NODIV:
2286 isa = "C";
2287 additional = ", nodiv";
2288 break;
266abb8f
NS		 2289 }
2290 strcat (buf, ", cf, isa ");
2291 strcat (buf, isa);
0b2e31dc
NS		 2292 if (additional)
2293 strcat (buf, additional);
c694fd50 2294 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2295 strcat (buf, ", float");
c694fd50 2296 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2297 {
2298 case 0:
2299 mac = NULL;
2300 break;
c694fd50 2301 case EF_M68K_CF_MAC:
266abb8f
NS		 2302 mac = "mac";
2303 break;
c694fd50 2304 case EF_M68K_CF_EMAC:
266abb8f
NS		 2305 mac = "emac";
2306 break;
f608cd77
NS		 2307 case EF_M68K_CF_EMAC_B:
2308 mac = "emac_b";
2309 break;
266abb8f
NS		 2310 }
2311 if (mac)
2312 {
2313 strcat (buf, ", ");
2314 strcat (buf, mac);
2315 }
266abb8f 2316 }
53c7db4b 2317 break;
33c63f9d 2318
252b5132
RH		 2319 case EM_PPC:
2320 if (e_flags & EF_PPC_EMB)
2321 strcat (buf, ", emb");
2322
2323 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2324 strcat (buf, _(", relocatable"));
252b5132
RH		 2325
2326 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 2327 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 2328 break;
2329
2b0337b0 2330 case EM_V850:
252b5132
RH		 2331 case EM_CYGNUS_V850:
2332 switch (e_flags & EF_V850_ARCH)
2333 {
1cd986c5
NC		 2334 case E_V850E2V3_ARCH:
2335 strcat (buf, ", v850e2v3");
2336 break;
2337 case E_V850E2_ARCH:
2338 strcat (buf, ", v850e2");
2339 break;
2340 case E_V850E1_ARCH:
2341 strcat (buf, ", v850e1");
8ad30312 2342 break;
252b5132
RH		 2343 case E_V850E_ARCH:
2344 strcat (buf, ", v850e");
2345 break;
252b5132
RH		 2346 case E_V850_ARCH:
2347 strcat (buf, ", v850");
2348 break;
2349 default:
2b692964 2350 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 2351 break;
2352 }
2353 break;
2354
2b0337b0 2355 case EM_M32R:
252b5132
RH		 2356 case EM_CYGNUS_M32R:
2357 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2358 strcat (buf, ", m32r");
252b5132
RH		 2359 break;
2360
2361 case EM_MIPS:
4fe85591 2362 case EM_MIPS_RS3_LE:
252b5132
RH		 2363 if (e_flags & EF_MIPS_NOREORDER)
2364 strcat (buf, ", noreorder");
2365
2366 if (e_flags & EF_MIPS_PIC)
2367 strcat (buf, ", pic");
2368
2369 if (e_flags & EF_MIPS_CPIC)
2370 strcat (buf, ", cpic");
2371
d1bdd336
TS		 2372 if (e_flags & EF_MIPS_UCODE)
2373 strcat (buf, ", ugen_reserved");
2374
252b5132
RH		 2375 if (e_flags & EF_MIPS_ABI2)
2376 strcat (buf, ", abi2");
2377
43521d43
TS		 2378 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2379 strcat (buf, ", odk first");
2380
a5d22d2a
TS		 2381 if (e_flags & EF_MIPS_32BITMODE)
2382 strcat (buf, ", 32bitmode");
2383
156c2f8b
NC		 2384 switch ((e_flags & EF_MIPS_MACH))
2385 {
2386 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2387 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2388 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 2389 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 2390 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2391 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2392 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2393 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 2394 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 2395 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 2396 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2397 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 2398 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 2399 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 2400 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
52b6b6b9 2401 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 2402 case 0:
2403 /* We simply ignore the field in this case to avoid confusion:
2404 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2405 extension. */
2406 break;
2b692964 2407 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 2408 }
43521d43
TS		 2409
2410 switch ((e_flags & EF_MIPS_ABI))
2411 {
2412 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2413 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2414 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2415 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2416 case 0:
2417 /* We simply ignore the field in this case to avoid confusion:
2418 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2419 This means it is likely to be an o32 file, but not for
2420 sure. */
2421 break;
2b692964 2422 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 2423 }
2424
2425 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2426 strcat (buf, ", mdmx");
2427
2428 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2429 strcat (buf, ", mips16");
2430
df58fc94
RS		 2431 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2432 strcat (buf, ", micromips");
2433
43521d43
TS		 2434 switch ((e_flags & EF_MIPS_ARCH))
2435 {
2436 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2437 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2438 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2439 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2440 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2441 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 2442 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
43521d43 2443 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 2444 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2b692964 2445 default: strcat (buf, _(", unknown ISA")); break;
43521d43
TS		 2446 }
2447
8e45593f
NC		 2448 if (e_flags & EF_SH_PIC)
2449 strcat (buf, ", pic");
2450
2451 if (e_flags & EF_SH_FDPIC)
2452 strcat (buf, ", fdpic");
252b5132 2453 break;
351b4b40 2454
ccde1100
AO		 2455 case EM_SH:
2456 switch ((e_flags & EF_SH_MACH_MASK))
2457 {
2458 case EF_SH1: strcat (buf, ", sh1"); break;
2459 case EF_SH2: strcat (buf, ", sh2"); break;
2460 case EF_SH3: strcat (buf, ", sh3"); break;
2461 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2462 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2463 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2464 case EF_SH3E: strcat (buf, ", sh3e"); break;
2465 case EF_SH4: strcat (buf, ", sh4"); break;
2466 case EF_SH5: strcat (buf, ", sh5"); break;
2467 case EF_SH2E: strcat (buf, ", sh2e"); break;
2468 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 2469 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 2470 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2471 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 2472 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 2473 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2474 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2475 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2476 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2477 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2478 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 2479 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 2480 }
2481
2482 break;
57346661 2483
351b4b40
RH		 2484 case EM_SPARCV9:
2485 if (e_flags & EF_SPARC_32PLUS)
2486 strcat (buf, ", v8+");
2487
2488 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 2489 strcat (buf, ", ultrasparcI");
2490
2491 if (e_flags & EF_SPARC_SUN_US3)
2492 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 2493
2494 if (e_flags & EF_SPARC_HAL_R1)
2495 strcat (buf, ", halr1");
2496
2497 if (e_flags & EF_SPARC_LEDATA)
2498 strcat (buf, ", ledata");
2499
2500 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2501 strcat (buf, ", tso");
2502
2503 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2504 strcat (buf, ", pso");
2505
2506 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2507 strcat (buf, ", rmo");
2508 break;
7d466069 2509
103f02d3
UD		 2510 case EM_PARISC:
2511 switch (e_flags & EF_PARISC_ARCH)
2512 {
2513 case EFA_PARISC_1_0:
2514 strcpy (buf, ", PA-RISC 1.0");
2515 break;
2516 case EFA_PARISC_1_1:
2517 strcpy (buf, ", PA-RISC 1.1");
2518 break;
2519 case EFA_PARISC_2_0:
2520 strcpy (buf, ", PA-RISC 2.0");
2521 break;
2522 default:
2523 break;
2524 }
2525 if (e_flags & EF_PARISC_TRAPNIL)
2526 strcat (buf, ", trapnil");
2527 if (e_flags & EF_PARISC_EXT)
2528 strcat (buf, ", ext");
2529 if (e_flags & EF_PARISC_LSB)
2530 strcat (buf, ", lsb");
2531 if (e_flags & EF_PARISC_WIDE)
2532 strcat (buf, ", wide");
2533 if (e_flags & EF_PARISC_NO_KABP)
2534 strcat (buf, ", no kabp");
2535 if (e_flags & EF_PARISC_LAZYSWAP)
2536 strcat (buf, ", lazyswap");
30800947 2537 break;
76da6bbe 2538
7d466069 2539 case EM_PJ:
2b0337b0 2540 case EM_PJ_OLD:
7d466069
ILT		 2541 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2542 strcat (buf, ", new calling convention");
2543
2544 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2545 strcat (buf, ", gnu calling convention");
2546 break;
4d6ed7c8
NC		 2547
2548 case EM_IA_64:
2549 if ((e_flags & EF_IA_64_ABI64))
2550 strcat (buf, ", 64-bit");
2551 else
2552 strcat (buf, ", 32-bit");
2553 if ((e_flags & EF_IA_64_REDUCEDFP))
2554 strcat (buf, ", reduced fp model");
2555 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2556 strcat (buf, ", no function descriptors, constant gp");
2557 else if ((e_flags & EF_IA_64_CONS_GP))
2558 strcat (buf, ", constant gp");
2559 if ((e_flags & EF_IA_64_ABSOLUTE))
2560 strcat (buf, ", absolute");
28f997cf
TG		 2561 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2562 {
2563 if ((e_flags & EF_IA_64_VMS_LINKAGES))
2564 strcat (buf, ", vms_linkages");
2565 switch ((e_flags & EF_IA_64_VMS_COMCOD))
2566 {
2567 case EF_IA_64_VMS_COMCOD_SUCCESS:
2568 break;
2569 case EF_IA_64_VMS_COMCOD_WARNING:
2570 strcat (buf, ", warning");
2571 break;
2572 case EF_IA_64_VMS_COMCOD_ERROR:
2573 strcat (buf, ", error");
2574 break;
2575 case EF_IA_64_VMS_COMCOD_ABORT:
2576 strcat (buf, ", abort");
2577 break;
2578 default:
2579 abort ();
2580 }
2581 }
4d6ed7c8 2582 break;
179d3252
JT		 2583
2584 case EM_VAX:
2585 if ((e_flags & EF_VAX_NONPIC))
2586 strcat (buf, ", non-PIC");
2587 if ((e_flags & EF_VAX_DFLOAT))
2588 strcat (buf, ", D-Float");
2589 if ((e_flags & EF_VAX_GFLOAT))
2590 strcat (buf, ", G-Float");
2591 break;
c7927a3c
NC		 2592
2593 case EM_RX:
2594 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2595 strcat (buf, ", 64-bit doubles");
2596 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 2597 strcat (buf, ", dsp");
55786da2
AK		 2598
2599 case EM_S390:
2600 if (e_flags & EF_S390_HIGH_GPRS)
2601 strcat (buf, ", highgprs");
40b36596
JM		 2602
2603 case EM_TI_C6000:
2604 if ((e_flags & EF_C6000_REL))
2605 strcat (buf, ", relocatable module");
252b5132
RH		 2606 }
2607 }
2608
2609 return buf;
2610}
2611
252b5132 2612static const char *
d3ba0551
AM		 2613get_osabi_name (unsigned int osabi)
2614{
2615 static char buff[32];
2616
2617 switch (osabi)
2618 {
2619 case ELFOSABI_NONE: return "UNIX - System V";
2620 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2621 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 2622 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 2623 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2624 case ELFOSABI_AIX: return "UNIX - AIX";
2625 case ELFOSABI_IRIX: return "UNIX - IRIX";
2626 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2627 case ELFOSABI_TRU64: return "UNIX - TRU64";
2628 case ELFOSABI_MODESTO: return "Novell - Modesto";
2629 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2630 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2631 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 2632 case ELFOSABI_AROS: return "AROS";
11636f9e 2633 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 2634 default:
40b36596
JM		 2635 if (osabi >= 64)
2636 switch (elf_header.e_machine)
2637 {
2638 case EM_ARM:
2639 switch (osabi)
2640 {
2641 case ELFOSABI_ARM: return "ARM";
2642 default:
2643 break;
2644 }
2645 break;
2646
2647 case EM_MSP430:
2648 case EM_MSP430_OLD:
2649 switch (osabi)
2650 {
2651 case ELFOSABI_STANDALONE: return _("Standalone App");
2652 default:
2653 break;
2654 }
2655 break;
2656
2657 case EM_TI_C6000:
2658 switch (osabi)
2659 {
2660 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
2661 case ELFOSABI_C6000_LINUX: return "Linux C6000";
2662 default:
2663 break;
2664 }
2665 break;
2666
2667 default:
2668 break;
2669 }
e9e44622 2670 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 2671 return buff;
2672 }
2673}
2674
b294bdf8
MM		 2675static const char *
2676get_arm_segment_type (unsigned long type)
2677{
2678 switch (type)
2679 {
2680 case PT_ARM_EXIDX:
2681 return "EXIDX";
2682 default:
2683 break;
2684 }
2685
2686 return NULL;
2687}
2688
d3ba0551
AM		 2689static const char *
2690get_mips_segment_type (unsigned long type)
252b5132
RH		 2691{
2692 switch (type)
2693 {
2694 case PT_MIPS_REGINFO:
2695 return "REGINFO";
2696 case PT_MIPS_RTPROC:
2697 return "RTPROC";
2698 case PT_MIPS_OPTIONS:
2699 return "OPTIONS";
2700 default:
2701 break;
2702 }
2703
2704 return NULL;
2705}
2706
103f02d3 2707static const char *
d3ba0551 2708get_parisc_segment_type (unsigned long type)
103f02d3
UD		 2709{
2710 switch (type)
2711 {
2712 case PT_HP_TLS: return "HP_TLS";
2713 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2714 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2715 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2716 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2717 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2718 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2719 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2720 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2721 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2722 case PT_HP_PARALLEL: return "HP_PARALLEL";
2723 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 2724 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
2725 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
2726 case PT_HP_STACK: return "HP_STACK";
2727 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 2728 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2729 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 2730 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 2731 default:
2732 break;
2733 }
2734
2735 return NULL;
2736}
2737
4d6ed7c8 2738static const char *
d3ba0551 2739get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 2740{
2741 switch (type)
2742 {
2743 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2744 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 2745 case PT_HP_TLS: return "HP_TLS";
2746 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2747 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2748 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 2749 default:
2750 break;
2751 }
2752
2753 return NULL;
2754}
2755
40b36596
JM		 2756static const char *
2757get_tic6x_segment_type (unsigned long type)
2758{
2759 switch (type)
2760 {
2761 case PT_C6000_PHATTR: return "C6000_PHATTR";
2762 default:
2763 break;
2764 }
2765
2766 return NULL;
2767}
2768
252b5132 2769static const char *
d3ba0551 2770get_segment_type (unsigned long p_type)
252b5132 2771{
b34976b6 2772 static char buff[32];
252b5132
RH		 2773
2774 switch (p_type)
2775 {
b34976b6
AM		 2776 case PT_NULL: return "NULL";
2777 case PT_LOAD: return "LOAD";
252b5132 2778 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 2779 case PT_INTERP: return "INTERP";
2780 case PT_NOTE: return "NOTE";
2781 case PT_SHLIB: return "SHLIB";
2782 case PT_PHDR: return "PHDR";
13ae64f3 2783 case PT_TLS: return "TLS";
252b5132 2784
65765700
JJ		 2785 case PT_GNU_EH_FRAME:
2786 return "GNU_EH_FRAME";
2b05f1b7 2787 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 2788 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 2789
252b5132
RH		 2790 default:
2791 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2792 {
2cf0635d 2793 const char * result;
103f02d3 2794
252b5132
RH		 2795 switch (elf_header.e_machine)
2796 {
b294bdf8
MM		 2797 case EM_ARM:
2798 result = get_arm_segment_type (p_type);
2799 break;
252b5132 2800 case EM_MIPS:
4fe85591 2801 case EM_MIPS_RS3_LE:
252b5132
RH		 2802 result = get_mips_segment_type (p_type);
2803 break;
103f02d3
UD		 2804 case EM_PARISC:
2805 result = get_parisc_segment_type (p_type);
2806 break;
4d6ed7c8
NC		 2807 case EM_IA_64:
2808 result = get_ia64_segment_type (p_type);
2809 break;
40b36596
JM		 2810 case EM_TI_C6000:
2811 result = get_tic6x_segment_type (p_type);
2812 break;
252b5132
RH		 2813 default:
2814 result = NULL;
2815 break;
2816 }
103f02d3 2817
252b5132
RH		 2818 if (result != NULL)
2819 return result;
103f02d3 2820
252b5132
RH		 2821 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2822 }
2823 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 2824 {
2cf0635d 2825 const char * result;
103f02d3
UD		 2826
2827 switch (elf_header.e_machine)
2828 {
2829 case EM_PARISC:
2830 result = get_parisc_segment_type (p_type);
2831 break;
00428cca
AM		 2832 case EM_IA_64:
2833 result = get_ia64_segment_type (p_type);
2834 break;
103f02d3
UD		 2835 default:
2836 result = NULL;
2837 break;
2838 }
2839
2840 if (result != NULL)
2841 return result;
2842
2843 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2844 }
252b5132 2845 else
e9e44622 2846 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 2847
2848 return buff;
2849 }
2850}
2851
2852static const char *
d3ba0551 2853get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 2854{
2855 switch (sh_type)
2856 {
b34976b6
AM		 2857 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
2858 case SHT_MIPS_MSYM: return "MIPS_MSYM";
2859 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
2860 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
2861 case SHT_MIPS_UCODE: return "MIPS_UCODE";
2862 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
2863 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
2864 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
2865 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
2866 case SHT_MIPS_RELD: return "MIPS_RELD";
2867 case SHT_MIPS_IFACE: return "MIPS_IFACE";
2868 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
2869 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
2870 case SHT_MIPS_SHDR: return "MIPS_SHDR";
2871 case SHT_MIPS_FDESC: return "MIPS_FDESC";
2872 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
2873 case SHT_MIPS_DENSE: return "MIPS_DENSE";
2874 case SHT_MIPS_PDESC: return "MIPS_PDESC";
2875 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
2876 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
2877 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
2878 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
2879 case SHT_MIPS_LINE: return "MIPS_LINE";
2880 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
2881 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
2882 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
2883 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
2884 case SHT_MIPS_DWARF: return "MIPS_DWARF";
2885 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
2886 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
2887 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
2888 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
2889 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
2890 case SHT_MIPS_XLATE: return "MIPS_XLATE";
2891 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
2892 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
2893 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
2894 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132
RH		 2895 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2896 default:
2897 break;
2898 }
2899 return NULL;
2900}
2901
103f02d3 2902static const char *
d3ba0551 2903get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 2904{
2905 switch (sh_type)
2906 {
2907 case SHT_PARISC_EXT: return "PARISC_EXT";
2908 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
2909 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 2910 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
2911 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
2912 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 2913 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 2914 default:
2915 break;
2916 }
2917 return NULL;
2918}
2919
4d6ed7c8 2920static const char *
d3ba0551 2921get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 2922{
18bd398b 2923 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 2924 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
2925 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 2926
4d6ed7c8
NC		 2927 switch (sh_type)
2928 {
148b93f2
NC		 2929 case SHT_IA_64_EXT: return "IA_64_EXT";
2930 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
2931 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
2932 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
2933 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
2934 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
2935 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
2936 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
2937 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
2938 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 2939 default:
2940 break;
2941 }
2942 return NULL;
2943}
2944
d2b2c203
DJ		 2945static const char *
2946get_x86_64_section_type_name (unsigned int sh_type)
2947{
2948 switch (sh_type)
2949 {
2950 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
2951 default:
2952 break;
2953 }
2954 return NULL;
2955}
2956
40a18ebd
NC		 2957static const char *
2958get_arm_section_type_name (unsigned int sh_type)
2959{
2960 switch (sh_type)
2961 {
7f6fed87
NC		 2962 case SHT_ARM_EXIDX: return "ARM_EXIDX";
2963 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
2964 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
2965 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
2966 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 2967 default:
2968 break;
2969 }
2970 return NULL;
2971}
2972
40b36596
JM		 2973static const char *
2974get_tic6x_section_type_name (unsigned int sh_type)
2975{
2976 switch (sh_type)
2977 {
2978 case SHT_C6000_UNWIND:
2979 return "C6000_UNWIND";
2980 case SHT_C6000_PREEMPTMAP:
2981 return "C6000_PREEMPTMAP";
2982 case SHT_C6000_ATTRIBUTES:
2983 return "C6000_ATTRIBUTES";
2984 case SHT_TI_ICODE:
2985 return "TI_ICODE";
2986 case SHT_TI_XREF:
2987 return "TI_XREF";
2988 case SHT_TI_HANDLER:
2989 return "TI_HANDLER";
2990 case SHT_TI_INITINFO:
2991 return "TI_INITINFO";
2992 case SHT_TI_PHATTRS:
2993 return "TI_PHATTRS";
2994 default:
2995 break;
2996 }
2997 return NULL;
2998}
2999
252b5132 3000static const char *
d3ba0551 3001get_section_type_name (unsigned int sh_type)
252b5132 3002{
b34976b6 3003 static char buff[32];
252b5132
RH		 3004
3005 switch (sh_type)
3006 {
3007 case SHT_NULL: return "NULL";
3008 case SHT_PROGBITS: return "PROGBITS";
3009 case SHT_SYMTAB: return "SYMTAB";
3010 case SHT_STRTAB: return "STRTAB";
3011 case SHT_RELA: return "RELA";
3012 case SHT_HASH: return "HASH";
3013 case SHT_DYNAMIC: return "DYNAMIC";
3014 case SHT_NOTE: return "NOTE";
3015 case SHT_NOBITS: return "NOBITS";
3016 case SHT_REL: return "REL";
3017 case SHT_SHLIB: return "SHLIB";
3018 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3019 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3020 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3021 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3022 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3023 case SHT_GROUP: return "GROUP";
3024 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3025 case SHT_GNU_verdef: return "VERDEF";
3026 case SHT_GNU_verneed: return "VERNEED";
3027 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3028 case 0x6ffffff0: return "VERSYM";
3029 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3030 case 0x7ffffffd: return "AUXILIARY";
3031 case 0x7fffffff: return "FILTER";
047b2264 3032 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3033
3034 default:
3035 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3036 {
2cf0635d 3037 const char * result;
252b5132
RH		 3038
3039 switch (elf_header.e_machine)
3040 {
3041 case EM_MIPS:
4fe85591 3042 case EM_MIPS_RS3_LE:
252b5132
RH		 3043 result = get_mips_section_type_name (sh_type);
3044 break;
103f02d3
UD		 3045 case EM_PARISC:
3046 result = get_parisc_section_type_name (sh_type);
3047 break;
4d6ed7c8
NC		 3048 case EM_IA_64:
3049 result = get_ia64_section_type_name (sh_type);
3050 break;
d2b2c203 3051 case EM_X86_64:
8a9036a4 3052 case EM_L1OM:
7a9068fe 3053 case EM_K1OM:
d2b2c203
DJ		 3054 result = get_x86_64_section_type_name (sh_type);
3055 break;
40a18ebd
NC		 3056 case EM_ARM:
3057 result = get_arm_section_type_name (sh_type);
3058 break;
40b36596
JM		 3059 case EM_TI_C6000:
3060 result = get_tic6x_section_type_name (sh_type);
3061 break;
252b5132
RH		 3062 default:
3063 result = NULL;
3064 break;
3065 }
3066
3067 if (result != NULL)
3068 return result;
3069
c91d0dfb 3070 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3071 }
3072 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3073 {
2cf0635d 3074 const char * result;
148b93f2
NC		 3075
3076 switch (elf_header.e_machine)
3077 {
3078 case EM_IA_64:
3079 result = get_ia64_section_type_name (sh_type);
3080 break;
3081 default:
3082 result = NULL;
3083 break;
3084 }
3085
3086 if (result != NULL)
3087 return result;
3088
3089 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3090 }
252b5132 3091 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
c91d0dfb 3092 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
252b5132 3093 else
a7dbfd1c
NC		 3094 /* This message is probably going to be displayed in a 15
3095 character wide field, so put the hex value first. */
3096 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3097
252b5132
RH		 3098 return buff;
3099 }
3100}
3101
2979dc34 3102#define OPTION_DEBUG_DUMP 512
2c610e4b 3103#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3104#define OPTION_DWARF_DEPTH 514
3105#define OPTION_DWARF_START 515
2979dc34 3106
85b1c36d 3107static struct option options[] =
252b5132 3108{
b34976b6 3109 {"all", no_argument, 0, 'a'},
252b5132
RH		 3110 {"file-header", no_argument, 0, 'h'},
3111 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3112 {"headers", no_argument, 0, 'e'},
3113 {"histogram", no_argument, 0, 'I'},
3114 {"segments", no_argument, 0, 'l'},
3115 {"sections", no_argument, 0, 'S'},
252b5132 3116 {"section-headers", no_argument, 0, 'S'},
f5842774 3117 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3118 {"section-details", no_argument, 0, 't'},
595cf52e 3119 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3120 {"symbols", no_argument, 0, 's'},
3121 {"syms", no_argument, 0, 's'},
2c610e4b 3122 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3123 {"relocs", no_argument, 0, 'r'},
3124 {"notes", no_argument, 0, 'n'},
3125 {"dynamic", no_argument, 0, 'd'},
a952a375 3126 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3127 {"version-info", no_argument, 0, 'V'},
3128 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3129 {"unwind", no_argument, 0, 'u'},
4145f1d5 3130 {"archive-index", no_argument, 0, 'c'},
b34976b6 3131 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3132 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3133 {"string-dump", required_argument, 0, 'p'},
252b5132
RH		 3134#ifdef SUPPORT_DISASSEMBLY
3135 {"instruction-dump", required_argument, 0, 'i'},
3136#endif
cf13d699 3137 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3138
fd2f0033
TT		 3139 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3140 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
3141
b34976b6
AM		 3142 {"version", no_argument, 0, 'v'},
3143 {"wide", no_argument, 0, 'W'},
3144 {"help", no_argument, 0, 'H'},
3145 {0, no_argument, 0, 0}
252b5132
RH		 3146};
3147
3148static void
2cf0635d 3149usage (FILE * stream)
252b5132 3150{
92f01d61
JM		 3151 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3152 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3153 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3154 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3155 -h --file-header Display the ELF file header\n\
3156 -l --program-headers Display the program headers\n\
3157 --segments An alias for --program-headers\n\
3158 -S --section-headers Display the sections' header\n\
3159 --sections An alias for --section-headers\n\
f5842774 3160 -g --section-groups Display the section groups\n\
5477e8a0 3161 -t --section-details Display the section details\n\
8b53311e
NC		 3162 -e --headers Equivalent to: -h -l -S\n\
3163 -s --syms Display the symbol table\n\
3f08eb35 3164 --symbols An alias for --syms\n\
2c610e4b 3165 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3166 -n --notes Display the core notes (if present)\n\
3167 -r --relocs Display the relocations (if present)\n\
3168 -u --unwind Display the unwind info (if present)\n\
b2d38a17 3169 -d --dynamic Display the dynamic section (if present)\n\
8b53311e
NC		 3170 -V --version-info Display the version sections (if present)\n\
3171 -A --arch-specific Display architecture specific information (if any).\n\
4145f1d5 3172 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 3173 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 3174 -x --hex-dump=<number|name>\n\
3175 Dump the contents of section <number|name> as bytes\n\
3176 -p --string-dump=<number|name>\n\
3177 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 3178 -R --relocated-dump=<number|name>\n\
3179 Dump the contents of section <number|name> as relocated bytes\n\
f9f0e732 3180 -w[lLiaprmfFsoRt] or\n\
1ed06042 3181 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 3182 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
5bbdf3d5 3183 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges]\n\
8b53311e 3184 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 3185 fprintf (stream, _("\
3186 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3187 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3188 or deeper\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;
fd2f0033
TT		 3395 case OPTION_DWARF_DEPTH:
3396 {
3397 char *cp;
3398
3399 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3400 }
3401 break;
3402 case OPTION_DWARF_START:
3403 {
3404 char *cp;
3405
3406 dwarf_start_die = strtoul (optarg, & cp, 0);
3407 }
3408 break;
2c610e4b
L		 3409 case OPTION_DYN_SYMS:
3410 do_dyn_syms++;
3411 break;
252b5132
RH		 3412#ifdef SUPPORT_DISASSEMBLY
3413 case 'i':
cf13d699
NC		 3414 request_dump (DISASS_DUMP);
3415 break;
252b5132
RH		 3416#endif
3417 case 'v':
3418 print_version (program_name);
3419 break;
3420 case 'V':
b34976b6 3421 do_version++;
252b5132 3422 break;
d974e256 3423 case 'W':
b34976b6 3424 do_wide++;
d974e256 3425 break;
252b5132 3426 default:
252b5132
RH		 3427 /* xgettext:c-format */
3428 error (_("Invalid option '-%c'\n"), c);
3429 /* Drop through. */
3430 case '?':
92f01d61 3431 usage (stderr);
252b5132
RH		 3432 }
3433 }
3434
4d6ed7c8 3435 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 3436 && !do_segments && !do_header && !do_dump && !do_version
f5842774 3437 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 3438 && !do_section_groups && !do_archive_index
3439 && !do_dyn_syms)
92f01d61 3440 usage (stderr);
252b5132
RH		 3441 else if (argc < 3)
3442 {
3443 warn (_("Nothing to do.\n"));
92f01d61 3444 usage (stderr);
252b5132
RH		 3445 }
3446}
3447
3448static const char *
d3ba0551 3449get_elf_class (unsigned int elf_class)
252b5132 3450{
b34976b6 3451 static char buff[32];
103f02d3 3452
252b5132
RH		 3453 switch (elf_class)
3454 {
3455 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 3456 case ELFCLASS32: return "ELF32";
3457 case ELFCLASS64: return "ELF64";
ab5e7794 3458 default:
e9e44622 3459 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 3460 return buff;
252b5132
RH		 3461 }
3462}
3463
3464static const char *
d3ba0551 3465get_data_encoding (unsigned int encoding)
252b5132 3466{
b34976b6 3467 static char buff[32];
103f02d3 3468
252b5132
RH		 3469 switch (encoding)
3470 {
3471 case ELFDATANONE: return _("none");
33c63f9d
CM		 3472 case ELFDATA2LSB: return _("2's complement, little endian");
3473 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 3474 default:
e9e44622 3475 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 3476 return buff;
252b5132
RH		 3477 }
3478}
3479
252b5132 3480/* Decode the data held in 'elf_header'. */
ee42cf8c 3481
252b5132 3482static int
d3ba0551 3483process_file_header (void)
252b5132 3484{
b34976b6
AM		 3485 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3486 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3487 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3488 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 3489 {
3490 error
3491 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3492 return 0;
3493 }
3494
2dc4cec1
L		 3495 init_dwarf_regnames (elf_header.e_machine);
3496
252b5132
RH		 3497 if (do_header)
3498 {
3499 int i;
3500
3501 printf (_("ELF Header:\n"));
3502 printf (_(" Magic: "));
b34976b6
AM		 3503 for (i = 0; i < EI_NIDENT; i++)
3504 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 3505 printf ("\n");
3506 printf (_(" Class: %s\n"),
b34976b6 3507 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 3508 printf (_(" Data: %s\n"),
b34976b6 3509 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 3510 printf (_(" Version: %d %s\n"),
b34976b6
AM		 3511 elf_header.e_ident[EI_VERSION],
3512 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 3513 ? "(current)"
b34976b6 3514 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 3515 ? _("<unknown: %lx>")
789be9f7 3516 : "")));
252b5132 3517 printf (_(" OS/ABI: %s\n"),
b34976b6 3518 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 3519 printf (_(" ABI Version: %d\n"),
b34976b6 3520 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 3521 printf (_(" Type: %s\n"),
3522 get_file_type (elf_header.e_type));
3523 printf (_(" Machine: %s\n"),
3524 get_machine_name (elf_header.e_machine));
3525 printf (_(" Version: 0x%lx\n"),
3526 (unsigned long) elf_header.e_version);
76da6bbe 3527
f7a99963
NC		 3528 printf (_(" Entry point address: "));
3529 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3530 printf (_("\n Start of program headers: "));
3531 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3532 printf (_(" (bytes into file)\n Start of section headers: "));
3533 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3534 printf (_(" (bytes into file)\n"));
76da6bbe 3535
252b5132
RH		 3536 printf (_(" Flags: 0x%lx%s\n"),
3537 (unsigned long) elf_header.e_flags,
3538 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3539 printf (_(" Size of this header: %ld (bytes)\n"),
3540 (long) elf_header.e_ehsize);
3541 printf (_(" Size of program headers: %ld (bytes)\n"),
3542 (long) elf_header.e_phentsize);
2046a35d 3543 printf (_(" Number of program headers: %ld"),
252b5132 3544 (long) elf_header.e_phnum);
2046a35d
AM		 3545 if (section_headers != NULL
3546 && elf_header.e_phnum == PN_XNUM
3547 && section_headers[0].sh_info != 0)
cc5914eb 3548 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 3549 putc ('\n', stdout);
252b5132
RH		 3550 printf (_(" Size of section headers: %ld (bytes)\n"),
3551 (long) elf_header.e_shentsize);
560f3c1c 3552 printf (_(" Number of section headers: %ld"),
252b5132 3553 (long) elf_header.e_shnum);
4fbb74a6 3554 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 3555 printf (" (%ld)", (long) section_headers[0].sh_size);
3556 putc ('\n', stdout);
3557 printf (_(" Section header string table index: %ld"),
252b5132 3558 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 3559 if (section_headers != NULL
3560 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 3561 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 3562 else if (elf_header.e_shstrndx != SHN_UNDEF
3563 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 3564 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 3565 putc ('\n', stdout);
3566 }
3567
3568 if (section_headers != NULL)
3569 {
2046a35d
AM		 3570 if (elf_header.e_phnum == PN_XNUM
3571 && section_headers[0].sh_info != 0)
3572 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 3573 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 3574 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 3575 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 3576 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 3577 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 3578 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 3579 free (section_headers);
3580 section_headers = NULL;
252b5132 3581 }
103f02d3 3582
9ea033b2
NC		 3583 return 1;
3584}
3585
252b5132 3586
9ea033b2 3587static int
91d6fa6a 3588get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3589{
2cf0635d
NC		 3590 Elf32_External_Phdr * phdrs;
3591 Elf32_External_Phdr * external;
3592 Elf_Internal_Phdr * internal;
b34976b6 3593 unsigned int i;
103f02d3 3594
3f5e193b
NC		 3595 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3596 elf_header.e_phentsize,
3597 elf_header.e_phnum,
3598 _("program headers"));
a6e9f9df
AM		 3599 if (!phdrs)
3600 return 0;
9ea033b2 3601
91d6fa6a 3602 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3603 i < elf_header.e_phnum;
b34976b6 3604 i++, internal++, external++)
252b5132 3605 {
9ea033b2
NC		 3606 internal->p_type = BYTE_GET (external->p_type);
3607 internal->p_offset = BYTE_GET (external->p_offset);
3608 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3609 internal->p_paddr = BYTE_GET (external->p_paddr);
3610 internal->p_filesz = BYTE_GET (external->p_filesz);
3611 internal->p_memsz = BYTE_GET (external->p_memsz);
3612 internal->p_flags = BYTE_GET (external->p_flags);
3613 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 3614 }
3615
9ea033b2
NC		 3616 free (phdrs);
3617
252b5132
RH		 3618 return 1;
3619}
3620
9ea033b2 3621static int
91d6fa6a 3622get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3623{
2cf0635d
NC		 3624 Elf64_External_Phdr * phdrs;
3625 Elf64_External_Phdr * external;
3626 Elf_Internal_Phdr * internal;
b34976b6 3627 unsigned int i;
103f02d3 3628
3f5e193b
NC		 3629 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3630 elf_header.e_phentsize,
3631 elf_header.e_phnum,
3632 _("program headers"));
a6e9f9df
AM		 3633 if (!phdrs)
3634 return 0;
9ea033b2 3635
91d6fa6a 3636 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3637 i < elf_header.e_phnum;
b34976b6 3638 i++, internal++, external++)
9ea033b2
NC		 3639 {
3640 internal->p_type = BYTE_GET (external->p_type);
3641 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 3642 internal->p_offset = BYTE_GET (external->p_offset);
3643 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3644 internal->p_paddr = BYTE_GET (external->p_paddr);
3645 internal->p_filesz = BYTE_GET (external->p_filesz);
3646 internal->p_memsz = BYTE_GET (external->p_memsz);
3647 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 3648 }
3649
3650 free (phdrs);
3651
3652 return 1;
3653}
252b5132 3654
d93f0186
NC		 3655/* Returns 1 if the program headers were read into `program_headers'. */
3656
3657static int
2cf0635d 3658get_program_headers (FILE * file)
d93f0186 3659{
2cf0635d 3660 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 3661
3662 /* Check cache of prior read. */
3663 if (program_headers != NULL)
3664 return 1;
3665
3f5e193b
NC		 3666 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3667 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 3668
3669 if (phdrs == NULL)
3670 {
3671 error (_("Out of memory\n"));
3672 return 0;
3673 }
3674
3675 if (is_32bit_elf
3676 ? get_32bit_program_headers (file, phdrs)
3677 : get_64bit_program_headers (file, phdrs))
3678 {
3679 program_headers = phdrs;
3680 return 1;
3681 }
3682
3683 free (phdrs);
3684 return 0;
3685}
3686
2f62977e
NC		 3687/* Returns 1 if the program headers were loaded. */
3688
252b5132 3689static int
2cf0635d 3690process_program_headers (FILE * file)
252b5132 3691{
2cf0635d 3692 Elf_Internal_Phdr * segment;
b34976b6 3693 unsigned int i;
252b5132
RH		 3694
3695 if (elf_header.e_phnum == 0)
3696 {
82f2dbf7
NC		 3697 /* PR binutils/12467. */
3698 if (elf_header.e_phoff != 0)
3699 warn (_("possibly corrupt ELF header - it has a non-zero program"
3700 " header offset, but no program headers"));
3701 else if (do_segments)
252b5132 3702 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 3703 return 0;
252b5132
RH		 3704 }
3705
3706 if (do_segments && !do_header)
3707 {
f7a99963
NC		 3708 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3709 printf (_("Entry point "));
3710 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3711 printf (_("\nThere are %d program headers, starting at offset "),
3712 elf_header.e_phnum);
3713 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3714 printf ("\n");
252b5132
RH		 3715 }
3716
d93f0186 3717 if (! get_program_headers (file))
252b5132 3718 return 0;
103f02d3 3719
252b5132
RH		 3720 if (do_segments)
3721 {
3a1a2036
NC		 3722 if (elf_header.e_phnum > 1)
3723 printf (_("\nProgram Headers:\n"));
3724 else
3725 printf (_("\nProgram Headers:\n"));
76da6bbe 3726
f7a99963
NC		 3727 if (is_32bit_elf)
3728 printf
3729 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 3730 else if (do_wide)
3731 printf
3732 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 3733 else
3734 {
3735 printf
3736 (_(" Type Offset VirtAddr PhysAddr\n"));
3737 printf
3738 (_(" FileSiz MemSiz Flags Align\n"));
3739 }
252b5132
RH		 3740 }
3741
252b5132 3742 dynamic_addr = 0;
1b228002 3743 dynamic_size = 0;
252b5132
RH		 3744
3745 for (i = 0, segment = program_headers;
3746 i < elf_header.e_phnum;
b34976b6 3747 i++, segment++)
252b5132
RH		 3748 {
3749 if (do_segments)
3750 {
103f02d3 3751 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 3752
3753 if (is_32bit_elf)
3754 {
3755 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3756 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3757 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3758 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3759 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3760 printf ("%c%c%c ",
3761 (segment->p_flags & PF_R ? 'R' : ' '),
3762 (segment->p_flags & PF_W ? 'W' : ' '),
3763 (segment->p_flags & PF_X ? 'E' : ' '));
3764 printf ("%#lx", (unsigned long) segment->p_align);
3765 }
d974e256
JJ		 3766 else if (do_wide)
3767 {
3768 if ((unsigned long) segment->p_offset == segment->p_offset)
3769 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3770 else
3771 {
3772 print_vma (segment->p_offset, FULL_HEX);
3773 putchar (' ');
3774 }
3775
3776 print_vma (segment->p_vaddr, FULL_HEX);
3777 putchar (' ');
3778 print_vma (segment->p_paddr, FULL_HEX);
3779 putchar (' ');
3780
3781 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3782 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3783 else
3784 {
3785 print_vma (segment->p_filesz, FULL_HEX);
3786 putchar (' ');
3787 }
3788
3789 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3790 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3791 else
3792 {
3793 print_vma (segment->p_offset, FULL_HEX);
3794 }
3795
3796 printf (" %c%c%c ",
3797 (segment->p_flags & PF_R ? 'R' : ' '),
3798 (segment->p_flags & PF_W ? 'W' : ' '),
3799 (segment->p_flags & PF_X ? 'E' : ' '));
3800
3801 if ((unsigned long) segment->p_align == segment->p_align)
3802 printf ("%#lx", (unsigned long) segment->p_align);
3803 else
3804 {
3805 print_vma (segment->p_align, PREFIX_HEX);
3806 }
3807 }
f7a99963
NC		 3808 else
3809 {
3810 print_vma (segment->p_offset, FULL_HEX);
3811 putchar (' ');
3812 print_vma (segment->p_vaddr, FULL_HEX);
3813 putchar (' ');
3814 print_vma (segment->p_paddr, FULL_HEX);
3815 printf ("\n ");
3816 print_vma (segment->p_filesz, FULL_HEX);
3817 putchar (' ');
3818 print_vma (segment->p_memsz, FULL_HEX);
3819 printf (" %c%c%c ",
3820 (segment->p_flags & PF_R ? 'R' : ' '),
3821 (segment->p_flags & PF_W ? 'W' : ' '),
3822 (segment->p_flags & PF_X ? 'E' : ' '));
3823 print_vma (segment->p_align, HEX);
3824 }
252b5132
RH		 3825 }
3826
3827 switch (segment->p_type)
3828 {
252b5132
RH		 3829 case PT_DYNAMIC:
3830 if (dynamic_addr)
3831 error (_("more than one dynamic segment\n"));
3832
20737c13
AM		 3833 /* By default, assume that the .dynamic section is the first
3834 section in the DYNAMIC segment. */
3835 dynamic_addr = segment->p_offset;
3836 dynamic_size = segment->p_filesz;
3837
b2d38a17
NC		 3838 /* Try to locate the .dynamic section. If there is
3839 a section header table, we can easily locate it. */
3840 if (section_headers != NULL)
3841 {
2cf0635d 3842 Elf_Internal_Shdr * sec;
b2d38a17 3843
89fac5e3
RS		 3844 sec = find_section (".dynamic");
3845 if (sec == NULL || sec->sh_size == 0)
b2d38a17 3846 {
28f997cf
TG		 3847 /* A corresponding .dynamic section is expected, but on
3848 IA-64/OpenVMS it is OK for it to be missing. */
3849 if (!is_ia64_vms ())
3850 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 3851 break;
3852 }
3853
42bb2e33 3854 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 3855 {
3856 dynamic_size = 0;
3857 break;
3858 }
42bb2e33 3859
b2d38a17
NC		 3860 dynamic_addr = sec->sh_offset;
3861 dynamic_size = sec->sh_size;
3862
3863 if (dynamic_addr < segment->p_offset
3864 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 3865 warn (_("the .dynamic section is not contained"
3866 " within the dynamic segment\n"));
b2d38a17 3867 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 3868 warn (_("the .dynamic section is not the first section"
3869 " in the dynamic segment.\n"));
b2d38a17 3870 }
252b5132
RH		 3871 break;
3872
3873 case PT_INTERP:
fb52b2f4
NC		 3874 if (fseek (file, archive_file_offset + (long) segment->p_offset,
3875 SEEK_SET))
252b5132
RH		 3876 error (_("Unable to find program interpreter name\n"));
3877 else
3878 {
f8eae8b2
L		 3879 char fmt [32];
3880 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
3881
3882 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 3883 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 3884
252b5132 3885 program_interpreter[0] = 0;
7bd7b3ef
AM		 3886 if (fscanf (file, fmt, program_interpreter) <= 0)
3887 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 3888
3889 if (do_segments)
3890 printf (_("\n [Requesting program interpreter: %s]"),
3891 program_interpreter);
3892 }
3893 break;
3894 }
3895
3896 if (do_segments)
3897 putc ('\n', stdout);
3898 }
3899
c256ffe7 3900 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 3901 {
3902 printf (_("\n Section to Segment mapping:\n"));
3903 printf (_(" Segment Sections...\n"));
3904
252b5132
RH		 3905 for (i = 0; i < elf_header.e_phnum; i++)
3906 {
9ad5cbcf 3907 unsigned int j;
2cf0635d 3908 Elf_Internal_Shdr * section;
252b5132
RH		 3909
3910 segment = program_headers + i;
b391a3e3 3911 section = section_headers + 1;
252b5132
RH		 3912
3913 printf (" %2.2d ", i);
3914
b34976b6 3915 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 3916 {
f4638467
AM		 3917 if (!ELF_TBSS_SPECIAL (section, segment)
3918 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
252b5132
RH		 3919 printf ("%s ", SECTION_NAME (section));
3920 }
3921
3922 putc ('\n',stdout);
3923 }
3924 }
3925
252b5132
RH		 3926 return 1;
3927}
3928
3929
d93f0186
NC		 3930/* Find the file offset corresponding to VMA by using the program headers. */
3931
3932static long
2cf0635d 3933offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 3934{
2cf0635d 3935 Elf_Internal_Phdr * seg;
d93f0186
NC		 3936
3937 if (! get_program_headers (file))
3938 {
3939 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3940 return (long) vma;
3941 }
3942
3943 for (seg = program_headers;
3944 seg < program_headers + elf_header.e_phnum;
3945 ++seg)
3946 {
3947 if (seg->p_type != PT_LOAD)
3948 continue;
3949
3950 if (vma >= (seg->p_vaddr & -seg->p_align)
3951 && vma + size <= seg->p_vaddr + seg->p_filesz)
3952 return vma - seg->p_vaddr + seg->p_offset;
3953 }
3954
3955 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 3956 (unsigned long) vma);
d93f0186
NC		 3957 return (long) vma;
3958}
3959
3960
252b5132 3961static int
2cf0635d 3962get_32bit_section_headers (FILE * file, unsigned int num)
252b5132 3963{
2cf0635d
NC		 3964 Elf32_External_Shdr * shdrs;
3965 Elf_Internal_Shdr * internal;
b34976b6 3966 unsigned int i;
252b5132 3967
3f5e193b
NC		 3968 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
3969 elf_header.e_shentsize, num,
3970 _("section headers"));
a6e9f9df
AM		 3971 if (!shdrs)
3972 return 0;
252b5132 3973
3f5e193b
NC		 3974 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
3975 sizeof (Elf_Internal_Shdr));
252b5132
RH		 3976
3977 if (section_headers == NULL)
3978 {
3979 error (_("Out of memory\n"));
3980 return 0;
3981 }
3982
3983 for (i = 0, internal = section_headers;
560f3c1c 3984 i < num;
b34976b6 3985 i++, internal++)
252b5132
RH		 3986 {
3987 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3988 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3989 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3990 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3991 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3992 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3993 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3994 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3995 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3996 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3997 }
3998
3999 free (shdrs);
4000
4001 return 1;
4002}
4003
9ea033b2 4004static int
2cf0635d 4005get_64bit_section_headers (FILE * file, unsigned int num)
9ea033b2 4006{
2cf0635d
NC		 4007 Elf64_External_Shdr * shdrs;
4008 Elf_Internal_Shdr * internal;
b34976b6 4009 unsigned int i;
9ea033b2 4010
3f5e193b
NC		 4011 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4012 elf_header.e_shentsize, num,
4013 _("section headers"));
a6e9f9df
AM		 4014 if (!shdrs)
4015 return 0;
9ea033b2 4016
3f5e193b
NC		 4017 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4018 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4019
4020 if (section_headers == NULL)
4021 {
4022 error (_("Out of memory\n"));
4023 return 0;
4024 }
4025
4026 for (i = 0, internal = section_headers;
560f3c1c 4027 i < num;
b34976b6 4028 i++, internal++)
9ea033b2
NC		 4029 {
4030 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4031 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4032 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4033 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4034 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4035 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4036 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4037 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4038 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4039 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4040 }
4041
4042 free (shdrs);
4043
4044 return 1;
4045}
4046
252b5132 4047static Elf_Internal_Sym *
2cf0635d 4048get_32bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
252b5132 4049{
9ad5cbcf 4050 unsigned long number;
dd24e3da 4051 Elf32_External_Sym * esyms = NULL;
2cf0635d 4052 Elf_External_Sym_Shndx * shndx;
dd24e3da 4053 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4054 Elf_Internal_Sym * psym;
b34976b6 4055 unsigned int j;
252b5132 4056
dd24e3da
NC		 4057 /* Run some sanity checks first. */
4058 if (section->sh_entsize == 0)
4059 {
4060 error (_("sh_entsize is zero\n"));
4061 return NULL;
4062 }
4063
4064 number = section->sh_size / section->sh_entsize;
4065
4066 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4067 {
4068 error (_("Invalid sh_entsize\n"));
4069 return NULL;
4070 }
4071
3f5e193b
NC		 4072 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4073 section->sh_size, _("symbols"));
dd24e3da 4074 if (esyms == NULL)
a6e9f9df 4075 return NULL;
252b5132 4076
9ad5cbcf
AM		 4077 shndx = NULL;
4078 if (symtab_shndx_hdr != NULL
4079 && (symtab_shndx_hdr->sh_link
4fbb74a6 4080 == (unsigned long) (section - section_headers)))
9ad5cbcf 4081 {
3f5e193b
NC		 4082 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4083 symtab_shndx_hdr->sh_offset,
4084 1, symtab_shndx_hdr->sh_size,
4085 _("symtab shndx"));
dd24e3da
NC		 4086 if (shndx == NULL)
4087 goto exit_point;
9ad5cbcf
AM		 4088 }
4089
3f5e193b 4090 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 4091
4092 if (isyms == NULL)
4093 {
4094 error (_("Out of memory\n"));
dd24e3da 4095 goto exit_point;
252b5132
RH		 4096 }
4097
dd24e3da 4098 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 4099 {
4100 psym->st_name = BYTE_GET (esyms[j].st_name);
4101 psym->st_value = BYTE_GET (esyms[j].st_value);
4102 psym->st_size = BYTE_GET (esyms[j].st_size);
4103 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4104 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4105 psym->st_shndx
4106 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4107 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4108 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 4109 psym->st_info = BYTE_GET (esyms[j].st_info);
4110 psym->st_other = BYTE_GET (esyms[j].st_other);
4111 }
4112
dd24e3da 4113 exit_point:
9ad5cbcf
AM		 4114 if (shndx)
4115 free (shndx);
dd24e3da
NC		 4116 if (esyms)
4117 free (esyms);
252b5132
RH		 4118
4119 return isyms;
4120}
4121
9ea033b2 4122static Elf_Internal_Sym *
2cf0635d 4123get_64bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
9ea033b2 4124{
9ad5cbcf 4125 unsigned long number;
2cf0635d
NC		 4126 Elf64_External_Sym * esyms;
4127 Elf_External_Sym_Shndx * shndx;
4128 Elf_Internal_Sym * isyms;
4129 Elf_Internal_Sym * psym;
b34976b6 4130 unsigned int j;
9ea033b2 4131
dd24e3da
NC		 4132 /* Run some sanity checks first. */
4133 if (section->sh_entsize == 0)
4134 {
4135 error (_("sh_entsize is zero\n"));
4136 return NULL;
4137 }
4138
4139 number = section->sh_size / section->sh_entsize;
4140
4141 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4142 {
4143 error (_("Invalid sh_entsize\n"));
4144 return NULL;
4145 }
4146
3f5e193b
NC		 4147 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4148 section->sh_size, _("symbols"));
a6e9f9df
AM		 4149 if (!esyms)
4150 return NULL;
9ea033b2 4151
9ad5cbcf
AM		 4152 shndx = NULL;
4153 if (symtab_shndx_hdr != NULL
4154 && (symtab_shndx_hdr->sh_link
4fbb74a6 4155 == (unsigned long) (section - section_headers)))
9ad5cbcf 4156 {
3f5e193b
NC		 4157 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4158 symtab_shndx_hdr->sh_offset,
4159 1, symtab_shndx_hdr->sh_size,
4160 _("symtab shndx"));
9ad5cbcf
AM		 4161 if (!shndx)
4162 {
4163 free (esyms);
4164 return NULL;
4165 }
4166 }
4167
3f5e193b 4168 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 4169
4170 if (isyms == NULL)
4171 {
4172 error (_("Out of memory\n"));
9ad5cbcf
AM		 4173 if (shndx)
4174 free (shndx);
9ea033b2 4175 free (esyms);
9ea033b2
NC		 4176 return NULL;
4177 }
4178
4179 for (j = 0, psym = isyms;
4180 j < number;
b34976b6 4181 j++, psym++)
9ea033b2
NC		 4182 {
4183 psym->st_name = BYTE_GET (esyms[j].st_name);
4184 psym->st_info = BYTE_GET (esyms[j].st_info);
4185 psym->st_other = BYTE_GET (esyms[j].st_other);
4186 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4187 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4188 psym->st_shndx
4189 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4190 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4191 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
66543521
AM		 4192 psym->st_value = BYTE_GET (esyms[j].st_value);
4193 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 4194 }
4195
9ad5cbcf
AM		 4196 if (shndx)
4197 free (shndx);
9ea033b2
NC		 4198 free (esyms);
4199
4200 return isyms;
4201}
4202
d1133906 4203static const char *
d3ba0551 4204get_elf_section_flags (bfd_vma sh_flags)
d1133906 4205{
5477e8a0 4206 static char buff[1024];
2cf0635d 4207 char * p = buff;
8d5ff12c 4208 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 4209 int sindex;
4210 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 4211 bfd_vma os_flags = 0;
4212 bfd_vma proc_flags = 0;
4213 bfd_vma unknown_flags = 0;
148b93f2 4214 static const struct
5477e8a0 4215 {
2cf0635d 4216 const char * str;
5477e8a0
L		 4217 int len;
4218 }
4219 flags [] =
4220 {
cfcac11d
NC		 4221 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4222 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4223 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4224 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4225 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4226 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4227 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4228 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4229 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4230 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4231 /* IA-64 specific. */
4232 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4233 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4234 /* IA-64 OpenVMS specific. */
4235 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4236 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4237 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4238 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4239 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4240 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 4241 /* Generic. */
cfcac11d 4242 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 4243 /* SPARC specific. */
cfcac11d 4244 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5477e8a0
L		 4245 };
4246
4247 if (do_section_details)
4248 {
8d5ff12c
L		 4249 sprintf (buff, "[%*.*lx]: ",
4250 field_size, field_size, (unsigned long) sh_flags);
4251 p += field_size + 4;
5477e8a0 4252 }
76da6bbe 4253
d1133906
NC		 4254 while (sh_flags)
4255 {
4256 bfd_vma flag;
4257
4258 flag = sh_flags & - sh_flags;
4259 sh_flags &= ~ flag;
76da6bbe 4260
5477e8a0 4261 if (do_section_details)
d1133906 4262 {
5477e8a0
L		 4263 switch (flag)
4264 {
91d6fa6a
NC		 4265 case SHF_WRITE: sindex = 0; break;
4266 case SHF_ALLOC: sindex = 1; break;
4267 case SHF_EXECINSTR: sindex = 2; break;
4268 case SHF_MERGE: sindex = 3; break;
4269 case SHF_STRINGS: sindex = 4; break;
4270 case SHF_INFO_LINK: sindex = 5; break;
4271 case SHF_LINK_ORDER: sindex = 6; break;
4272 case SHF_OS_NONCONFORMING: sindex = 7; break;
4273 case SHF_GROUP: sindex = 8; break;
4274 case SHF_TLS: sindex = 9; break;
18ae9cc1 4275 case SHF_EXCLUDE: sindex = 18; break;
76da6bbe 4276
5477e8a0 4277 default:
91d6fa6a 4278 sindex = -1;
cfcac11d 4279 switch (elf_header.e_machine)
148b93f2 4280 {
cfcac11d 4281 case EM_IA_64:
148b93f2 4282 if (flag == SHF_IA_64_SHORT)
91d6fa6a 4283 sindex = 10;
148b93f2 4284 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 4285 sindex = 11;
148b93f2
NC		 4286#ifdef BFD64
4287 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4288 switch (flag)
4289 {
91d6fa6a
NC		 4290 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4291 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4292 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4293 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4294 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4295 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 4296 default: break;
4297 }
4298#endif
cfcac11d
NC		 4299 break;
4300
caa83f8b
NC		 4301 case EM_386:
4302 case EM_486:
4303 case EM_X86_64:
7f502d6c 4304 case EM_L1OM:
7a9068fe 4305 case EM_K1OM:
cfcac11d
NC		 4306 case EM_OLD_SPARCV9:
4307 case EM_SPARC32PLUS:
4308 case EM_SPARCV9:
4309 case EM_SPARC:
18ae9cc1 4310 if (flag == SHF_ORDERED)
91d6fa6a 4311 sindex = 19;
cfcac11d
NC		 4312 break;
4313 default:
4314 break;
148b93f2 4315 }
5477e8a0
L		 4316 }
4317
91d6fa6a 4318 if (sindex != -1)
5477e8a0 4319 {
8d5ff12c
L		 4320 if (p != buff + field_size + 4)
4321 {
4322 if (size < (10 + 2))
4323 abort ();
4324 size -= 2;
4325 *p++ = ',';
4326 *p++ = ' ';
4327 }
4328
91d6fa6a
NC		 4329 size -= flags [sindex].len;
4330 p = stpcpy (p, flags [sindex].str);
5477e8a0 4331 }
3b22753a 4332 else if (flag & SHF_MASKOS)
8d5ff12c 4333 os_flags |= flag;
d1133906 4334 else if (flag & SHF_MASKPROC)
8d5ff12c 4335 proc_flags |= flag;
d1133906 4336 else
8d5ff12c 4337 unknown_flags |= flag;
5477e8a0
L		 4338 }
4339 else
4340 {
4341 switch (flag)
4342 {
4343 case SHF_WRITE: *p = 'W'; break;
4344 case SHF_ALLOC: *p = 'A'; break;
4345 case SHF_EXECINSTR: *p = 'X'; break;
4346 case SHF_MERGE: *p = 'M'; break;
4347 case SHF_STRINGS: *p = 'S'; break;
4348 case SHF_INFO_LINK: *p = 'I'; break;
4349 case SHF_LINK_ORDER: *p = 'L'; break;
4350 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4351 case SHF_GROUP: *p = 'G'; break;
4352 case SHF_TLS: *p = 'T'; break;
18ae9cc1 4353 case SHF_EXCLUDE: *p = 'E'; break;
5477e8a0
L		 4354
4355 default:
8a9036a4 4356 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 4357 || elf_header.e_machine == EM_L1OM
4358 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 4359 && flag == SHF_X86_64_LARGE)
4360 *p = 'l';
4361 else if (flag & SHF_MASKOS)
4362 {
4363 *p = 'o';
4364 sh_flags &= ~ SHF_MASKOS;
4365 }
4366 else if (flag & SHF_MASKPROC)
4367 {
4368 *p = 'p';
4369 sh_flags &= ~ SHF_MASKPROC;
4370 }
4371 else
4372 *p = 'x';
4373 break;
4374 }
4375 p++;
d1133906
NC		 4376 }
4377 }
76da6bbe 4378
8d5ff12c
L		 4379 if (do_section_details)
4380 {
4381 if (os_flags)
4382 {
4383 size -= 5 + field_size;
4384 if (p != buff + field_size + 4)
4385 {
4386 if (size < (2 + 1))
4387 abort ();
4388 size -= 2;
4389 *p++ = ',';
4390 *p++ = ' ';
4391 }
4392 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4393 (unsigned long) os_flags);
4394 p += 5 + field_size;
4395 }
4396 if (proc_flags)
4397 {
4398 size -= 7 + field_size;
4399 if (p != buff + field_size + 4)
4400 {
4401 if (size < (2 + 1))
4402 abort ();
4403 size -= 2;
4404 *p++ = ',';
4405 *p++ = ' ';
4406 }
4407 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4408 (unsigned long) proc_flags);
4409 p += 7 + field_size;
4410 }
4411 if (unknown_flags)
4412 {
4413 size -= 10 + field_size;
4414 if (p != buff + field_size + 4)
4415 {
4416 if (size < (2 + 1))
4417 abort ();
4418 size -= 2;
4419 *p++ = ',';
4420 *p++ = ' ';
4421 }
2b692964 4422 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 4423 (unsigned long) unknown_flags);
4424 p += 10 + field_size;
4425 }
4426 }
4427
e9e44622 4428 *p = '\0';
d1133906
NC		 4429 return buff;
4430}
4431
252b5132 4432static int
2cf0635d 4433process_section_headers (FILE * file)
252b5132 4434{
2cf0635d 4435 Elf_Internal_Shdr * section;
b34976b6 4436 unsigned int i;
252b5132
RH		 4437
4438 section_headers = NULL;
4439
4440 if (elf_header.e_shnum == 0)
4441 {
82f2dbf7
NC		 4442 /* PR binutils/12467. */
4443 if (elf_header.e_shoff != 0)
4444 warn (_("possibly corrupt ELF file header - it has a non-zero"
4445 " section header offset, but no section headers\n"));
4446 else if (do_sections)
252b5132
RH		 4447 printf (_("\nThere are no sections in this file.\n"));
4448
4449 return 1;
4450 }
4451
4452 if (do_sections && !do_header)
9ea033b2 4453 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 4454 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4455
9ea033b2
NC		 4456 if (is_32bit_elf)
4457 {
560f3c1c 4458 if (! get_32bit_section_headers (file, elf_header.e_shnum))
9ea033b2
NC		 4459 return 0;
4460 }
560f3c1c 4461 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
252b5132
RH		 4462 return 0;
4463
4464 /* Read in the string table, so that we have names to display. */
0b49d371 4465 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 4466 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 4467 {
4fbb74a6 4468 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 4469
c256ffe7
JJ		 4470 if (section->sh_size != 0)
4471 {
3f5e193b
NC		 4472 string_table = (char *) get_data (NULL, file, section->sh_offset,
4473 1, section->sh_size,
4474 _("string table"));
0de14b54 4475
c256ffe7
JJ		 4476 string_table_length = string_table != NULL ? section->sh_size : 0;
4477 }
252b5132
RH		 4478 }
4479
4480 /* Scan the sections for the dynamic symbol table
e3c8793a 4481 and dynamic string table and debug sections. */
252b5132
RH		 4482 dynamic_symbols = NULL;
4483 dynamic_strings = NULL;
4484 dynamic_syminfo = NULL;
f1ef08cb 4485 symtab_shndx_hdr = NULL;
103f02d3 4486
89fac5e3
RS		 4487 eh_addr_size = is_32bit_elf ? 4 : 8;
4488 switch (elf_header.e_machine)
4489 {
4490 case EM_MIPS:
4491 case EM_MIPS_RS3_LE:
4492 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4493 FDE addresses. However, the ABI also has a semi-official ILP32
4494 variant for which the normal FDE address size rules apply.
4495
4496 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4497 section, where XX is the size of longs in bits. Unfortunately,
4498 earlier compilers provided no way of distinguishing ILP32 objects
4499 from LP64 objects, so if there's any doubt, we should assume that
4500 the official LP64 form is being used. */
4501 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4502 && find_section (".gcc_compiled_long32") == NULL)
4503 eh_addr_size = 8;
4504 break;
0f56a26a
DD		 4505
4506 case EM_H8_300:
4507 case EM_H8_300H:
4508 switch (elf_header.e_flags & EF_H8_MACH)
4509 {
4510 case E_H8_MACH_H8300:
4511 case E_H8_MACH_H8300HN:
4512 case E_H8_MACH_H8300SN:
4513 case E_H8_MACH_H8300SXN:
4514 eh_addr_size = 2;
4515 break;
4516 case E_H8_MACH_H8300H:
4517 case E_H8_MACH_H8300S:
4518 case E_H8_MACH_H8300SX:
4519 eh_addr_size = 4;
4520 break;
4521 }
f4236fe4
DD		 4522 break;
4523
ff7eeb89 4524 case EM_M32C_OLD:
f4236fe4
DD		 4525 case EM_M32C:
4526 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4527 {
4528 case EF_M32C_CPU_M16C:
4529 eh_addr_size = 2;
4530 break;
4531 }
4532 break;
89fac5e3
RS		 4533 }
4534
08d8fa11
JJ		 4535#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4536 do \
4537 { \
4538 size_t expected_entsize \
4539 = is_32bit_elf ? size32 : size64; \
4540 if (section->sh_entsize != expected_entsize) \
4541 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4542 i, (unsigned long int) section->sh_entsize, \
4543 (unsigned long int) expected_entsize); \
4544 section->sh_entsize = expected_entsize; \
4545 } \
4546 while (0)
4547#define CHECK_ENTSIZE(section, i, type) \
4548 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4549 sizeof (Elf64_External_##type))
4550
252b5132
RH		 4551 for (i = 0, section = section_headers;
4552 i < elf_header.e_shnum;
b34976b6 4553 i++, section++)
252b5132 4554 {
2cf0635d 4555 char * name = SECTION_NAME (section);
252b5132
RH		 4556
4557 if (section->sh_type == SHT_DYNSYM)
4558 {
4559 if (dynamic_symbols != NULL)
4560 {
4561 error (_("File contains multiple dynamic symbol tables\n"));
4562 continue;
4563 }
4564
08d8fa11 4565 CHECK_ENTSIZE (section, i, Sym);
19936277 4566 num_dynamic_syms = section->sh_size / section->sh_entsize;
9ad5cbcf 4567 dynamic_symbols = GET_ELF_SYMBOLS (file, section);
252b5132
RH		 4568 }
4569 else if (section->sh_type == SHT_STRTAB
18bd398b 4570 && streq (name, ".dynstr"))
252b5132
RH		 4571 {
4572 if (dynamic_strings != NULL)
4573 {
4574 error (_("File contains multiple dynamic string tables\n"));
4575 continue;
4576 }
4577
3f5e193b
NC		 4578 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4579 1, section->sh_size,
4580 _("dynamic strings"));
59245841 4581 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 4582 }
9ad5cbcf
AM		 4583 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4584 {
4585 if (symtab_shndx_hdr != NULL)
4586 {
4587 error (_("File contains multiple symtab shndx tables\n"));
4588 continue;
4589 }
4590 symtab_shndx_hdr = section;
4591 }
08d8fa11
JJ		 4592 else if (section->sh_type == SHT_SYMTAB)
4593 CHECK_ENTSIZE (section, i, Sym);
4594 else if (section->sh_type == SHT_GROUP)
4595 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4596 else if (section->sh_type == SHT_REL)
4597 CHECK_ENTSIZE (section, i, Rel);
4598 else if (section->sh_type == SHT_RELA)
4599 CHECK_ENTSIZE (section, i, Rela);
252b5132 4600 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 4601 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 4602 || do_debug_aranges || do_debug_frames || do_debug_macinfo
a262ae96 4603 || do_debug_str || do_debug_loc || do_debug_ranges)
1b315056
CS		 4604 && (const_strneq (name, ".debug_")
4605 || const_strneq (name, ".zdebug_")))
252b5132 4606 {
1b315056
CS		 4607 if (name[1] == 'z')
4608 name += sizeof (".zdebug_") - 1;
4609 else
4610 name += sizeof (".debug_") - 1;
252b5132
RH		 4611
4612 if (do_debugging
18bd398b 4613 || (do_debug_info && streq (name, "info"))
2b6f5997 4614 || (do_debug_info && streq (name, "types"))
18bd398b 4615 || (do_debug_abbrevs && streq (name, "abbrev"))
4cb93e3b 4616 || (do_debug_lines && streq (name, "line"))
18bd398b 4617 || (do_debug_pubnames && streq (name, "pubnames"))
f9f0e732 4618 || (do_debug_pubtypes && streq (name, "pubtypes"))
18bd398b
NC		 4619 || (do_debug_aranges && streq (name, "aranges"))
4620 || (do_debug_ranges && streq (name, "ranges"))
4621 || (do_debug_frames && streq (name, "frame"))
4622 || (do_debug_macinfo && streq (name, "macinfo"))
4ccf1e31 4623 || (do_debug_macinfo && streq (name, "macro"))
18bd398b
NC		 4624 || (do_debug_str && streq (name, "str"))
4625 || (do_debug_loc && streq (name, "loc"))
252b5132 4626 )
09c11c86 4627 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 4628 }
a262ae96 4629 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 4630 else if ((do_debugging || do_debug_info)
0112cd26 4631 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 4632 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 4633 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 4634 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 4635 else if (do_gdb_index && streq (name, ".gdb_index"))
4636 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 4637 /* Trace sections for Itanium VMS. */
4638 else if ((do_debugging || do_trace_info || do_trace_abbrevs
4639 || do_trace_aranges)
4640 && const_strneq (name, ".trace_"))
4641 {
4642 name += sizeof (".trace_") - 1;
4643
4644 if (do_debugging
4645 || (do_trace_info && streq (name, "info"))
4646 || (do_trace_abbrevs && streq (name, "abbrev"))
4647 || (do_trace_aranges && streq (name, "aranges"))
4648 )
4649 request_dump_bynumber (i, DEBUG_DUMP);
4650 }
4651
252b5132
RH		 4652 }
4653
4654 if (! do_sections)
4655 return 1;
4656
3a1a2036
NC		 4657 if (elf_header.e_shnum > 1)
4658 printf (_("\nSection Headers:\n"));
4659 else
4660 printf (_("\nSection Header:\n"));
76da6bbe 4661
f7a99963 4662 if (is_32bit_elf)
595cf52e 4663 {
5477e8a0 4664 if (do_section_details)
595cf52e
L		 4665 {
4666 printf (_(" [Nr] Name\n"));
5477e8a0 4667 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 4668 }
4669 else
4670 printf
4671 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4672 }
d974e256 4673 else if (do_wide)
595cf52e 4674 {
5477e8a0 4675 if (do_section_details)
595cf52e
L		 4676 {
4677 printf (_(" [Nr] Name\n"));
5477e8a0 4678 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 4679 }
4680 else
4681 printf
4682 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4683 }
f7a99963
NC		 4684 else
4685 {
5477e8a0 4686 if (do_section_details)
595cf52e
L		 4687 {
4688 printf (_(" [Nr] Name\n"));
5477e8a0
L		 4689 printf (_(" Type Address Offset Link\n"));
4690 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 4691 }
4692 else
4693 {
4694 printf (_(" [Nr] Name Type Address Offset\n"));
4695 printf (_(" Size EntSize Flags Link Info Align\n"));
4696 }
f7a99963 4697 }
252b5132 4698
5477e8a0
L		 4699 if (do_section_details)
4700 printf (_(" Flags\n"));
4701
252b5132
RH		 4702 for (i = 0, section = section_headers;
4703 i < elf_header.e_shnum;
b34976b6 4704 i++, section++)
252b5132 4705 {
5477e8a0 4706 if (do_section_details)
595cf52e
L		 4707 {
4708 printf (" [%2u] %s\n",
4fbb74a6 4709 i,
595cf52e
L		 4710 SECTION_NAME (section));
4711 if (is_32bit_elf || do_wide)
4712 printf (" %-15.15s ",
4713 get_section_type_name (section->sh_type));
4714 }
4715 else
b9eb56c1
NC		 4716 printf ((do_wide ? " [%2u] %-17s %-15s "
4717 : " [%2u] %-17.17s %-15.15s "),
4fbb74a6 4718 i,
595cf52e
L		 4719 SECTION_NAME (section),
4720 get_section_type_name (section->sh_type));
252b5132 4721
f7a99963
NC		 4722 if (is_32bit_elf)
4723 {
cfcac11d
NC		 4724 const char * link_too_big = NULL;
4725
f7a99963 4726 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 4727
f7a99963
NC		 4728 printf ( " %6.6lx %6.6lx %2.2lx",
4729 (unsigned long) section->sh_offset,
4730 (unsigned long) section->sh_size,
4731 (unsigned long) section->sh_entsize);
d1133906 4732
5477e8a0
L		 4733 if (do_section_details)
4734 fputs (" ", stdout);
4735 else
4736 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 4737
cfcac11d
NC		 4738 if (section->sh_link >= elf_header.e_shnum)
4739 {
4740 link_too_big = "";
4741 /* The sh_link value is out of range. Normally this indicates
caa83f8b 4742 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 4743 switch (elf_header.e_machine)
4744 {
caa83f8b
NC		 4745 case EM_386:
4746 case EM_486:
4747 case EM_X86_64:
7f502d6c 4748 case EM_L1OM:
7a9068fe 4749 case EM_K1OM:
cfcac11d
NC		 4750 case EM_OLD_SPARCV9:
4751 case EM_SPARC32PLUS:
4752 case EM_SPARCV9:
4753 case EM_SPARC:
4754 if (section->sh_link == (SHN_BEFORE & 0xffff))
4755 link_too_big = "BEFORE";
4756 else if (section->sh_link == (SHN_AFTER & 0xffff))
4757 link_too_big = "AFTER";
4758 break;
4759 default:
4760 break;
4761 }
4762 }
4763
4764 if (do_section_details)
4765 {
4766 if (link_too_big != NULL && * link_too_big)
4767 printf ("<%s> ", link_too_big);
4768 else
4769 printf ("%2u ", section->sh_link);
4770 printf ("%3u %2lu\n", section->sh_info,
4771 (unsigned long) section->sh_addralign);
4772 }
4773 else
4774 printf ("%2u %3u %2lu\n",
4775 section->sh_link,
4776 section->sh_info,
4777 (unsigned long) section->sh_addralign);
4778
4779 if (link_too_big && ! * link_too_big)
4780 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4781 i, section->sh_link);
f7a99963 4782 }
d974e256
JJ		 4783 else if (do_wide)
4784 {
4785 print_vma (section->sh_addr, LONG_HEX);
4786
4787 if ((long) section->sh_offset == section->sh_offset)
4788 printf (" %6.6lx", (unsigned long) section->sh_offset);
4789 else
4790 {
4791 putchar (' ');
4792 print_vma (section->sh_offset, LONG_HEX);
4793 }
4794
4795 if ((unsigned long) section->sh_size == section->sh_size)
4796 printf (" %6.6lx", (unsigned long) section->sh_size);
4797 else
4798 {
4799 putchar (' ');
4800 print_vma (section->sh_size, LONG_HEX);
4801 }
4802
4803 if ((unsigned long) section->sh_entsize == section->sh_entsize)
4804 printf (" %2.2lx", (unsigned long) section->sh_entsize);
4805 else
4806 {
4807 putchar (' ');
4808 print_vma (section->sh_entsize, LONG_HEX);
4809 }
4810
5477e8a0
L		 4811 if (do_section_details)
4812 fputs (" ", stdout);
4813 else
4814 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 4815
72de5009 4816 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 4817
4818 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 4819 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 4820 else
4821 {
4822 print_vma (section->sh_addralign, DEC);
4823 putchar ('\n');
4824 }
4825 }
5477e8a0 4826 else if (do_section_details)
595cf52e 4827 {
5477e8a0 4828 printf (" %-15.15s ",
595cf52e 4829 get_section_type_name (section->sh_type));
595cf52e
L		 4830 print_vma (section->sh_addr, LONG_HEX);
4831 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 4832 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 4833 else
4834 {
4835 printf (" ");
4836 print_vma (section->sh_offset, LONG_HEX);
4837 }
72de5009 4838 printf (" %u\n ", section->sh_link);
595cf52e 4839 print_vma (section->sh_size, LONG_HEX);
5477e8a0 4840 putchar (' ');
595cf52e
L		 4841 print_vma (section->sh_entsize, LONG_HEX);
4842
72de5009
AM		 4843 printf (" %-16u %lu\n",
4844 section->sh_info,
595cf52e
L		 4845 (unsigned long) section->sh_addralign);
4846 }
f7a99963
NC		 4847 else
4848 {
4849 putchar (' ');
4850 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 4851 if ((long) section->sh_offset == section->sh_offset)
4852 printf (" %8.8lx", (unsigned long) section->sh_offset);
4853 else
4854 {
4855 printf (" ");
4856 print_vma (section->sh_offset, LONG_HEX);
4857 }
f7a99963
NC		 4858 printf ("\n ");
4859 print_vma (section->sh_size, LONG_HEX);
4860 printf (" ");
4861 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 4862
d1133906 4863 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 4864
72de5009
AM		 4865 printf (" %2u %3u %lu\n",
4866 section->sh_link,
4867 section->sh_info,
f7a99963
NC		 4868 (unsigned long) section->sh_addralign);
4869 }
5477e8a0
L		 4870
4871 if (do_section_details)
4872 printf (" %s\n", get_elf_section_flags (section->sh_flags));
252b5132
RH		 4873 }
4874
5477e8a0 4875 if (!do_section_details)
3dbcc61d
NC		 4876 {
4877 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 4878 || elf_header.e_machine == EM_L1OM
4879 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 4880 printf (_("Key to Flags:\n\
4881 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
4882 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4883 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4884 else
4885 printf (_("Key to Flags:\n\
e3c8793a 4886 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 4887 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 4888 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3dbcc61d 4889 }
d1133906 4890
252b5132
RH		 4891 return 1;
4892}
4893
f5842774
L		 4894static const char *
4895get_group_flags (unsigned int flags)
4896{
4897 static char buff[32];
4898 switch (flags)
4899 {
220453ec
AM		 4900 case 0:
4901 return "";
4902
f5842774 4903 case GRP_COMDAT:
220453ec 4904 return "COMDAT ";
f5842774
L		 4905
4906 default:
220453ec 4907 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 4908 break;
4909 }
4910 return buff;
4911}
4912
4913static int
2cf0635d 4914process_section_groups (FILE * file)
f5842774 4915{
2cf0635d 4916 Elf_Internal_Shdr * section;
f5842774 4917 unsigned int i;
2cf0635d
NC		 4918 struct group * group;
4919 Elf_Internal_Shdr * symtab_sec;
4920 Elf_Internal_Shdr * strtab_sec;
4921 Elf_Internal_Sym * symtab;
4922 char * strtab;
c256ffe7 4923 size_t strtab_size;
d1f5c6e3
L		 4924
4925 /* Don't process section groups unless needed. */
4926 if (!do_unwind && !do_section_groups)
4927 return 1;
f5842774
L		 4928
4929 if (elf_header.e_shnum == 0)
4930 {
4931 if (do_section_groups)
82f2dbf7 4932 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 4933
4934 return 1;
4935 }
4936
4937 if (section_headers == NULL)
4938 {
4939 error (_("Section headers are not available!\n"));
4940 abort ();
4941 }
4942
3f5e193b
NC		 4943 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
4944 sizeof (struct group *));
e4b17d5c
L		 4945
4946 if (section_headers_groups == NULL)
4947 {
4948 error (_("Out of memory\n"));
4949 return 0;
4950 }
4951
f5842774 4952 /* Scan the sections for the group section. */
d1f5c6e3 4953 group_count = 0;
f5842774
L		 4954 for (i = 0, section = section_headers;
4955 i < elf_header.e_shnum;
4956 i++, section++)
e4b17d5c
L		 4957 if (section->sh_type == SHT_GROUP)
4958 group_count++;
4959
d1f5c6e3
L		 4960 if (group_count == 0)
4961 {
4962 if (do_section_groups)
4963 printf (_("\nThere are no section groups in this file.\n"));
4964
4965 return 1;
4966 }
4967
3f5e193b 4968 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 4969
4970 if (section_groups == NULL)
4971 {
4972 error (_("Out of memory\n"));
4973 return 0;
4974 }
4975
d1f5c6e3
L		 4976 symtab_sec = NULL;
4977 strtab_sec = NULL;
4978 symtab = NULL;
4979 strtab = NULL;
c256ffe7 4980 strtab_size = 0;
e4b17d5c
L		 4981 for (i = 0, section = section_headers, group = section_groups;
4982 i < elf_header.e_shnum;
4983 i++, section++)
f5842774
L		 4984 {
4985 if (section->sh_type == SHT_GROUP)
4986 {
2cf0635d
NC		 4987 char * name = SECTION_NAME (section);
4988 char * group_name;
4989 unsigned char * start;
4990 unsigned char * indices;
f5842774 4991 unsigned int entry, j, size;
2cf0635d
NC		 4992 Elf_Internal_Shdr * sec;
4993 Elf_Internal_Sym * sym;
f5842774
L		 4994
4995 /* Get the symbol table. */
4fbb74a6
AM		 4996 if (section->sh_link >= elf_header.e_shnum
4997 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 4998 != SHT_SYMTAB))
f5842774
L		 4999 {
5000 error (_("Bad sh_link in group section `%s'\n"), name);
5001 continue;
5002 }
d1f5c6e3
L		 5003
5004 if (symtab_sec != sec)
5005 {
5006 symtab_sec = sec;
5007 if (symtab)
5008 free (symtab);
5009 symtab = GET_ELF_SYMBOLS (file, symtab_sec);
5010 }
f5842774 5011
dd24e3da
NC		 5012 if (symtab == NULL)
5013 {
5014 error (_("Corrupt header in group section `%s'\n"), name);
5015 continue;
5016 }
5017
f5842774
L		 5018 sym = symtab + section->sh_info;
5019
5020 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5021 {
4fbb74a6
AM		 5022 if (sym->st_shndx == 0
5023 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 5024 {
5025 error (_("Bad sh_info in group section `%s'\n"), name);
5026 continue;
5027 }
ba2685cc 5028
4fbb74a6 5029 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 5030 strtab_sec = NULL;
5031 if (strtab)
5032 free (strtab);
f5842774 5033 strtab = NULL;
c256ffe7 5034 strtab_size = 0;
f5842774
L		 5035 }
5036 else
5037 {
5038 /* Get the string table. */
4fbb74a6 5039 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 5040 {
5041 strtab_sec = NULL;
5042 if (strtab)
5043 free (strtab);
5044 strtab = NULL;
5045 strtab_size = 0;
5046 }
5047 else if (strtab_sec
4fbb74a6 5048 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 5049 {
5050 strtab_sec = sec;
5051 if (strtab)
5052 free (strtab);
3f5e193b
NC		 5053 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5054 1, strtab_sec->sh_size,
5055 _("string table"));
c256ffe7 5056 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 5057 }
c256ffe7 5058 group_name = sym->st_name < strtab_size
2b692964 5059 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 5060 }
5061
3f5e193b
NC		 5062 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5063 1, section->sh_size,
5064 _("section data"));
59245841
NC		 5065 if (start == NULL)
5066 continue;
f5842774
L		 5067
5068 indices = start;
5069 size = (section->sh_size / section->sh_entsize) - 1;
5070 entry = byte_get (indices, 4);
5071 indices += 4;
e4b17d5c
L		 5072
5073 if (do_section_groups)
5074 {
2b692964 5075 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 5076 get_group_flags (entry), i, name, group_name, size);
ba2685cc 5077
e4b17d5c
L		 5078 printf (_(" [Index] Name\n"));
5079 }
5080
5081 group->group_index = i;
5082
f5842774
L		 5083 for (j = 0; j < size; j++)
5084 {
2cf0635d 5085 struct group_list * g;
e4b17d5c 5086
f5842774
L		 5087 entry = byte_get (indices, 4);
5088 indices += 4;
5089
4fbb74a6 5090 if (entry >= elf_header.e_shnum)
391cb864
L		 5091 {
5092 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5093 entry, i, elf_header.e_shnum - 1);
5094 continue;
5095 }
391cb864 5096
4fbb74a6 5097 if (section_headers_groups [entry] != NULL)
e4b17d5c 5098 {
d1f5c6e3
L		 5099 if (entry)
5100 {
391cb864
L		 5101 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5102 entry, i,
4fbb74a6 5103 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5104 continue;
5105 }
5106 else
5107 {
5108 /* Intel C/C++ compiler may put section 0 in a
5109 section group. We just warn it the first time
5110 and ignore it afterwards. */
5111 static int warned = 0;
5112 if (!warned)
5113 {
5114 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 5115 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5116 warned++;
5117 }
5118 }
e4b17d5c
L		 5119 }
5120
4fbb74a6 5121 section_headers_groups [entry] = group;
e4b17d5c
L		 5122
5123 if (do_section_groups)
5124 {
4fbb74a6 5125 sec = section_headers + entry;
c256ffe7 5126 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
ba2685cc
AM		 5127 }
5128
3f5e193b 5129 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 5130 g->section_index = entry;
5131 g->next = group->root;
5132 group->root = g;
f5842774
L		 5133 }
5134
f5842774
L		 5135 if (start)
5136 free (start);
e4b17d5c
L		 5137
5138 group++;
f5842774
L		 5139 }
5140 }
5141
d1f5c6e3
L		 5142 if (symtab)
5143 free (symtab);
5144 if (strtab)
5145 free (strtab);
f5842774
L		 5146 return 1;
5147}
5148
28f997cf
TG		 5149/* Data used to display dynamic fixups. */
5150
5151struct ia64_vms_dynfixup
5152{
5153 bfd_vma needed_ident; /* Library ident number. */
5154 bfd_vma needed; /* Index in the dstrtab of the library name. */
5155 bfd_vma fixup_needed; /* Index of the library. */
5156 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5157 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5158};
5159
5160/* Data used to display dynamic relocations. */
5161
5162struct ia64_vms_dynimgrela
5163{
5164 bfd_vma img_rela_cnt; /* Number of relocations. */
5165 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5166};
5167
5168/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5169 library). */
5170
5171static void
5172dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5173 const char *strtab, unsigned int strtab_sz)
5174{
5175 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5176 long i;
5177 const char *lib_name;
5178
5179 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5180 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5181 _("dynamic section image fixups"));
5182 if (!imfs)
5183 return;
5184
5185 if (fixup->needed < strtab_sz)
5186 lib_name = strtab + fixup->needed;
5187 else
5188 {
5189 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 5190 (unsigned long) fixup->needed);
28f997cf
TG		 5191 lib_name = "???";
5192 }
5193 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5194 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5195 printf
5196 (_("Seg Offset Type SymVec DataType\n"));
5197
5198 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5199 {
5200 unsigned int type;
5201 const char *rtype;
5202
5203 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5204 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5205 type = BYTE_GET (imfs [i].type);
5206 rtype = elf_ia64_reloc_type (type);
5207 if (rtype == NULL)
5208 printf (" 0x%08x ", type);
5209 else
5210 printf (" %-32s ", rtype);
5211 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5212 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5213 }
5214
5215 free (imfs);
5216}
5217
5218/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5219
5220static void
5221dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5222{
5223 Elf64_External_VMS_IMAGE_RELA *imrs;
5224 long i;
5225
5226 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5227 1, imgrela->img_rela_cnt * sizeof (*imrs),
5228 _("dynamic section image relas"));
5229 if (!imrs)
5230 return;
5231
5232 printf (_("\nImage relocs\n"));
5233 printf
5234 (_("Seg Offset Type Addend Seg Sym Off\n"));
5235
5236 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5237 {
5238 unsigned int type;
5239 const char *rtype;
5240
5241 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5242 printf ("%08" BFD_VMA_FMT "x ",
5243 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5244 type = BYTE_GET (imrs [i].type);
5245 rtype = elf_ia64_reloc_type (type);
5246 if (rtype == NULL)
5247 printf ("0x%08x ", type);
5248 else
5249 printf ("%-31s ", rtype);
5250 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5251 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5252 printf ("%08" BFD_VMA_FMT "x\n",
5253 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5254 }
5255
5256 free (imrs);
5257}
5258
5259/* Display IA-64 OpenVMS dynamic relocations and fixups. */
5260
5261static int
5262process_ia64_vms_dynamic_relocs (FILE *file)
5263{
5264 struct ia64_vms_dynfixup fixup;
5265 struct ia64_vms_dynimgrela imgrela;
5266 Elf_Internal_Dyn *entry;
5267 int res = 0;
5268 bfd_vma strtab_off = 0;
5269 bfd_vma strtab_sz = 0;
5270 char *strtab = NULL;
5271
5272 memset (&fixup, 0, sizeof (fixup));
5273 memset (&imgrela, 0, sizeof (imgrela));
5274
5275 /* Note: the order of the entries is specified by the OpenVMS specs. */
5276 for (entry = dynamic_section;
5277 entry < dynamic_section + dynamic_nent;
5278 entry++)
5279 {
5280 switch (entry->d_tag)
5281 {
5282 case DT_IA_64_VMS_STRTAB_OFFSET:
5283 strtab_off = entry->d_un.d_val;
5284 break;
5285 case DT_STRSZ:
5286 strtab_sz = entry->d_un.d_val;
5287 if (strtab == NULL)
5288 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5289 1, strtab_sz, _("dynamic string section"));
5290 break;
5291
5292 case DT_IA_64_VMS_NEEDED_IDENT:
5293 fixup.needed_ident = entry->d_un.d_val;
5294 break;
5295 case DT_NEEDED:
5296 fixup.needed = entry->d_un.d_val;
5297 break;
5298 case DT_IA_64_VMS_FIXUP_NEEDED:
5299 fixup.fixup_needed = entry->d_un.d_val;
5300 break;
5301 case DT_IA_64_VMS_FIXUP_RELA_CNT:
5302 fixup.fixup_rela_cnt = entry->d_un.d_val;
5303 break;
5304 case DT_IA_64_VMS_FIXUP_RELA_OFF:
5305 fixup.fixup_rela_off = entry->d_un.d_val;
5306 res++;
5307 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5308 break;
5309
5310 case DT_IA_64_VMS_IMG_RELA_CNT:
5311 imgrela.img_rela_cnt = entry->d_un.d_val;
5312 break;
5313 case DT_IA_64_VMS_IMG_RELA_OFF:
5314 imgrela.img_rela_off = entry->d_un.d_val;
5315 res++;
5316 dump_ia64_vms_dynamic_relocs (file, &imgrela);
5317 break;
5318
5319 default:
5320 break;
5321 }
5322 }
5323
5324 if (strtab != NULL)
5325 free (strtab);
5326
5327 return res;
5328}
5329
85b1c36d 5330static struct
566b0d53 5331{
2cf0635d 5332 const char * name;
566b0d53
L		 5333 int reloc;
5334 int size;
5335 int rela;
5336} dynamic_relocations [] =
5337{
5338 { "REL", DT_REL, DT_RELSZ, FALSE },
5339 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5340 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5341};
5342
252b5132 5343/* Process the reloc section. */
18bd398b 5344
252b5132 5345static int
2cf0635d 5346process_relocs (FILE * file)
252b5132 5347{
b34976b6
AM		 5348 unsigned long rel_size;
5349 unsigned long rel_offset;
252b5132
RH		 5350
5351
5352 if (!do_reloc)
5353 return 1;
5354
5355 if (do_using_dynamic)
5356 {
566b0d53 5357 int is_rela;
2cf0635d 5358 const char * name;
566b0d53
L		 5359 int has_dynamic_reloc;
5360 unsigned int i;
0de14b54 5361
566b0d53 5362 has_dynamic_reloc = 0;
252b5132 5363
566b0d53 5364 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 5365 {
566b0d53
L		 5366 is_rela = dynamic_relocations [i].rela;
5367 name = dynamic_relocations [i].name;
5368 rel_size = dynamic_info [dynamic_relocations [i].size];
5369 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 5370
566b0d53
L		 5371 has_dynamic_reloc |= rel_size;
5372
5373 if (is_rela == UNKNOWN)
aa903cfb 5374 {
566b0d53
L		 5375 if (dynamic_relocations [i].reloc == DT_JMPREL)
5376 switch (dynamic_info[DT_PLTREL])
5377 {
5378 case DT_REL:
5379 is_rela = FALSE;
5380 break;
5381 case DT_RELA:
5382 is_rela = TRUE;
5383 break;
5384 }
aa903cfb 5385 }
252b5132 5386
566b0d53
L		 5387 if (rel_size)
5388 {
5389 printf
5390 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5391 name, rel_offset, rel_size);
252b5132 5392
d93f0186
NC		 5393 dump_relocations (file,
5394 offset_from_vma (file, rel_offset, rel_size),
5395 rel_size,
566b0d53 5396 dynamic_symbols, num_dynamic_syms,
d79b3d50 5397 dynamic_strings, dynamic_strings_length, is_rela);
566b0d53 5398 }
252b5132 5399 }
566b0d53 5400
28f997cf
TG		 5401 if (is_ia64_vms ())
5402 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5403
566b0d53 5404 if (! has_dynamic_reloc)
252b5132
RH		 5405 printf (_("\nThere are no dynamic relocations in this file.\n"));
5406 }
5407 else
5408 {
2cf0635d 5409 Elf_Internal_Shdr * section;
b34976b6
AM		 5410 unsigned long i;
5411 int found = 0;
252b5132
RH		 5412
5413 for (i = 0, section = section_headers;
5414 i < elf_header.e_shnum;
b34976b6 5415 i++, section++)
252b5132
RH		 5416 {
5417 if ( section->sh_type != SHT_RELA
5418 && section->sh_type != SHT_REL)
5419 continue;
5420
5421 rel_offset = section->sh_offset;
5422 rel_size = section->sh_size;
5423
5424 if (rel_size)
5425 {
2cf0635d 5426 Elf_Internal_Shdr * strsec;
b34976b6 5427 int is_rela;
103f02d3 5428
252b5132
RH		 5429 printf (_("\nRelocation section "));
5430
5431 if (string_table == NULL)
19936277 5432 printf ("%d", section->sh_name);
252b5132 5433 else
3a1a2036 5434 printf (_("'%s'"), SECTION_NAME (section));
252b5132
RH		 5435
5436 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5437 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5438
d79b3d50
NC		 5439 is_rela = section->sh_type == SHT_RELA;
5440
4fbb74a6
AM		 5441 if (section->sh_link != 0
5442 && section->sh_link < elf_header.e_shnum)
af3fc3bc 5443 {
2cf0635d
NC		 5444 Elf_Internal_Shdr * symsec;
5445 Elf_Internal_Sym * symtab;
d79b3d50 5446 unsigned long nsyms;
c256ffe7 5447 unsigned long strtablen = 0;
2cf0635d 5448 char * strtab = NULL;
57346661 5449
4fbb74a6 5450 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 5451 if (symsec->sh_type != SHT_SYMTAB
5452 && symsec->sh_type != SHT_DYNSYM)
5453 continue;
5454
af3fc3bc 5455 nsyms = symsec->sh_size / symsec->sh_entsize;
9ad5cbcf 5456 symtab = GET_ELF_SYMBOLS (file, symsec);
252b5132 5457
af3fc3bc
AM		 5458 if (symtab == NULL)
5459 continue;
252b5132 5460
4fbb74a6
AM		 5461 if (symsec->sh_link != 0
5462 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 5463 {
4fbb74a6 5464 strsec = section_headers + symsec->sh_link;
103f02d3 5465
3f5e193b
NC		 5466 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5467 1, strsec->sh_size,
5468 _("string table"));
c256ffe7
JJ		 5469 strtablen = strtab == NULL ? 0 : strsec->sh_size;
5470 }
252b5132 5471
d79b3d50
NC		 5472 dump_relocations (file, rel_offset, rel_size,
5473 symtab, nsyms, strtab, strtablen, is_rela);
5474 if (strtab)
5475 free (strtab);
5476 free (symtab);
5477 }
5478 else
5479 dump_relocations (file, rel_offset, rel_size,
5480 NULL, 0, NULL, 0, is_rela);
252b5132
RH		 5481
5482 found = 1;
5483 }
5484 }
5485
5486 if (! found)
5487 printf (_("\nThere are no relocations in this file.\n"));
5488 }
5489
5490 return 1;
5491}
5492
57346661
AM		 5493/* Process the unwind section. */
5494
4d6ed7c8
NC		 5495#include "unwind-ia64.h"
5496
5497/* An absolute address consists of a section and an offset. If the
5498 section is NULL, the offset itself is the address, otherwise, the
5499 address equals to LOAD_ADDRESS(section) + offset. */
5500
5501struct absaddr
5502 {
5503 unsigned short section;
5504 bfd_vma offset;
5505 };
5506
1949de15
L		 5507#define ABSADDR(a) \
5508 ((a).section \
5509 ? section_headers [(a).section].sh_addr + (a).offset \
5510 : (a).offset)
5511
3f5e193b
NC		 5512struct ia64_unw_table_entry
5513 {
5514 struct absaddr start;
5515 struct absaddr end;
5516 struct absaddr info;
5517 };
5518
57346661 5519struct ia64_unw_aux_info
4d6ed7c8 5520 {
3f5e193b
NC		 5521
5522 struct ia64_unw_table_entry *table; /* Unwind table. */
b34976b6 5523 unsigned long table_len; /* Length of unwind table. */
2cf0635d 5524 unsigned char * info; /* Unwind info. */
b34976b6
AM		 5525 unsigned long info_size; /* Size of unwind info. */
5526 bfd_vma info_addr; /* starting address of unwind info. */
5527 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 5528 Elf_Internal_Sym * symtab; /* The symbol table. */
b34976b6 5529 unsigned long nsyms; /* Number of symbols. */
2cf0635d 5530 char * strtab; /* The string table. */
b34976b6 5531 unsigned long strtab_size; /* Size of string table. */
4d6ed7c8
NC		 5532 };
5533
4d6ed7c8 5534static void
2cf0635d 5535find_symbol_for_address (Elf_Internal_Sym * symtab,
57346661 5536 unsigned long nsyms,
2cf0635d 5537 const char * strtab,
57346661 5538 unsigned long strtab_size,
d3ba0551 5539 struct absaddr addr,
2cf0635d
NC		 5540 const char ** symname,
5541 bfd_vma * offset)
4d6ed7c8 5542{
d3ba0551 5543 bfd_vma dist = 0x100000;
2cf0635d
NC		 5544 Elf_Internal_Sym * sym;
5545 Elf_Internal_Sym * best = NULL;
4d6ed7c8
NC		 5546 unsigned long i;
5547
0b6ae522
DJ		 5548 REMOVE_ARCH_BITS (addr.offset);
5549
57346661 5550 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4d6ed7c8 5551 {
0b6ae522
DJ		 5552 bfd_vma value = sym->st_value;
5553
5554 REMOVE_ARCH_BITS (value);
5555
4d6ed7c8
NC		 5556 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5557 && sym->st_name != 0
5558 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 5559 && addr.offset >= value
5560 && addr.offset - value < dist)
4d6ed7c8
NC		 5561 {
5562 best = sym;
0b6ae522 5563 dist = addr.offset - value;
4d6ed7c8
NC		 5564 if (!dist)
5565 break;
5566 }
5567 }
5568 if (best)
5569 {
57346661 5570 *symname = (best->st_name >= strtab_size
2b692964 5571 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 5572 *offset = dist;
5573 return;
5574 }
5575 *symname = NULL;
5576 *offset = addr.offset;
5577}
5578
5579static void
2cf0635d 5580dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 5581{
2cf0635d 5582 struct ia64_unw_table_entry * tp;
4d6ed7c8 5583 int in_body;
7036c0e1 5584
4d6ed7c8
NC		 5585 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5586 {
5587 bfd_vma stamp;
5588 bfd_vma offset;
2cf0635d
NC		 5589 const unsigned char * dp;
5590 const unsigned char * head;
5591 const char * procname;
4d6ed7c8 5592
57346661
AM		 5593 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5594 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 5595
5596 fputs ("\n<", stdout);
5597
5598 if (procname)
5599 {
5600 fputs (procname, stdout);
5601
5602 if (offset)
5603 printf ("+%lx", (unsigned long) offset);
5604 }
5605
5606 fputs (">: [", stdout);
5607 print_vma (tp->start.offset, PREFIX_HEX);
5608 fputc ('-', stdout);
5609 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 5610 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 5611 (unsigned long) (tp->info.offset - aux->seg_base));
5612
1949de15 5613 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 5614 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 5615
86f55779 5616 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 5617 (unsigned) UNW_VER (stamp),
5618 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5619 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5620 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 5621 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 5622
5623 if (UNW_VER (stamp) != 1)
5624 {
2b692964 5625 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 5626 continue;
5627 }
5628
5629 in_body = 0;
89fac5e3 5630 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
4d6ed7c8
NC		 5631 dp = unw_decode (dp, in_body, & in_body);
5632 }
5633}
5634
5635static int
2cf0635d
NC		 5636slurp_ia64_unwind_table (FILE * file,
5637 struct ia64_unw_aux_info * aux,
5638 Elf_Internal_Shdr * sec)
4d6ed7c8 5639{
89fac5e3 5640 unsigned long size, nrelas, i;
2cf0635d
NC		 5641 Elf_Internal_Phdr * seg;
5642 struct ia64_unw_table_entry * tep;
5643 Elf_Internal_Shdr * relsec;
5644 Elf_Internal_Rela * rela;
5645 Elf_Internal_Rela * rp;
5646 unsigned char * table;
5647 unsigned char * tp;
5648 Elf_Internal_Sym * sym;
5649 const char * relname;
4d6ed7c8 5650
4d6ed7c8
NC		 5651 /* First, find the starting address of the segment that includes
5652 this section: */
5653
5654 if (elf_header.e_phnum)
5655 {
d93f0186 5656 if (! get_program_headers (file))
4d6ed7c8 5657 return 0;
4d6ed7c8 5658
d93f0186
NC		 5659 for (seg = program_headers;
5660 seg < program_headers + elf_header.e_phnum;
5661 ++seg)
4d6ed7c8
NC		 5662 {
5663 if (seg->p_type != PT_LOAD)
5664 continue;
5665
5666 if (sec->sh_addr >= seg->p_vaddr
5667 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5668 {
5669 aux->seg_base = seg->p_vaddr;
5670 break;
5671 }
5672 }
4d6ed7c8
NC		 5673 }
5674
5675 /* Second, build the unwind table from the contents of the unwind section: */
5676 size = sec->sh_size;
3f5e193b
NC		 5677 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5678 _("unwind table"));
a6e9f9df
AM		 5679 if (!table)
5680 return 0;
4d6ed7c8 5681
3f5e193b
NC		 5682 aux->table = (struct ia64_unw_table_entry *)
5683 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
89fac5e3 5684 tep = aux->table;
c6a0c689 5685 for (tp = table; tp < table + size; ++tep)
4d6ed7c8
NC		 5686 {
5687 tep->start.section = SHN_UNDEF;
5688 tep->end.section = SHN_UNDEF;
5689 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 5690 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5691 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5692 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 5693 tep->start.offset += aux->seg_base;
5694 tep->end.offset += aux->seg_base;
5695 tep->info.offset += aux->seg_base;
5696 }
5697 free (table);
5698
41e92641 5699 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 5700 for (relsec = section_headers;
5701 relsec < section_headers + elf_header.e_shnum;
5702 ++relsec)
5703 {
5704 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 5705 || relsec->sh_info >= elf_header.e_shnum
5706 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 5707 continue;
5708
5709 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5710 & rela, & nrelas))
5711 return 0;
5712
5713 for (rp = rela; rp < rela + nrelas; ++rp)
5714 {
aca88567
NC		 5715 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5716 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 5717
0112cd26 5718 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 5719 {
e5fb9629 5720 warn (_("Skipping unexpected relocation type %s\n"), relname);
4d6ed7c8
NC		 5721 continue;
5722 }
5723
89fac5e3 5724 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 5725
89fac5e3 5726 switch (rp->r_offset/eh_addr_size % 3)
4d6ed7c8
NC		 5727 {
5728 case 0:
5729 aux->table[i].start.section = sym->st_shndx;
e466bc6e 5730 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5731 break;
5732 case 1:
5733 aux->table[i].end.section = sym->st_shndx;
e466bc6e 5734 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5735 break;
5736 case 2:
5737 aux->table[i].info.section = sym->st_shndx;
e466bc6e 5738 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5739 break;
5740 default:
5741 break;
5742 }
5743 }
5744
5745 free (rela);
5746 }
5747
89fac5e3 5748 aux->table_len = size / (3 * eh_addr_size);
4d6ed7c8
NC		 5749 return 1;
5750}
5751
5752static int
2cf0635d 5753ia64_process_unwind (FILE * file)
4d6ed7c8 5754{
2cf0635d
NC		 5755 Elf_Internal_Shdr * sec;
5756 Elf_Internal_Shdr * unwsec = NULL;
5757 Elf_Internal_Shdr * strsec;
89fac5e3 5758 unsigned long i, unwcount = 0, unwstart = 0;
57346661 5759 struct ia64_unw_aux_info aux;
f1467e33 5760
4d6ed7c8
NC		 5761 memset (& aux, 0, sizeof (aux));
5762
4d6ed7c8
NC		 5763 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5764 {
c256ffe7 5765 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 5766 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8
NC		 5767 {
5768 aux.nsyms = sec->sh_size / sec->sh_entsize;
9ad5cbcf 5769 aux.symtab = GET_ELF_SYMBOLS (file, sec);
4d6ed7c8 5770
4fbb74a6 5771 strsec = section_headers + sec->sh_link;
59245841 5772 assert (aux.strtab == NULL);
3f5e193b
NC		 5773 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5774 1, strsec->sh_size,
5775 _("string table"));
c256ffe7 5776 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 5777 }
5778 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 5779 unwcount++;
5780 }
5781
5782 if (!unwcount)
5783 printf (_("\nThere are no unwind sections in this file.\n"));
5784
5785 while (unwcount-- > 0)
5786 {
2cf0635d 5787 char * suffix;
579f31ac
JJ		 5788 size_t len, len2;
5789
5790 for (i = unwstart, sec = section_headers + unwstart;
5791 i < elf_header.e_shnum; ++i, ++sec)
5792 if (sec->sh_type == SHT_IA_64_UNWIND)
5793 {
5794 unwsec = sec;
5795 break;
5796 }
5797
5798 unwstart = i + 1;
5799 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
5800
e4b17d5c
L		 5801 if ((unwsec->sh_flags & SHF_GROUP) != 0)
5802 {
5803 /* We need to find which section group it is in. */
2cf0635d 5804 struct group_list * g = section_headers_groups [i]->root;
e4b17d5c
L		 5805
5806 for (; g != NULL; g = g->next)
5807 {
4fbb74a6 5808 sec = section_headers + g->section_index;
18bd398b
NC		 5809
5810 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
57346661 5811 break;
e4b17d5c
L		 5812 }
5813
5814 if (g == NULL)
5815 i = elf_header.e_shnum;
5816 }
18bd398b 5817 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 5818 {
18bd398b 5819 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 5820 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
5821 suffix = SECTION_NAME (unwsec) + len;
5822 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5823 ++i, ++sec)
18bd398b
NC		 5824 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
5825 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 5826 break;
5827 }
5828 else
5829 {
5830 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 5831 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 5832 len = sizeof (ELF_STRING_ia64_unwind) - 1;
5833 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
5834 suffix = "";
18bd398b 5835 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 5836 suffix = SECTION_NAME (unwsec) + len;
5837 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5838 ++i, ++sec)
18bd398b
NC		 5839 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
5840 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 5841 break;
5842 }
5843
5844 if (i == elf_header.e_shnum)
5845 {
5846 printf (_("\nCould not find unwind info section for "));
5847
5848 if (string_table == NULL)
5849 printf ("%d", unwsec->sh_name);
5850 else
3a1a2036 5851 printf (_("'%s'"), SECTION_NAME (unwsec));
579f31ac
JJ		 5852 }
5853 else
4d6ed7c8 5854 {
4d6ed7c8 5855 aux.info_addr = sec->sh_addr;
3f5e193b 5856 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
59245841 5857 sec->sh_size,
3f5e193b 5858 _("unwind info"));
59245841 5859 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 5860
579f31ac 5861 printf (_("\nUnwind section "));
4d6ed7c8 5862
579f31ac
JJ		 5863 if (string_table == NULL)
5864 printf ("%d", unwsec->sh_name);
5865 else
3a1a2036 5866 printf (_("'%s'"), SECTION_NAME (unwsec));
4d6ed7c8 5867
579f31ac 5868 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 5869 (unsigned long) unwsec->sh_offset,
89fac5e3 5870 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 5871
579f31ac 5872 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4d6ed7c8 5873
579f31ac
JJ		 5874 if (aux.table_len > 0)
5875 dump_ia64_unwind (& aux);
5876
5877 if (aux.table)
5878 free ((char *) aux.table);
5879 if (aux.info)
5880 free ((char *) aux.info);
5881 aux.table = NULL;
5882 aux.info = NULL;
5883 }
4d6ed7c8 5884 }
4d6ed7c8 5885
4d6ed7c8
NC		 5886 if (aux.symtab)
5887 free (aux.symtab);
5888 if (aux.strtab)
5889 free ((char *) aux.strtab);
5890
5891 return 1;
5892}
5893
3f5e193b
NC		 5894struct hppa_unw_table_entry
5895 {
5896 struct absaddr start;
5897 struct absaddr end;
5898 unsigned int Cannot_unwind:1; /* 0 */
5899 unsigned int Millicode:1; /* 1 */
5900 unsigned int Millicode_save_sr0:1; /* 2 */
5901 unsigned int Region_description:2; /* 3..4 */
5902 unsigned int reserved1:1; /* 5 */
5903 unsigned int Entry_SR:1; /* 6 */
5904 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
5905 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
5906 unsigned int Args_stored:1; /* 16 */
5907 unsigned int Variable_Frame:1; /* 17 */
5908 unsigned int Separate_Package_Body:1; /* 18 */
5909 unsigned int Frame_Extension_Millicode:1; /* 19 */
5910 unsigned int Stack_Overflow_Check:1; /* 20 */
5911 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
5912 unsigned int Ada_Region:1; /* 22 */
5913 unsigned int cxx_info:1; /* 23 */
5914 unsigned int cxx_try_catch:1; /* 24 */
5915 unsigned int sched_entry_seq:1; /* 25 */
5916 unsigned int reserved2:1; /* 26 */
5917 unsigned int Save_SP:1; /* 27 */
5918 unsigned int Save_RP:1; /* 28 */
5919 unsigned int Save_MRP_in_frame:1; /* 29 */
5920 unsigned int extn_ptr_defined:1; /* 30 */
5921 unsigned int Cleanup_defined:1; /* 31 */
5922
5923 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
5924 unsigned int HP_UX_interrupt_marker:1; /* 1 */
5925 unsigned int Large_frame:1; /* 2 */
5926 unsigned int Pseudo_SP_Set:1; /* 3 */
5927 unsigned int reserved4:1; /* 4 */
5928 unsigned int Total_frame_size:27; /* 5..31 */
5929 };
5930
57346661
AM		 5931struct hppa_unw_aux_info
5932 {
3f5e193b 5933 struct hppa_unw_table_entry *table; /* Unwind table. */
57346661
AM		 5934 unsigned long table_len; /* Length of unwind table. */
5935 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 5936 Elf_Internal_Sym * symtab; /* The symbol table. */
57346661 5937 unsigned long nsyms; /* Number of symbols. */
2cf0635d 5938 char * strtab; /* The string table. */
57346661
AM		 5939 unsigned long strtab_size; /* Size of string table. */
5940 };
5941
5942static void
2cf0635d 5943dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 5944{
2cf0635d 5945 struct hppa_unw_table_entry * tp;
57346661 5946
57346661
AM		 5947 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5948 {
5949 bfd_vma offset;
2cf0635d 5950 const char * procname;
57346661
AM		 5951
5952 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5953 aux->strtab_size, tp->start, &procname,
5954 &offset);
5955
5956 fputs ("\n<", stdout);
5957
5958 if (procname)
5959 {
5960 fputs (procname, stdout);
5961
5962 if (offset)
5963 printf ("+%lx", (unsigned long) offset);
5964 }
5965
5966 fputs (">: [", stdout);
5967 print_vma (tp->start.offset, PREFIX_HEX);
5968 fputc ('-', stdout);
5969 print_vma (tp->end.offset, PREFIX_HEX);
5970 printf ("]\n\t");
5971
18bd398b
NC		 5972#define PF(_m) if (tp->_m) printf (#_m " ");
5973#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 5974 PF(Cannot_unwind);
5975 PF(Millicode);
5976 PF(Millicode_save_sr0);
18bd398b 5977 /* PV(Region_description); */
57346661
AM		 5978 PF(Entry_SR);
5979 PV(Entry_FR);
5980 PV(Entry_GR);
5981 PF(Args_stored);
5982 PF(Variable_Frame);
5983 PF(Separate_Package_Body);
5984 PF(Frame_Extension_Millicode);
5985 PF(Stack_Overflow_Check);
5986 PF(Two_Instruction_SP_Increment);
5987 PF(Ada_Region);
5988 PF(cxx_info);
5989 PF(cxx_try_catch);
5990 PF(sched_entry_seq);
5991 PF(Save_SP);
5992 PF(Save_RP);
5993 PF(Save_MRP_in_frame);
5994 PF(extn_ptr_defined);
5995 PF(Cleanup_defined);
5996 PF(MPE_XL_interrupt_marker);
5997 PF(HP_UX_interrupt_marker);
5998 PF(Large_frame);
5999 PF(Pseudo_SP_Set);
6000 PV(Total_frame_size);
6001#undef PF
6002#undef PV
6003 }
6004
18bd398b 6005 printf ("\n");
57346661
AM		 6006}
6007
6008static int
2cf0635d
NC		 6009slurp_hppa_unwind_table (FILE * file,
6010 struct hppa_unw_aux_info * aux,
6011 Elf_Internal_Shdr * sec)
57346661 6012{
1c0751b2 6013 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 6014 Elf_Internal_Phdr * seg;
6015 struct hppa_unw_table_entry * tep;
6016 Elf_Internal_Shdr * relsec;
6017 Elf_Internal_Rela * rela;
6018 Elf_Internal_Rela * rp;
6019 unsigned char * table;
6020 unsigned char * tp;
6021 Elf_Internal_Sym * sym;
6022 const char * relname;
57346661 6023
57346661
AM		 6024 /* First, find the starting address of the segment that includes
6025 this section. */
6026
6027 if (elf_header.e_phnum)
6028 {
6029 if (! get_program_headers (file))
6030 return 0;
6031
6032 for (seg = program_headers;
6033 seg < program_headers + elf_header.e_phnum;
6034 ++seg)
6035 {
6036 if (seg->p_type != PT_LOAD)
6037 continue;
6038
6039 if (sec->sh_addr >= seg->p_vaddr
6040 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6041 {
6042 aux->seg_base = seg->p_vaddr;
6043 break;
6044 }
6045 }
6046 }
6047
6048 /* Second, build the unwind table from the contents of the unwind
6049 section. */
6050 size = sec->sh_size;
3f5e193b
NC		 6051 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6052 _("unwind table"));
57346661
AM		 6053 if (!table)
6054 return 0;
6055
1c0751b2
DA		 6056 unw_ent_size = 16;
6057 nentries = size / unw_ent_size;
6058 size = unw_ent_size * nentries;
57346661 6059
3f5e193b
NC		 6060 tep = aux->table = (struct hppa_unw_table_entry *)
6061 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 6062
1c0751b2 6063 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 6064 {
6065 unsigned int tmp1, tmp2;
6066
6067 tep->start.section = SHN_UNDEF;
6068 tep->end.section = SHN_UNDEF;
6069
1c0751b2
DA		 6070 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6071 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6072 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6073 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6074
6075 tep->start.offset += aux->seg_base;
6076 tep->end.offset += aux->seg_base;
57346661
AM		 6077
6078 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6079 tep->Millicode = (tmp1 >> 30) & 0x1;
6080 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6081 tep->Region_description = (tmp1 >> 27) & 0x3;
6082 tep->reserved1 = (tmp1 >> 26) & 0x1;
6083 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6084 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6085 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6086 tep->Args_stored = (tmp1 >> 15) & 0x1;
6087 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6088 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6089 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6090 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6091 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6092 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6093 tep->cxx_info = (tmp1 >> 8) & 0x1;
6094 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6095 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6096 tep->reserved2 = (tmp1 >> 5) & 0x1;
6097 tep->Save_SP = (tmp1 >> 4) & 0x1;
6098 tep->Save_RP = (tmp1 >> 3) & 0x1;
6099 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6100 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6101 tep->Cleanup_defined = tmp1 & 0x1;
6102
6103 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6104 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6105 tep->Large_frame = (tmp2 >> 29) & 0x1;
6106 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6107 tep->reserved4 = (tmp2 >> 27) & 0x1;
6108 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 6109 }
6110 free (table);
6111
6112 /* Third, apply any relocations to the unwind table. */
57346661
AM		 6113 for (relsec = section_headers;
6114 relsec < section_headers + elf_header.e_shnum;
6115 ++relsec)
6116 {
6117 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6118 || relsec->sh_info >= elf_header.e_shnum
6119 || section_headers + relsec->sh_info != sec)
57346661
AM		 6120 continue;
6121
6122 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6123 & rela, & nrelas))
6124 return 0;
6125
6126 for (rp = rela; rp < rela + nrelas; ++rp)
6127 {
aca88567
NC		 6128 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6129 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 6130
6131 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 6132 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 6133 {
6134 warn (_("Skipping unexpected relocation type %s\n"), relname);
6135 continue;
6136 }
6137
6138 i = rp->r_offset / unw_ent_size;
6139
89fac5e3 6140 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 6141 {
6142 case 0:
6143 aux->table[i].start.section = sym->st_shndx;
1e456d54 6144 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 6145 break;
6146 case 1:
6147 aux->table[i].end.section = sym->st_shndx;
1e456d54 6148 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 6149 break;
6150 default:
6151 break;
6152 }
6153 }
6154
6155 free (rela);
6156 }
6157
1c0751b2 6158 aux->table_len = nentries;
57346661
AM		 6159
6160 return 1;
6161}
6162
6163static int
2cf0635d 6164hppa_process_unwind (FILE * file)
57346661 6165{
57346661 6166 struct hppa_unw_aux_info aux;
2cf0635d
NC		 6167 Elf_Internal_Shdr * unwsec = NULL;
6168 Elf_Internal_Shdr * strsec;
6169 Elf_Internal_Shdr * sec;
18bd398b 6170 unsigned long i;
57346661
AM		 6171
6172 memset (& aux, 0, sizeof (aux));
6173
c256ffe7
JJ		 6174 if (string_table == NULL)
6175 return 1;
57346661
AM		 6176
6177 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6178 {
c256ffe7 6179 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6180 && sec->sh_link < elf_header.e_shnum)
57346661
AM		 6181 {
6182 aux.nsyms = sec->sh_size / sec->sh_entsize;
6183 aux.symtab = GET_ELF_SYMBOLS (file, sec);
6184
4fbb74a6 6185 strsec = section_headers + sec->sh_link;
59245841 6186 assert (aux.strtab == NULL);
3f5e193b
NC		 6187 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6188 1, strsec->sh_size,
6189 _("string table"));
c256ffe7 6190 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 6191 }
18bd398b 6192 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 6193 unwsec = sec;
6194 }
6195
6196 if (!unwsec)
6197 printf (_("\nThere are no unwind sections in this file.\n"));
6198
6199 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6200 {
18bd398b 6201 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 6202 {
57346661
AM		 6203 printf (_("\nUnwind section "));
6204 printf (_("'%s'"), SECTION_NAME (sec));
6205
6206 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6207 (unsigned long) sec->sh_offset,
89fac5e3 6208 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 6209
6210 slurp_hppa_unwind_table (file, &aux, sec);
6211 if (aux.table_len > 0)
6212 dump_hppa_unwind (&aux);
6213
6214 if (aux.table)
6215 free ((char *) aux.table);
6216 aux.table = NULL;
6217 }
6218 }
6219
6220 if (aux.symtab)
6221 free (aux.symtab);
6222 if (aux.strtab)
6223 free ((char *) aux.strtab);
6224
6225 return 1;
6226}
6227
0b6ae522
DJ		 6228struct arm_section
6229{
6230 unsigned char *data;
6231
6232 Elf_Internal_Shdr *sec;
6233 Elf_Internal_Rela *rela;
6234 unsigned long nrelas;
6235 unsigned int rel_type;
6236
6237 Elf_Internal_Rela *next_rela;
6238};
6239
6240struct arm_unw_aux_info
6241{
6242 FILE *file;
6243
6244 Elf_Internal_Sym *symtab; /* The symbol table. */
6245 unsigned long nsyms; /* Number of symbols. */
6246 char *strtab; /* The string table. */
6247 unsigned long strtab_size; /* Size of string table. */
6248};
6249
6250static const char *
6251arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6252 bfd_vma fn, struct absaddr addr)
6253{
6254 const char *procname;
6255 bfd_vma sym_offset;
6256
6257 if (addr.section == SHN_UNDEF)
6258 addr.offset = fn;
6259
6260 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6261 aux->strtab_size, addr, &procname,
6262 &sym_offset);
6263
6264 print_vma (fn, PREFIX_HEX);
6265
6266 if (procname)
6267 {
6268 fputs (" <", stdout);
6269 fputs (procname, stdout);
6270
6271 if (sym_offset)
6272 printf ("+0x%lx", (unsigned long) sym_offset);
6273 fputc ('>', stdout);
6274 }
6275
6276 return procname;
6277}
6278
6279static void
6280arm_free_section (struct arm_section *arm_sec)
6281{
6282 if (arm_sec->data != NULL)
6283 free (arm_sec->data);
6284
6285 if (arm_sec->rela != NULL)
6286 free (arm_sec->rela);
6287}
6288
6289static int
6290arm_section_get_word (struct arm_unw_aux_info *aux,
6291 struct arm_section *arm_sec,
6292 Elf_Internal_Shdr *sec, bfd_vma word_offset,
6293 unsigned int *wordp, struct absaddr *addr)
6294{
6295 Elf_Internal_Rela *rp;
6296 Elf_Internal_Sym *sym;
6297 const char * relname;
6298 unsigned int word;
6299 bfd_boolean wrapped;
6300
6301 addr->section = SHN_UNDEF;
6302 addr->offset = 0;
6303
6304 if (sec != arm_sec->sec)
6305 {
6306 Elf_Internal_Shdr *relsec;
6307
6308 arm_free_section (arm_sec);
6309
6310 arm_sec->sec = sec;
6311 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6312 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 6313 arm_sec->rela = NULL;
6314 arm_sec->nrelas = 0;
6315
6316 for (relsec = section_headers;
6317 relsec < section_headers + elf_header.e_shnum;
6318 ++relsec)
6319 {
6320 if (relsec->sh_info >= elf_header.e_shnum
6321 || section_headers + relsec->sh_info != sec)
6322 continue;
6323
6324 if (relsec->sh_type == SHT_REL)
6325 {
6326 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6327 relsec->sh_size,
6328 & arm_sec->rela, & arm_sec->nrelas))
6329 return 0;
6330 break;
6331 }
6332 else if (relsec->sh_type == SHT_RELA)
6333 {
6334 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6335 relsec->sh_size,
6336 & arm_sec->rela, & arm_sec->nrelas))
6337 return 0;
6338 break;
6339 }
6340 }
6341
6342 arm_sec->next_rela = arm_sec->rela;
6343 }
6344
6345 if (arm_sec->data == NULL)
6346 return 0;
6347
6348 word = byte_get (arm_sec->data + word_offset, 4);
6349
6350 wrapped = FALSE;
6351 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6352 {
6353 bfd_vma prelval, offset;
6354
6355 if (rp->r_offset > word_offset && !wrapped)
6356 {
6357 rp = arm_sec->rela;
6358 wrapped = TRUE;
6359 }
6360 if (rp->r_offset > word_offset)
6361 break;
6362
6363 if (rp->r_offset & 3)
6364 {
6365 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6366 (unsigned long) rp->r_offset);
6367 continue;
6368 }
6369
6370 if (rp->r_offset < word_offset)
6371 continue;
6372
fa197c1c
PB		 6373 switch (elf_header.e_machine)
6374 {
6375 case EM_ARM:
6376 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6377 break;
6378
6379 case EM_TI_C6000:
6380 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6381 break;
6382
6383 default:
6384 abort();
6385 }
0b6ae522 6386
fa197c1c
PB		 6387 if (streq (relname, "R_ARM_NONE")
6388 || streq (relname, "R_C6000_NONE"))
0b6ae522
DJ		 6389 continue;
6390
fa197c1c
PB		 6391 if (!(streq (relname, "R_ARM_PREL31")
6392 || streq (relname, "R_C6000_PREL31")))
0b6ae522
DJ		 6393 {
6394 warn (_("Skipping unexpected relocation type %s\n"), relname);
6395 continue;
6396 }
6397
6398 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6399
6400 if (arm_sec->rel_type == SHT_REL)
6401 {
6402 offset = word & 0x7fffffff;
6403 if (offset & 0x40000000)
6404 offset |= ~ (bfd_vma) 0x7fffffff;
6405 }
6406 else
6407 offset = rp->r_addend;
6408
6409 offset += sym->st_value;
6410 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6411
fa197c1c
PB		 6412 if (streq (relname, "R_C6000_PREL31"))
6413 prelval >>= 1;
6414
0b6ae522
DJ		 6415 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6416 addr->section = sym->st_shndx;
6417 addr->offset = offset;
6418 break;
6419 }
6420
6421 *wordp = word;
6422 arm_sec->next_rela = rp;
6423
6424 return 1;
6425}
6426
fa197c1c
PB		 6427static const char *tic6x_unwind_regnames[16] = {
6428 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6429 "A14", "A13", "A12", "A11", "A10",
6430 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"};
6431
0b6ae522 6432static void
fa197c1c 6433decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 6434{
fa197c1c
PB		 6435 int i;
6436
6437 for (i = 12; mask; mask >>= 1, i--)
6438 {
6439 if (mask & 1)
6440 {
6441 fputs (tic6x_unwind_regnames[i], stdout);
6442 if (mask > 1)
6443 fputs (", ", stdout);
6444 }
6445 }
6446}
0b6ae522
DJ		 6447
6448#define ADVANCE \
6449 if (remaining == 0 && more_words) \
6450 { \
6451 data_offset += 4; \
6452 if (!arm_section_get_word (aux, data_arm_sec, data_sec, \
6453 data_offset, &word, &addr)) \
6454 return; \
6455 remaining = 4; \
6456 more_words--; \
6457 } \
6458
6459#define GET_OP(OP) \
6460 ADVANCE; \
6461 if (remaining) \
6462 { \
6463 remaining--; \
6464 (OP) = word >> 24; \
6465 word <<= 8; \
6466 } \
6467 else \
6468 { \
2b692964 6469 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 6470 return; \
6471 } \
cc5914eb 6472 printf ("0x%02x ", OP)
0b6ae522 6473
fa197c1c
PB		 6474static void
6475decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
6476 unsigned int word, unsigned int remaining,
6477 unsigned int more_words,
6478 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6479 struct arm_section *data_arm_sec)
6480{
6481 struct absaddr addr;
0b6ae522
DJ		 6482
6483 /* Decode the unwinding instructions. */
6484 while (1)
6485 {
6486 unsigned int op, op2;
6487
6488 ADVANCE;
6489 if (remaining == 0)
6490 break;
6491 remaining--;
6492 op = word >> 24;
6493 word <<= 8;
6494
cc5914eb 6495 printf (" 0x%02x ", op);
0b6ae522
DJ		 6496
6497 if ((op & 0xc0) == 0x00)
6498 {
6499 int offset = ((op & 0x3f) << 2) + 4;
61865e30 6500
cc5914eb 6501 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 6502 }
6503 else if ((op & 0xc0) == 0x40)
6504 {
6505 int offset = ((op & 0x3f) << 2) + 4;
61865e30 6506
cc5914eb 6507 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 6508 }
6509 else if ((op & 0xf0) == 0x80)
6510 {
6511 GET_OP (op2);
6512 if (op == 0x80 && op2 == 0)
6513 printf (_("Refuse to unwind"));
6514 else
6515 {
6516 unsigned int mask = ((op & 0x0f) << 8) | op2;
6517 int first = 1;
6518 int i;
2b692964 6519
0b6ae522
DJ		 6520 printf ("pop {");
6521 for (i = 0; i < 12; i++)
6522 if (mask & (1 << i))
6523 {
6524 if (first)
6525 first = 0;
6526 else
6527 printf (", ");
6528 printf ("r%d", 4 + i);
6529 }
6530 printf ("}");
6531 }
6532 }
6533 else if ((op & 0xf0) == 0x90)
6534 {
6535 if (op == 0x9d || op == 0x9f)
6536 printf (_(" [Reserved]"));
6537 else
cc5914eb 6538 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 6539 }
6540 else if ((op & 0xf0) == 0xa0)
6541 {
6542 int end = 4 + (op & 0x07);
6543 int first = 1;
6544 int i;
61865e30 6545
0b6ae522
DJ		 6546 printf (" pop {");
6547 for (i = 4; i <= end; i++)
6548 {
6549 if (first)
6550 first = 0;
6551 else
6552 printf (", ");
6553 printf ("r%d", i);
6554 }
6555 if (op & 0x08)
6556 {
6557 if (first)
6558 printf (", ");
6559 printf ("r14");
6560 }
6561 printf ("}");
6562 }
6563 else if (op == 0xb0)
6564 printf (_(" finish"));
6565 else if (op == 0xb1)
6566 {
6567 GET_OP (op2);
6568 if (op2 == 0 || (op2 & 0xf0) != 0)
6569 printf (_("[Spare]"));
6570 else
6571 {
6572 unsigned int mask = op2 & 0x0f;
6573 int first = 1;
6574 int i;
61865e30 6575
0b6ae522
DJ		 6576 printf ("pop {");
6577 for (i = 0; i < 12; i++)
6578 if (mask & (1 << i))
6579 {
6580 if (first)
6581 first = 0;
6582 else
6583 printf (", ");
6584 printf ("r%d", i);
6585 }
6586 printf ("}");
6587 }
6588 }
6589 else if (op == 0xb2)
6590 {
b115cf96 6591 unsigned char buf[9];
0b6ae522
DJ		 6592 unsigned int i, len;
6593 unsigned long offset;
61865e30 6594
b115cf96 6595 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 6596 {
6597 GET_OP (buf[i]);
6598 if ((buf[i] & 0x80) == 0)
6599 break;
6600 }
6601 assert (i < sizeof (buf));
6602 offset = read_uleb128 (buf, &len);
6603 assert (len == i + 1);
6604 offset = offset * 4 + 0x204;
cc5914eb 6605 printf ("vsp = vsp + %ld", offset);
0b6ae522 6606 }
61865e30 6607 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 6608 {
61865e30
NC		 6609 unsigned int first, last;
6610
6611 GET_OP (op2);
6612 first = op2 >> 4;
6613 last = op2 & 0x0f;
6614 if (op == 0xc8)
6615 first = first + 16;
6616 printf ("pop {D%d", first);
6617 if (last)
6618 printf ("-D%d", first + last);
6619 printf ("}");
6620 }
6621 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
6622 {
6623 unsigned int count = op & 0x07;
6624
6625 printf ("pop {D8");
6626 if (count)
6627 printf ("-D%d", 8 + count);
6628 printf ("}");
6629 }
6630 else if (op >= 0xc0 && op <= 0xc5)
6631 {
6632 unsigned int count = op & 0x07;
6633
6634 printf (" pop {wR10");
6635 if (count)
6636 printf ("-wR%d", 10 + count);
6637 printf ("}");
6638 }
6639 else if (op == 0xc6)
6640 {
6641 unsigned int first, last;
6642
6643 GET_OP (op2);
6644 first = op2 >> 4;
6645 last = op2 & 0x0f;
6646 printf ("pop {wR%d", first);
6647 if (last)
6648 printf ("-wR%d", first + last);
6649 printf ("}");
6650 }
6651 else if (op == 0xc7)
6652 {
6653 GET_OP (op2);
6654 if (op2 == 0 || (op2 & 0xf0) != 0)
6655 printf (_("[Spare]"));
0b6ae522
DJ		 6656 else
6657 {
61865e30
NC		 6658 unsigned int mask = op2 & 0x0f;
6659 int first = 1;
6660 int i;
6661
6662 printf ("pop {");
6663 for (i = 0; i < 4; i++)
6664 if (mask & (1 << i))
6665 {
6666 if (first)
6667 first = 0;
6668 else
6669 printf (", ");
6670 printf ("wCGR%d", i);
6671 }
6672 printf ("}");
0b6ae522
DJ		 6673 }
6674 }
61865e30
NC		 6675 else
6676 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 6677 printf ("\n");
6678 }
fa197c1c
PB		 6679}
6680
6681static void
6682decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
6683 unsigned int word, unsigned int remaining,
6684 unsigned int more_words,
6685 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6686 struct arm_section *data_arm_sec)
6687{
6688 struct absaddr addr;
6689
6690 /* Decode the unwinding instructions. */
6691 while (1)
6692 {
6693 unsigned int op, op2;
6694
6695 ADVANCE;
6696 if (remaining == 0)
6697 break;
6698 remaining--;
6699 op = word >> 24;
6700 word <<= 8;
6701
6702 printf (_(" 0x%02x "), op);
6703
6704 if ((op & 0xc0) == 0x00)
6705 {
6706 int offset = ((op & 0x3f) << 3) + 8;
6707 printf (_(" sp = sp + %d"), offset);
6708 }
6709 else if ((op & 0xc0) == 0x80)
6710 {
6711 GET_OP (op2);
6712 if (op == 0x80 && op2 == 0)
6713 printf (_("Refuse to unwind"));
6714 else
6715 {
6716 unsigned int mask = ((op & 0x1f) << 8) | op2;
6717 if (op & 0x20)
6718 printf ("pop compact {");
6719 else
6720 printf ("pop {");
6721
6722 decode_tic6x_unwind_regmask (mask);
6723 printf("}");
6724 }
6725 }
6726 else if ((op & 0xf0) == 0xc0)
6727 {
6728 unsigned int reg;
6729 unsigned int nregs;
6730 unsigned int i;
6731 const char *name;
6732 struct {
6733 unsigned int offset;
6734 unsigned int reg;
6735 } regpos[16];
6736
6737 /* Scan entire instruction first so that GET_OP output is not
6738 interleaved with disassembly. */
6739 nregs = 0;
6740 for (i = 0; nregs < (op & 0xf); i++)
6741 {
6742 GET_OP (op2);
6743 reg = op2 >> 4;
6744 if (reg != 0xf)
6745 {
6746 regpos[nregs].offset = i * 2;
6747 regpos[nregs].reg = reg;
6748 nregs++;
6749 }
6750
6751 reg = op2 & 0xf;
6752 if (reg != 0xf)
6753 {
6754 regpos[nregs].offset = i * 2 + 1;
6755 regpos[nregs].reg = reg;
6756 nregs++;
6757 }
6758 }
6759
6760 printf (_("pop frame {"));
6761 reg = nregs - 1;
6762 for (i = i * 2; i > 0; i--)
6763 {
6764 if (regpos[reg].offset == i - 1)
6765 {
6766 name = tic6x_unwind_regnames[regpos[reg].reg];
6767 if (reg > 0)
6768 reg--;
6769 }
6770 else
6771 name = _("[pad]");
6772
6773 fputs (name, stdout);
6774 if (i > 1)
6775 printf (", ");
6776 }
6777
6778 printf ("}");
6779 }
6780 else if (op == 0xd0)
6781 printf (" MOV FP, SP");
6782 else if (op == 0xd1)
6783 printf (" __c6xabi_pop_rts");
6784 else if (op == 0xd2)
6785 {
6786 unsigned char buf[9];
6787 unsigned int i, len;
6788 unsigned long offset;
6789 for (i = 0; i < sizeof (buf); i++)
6790 {
6791 GET_OP (buf[i]);
6792 if ((buf[i] & 0x80) == 0)
6793 break;
6794 }
6795 assert (i < sizeof (buf));
6796 offset = read_uleb128 (buf, &len);
6797 assert (len == i + 1);
6798 offset = offset * 8 + 0x408;
6799 printf (_("sp = sp + %ld"), offset);
6800 }
6801 else if ((op & 0xf0) == 0xe0)
6802 {
6803 if ((op & 0x0f) == 7)
6804 printf (" RETURN");
6805 else
6806 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
6807 }
6808 else
6809 {
6810 printf (_(" [unsupported opcode]"));
6811 }
6812 putchar ('\n');
6813 }
6814}
6815
6816static bfd_vma
6817expand_prel31 (bfd_vma word, bfd_vma where)
6818{
6819 bfd_vma offset;
6820
6821 offset = word & 0x7fffffff;
6822 if (offset & 0x40000000)
6823 offset |= ~ (bfd_vma) 0x7fffffff;
6824
6825 if (elf_header.e_machine == EM_TI_C6000)
6826 offset <<= 1;
6827
6828 return offset + where;
6829}
6830
6831static void
6832decode_arm_unwind (struct arm_unw_aux_info *aux,
6833 unsigned int word, unsigned int remaining,
6834 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6835 struct arm_section *data_arm_sec)
6836{
6837 int per_index;
6838 unsigned int more_words = 0;
6839 struct absaddr addr;
6840
6841 if (remaining == 0)
6842 {
6843 /* Fetch the first word. */
6844 if (!arm_section_get_word (aux, data_arm_sec, data_sec, data_offset,
6845 &word, &addr))
6846 return;
6847 remaining = 4;
6848 }
6849
6850 if ((word & 0x80000000) == 0)
6851 {
6852 /* Expand prel31 for personality routine. */
6853 bfd_vma fn;
6854 const char *procname;
6855
6856 fn = expand_prel31 (word, data_sec->sh_addr + data_offset);
6857 printf (_(" Personality routine: "));
6858 procname = arm_print_vma_and_name (aux, fn, addr);
6859 fputc ('\n', stdout);
6860
6861 /* The GCC personality routines use the standard compact
6862 encoding, starting with one byte giving the number of
6863 words. */
6864 if (procname != NULL
6865 && (const_strneq (procname, "__gcc_personality_v0")
6866 || const_strneq (procname, "__gxx_personality_v0")
6867 || const_strneq (procname, "__gcj_personality_v0")
6868 || const_strneq (procname, "__gnu_objc_personality_v0")))
6869 {
6870 remaining = 0;
6871 more_words = 1;
6872 ADVANCE;
6873 if (!remaining)
6874 {
6875 printf (_(" [Truncated data]\n"));
6876 return;
6877 }
6878 more_words = word >> 24;
6879 word <<= 8;
6880 remaining--;
6881 per_index = -1;
6882 }
6883 else
6884 return;
6885 }
6886 else
6887 {
6888
6889 per_index = (word >> 24) & 0x7f;
6890 printf (_(" Compact model %d\n"), per_index);
6891 if (per_index == 0)
6892 {
6893 more_words = 0;
6894 word <<= 8;
6895 remaining--;
6896 }
6897 else if (per_index < 3)
6898 {
6899 more_words = (word >> 16) & 0xff;
6900 word <<= 16;
6901 remaining -= 2;
6902 }
6903 }
6904
6905 switch (elf_header.e_machine)
6906 {
6907 case EM_ARM:
6908 if (per_index < 3)
6909 {
6910 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
6911 data_offset, data_sec, data_arm_sec);
6912 }
6913 else
6914 printf (" [reserved]\n");
6915 break;
6916
6917 case EM_TI_C6000:
6918 if (per_index < 3)
6919 {
6920 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
6921 data_offset, data_sec, data_arm_sec);
6922 }
6923 else if (per_index < 5)
6924 {
6925 if (((word >> 17) & 0x7f) == 0x7f)
6926 printf (_(" Restore stack from frame pointer\n"));
6927 else
6928 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
6929 printf (_(" Registers restored: "));
6930 if (per_index == 4)
6931 printf (" (compact) ");
6932 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
6933 putchar ('\n');
6934 printf (_(" Return register: %s\n"),
6935 tic6x_unwind_regnames[word & 0xf]);
6936 }
6937 else
6938 printf (" [reserved]\n");
6939 break;
6940
6941 default:
6942 abort ();
6943 }
0b6ae522
DJ		 6944
6945 /* Decode the descriptors. Not implemented. */
6946}
6947
6948static void
6949dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
6950{
6951 struct arm_section exidx_arm_sec, extab_arm_sec;
6952 unsigned int i, exidx_len;
6953
6954 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
6955 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
6956 exidx_len = exidx_sec->sh_size / 8;
6957
6958 for (i = 0; i < exidx_len; i++)
6959 {
6960 unsigned int exidx_fn, exidx_entry;
6961 struct absaddr fn_addr, entry_addr;
6962 bfd_vma fn;
6963
6964 fputc ('\n', stdout);
6965
6966 if (!arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6967 8 * i, &exidx_fn, &fn_addr)
6968 || !arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6969 8 * i + 4, &exidx_entry, &entry_addr))
6970 {
6971 arm_free_section (&exidx_arm_sec);
6972 arm_free_section (&extab_arm_sec);
6973 return;
6974 }
6975
fa197c1c 6976 fn = expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522
DJ		 6977
6978 arm_print_vma_and_name (aux, fn, entry_addr);
6979 fputs (": ", stdout);
6980
6981 if (exidx_entry == 1)
6982 {
6983 print_vma (exidx_entry, PREFIX_HEX);
6984 fputs (" [cantunwind]\n", stdout);
6985 }
6986 else if (exidx_entry & 0x80000000)
6987 {
6988 print_vma (exidx_entry, PREFIX_HEX);
6989 fputc ('\n', stdout);
6990 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
6991 }
6992 else
6993 {
8f73510c 6994 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 6995 Elf_Internal_Shdr *table_sec;
6996
6997 fputs ("@", stdout);
fa197c1c 6998 table = expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 6999 print_vma (table, PREFIX_HEX);
7000 printf ("\n");
7001
7002 /* Locate the matching .ARM.extab. */
7003 if (entry_addr.section != SHN_UNDEF
7004 && entry_addr.section < elf_header.e_shnum)
7005 {
7006 table_sec = section_headers + entry_addr.section;
7007 table_offset = entry_addr.offset;
7008 }
7009 else
7010 {
7011 table_sec = find_section_by_address (table);
7012 if (table_sec != NULL)
7013 table_offset = table - table_sec->sh_addr;
7014 }
7015 if (table_sec == NULL)
7016 {
7017 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7018 (unsigned long) table);
7019 continue;
7020 }
7021 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7022 &extab_arm_sec);
7023 }
7024 }
7025
7026 printf ("\n");
7027
7028 arm_free_section (&exidx_arm_sec);
7029 arm_free_section (&extab_arm_sec);
7030}
7031
fa197c1c 7032/* Used for both ARM and C6X unwinding tables. */
0b6ae522
DJ		 7033static int
7034arm_process_unwind (FILE *file)
7035{
7036 struct arm_unw_aux_info aux;
7037 Elf_Internal_Shdr *unwsec = NULL;
7038 Elf_Internal_Shdr *strsec;
7039 Elf_Internal_Shdr *sec;
7040 unsigned long i;
fa197c1c 7041 unsigned int sec_type;
0b6ae522
DJ		 7042
7043 memset (& aux, 0, sizeof (aux));
7044 aux.file = file;
7045
fa197c1c
PB		 7046 switch (elf_header.e_machine)
7047 {
7048 case EM_ARM:
7049 sec_type = SHT_ARM_EXIDX;
7050 break;
7051
7052 case EM_TI_C6000:
7053 sec_type = SHT_C6000_UNWIND;
7054 break;
7055
7056 default:
7057 abort();
7058 }
7059
0b6ae522
DJ		 7060 if (string_table == NULL)
7061 return 1;
7062
7063 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7064 {
7065 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7066 {
7067 aux.nsyms = sec->sh_size / sec->sh_entsize;
7068 aux.symtab = GET_ELF_SYMBOLS (file, sec);
7069
7070 strsec = section_headers + sec->sh_link;
59245841 7071 assert (aux.strtab == NULL);
0b6ae522
DJ		 7072 aux.strtab = get_data (NULL, file, strsec->sh_offset,
7073 1, strsec->sh_size, _("string table"));
7074 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7075 }
fa197c1c 7076 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 7077 unwsec = sec;
7078 }
7079
7080 if (!unwsec)
7081 printf (_("\nThere are no unwind sections in this file.\n"));
7082
7083 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7084 {
fa197c1c 7085 if (sec->sh_type == sec_type)
0b6ae522
DJ		 7086 {
7087 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7088 SECTION_NAME (sec),
7089 (unsigned long) sec->sh_offset,
7090 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
7091
7092 dump_arm_unwind (&aux, sec);
7093 }
7094 }
7095
7096 if (aux.symtab)
7097 free (aux.symtab);
7098 if (aux.strtab)
7099 free ((char *) aux.strtab);
7100
7101 return 1;
7102}
7103
57346661 7104static int
2cf0635d 7105process_unwind (FILE * file)
57346661 7106{
2cf0635d
NC		 7107 struct unwind_handler
7108 {
57346661 7109 int machtype;
2cf0635d
NC		 7110 int (* handler)(FILE *);
7111 } handlers[] =
7112 {
0b6ae522 7113 { EM_ARM, arm_process_unwind },
57346661
AM		 7114 { EM_IA_64, ia64_process_unwind },
7115 { EM_PARISC, hppa_process_unwind },
fa197c1c 7116 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 7117 { 0, 0 }
7118 };
7119 int i;
7120
7121 if (!do_unwind)
7122 return 1;
7123
7124 for (i = 0; handlers[i].handler != NULL; i++)
7125 if (elf_header.e_machine == handlers[i].machtype)
18bd398b 7126 return handlers[i].handler (file);
57346661
AM		 7127
7128 printf (_("\nThere are no unwind sections in this file.\n"));
7129 return 1;
7130}
7131
252b5132 7132static void
2cf0635d 7133dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 7134{
7135 switch (entry->d_tag)
7136 {
7137 case DT_MIPS_FLAGS:
7138 if (entry->d_un.d_val == 0)
2b692964 7139 printf (_("NONE\n"));
252b5132
RH		 7140 else
7141 {
7142 static const char * opts[] =
7143 {
7144 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7145 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7146 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7147 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7148 "RLD_ORDER_SAFE"
7149 };
7150 unsigned int cnt;
7151 int first = 1;
2b692964 7152
60bca95a 7153 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 7154 if (entry->d_un.d_val & (1 << cnt))
7155 {
7156 printf ("%s%s", first ? "" : " ", opts[cnt]);
7157 first = 0;
7158 }
7159 puts ("");
7160 }
7161 break;
103f02d3 7162
252b5132 7163 case DT_MIPS_IVERSION:
d79b3d50 7164 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
2b692964 7165 printf (_("Interface Version: %s\n"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 7166 else
2b692964 7167 printf (_("<corrupt: %ld>\n"), (long) entry->d_un.d_ptr);
252b5132 7168 break;
103f02d3 7169
252b5132
RH		 7170 case DT_MIPS_TIME_STAMP:
7171 {
7172 char timebuf[20];
2cf0635d 7173 struct tm * tmp;
50da7a9c 7174
91d6fa6a
NC		 7175 time_t atime = entry->d_un.d_val;
7176 tmp = gmtime (&atime);
e9e44622
JJ		 7177 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7178 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7179 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
2b692964 7180 printf (_("Time Stamp: %s\n"), timebuf);
252b5132
RH		 7181 }
7182 break;
103f02d3 7183
252b5132
RH		 7184 case DT_MIPS_RLD_VERSION:
7185 case DT_MIPS_LOCAL_GOTNO:
7186 case DT_MIPS_CONFLICTNO:
7187 case DT_MIPS_LIBLISTNO:
7188 case DT_MIPS_SYMTABNO:
7189 case DT_MIPS_UNREFEXTNO:
7190 case DT_MIPS_HIPAGENO:
7191 case DT_MIPS_DELTA_CLASS_NO:
7192 case DT_MIPS_DELTA_INSTANCE_NO:
7193 case DT_MIPS_DELTA_RELOC_NO:
7194 case DT_MIPS_DELTA_SYM_NO:
7195 case DT_MIPS_DELTA_CLASSSYM_NO:
7196 case DT_MIPS_COMPACT_SIZE:
7197 printf ("%ld\n", (long) entry->d_un.d_ptr);
7198 break;
103f02d3
UD		 7199
7200 default:
0af1713e 7201 printf ("%#lx\n", (unsigned long) entry->d_un.d_ptr);
103f02d3
UD		 7202 }
7203}
7204
103f02d3 7205static void
2cf0635d 7206dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 7207{
7208 switch (entry->d_tag)
7209 {
7210 case DT_HP_DLD_FLAGS:
7211 {
7212 static struct
7213 {
7214 long int bit;
2cf0635d 7215 const char * str;
5e220199
NC		 7216 }
7217 flags[] =
7218 {
7219 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7220 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7221 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7222 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7223 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7224 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7225 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7226 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7227 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7228 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 7229 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7230 { DT_HP_GST, "HP_GST" },
7231 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7232 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7233 { DT_HP_NODELETE, "HP_NODELETE" },
7234 { DT_HP_GROUP, "HP_GROUP" },
7235 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 7236 };
103f02d3 7237 int first = 1;
5e220199 7238 size_t cnt;
f7a99963 7239 bfd_vma val = entry->d_un.d_val;
103f02d3 7240
60bca95a 7241 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 7242 if (val & flags[cnt].bit)
30800947
NC		 7243 {
7244 if (! first)
7245 putchar (' ');
7246 fputs (flags[cnt].str, stdout);
7247 first = 0;
7248 val ^= flags[cnt].bit;
7249 }
76da6bbe 7250
103f02d3 7251 if (val != 0 || first)
f7a99963
NC		 7252 {
7253 if (! first)
7254 putchar (' ');
7255 print_vma (val, HEX);
7256 }
103f02d3
UD		 7257 }
7258 break;
76da6bbe 7259
252b5132 7260 default:
f7a99963
NC		 7261 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7262 break;
252b5132 7263 }
35b1837e 7264 putchar ('\n');
252b5132
RH		 7265}
7266
28f997cf
TG		 7267#ifdef BFD64
7268
7269/* VMS vs Unix time offset and factor. */
7270
7271#define VMS_EPOCH_OFFSET 35067168000000000LL
7272#define VMS_GRANULARITY_FACTOR 10000000
7273
7274/* Display a VMS time in a human readable format. */
7275
7276static void
7277print_vms_time (bfd_int64_t vmstime)
7278{
7279 struct tm *tm;
7280 time_t unxtime;
7281
7282 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7283 tm = gmtime (&unxtime);
7284 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7285 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7286 tm->tm_hour, tm->tm_min, tm->tm_sec);
7287}
7288#endif /* BFD64 */
7289
ecc51f48 7290static void
2cf0635d 7291dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 7292{
7293 switch (entry->d_tag)
7294 {
0de14b54 7295 case DT_IA_64_PLT_RESERVE:
bdf4d63a 7296 /* First 3 slots reserved. */
ecc51f48
NC		 7297 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7298 printf (" -- ");
7299 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 7300 break;
7301
28f997cf
TG		 7302 case DT_IA_64_VMS_LINKTIME:
7303#ifdef BFD64
7304 print_vms_time (entry->d_un.d_val);
7305#endif
7306 break;
7307
7308 case DT_IA_64_VMS_LNKFLAGS:
7309 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7310 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7311 printf (" CALL_DEBUG");
7312 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7313 printf (" NOP0BUFS");
7314 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7315 printf (" P0IMAGE");
7316 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7317 printf (" MKTHREADS");
7318 if (entry->d_un.d_val & VMS_LF_UPCALLS)
7319 printf (" UPCALLS");
7320 if (entry->d_un.d_val & VMS_LF_IMGSTA)
7321 printf (" IMGSTA");
7322 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7323 printf (" INITIALIZE");
7324 if (entry->d_un.d_val & VMS_LF_MAIN)
7325 printf (" MAIN");
7326 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7327 printf (" EXE_INIT");
7328 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7329 printf (" TBK_IN_IMG");
7330 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7331 printf (" DBG_IN_IMG");
7332 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7333 printf (" TBK_IN_DSF");
7334 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7335 printf (" DBG_IN_DSF");
7336 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7337 printf (" SIGNATURES");
7338 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7339 printf (" REL_SEG_OFF");
7340 break;
7341
bdf4d63a
JJ		 7342 default:
7343 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7344 break;
ecc51f48 7345 }
bdf4d63a 7346 putchar ('\n');
ecc51f48
NC		 7347}
7348
252b5132 7349static int
2cf0635d 7350get_32bit_dynamic_section (FILE * file)
252b5132 7351{
2cf0635d
NC		 7352 Elf32_External_Dyn * edyn;
7353 Elf32_External_Dyn * ext;
7354 Elf_Internal_Dyn * entry;
103f02d3 7355
3f5e193b
NC		 7356 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7357 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 7358 if (!edyn)
7359 return 0;
103f02d3 7360
ba2685cc
AM		 7361/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7362 might not have the luxury of section headers. Look for the DT_NULL
7363 terminator to determine the number of entries. */
7364 for (ext = edyn, dynamic_nent = 0;
7365 (char *) ext < (char *) edyn + dynamic_size;
7366 ext++)
7367 {
7368 dynamic_nent++;
7369 if (BYTE_GET (ext->d_tag) == DT_NULL)
7370 break;
7371 }
252b5132 7372
3f5e193b
NC		 7373 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7374 sizeof (* entry));
b2d38a17 7375 if (dynamic_section == NULL)
252b5132 7376 {
9ea033b2
NC		 7377 error (_("Out of memory\n"));
7378 free (edyn);
7379 return 0;
7380 }
252b5132 7381
fb514b26 7382 for (ext = edyn, entry = dynamic_section;
ba2685cc 7383 entry < dynamic_section + dynamic_nent;
fb514b26 7384 ext++, entry++)
9ea033b2 7385 {
fb514b26
AM		 7386 entry->d_tag = BYTE_GET (ext->d_tag);
7387 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 7388 }
7389
9ea033b2
NC		 7390 free (edyn);
7391
7392 return 1;
7393}
7394
7395static int
2cf0635d 7396get_64bit_dynamic_section (FILE * file)
9ea033b2 7397{
2cf0635d
NC		 7398 Elf64_External_Dyn * edyn;
7399 Elf64_External_Dyn * ext;
7400 Elf_Internal_Dyn * entry;
103f02d3 7401
3f5e193b
NC		 7402 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7403 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 7404 if (!edyn)
7405 return 0;
103f02d3 7406
ba2685cc
AM		 7407/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7408 might not have the luxury of section headers. Look for the DT_NULL
7409 terminator to determine the number of entries. */
7410 for (ext = edyn, dynamic_nent = 0;
7411 (char *) ext < (char *) edyn + dynamic_size;
7412 ext++)
7413 {
7414 dynamic_nent++;
66543521 7415 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 7416 break;
7417 }
252b5132 7418
3f5e193b
NC		 7419 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7420 sizeof (* entry));
b2d38a17 7421 if (dynamic_section == NULL)
252b5132
RH		 7422 {
7423 error (_("Out of memory\n"));
7424 free (edyn);
7425 return 0;
7426 }
7427
fb514b26 7428 for (ext = edyn, entry = dynamic_section;
ba2685cc 7429 entry < dynamic_section + dynamic_nent;
fb514b26 7430 ext++, entry++)
252b5132 7431 {
66543521
AM		 7432 entry->d_tag = BYTE_GET (ext->d_tag);
7433 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 7434 }
7435
7436 free (edyn);
7437
9ea033b2
NC		 7438 return 1;
7439}
7440
e9e44622
JJ		 7441static void
7442print_dynamic_flags (bfd_vma flags)
d1133906 7443{
e9e44622 7444 int first = 1;
13ae64f3 7445
d1133906
NC		 7446 while (flags)
7447 {
7448 bfd_vma flag;
7449
7450 flag = flags & - flags;
7451 flags &= ~ flag;
7452
e9e44622
JJ		 7453 if (first)
7454 first = 0;
7455 else
7456 putc (' ', stdout);
13ae64f3 7457
d1133906
NC		 7458 switch (flag)
7459 {
e9e44622
JJ		 7460 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
7461 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
7462 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
7463 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
7464 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 7465 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 7466 }
7467 }
e9e44622 7468 puts ("");
d1133906
NC		 7469}
7470
b2d38a17
NC		 7471/* Parse and display the contents of the dynamic section. */
7472
9ea033b2 7473static int
2cf0635d 7474process_dynamic_section (FILE * file)
9ea033b2 7475{
2cf0635d 7476 Elf_Internal_Dyn * entry;
9ea033b2
NC		 7477
7478 if (dynamic_size == 0)
7479 {
7480 if (do_dynamic)
b2d38a17 7481 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 7482
7483 return 1;
7484 }
7485
7486 if (is_32bit_elf)
7487 {
b2d38a17 7488 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 7489 return 0;
7490 }
b2d38a17 7491 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 7492 return 0;
7493
252b5132
RH		 7494 /* Find the appropriate symbol table. */
7495 if (dynamic_symbols == NULL)
7496 {
86dba8ee
AM		 7497 for (entry = dynamic_section;
7498 entry < dynamic_section + dynamic_nent;
7499 ++entry)
252b5132 7500 {
c8286bd1 7501 Elf_Internal_Shdr section;
252b5132
RH		 7502
7503 if (entry->d_tag != DT_SYMTAB)
7504 continue;
7505
7506 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7507
7508 /* Since we do not know how big the symbol table is,
7509 we default to reading in the entire file (!) and
7510 processing that. This is overkill, I know, but it
e3c8793a 7511 should work. */
d93f0186 7512 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 7513
fb52b2f4
NC		 7514 if (archive_file_offset != 0)
7515 section.sh_size = archive_file_size - section.sh_offset;
7516 else
7517 {
7518 if (fseek (file, 0, SEEK_END))
591a748a 7519 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 7520
7521 section.sh_size = ftell (file) - section.sh_offset;
7522 }
252b5132 7523
9ea033b2 7524 if (is_32bit_elf)
9ad5cbcf 7525 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 7526 else
9ad5cbcf 7527 section.sh_entsize = sizeof (Elf64_External_Sym);
252b5132 7528
9ad5cbcf 7529 num_dynamic_syms = section.sh_size / section.sh_entsize;
19936277 7530 if (num_dynamic_syms < 1)
252b5132
RH		 7531 {
7532 error (_("Unable to determine the number of symbols to load\n"));
7533 continue;
7534 }
7535
9ad5cbcf 7536 dynamic_symbols = GET_ELF_SYMBOLS (file, &section);
252b5132
RH		 7537 }
7538 }
7539
7540 /* Similarly find a string table. */
7541 if (dynamic_strings == NULL)
7542 {
86dba8ee
AM		 7543 for (entry = dynamic_section;
7544 entry < dynamic_section + dynamic_nent;
7545 ++entry)
252b5132
RH		 7546 {
7547 unsigned long offset;
b34976b6 7548 long str_tab_len;
252b5132
RH		 7549
7550 if (entry->d_tag != DT_STRTAB)
7551 continue;
7552
7553 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7554
7555 /* Since we do not know how big the string table is,
7556 we default to reading in the entire file (!) and
7557 processing that. This is overkill, I know, but it
e3c8793a 7558 should work. */
252b5132 7559
d93f0186 7560 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 7561
7562 if (archive_file_offset != 0)
7563 str_tab_len = archive_file_size - offset;
7564 else
7565 {
7566 if (fseek (file, 0, SEEK_END))
7567 error (_("Unable to seek to end of file\n"));
7568 str_tab_len = ftell (file) - offset;
7569 }
252b5132
RH		 7570
7571 if (str_tab_len < 1)
7572 {
7573 error
7574 (_("Unable to determine the length of the dynamic string table\n"));
7575 continue;
7576 }
7577
3f5e193b
NC		 7578 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7579 str_tab_len,
7580 _("dynamic string table"));
59245841 7581 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 7582 break;
7583 }
7584 }
7585
7586 /* And find the syminfo section if available. */
7587 if (dynamic_syminfo == NULL)
7588 {
3e8bba36 7589 unsigned long syminsz = 0;
252b5132 7590
86dba8ee
AM		 7591 for (entry = dynamic_section;
7592 entry < dynamic_section + dynamic_nent;
7593 ++entry)
252b5132
RH		 7594 {
7595 if (entry->d_tag == DT_SYMINENT)
7596 {
7597 /* Note: these braces are necessary to avoid a syntax
7598 error from the SunOS4 C compiler. */
7599 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7600 }
7601 else if (entry->d_tag == DT_SYMINSZ)
7602 syminsz = entry->d_un.d_val;
7603 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 7604 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7605 syminsz);
252b5132
RH		 7606 }
7607
7608 if (dynamic_syminfo_offset != 0 && syminsz != 0)
7609 {
2cf0635d
NC		 7610 Elf_External_Syminfo * extsyminfo;
7611 Elf_External_Syminfo * extsym;
7612 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 7613
7614 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 7615 extsyminfo = (Elf_External_Syminfo *)
7616 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
7617 _("symbol information"));
a6e9f9df
AM		 7618 if (!extsyminfo)
7619 return 0;
252b5132 7620
3f5e193b 7621 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 7622 if (dynamic_syminfo == NULL)
7623 {
7624 error (_("Out of memory\n"));
7625 return 0;
7626 }
7627
7628 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 7629 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
7630 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
7631 ++syminfo, ++extsym)
252b5132 7632 {
86dba8ee
AM		 7633 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
7634 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 7635 }
7636
7637 free (extsyminfo);
7638 }
7639 }
7640
7641 if (do_dynamic && dynamic_addr)
86dba8ee
AM		 7642 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7643 dynamic_addr, dynamic_nent);
252b5132
RH		 7644 if (do_dynamic)
7645 printf (_(" Tag Type Name/Value\n"));
7646
86dba8ee
AM		 7647 for (entry = dynamic_section;
7648 entry < dynamic_section + dynamic_nent;
7649 entry++)
252b5132
RH		 7650 {
7651 if (do_dynamic)
f7a99963 7652 {
2cf0635d 7653 const char * dtype;
e699b9ff 7654
f7a99963
NC		 7655 putchar (' ');
7656 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 7657 dtype = get_dynamic_type (entry->d_tag);
7658 printf (" (%s)%*s", dtype,
7659 ((is_32bit_elf ? 27 : 19)
7660 - (int) strlen (dtype)),
f7a99963
NC		 7661 " ");
7662 }
252b5132
RH		 7663
7664 switch (entry->d_tag)
7665 {
d1133906
NC		 7666 case DT_FLAGS:
7667 if (do_dynamic)
e9e44622 7668 print_dynamic_flags (entry->d_un.d_val);
d1133906 7669 break;
76da6bbe 7670
252b5132
RH		 7671 case DT_AUXILIARY:
7672 case DT_FILTER:
019148e4
L		 7673 case DT_CONFIG:
7674 case DT_DEPAUDIT:
7675 case DT_AUDIT:
252b5132
RH		 7676 if (do_dynamic)
7677 {
019148e4 7678 switch (entry->d_tag)
b34976b6 7679 {
019148e4
L		 7680 case DT_AUXILIARY:
7681 printf (_("Auxiliary library"));
7682 break;
7683
7684 case DT_FILTER:
7685 printf (_("Filter library"));
7686 break;
7687
b34976b6 7688 case DT_CONFIG:
019148e4
L		 7689 printf (_("Configuration file"));
7690 break;
7691
7692 case DT_DEPAUDIT:
7693 printf (_("Dependency audit library"));
7694 break;
7695
7696 case DT_AUDIT:
7697 printf (_("Audit library"));
7698 break;
7699 }
252b5132 7700
d79b3d50
NC		 7701 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7702 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 7703 else
f7a99963
NC		 7704 {
7705 printf (": ");
7706 print_vma (entry->d_un.d_val, PREFIX_HEX);
7707 putchar ('\n');
7708 }
252b5132
RH		 7709 }
7710 break;
7711
dcefbbbd 7712 case DT_FEATURE:
252b5132
RH		 7713 if (do_dynamic)
7714 {
7715 printf (_("Flags:"));
86f55779 7716
252b5132
RH		 7717 if (entry->d_un.d_val == 0)
7718 printf (_(" None\n"));
7719 else
7720 {
7721 unsigned long int val = entry->d_un.d_val;
86f55779 7722
252b5132
RH		 7723 if (val & DTF_1_PARINIT)
7724 {
7725 printf (" PARINIT");
7726 val ^= DTF_1_PARINIT;
7727 }
dcefbbbd
L		 7728 if (val & DTF_1_CONFEXP)
7729 {
7730 printf (" CONFEXP");
7731 val ^= DTF_1_CONFEXP;
7732 }
252b5132
RH		 7733 if (val != 0)
7734 printf (" %lx", val);
7735 puts ("");
7736 }
7737 }
7738 break;
7739
7740 case DT_POSFLAG_1:
7741 if (do_dynamic)
7742 {
7743 printf (_("Flags:"));
86f55779 7744
252b5132
RH		 7745 if (entry->d_un.d_val == 0)
7746 printf (_(" None\n"));
7747 else
7748 {
7749 unsigned long int val = entry->d_un.d_val;
86f55779 7750
252b5132
RH		 7751 if (val & DF_P1_LAZYLOAD)
7752 {
7753 printf (" LAZYLOAD");
7754 val ^= DF_P1_LAZYLOAD;
7755 }
7756 if (val & DF_P1_GROUPPERM)
7757 {
7758 printf (" GROUPPERM");
7759 val ^= DF_P1_GROUPPERM;
7760 }
7761 if (val != 0)
7762 printf (" %lx", val);
7763 puts ("");
7764 }
7765 }
7766 break;
7767
7768 case DT_FLAGS_1:
7769 if (do_dynamic)
7770 {
7771 printf (_("Flags:"));
7772 if (entry->d_un.d_val == 0)
7773 printf (_(" None\n"));
7774 else
7775 {
7776 unsigned long int val = entry->d_un.d_val;
86f55779 7777
252b5132
RH		 7778 if (val & DF_1_NOW)
7779 {
7780 printf (" NOW");
7781 val ^= DF_1_NOW;
7782 }
7783 if (val & DF_1_GLOBAL)
7784 {
7785 printf (" GLOBAL");
7786 val ^= DF_1_GLOBAL;
7787 }
7788 if (val & DF_1_GROUP)
7789 {
7790 printf (" GROUP");
7791 val ^= DF_1_GROUP;
7792 }
7793 if (val & DF_1_NODELETE)
7794 {
7795 printf (" NODELETE");
7796 val ^= DF_1_NODELETE;
7797 }
7798 if (val & DF_1_LOADFLTR)
7799 {
7800 printf (" LOADFLTR");
7801 val ^= DF_1_LOADFLTR;
7802 }
7803 if (val & DF_1_INITFIRST)
7804 {
7805 printf (" INITFIRST");
7806 val ^= DF_1_INITFIRST;
7807 }
7808 if (val & DF_1_NOOPEN)
7809 {
7810 printf (" NOOPEN");
7811 val ^= DF_1_NOOPEN;
7812 }
7813 if (val & DF_1_ORIGIN)
7814 {
7815 printf (" ORIGIN");
7816 val ^= DF_1_ORIGIN;
7817 }
7818 if (val & DF_1_DIRECT)
7819 {
7820 printf (" DIRECT");
7821 val ^= DF_1_DIRECT;
7822 }
7823 if (val & DF_1_TRANS)
7824 {
7825 printf (" TRANS");
7826 val ^= DF_1_TRANS;
7827 }
7828 if (val & DF_1_INTERPOSE)
7829 {
7830 printf (" INTERPOSE");
7831 val ^= DF_1_INTERPOSE;
7832 }
f7db6139 7833 if (val & DF_1_NODEFLIB)
dcefbbbd 7834 {
f7db6139
L		 7835 printf (" NODEFLIB");
7836 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 7837 }
7838 if (val & DF_1_NODUMP)
7839 {
7840 printf (" NODUMP");
7841 val ^= DF_1_NODUMP;
7842 }
7843 if (val & DF_1_CONLFAT)
7844 {
7845 printf (" CONLFAT");
7846 val ^= DF_1_CONLFAT;
7847 }
252b5132
RH		 7848 if (val != 0)
7849 printf (" %lx", val);
7850 puts ("");
7851 }
7852 }
7853 break;
7854
7855 case DT_PLTREL:
566b0d53 7856 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 7857 if (do_dynamic)
7858 puts (get_dynamic_type (entry->d_un.d_val));
7859 break;
7860
7861 case DT_NULL :
7862 case DT_NEEDED :
7863 case DT_PLTGOT :
7864 case DT_HASH :
7865 case DT_STRTAB :
7866 case DT_SYMTAB :
7867 case DT_RELA :
7868 case DT_INIT :
7869 case DT_FINI :
7870 case DT_SONAME :
7871 case DT_RPATH :
7872 case DT_SYMBOLIC:
7873 case DT_REL :
7874 case DT_DEBUG :
7875 case DT_TEXTREL :
7876 case DT_JMPREL :
019148e4 7877 case DT_RUNPATH :
252b5132
RH		 7878 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7879
7880 if (do_dynamic)
7881 {
2cf0635d 7882 char * name;
252b5132 7883
d79b3d50
NC		 7884 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7885 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 7886 else
d79b3d50 7887 name = NULL;
252b5132
RH		 7888
7889 if (name)
7890 {
7891 switch (entry->d_tag)
7892 {
7893 case DT_NEEDED:
7894 printf (_("Shared library: [%s]"), name);
7895
18bd398b 7896 if (streq (name, program_interpreter))
f7a99963 7897 printf (_(" program interpreter"));
252b5132
RH		 7898 break;
7899
7900 case DT_SONAME:
f7a99963 7901 printf (_("Library soname: [%s]"), name);
252b5132
RH		 7902 break;
7903
7904 case DT_RPATH:
f7a99963 7905 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 7906 break;
7907
019148e4
L		 7908 case DT_RUNPATH:
7909 printf (_("Library runpath: [%s]"), name);
7910 break;
7911
252b5132 7912 default:
f7a99963
NC		 7913 print_vma (entry->d_un.d_val, PREFIX_HEX);
7914 break;
252b5132
RH		 7915 }
7916 }
7917 else
f7a99963
NC		 7918 print_vma (entry->d_un.d_val, PREFIX_HEX);
7919
7920 putchar ('\n');
252b5132
RH		 7921 }
7922 break;
7923
7924 case DT_PLTRELSZ:
7925 case DT_RELASZ :
7926 case DT_STRSZ :
7927 case DT_RELSZ :
7928 case DT_RELAENT :
7929 case DT_SYMENT :
7930 case DT_RELENT :
566b0d53 7931 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 7932 case DT_PLTPADSZ:
7933 case DT_MOVEENT :
7934 case DT_MOVESZ :
7935 case DT_INIT_ARRAYSZ:
7936 case DT_FINI_ARRAYSZ:
047b2264
JJ		 7937 case DT_GNU_CONFLICTSZ:
7938 case DT_GNU_LIBLISTSZ:
252b5132 7939 if (do_dynamic)
f7a99963
NC		 7940 {
7941 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 7942 printf (_(" (bytes)\n"));
f7a99963 7943 }
252b5132
RH		 7944 break;
7945
7946 case DT_VERDEFNUM:
7947 case DT_VERNEEDNUM:
7948 case DT_RELACOUNT:
7949 case DT_RELCOUNT:
7950 if (do_dynamic)
f7a99963
NC		 7951 {
7952 print_vma (entry->d_un.d_val, UNSIGNED);
7953 putchar ('\n');
7954 }
252b5132
RH		 7955 break;
7956
7957 case DT_SYMINSZ:
7958 case DT_SYMINENT:
7959 case DT_SYMINFO:
7960 case DT_USED:
7961 case DT_INIT_ARRAY:
7962 case DT_FINI_ARRAY:
7963 if (do_dynamic)
7964 {
d79b3d50
NC		 7965 if (entry->d_tag == DT_USED
7966 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 7967 {
2cf0635d 7968 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 7969
b34976b6 7970 if (*name)
252b5132
RH		 7971 {
7972 printf (_("Not needed object: [%s]\n"), name);
7973 break;
7974 }
7975 }
103f02d3 7976
f7a99963
NC		 7977 print_vma (entry->d_un.d_val, PREFIX_HEX);
7978 putchar ('\n');
252b5132
RH		 7979 }
7980 break;
7981
7982 case DT_BIND_NOW:
7983 /* The value of this entry is ignored. */
35b1837e
AM		 7984 if (do_dynamic)
7985 putchar ('\n');
252b5132 7986 break;
103f02d3 7987
047b2264
JJ		 7988 case DT_GNU_PRELINKED:
7989 if (do_dynamic)
7990 {
2cf0635d 7991 struct tm * tmp;
91d6fa6a 7992 time_t atime = entry->d_un.d_val;
047b2264 7993
91d6fa6a 7994 tmp = gmtime (&atime);
047b2264
JJ		 7995 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
7996 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7997 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7998
7999 }
8000 break;
8001
fdc90cb4
JJ		 8002 case DT_GNU_HASH:
8003 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8004 if (do_dynamic)
8005 {
8006 print_vma (entry->d_un.d_val, PREFIX_HEX);
8007 putchar ('\n');
8008 }
8009 break;
8010
252b5132
RH		 8011 default:
8012 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 8013 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 8014 entry->d_un.d_val;
8015
8016 if (do_dynamic)
8017 {
8018 switch (elf_header.e_machine)
8019 {
8020 case EM_MIPS:
4fe85591 8021 case EM_MIPS_RS3_LE:
b2d38a17 8022 dynamic_section_mips_val (entry);
252b5132 8023 break;
103f02d3 8024 case EM_PARISC:
b2d38a17 8025 dynamic_section_parisc_val (entry);
103f02d3 8026 break;
ecc51f48 8027 case EM_IA_64:
b2d38a17 8028 dynamic_section_ia64_val (entry);
ecc51f48 8029 break;
252b5132 8030 default:
f7a99963
NC		 8031 print_vma (entry->d_un.d_val, PREFIX_HEX);
8032 putchar ('\n');
252b5132
RH		 8033 }
8034 }
8035 break;
8036 }
8037 }
8038
8039 return 1;
8040}
8041
8042static char *
d3ba0551 8043get_ver_flags (unsigned int flags)
252b5132 8044{
b34976b6 8045 static char buff[32];
252b5132
RH		 8046
8047 buff[0] = 0;
8048
8049 if (flags == 0)
8050 return _("none");
8051
8052 if (flags & VER_FLG_BASE)
8053 strcat (buff, "BASE ");
8054
8055 if (flags & VER_FLG_WEAK)
8056 {
8057 if (flags & VER_FLG_BASE)
8058 strcat (buff, "| ");
8059
8060 strcat (buff, "WEAK ");
8061 }
8062
44ec90b9
RO		 8063 if (flags & VER_FLG_INFO)
8064 {
8065 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8066 strcat (buff, "| ");
8067
8068 strcat (buff, "INFO ");
8069 }
8070
8071 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 8072 strcat (buff, _("| <unknown>"));
252b5132
RH		 8073
8074 return buff;
8075}
8076
8077/* Display the contents of the version sections. */
98fb390a 8078
252b5132 8079static int
2cf0635d 8080process_version_sections (FILE * file)
252b5132 8081{
2cf0635d 8082 Elf_Internal_Shdr * section;
b34976b6
AM		 8083 unsigned i;
8084 int found = 0;
252b5132
RH		 8085
8086 if (! do_version)
8087 return 1;
8088
8089 for (i = 0, section = section_headers;
8090 i < elf_header.e_shnum;
b34976b6 8091 i++, section++)
252b5132
RH		 8092 {
8093 switch (section->sh_type)
8094 {
8095 case SHT_GNU_verdef:
8096 {
2cf0635d 8097 Elf_External_Verdef * edefs;
b34976b6
AM		 8098 unsigned int idx;
8099 unsigned int cnt;
2cf0635d 8100 char * endbuf;
252b5132
RH		 8101
8102 found = 1;
8103
8104 printf
72de5009 8105 (_("\nVersion definition section '%s' contains %u entries:\n"),
252b5132
RH		 8106 SECTION_NAME (section), section->sh_info);
8107
8108 printf (_(" Addr: 0x"));
8109 printf_vma (section->sh_addr);
72de5009 8110 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8111 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8112 section->sh_link < elf_header.e_shnum
8113 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8114 : _("<corrupt>"));
252b5132 8115
3f5e193b
NC		 8116 edefs = (Elf_External_Verdef *)
8117 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8118 _("version definition section"));
a6e9f9df
AM		 8119 if (!edefs)
8120 break;
59245841 8121 endbuf = (char *) edefs + section->sh_size;
252b5132 8122
b34976b6 8123 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 8124 {
2cf0635d
NC		 8125 char * vstart;
8126 Elf_External_Verdef * edef;
b34976b6 8127 Elf_Internal_Verdef ent;
2cf0635d 8128 Elf_External_Verdaux * eaux;
b34976b6
AM		 8129 Elf_Internal_Verdaux aux;
8130 int j;
8131 int isum;
103f02d3 8132
dd24e3da
NC		 8133 /* Check for negative or very large indicies. */
8134 if ((unsigned char *) edefs + idx < (unsigned char *) edefs)
8135 break;
8136
252b5132 8137 vstart = ((char *) edefs) + idx;
54806181
AM		 8138 if (vstart + sizeof (*edef) > endbuf)
8139 break;
252b5132
RH		 8140
8141 edef = (Elf_External_Verdef *) vstart;
8142
8143 ent.vd_version = BYTE_GET (edef->vd_version);
8144 ent.vd_flags = BYTE_GET (edef->vd_flags);
8145 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
8146 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
8147 ent.vd_hash = BYTE_GET (edef->vd_hash);
8148 ent.vd_aux = BYTE_GET (edef->vd_aux);
8149 ent.vd_next = BYTE_GET (edef->vd_next);
8150
8151 printf (_(" %#06x: Rev: %d Flags: %s"),
8152 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8153
8154 printf (_(" Index: %d Cnt: %d "),
8155 ent.vd_ndx, ent.vd_cnt);
8156
dd24e3da
NC		 8157 /* Check for overflow. */
8158 if ((unsigned char *)(vstart + ent.vd_aux) < (unsigned char *) vstart
8159 || (unsigned char *)(vstart + ent.vd_aux) > (unsigned char *) endbuf)
8160 break;
8161
252b5132
RH		 8162 vstart += ent.vd_aux;
8163
8164 eaux = (Elf_External_Verdaux *) vstart;
8165
8166 aux.vda_name = BYTE_GET (eaux->vda_name);
8167 aux.vda_next = BYTE_GET (eaux->vda_next);
8168
d79b3d50
NC		 8169 if (VALID_DYNAMIC_NAME (aux.vda_name))
8170 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8171 else
8172 printf (_("Name index: %ld\n"), aux.vda_name);
8173
8174 isum = idx + ent.vd_aux;
8175
b34976b6 8176 for (j = 1; j < ent.vd_cnt; j++)
252b5132 8177 {
dd24e3da
NC		 8178 /* Check for overflow. */
8179 if ((unsigned char *)(vstart + aux.vda_next) < (unsigned char *) vstart
8180 || (unsigned char *)(vstart + aux.vda_next) > (unsigned char *) endbuf)
8181 break;
8182
252b5132
RH		 8183 isum += aux.vda_next;
8184 vstart += aux.vda_next;
8185
8186 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 8187 if (vstart + sizeof (*eaux) > endbuf)
8188 break;
252b5132
RH		 8189
8190 aux.vda_name = BYTE_GET (eaux->vda_name);
8191 aux.vda_next = BYTE_GET (eaux->vda_next);
8192
d79b3d50 8193 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 8194 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 8195 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8196 else
8197 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8198 isum, j, aux.vda_name);
8199 }
dd24e3da 8200
54806181
AM		 8201 if (j < ent.vd_cnt)
8202 printf (_(" Version def aux past end of section\n"));
252b5132
RH		 8203
8204 idx += ent.vd_next;
8205 }
dd24e3da 8206
54806181
AM		 8207 if (cnt < section->sh_info)
8208 printf (_(" Version definition past end of section\n"));
252b5132
RH		 8209
8210 free (edefs);
8211 }
8212 break;
103f02d3 8213
252b5132
RH		 8214 case SHT_GNU_verneed:
8215 {
2cf0635d 8216 Elf_External_Verneed * eneed;
b34976b6
AM		 8217 unsigned int idx;
8218 unsigned int cnt;
2cf0635d 8219 char * endbuf;
252b5132
RH		 8220
8221 found = 1;
8222
72de5009 8223 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
252b5132
RH		 8224 SECTION_NAME (section), section->sh_info);
8225
8226 printf (_(" Addr: 0x"));
8227 printf_vma (section->sh_addr);
72de5009 8228 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8229 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8230 section->sh_link < elf_header.e_shnum
8231 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8232 : _("<corrupt>"));
252b5132 8233
3f5e193b
NC		 8234 eneed = (Elf_External_Verneed *) get_data (NULL, file,
8235 section->sh_offset, 1,
8236 section->sh_size,
8237 _("version need section"));
a6e9f9df
AM		 8238 if (!eneed)
8239 break;
59245841 8240 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 8241
8242 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8243 {
2cf0635d 8244 Elf_External_Verneed * entry;
b34976b6
AM		 8245 Elf_Internal_Verneed ent;
8246 int j;
8247 int isum;
2cf0635d 8248 char * vstart;
252b5132 8249
dd24e3da
NC		 8250 if ((unsigned char *) eneed + idx < (unsigned char *) eneed)
8251 break;
8252
252b5132 8253 vstart = ((char *) eneed) + idx;
54806181
AM		 8254 if (vstart + sizeof (*entry) > endbuf)
8255 break;
252b5132
RH		 8256
8257 entry = (Elf_External_Verneed *) vstart;
8258
8259 ent.vn_version = BYTE_GET (entry->vn_version);
8260 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
8261 ent.vn_file = BYTE_GET (entry->vn_file);
8262 ent.vn_aux = BYTE_GET (entry->vn_aux);
8263 ent.vn_next = BYTE_GET (entry->vn_next);
8264
8265 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
8266
d79b3d50
NC		 8267 if (VALID_DYNAMIC_NAME (ent.vn_file))
8268 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 8269 else
8270 printf (_(" File: %lx"), ent.vn_file);
8271
8272 printf (_(" Cnt: %d\n"), ent.vn_cnt);
8273
dd24e3da
NC		 8274 /* Check for overflow. */
8275 if ((unsigned char *)(vstart + ent.vn_aux) < (unsigned char *) vstart
8276 || (unsigned char *)(vstart + ent.vn_aux) > (unsigned char *) endbuf)
8277 break;
8278
252b5132
RH		 8279 vstart += ent.vn_aux;
8280
8281 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8282 {
2cf0635d 8283 Elf_External_Vernaux * eaux;
b34976b6 8284 Elf_Internal_Vernaux aux;
252b5132 8285
54806181
AM		 8286 if (vstart + sizeof (*eaux) > endbuf)
8287 break;
252b5132
RH		 8288 eaux = (Elf_External_Vernaux *) vstart;
8289
8290 aux.vna_hash = BYTE_GET (eaux->vna_hash);
8291 aux.vna_flags = BYTE_GET (eaux->vna_flags);
8292 aux.vna_other = BYTE_GET (eaux->vna_other);
8293 aux.vna_name = BYTE_GET (eaux->vna_name);
8294 aux.vna_next = BYTE_GET (eaux->vna_next);
8295
d79b3d50 8296 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 8297 printf (_(" %#06x: Name: %s"),
d79b3d50 8298 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 8299 else
ecc2063b 8300 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 8301 isum, aux.vna_name);
8302
8303 printf (_(" Flags: %s Version: %d\n"),
8304 get_ver_flags (aux.vna_flags), aux.vna_other);
8305
dd24e3da
NC		 8306 /* Check for overflow. */
8307 if ((unsigned char *)(vstart + aux.vna_next) < (unsigned char *) vstart
8308 || (unsigned char *)(vstart + aux.vna_next) > (unsigned char *) endbuf)
8309 break;
8310
252b5132
RH		 8311 isum += aux.vna_next;
8312 vstart += aux.vna_next;
8313 }
54806181
AM		 8314 if (j < ent.vn_cnt)
8315 printf (_(" Version need aux past end of section\n"));
252b5132
RH		 8316
8317 idx += ent.vn_next;
8318 }
54806181
AM		 8319 if (cnt < section->sh_info)
8320 printf (_(" Version need past end of section\n"));
103f02d3 8321
252b5132
RH		 8322 free (eneed);
8323 }
8324 break;
8325
8326 case SHT_GNU_versym:
8327 {
2cf0635d 8328 Elf_Internal_Shdr * link_section;
b34976b6
AM		 8329 int total;
8330 int cnt;
2cf0635d
NC		 8331 unsigned char * edata;
8332 unsigned short * data;
8333 char * strtab;
8334 Elf_Internal_Sym * symbols;
8335 Elf_Internal_Shdr * string_sec;
d3ba0551 8336 long off;
252b5132 8337
4fbb74a6 8338 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 8339 break;
8340
4fbb74a6 8341 link_section = section_headers + section->sh_link;
08d8fa11 8342 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 8343
4fbb74a6 8344 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 8345 break;
8346
252b5132
RH		 8347 found = 1;
8348
9ad5cbcf 8349 symbols = GET_ELF_SYMBOLS (file, link_section);
dd24e3da
NC		 8350 if (symbols == NULL)
8351 break;
252b5132 8352
4fbb74a6 8353 string_sec = section_headers + link_section->sh_link;
252b5132 8354
3f5e193b
NC		 8355 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8356 string_sec->sh_size,
8357 _("version string table"));
a6e9f9df 8358 if (!strtab)
0429c154
MS		 8359 {
8360 free (symbols);
8361 break;
8362 }
252b5132
RH		 8363
8364 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8365 SECTION_NAME (section), total);
8366
8367 printf (_(" Addr: "));
8368 printf_vma (section->sh_addr);
72de5009 8369 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8370 (unsigned long) section->sh_offset, section->sh_link,
252b5132
RH		 8371 SECTION_NAME (link_section));
8372
d3ba0551
AM		 8373 off = offset_from_vma (file,
8374 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8375 total * sizeof (short));
3f5e193b
NC		 8376 edata = (unsigned char *) get_data (NULL, file, off, total,
8377 sizeof (short),
8378 _("version symbol data"));
a6e9f9df
AM		 8379 if (!edata)
8380 {
8381 free (strtab);
0429c154 8382 free (symbols);
a6e9f9df
AM		 8383 break;
8384 }
252b5132 8385
3f5e193b 8386 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 8387
8388 for (cnt = total; cnt --;)
b34976b6
AM		 8389 data[cnt] = byte_get (edata + cnt * sizeof (short),
8390 sizeof (short));
252b5132
RH		 8391
8392 free (edata);
8393
8394 for (cnt = 0; cnt < total; cnt += 4)
8395 {
8396 int j, nn;
00d93f34 8397 int check_def, check_need;
2cf0635d 8398 char * name;
252b5132
RH		 8399
8400 printf (" %03x:", cnt);
8401
8402 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 8403 switch (data[cnt + j])
252b5132
RH		 8404 {
8405 case 0:
8406 fputs (_(" 0 (*local*) "), stdout);
8407 break;
8408
8409 case 1:
8410 fputs (_(" 1 (*global*) "), stdout);
8411 break;
8412
8413 default:
c244d050
NC		 8414 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8415 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 8416
dd24e3da
NC		 8417 /* If this index value is greater than the size of the symbols
8418 array, break to avoid an out-of-bounds read, */
8419 if ((unsigned long)(cnt + j) >=
8420 ((unsigned long)link_section->sh_size /
8421 (unsigned long)link_section->sh_entsize))
8422 {
8423 warn (_("invalid index into symbol array\n"));
8424 break;
8425 }
8426
00d93f34
JJ		 8427 check_def = 1;
8428 check_need = 1;
4fbb74a6
AM		 8429 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8430 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 8431 != SHT_NOBITS)
252b5132 8432 {
b34976b6 8433 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 8434 check_def = 0;
8435 else
8436 check_need = 0;
252b5132 8437 }
00d93f34
JJ		 8438
8439 if (check_need
b34976b6 8440 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 8441 {
b34976b6
AM		 8442 Elf_Internal_Verneed ivn;
8443 unsigned long offset;
252b5132 8444
d93f0186
NC		 8445 offset = offset_from_vma
8446 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8447 sizeof (Elf_External_Verneed));
252b5132 8448
b34976b6 8449 do
252b5132 8450 {
b34976b6
AM		 8451 Elf_Internal_Vernaux ivna;
8452 Elf_External_Verneed evn;
8453 Elf_External_Vernaux evna;
8454 unsigned long a_off;
252b5132 8455
59245841
NC		 8456 if (get_data (&evn, file, offset, sizeof (evn), 1,
8457 _("version need")) == NULL)
8458 break;
8459
252b5132
RH		 8460 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8461 ivn.vn_next = BYTE_GET (evn.vn_next);
8462
8463 a_off = offset + ivn.vn_aux;
8464
8465 do
8466 {
59245841
NC		 8467 if (get_data (&evna, file, a_off, sizeof (evna),
8468 1, _("version need aux (2)")) == NULL)
8469 {
8470 ivna.vna_next = 0;
8471 ivna.vna_other = 0;
8472 }
8473 else
8474 {
8475 ivna.vna_next = BYTE_GET (evna.vna_next);
8476 ivna.vna_other = BYTE_GET (evna.vna_other);
8477 }
252b5132
RH		 8478
8479 a_off += ivna.vna_next;
8480 }
b34976b6 8481 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 8482 && ivna.vna_next != 0);
8483
b34976b6 8484 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 8485 {
8486 ivna.vna_name = BYTE_GET (evna.vna_name);
8487
54806181
AM		 8488 if (ivna.vna_name >= string_sec->sh_size)
8489 name = _("*invalid*");
8490 else
8491 name = strtab + ivna.vna_name;
252b5132 8492 nn += printf ("(%s%-*s",
16062207
ILT		 8493 name,
8494 12 - (int) strlen (name),
252b5132 8495 ")");
00d93f34 8496 check_def = 0;
252b5132
RH		 8497 break;
8498 }
8499
8500 offset += ivn.vn_next;
8501 }
8502 while (ivn.vn_next);
8503 }
00d93f34 8504
b34976b6
AM		 8505 if (check_def && data[cnt + j] != 0x8001
8506 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 8507 {
b34976b6
AM		 8508 Elf_Internal_Verdef ivd;
8509 Elf_External_Verdef evd;
8510 unsigned long offset;
252b5132 8511
d93f0186
NC		 8512 offset = offset_from_vma
8513 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8514 sizeof evd);
252b5132
RH		 8515
8516 do
8517 {
59245841
NC		 8518 if (get_data (&evd, file, offset, sizeof (evd), 1,
8519 _("version def")) == NULL)
8520 {
8521 ivd.vd_next = 0;
8522 ivd.vd_ndx = 0;
8523 }
8524 else
8525 {
8526 ivd.vd_next = BYTE_GET (evd.vd_next);
8527 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8528 }
252b5132
RH		 8529
8530 offset += ivd.vd_next;
8531 }
c244d050 8532 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 8533 && ivd.vd_next != 0);
8534
c244d050 8535 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 8536 {
b34976b6
AM		 8537 Elf_External_Verdaux evda;
8538 Elf_Internal_Verdaux ivda;
252b5132
RH		 8539
8540 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8541
59245841
NC		 8542 if (get_data (&evda, file,
8543 offset - ivd.vd_next + ivd.vd_aux,
8544 sizeof (evda), 1,
8545 _("version def aux")) == NULL)
8546 break;
252b5132
RH		 8547
8548 ivda.vda_name = BYTE_GET (evda.vda_name);
8549
54806181
AM		 8550 if (ivda.vda_name >= string_sec->sh_size)
8551 name = _("*invalid*");
8552 else
8553 name = strtab + ivda.vda_name;
252b5132 8554 nn += printf ("(%s%-*s",
16062207
ILT		 8555 name,
8556 12 - (int) strlen (name),
252b5132
RH		 8557 ")");
8558 }
8559 }
8560
8561 if (nn < 18)
8562 printf ("%*c", 18 - nn, ' ');
8563 }
8564
8565 putchar ('\n');
8566 }
8567
8568 free (data);
8569 free (strtab);
8570 free (symbols);
8571 }
8572 break;
103f02d3 8573
252b5132
RH		 8574 default:
8575 break;
8576 }
8577 }
8578
8579 if (! found)
8580 printf (_("\nNo version information found in this file.\n"));
8581
8582 return 1;
8583}
8584
d1133906 8585static const char *
d3ba0551 8586get_symbol_binding (unsigned int binding)
252b5132 8587{
b34976b6 8588 static char buff[32];
252b5132
RH		 8589
8590 switch (binding)
8591 {
b34976b6
AM		 8592 case STB_LOCAL: return "LOCAL";
8593 case STB_GLOBAL: return "GLOBAL";
8594 case STB_WEAK: return "WEAK";
252b5132
RH		 8595 default:
8596 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 8597 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
8598 binding);
252b5132 8599 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 8600 {
8601 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 8602 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
8603 /* GNU is still using the default value 0. */
3e7a7d11
NC		 8604 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8605 return "UNIQUE";
8606 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
8607 }
252b5132 8608 else
e9e44622 8609 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 8610 return buff;
8611 }
8612}
8613
d1133906 8614static const char *
d3ba0551 8615get_symbol_type (unsigned int type)
252b5132 8616{
b34976b6 8617 static char buff[32];
252b5132
RH		 8618
8619 switch (type)
8620 {
b34976b6
AM		 8621 case STT_NOTYPE: return "NOTYPE";
8622 case STT_OBJECT: return "OBJECT";
8623 case STT_FUNC: return "FUNC";
8624 case STT_SECTION: return "SECTION";
8625 case STT_FILE: return "FILE";
8626 case STT_COMMON: return "COMMON";
8627 case STT_TLS: return "TLS";
15ab5209
DB		 8628 case STT_RELC: return "RELC";
8629 case STT_SRELC: return "SRELC";
252b5132
RH		 8630 default:
8631 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af
NC		 8632 {
8633 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
103f02d3
UD		 8634 return "THUMB_FUNC";
8635
351b4b40 8636 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 8637 return "REGISTER";
8638
8639 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
8640 return "PARISC_MILLI";
8641
e9e44622 8642 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 8643 }
252b5132 8644 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 8645 {
8646 if (elf_header.e_machine == EM_PARISC)
8647 {
8648 if (type == STT_HP_OPAQUE)
8649 return "HP_OPAQUE";
8650 if (type == STT_HP_STUB)
8651 return "HP_STUB";
8652 }
8653
d8045f23 8654 if (type == STT_GNU_IFUNC
9c55345c
TS		 8655 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
8656 /* GNU is still using the default value 0. */
d8045f23
NC		 8657 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8658 return "IFUNC";
8659
e9e44622 8660 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 8661 }
252b5132 8662 else
e9e44622 8663 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 8664 return buff;
8665 }
8666}
8667
d1133906 8668static const char *
d3ba0551 8669get_symbol_visibility (unsigned int visibility)
d1133906
NC		 8670{
8671 switch (visibility)
8672 {
b34976b6
AM		 8673 case STV_DEFAULT: return "DEFAULT";
8674 case STV_INTERNAL: return "INTERNAL";
8675 case STV_HIDDEN: return "HIDDEN";
d1133906
NC		 8676 case STV_PROTECTED: return "PROTECTED";
8677 default: abort ();
8678 }
8679}
8680
5e2b0d47
NC		 8681static const char *
8682get_mips_symbol_other (unsigned int other)
8683{
8684 switch (other)
8685 {
df58fc94
RS		 8686 case STO_OPTIONAL:
8687 return "OPTIONAL";
8688 case STO_MIPS_PLT:
8689 return "MIPS PLT";
8690 case STO_MIPS_PIC:
8691 return "MIPS PIC";
8692 case STO_MICROMIPS:
8693 return "MICROMIPS";
8694 case STO_MICROMIPS | STO_MIPS_PIC:
8695 return "MICROMIPS, MIPS PIC";
8696 case STO_MIPS16:
8697 return "MIPS16";
8698 default:
8699 return NULL;
5e2b0d47
NC		 8700 }
8701}
8702
28f997cf
TG		 8703static const char *
8704get_ia64_symbol_other (unsigned int other)
8705{
8706 if (is_ia64_vms ())
8707 {
8708 static char res[32];
8709
8710 res[0] = 0;
8711
8712 /* Function types is for images and .STB files only. */
8713 switch (elf_header.e_type)
8714 {
8715 case ET_DYN:
8716 case ET_EXEC:
8717 switch (VMS_ST_FUNC_TYPE (other))
8718 {
8719 case VMS_SFT_CODE_ADDR:
8720 strcat (res, " CA");
8721 break;
8722 case VMS_SFT_SYMV_IDX:
8723 strcat (res, " VEC");
8724 break;
8725 case VMS_SFT_FD:
8726 strcat (res, " FD");
8727 break;
8728 case VMS_SFT_RESERVE:
8729 strcat (res, " RSV");
8730 break;
8731 default:
8732 abort ();
8733 }
8734 break;
8735 default:
8736 break;
8737 }
8738 switch (VMS_ST_LINKAGE (other))
8739 {
8740 case VMS_STL_IGNORE:
8741 strcat (res, " IGN");
8742 break;
8743 case VMS_STL_RESERVE:
8744 strcat (res, " RSV");
8745 break;
8746 case VMS_STL_STD:
8747 strcat (res, " STD");
8748 break;
8749 case VMS_STL_LNK:
8750 strcat (res, " LNK");
8751 break;
8752 default:
8753 abort ();
8754 }
8755
8756 if (res[0] != 0)
8757 return res + 1;
8758 else
8759 return res;
8760 }
8761 return NULL;
8762}
8763
5e2b0d47
NC		 8764static const char *
8765get_symbol_other (unsigned int other)
8766{
8767 const char * result = NULL;
8768 static char buff [32];
8769
8770 if (other == 0)
8771 return "";
8772
8773 switch (elf_header.e_machine)
8774 {
8775 case EM_MIPS:
8776 result = get_mips_symbol_other (other);
28f997cf
TG		 8777 break;
8778 case EM_IA_64:
8779 result = get_ia64_symbol_other (other);
8780 break;
5e2b0d47
NC		 8781 default:
8782 break;
8783 }
8784
8785 if (result)
8786 return result;
8787
8788 snprintf (buff, sizeof buff, _("<other>: %x"), other);
8789 return buff;
8790}
8791
d1133906 8792static const char *
d3ba0551 8793get_symbol_index_type (unsigned int type)
252b5132 8794{
b34976b6 8795 static char buff[32];
5cf1065c 8796
252b5132
RH		 8797 switch (type)
8798 {
b34976b6
AM		 8799 case SHN_UNDEF: return "UND";
8800 case SHN_ABS: return "ABS";
8801 case SHN_COMMON: return "COM";
252b5132 8802 default:
9ce701e2
L		 8803 if (type == SHN_IA_64_ANSI_COMMON
8804 && elf_header.e_machine == EM_IA_64
8805 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
8806 return "ANSI_COM";
8a9036a4 8807 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 8808 || elf_header.e_machine == EM_L1OM
8809 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 8810 && type == SHN_X86_64_LCOMMON)
8811 return "LARGE_COM";
ac145307
BS		 8812 else if ((type == SHN_MIPS_SCOMMON
8813 && elf_header.e_machine == EM_MIPS)
8814 || (type == SHN_TIC6X_SCOMMON
8815 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 8816 return "SCOM";
8817 else if (type == SHN_MIPS_SUNDEFINED
8818 && elf_header.e_machine == EM_MIPS)
8819 return "SUND";
9ce701e2 8820 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 8821 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 8822 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 8823 sprintf (buff, "OS [0x%04x]", type & 0xffff);
8824 else if (type >= SHN_LORESERVE)
8825 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
252b5132 8826 else
232e7cb8 8827 sprintf (buff, "%3d", type);
5cf1065c 8828 break;
252b5132 8829 }
5cf1065c
NC		 8830
8831 return buff;
252b5132
RH		 8832}
8833
66543521 8834static bfd_vma *
2cf0635d 8835get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
252b5132 8836{
2cf0635d
NC		 8837 unsigned char * e_data;
8838 bfd_vma * i_data;
252b5132 8839
3f5e193b 8840 e_data = (unsigned char *) cmalloc (number, ent_size);
252b5132
RH		 8841
8842 if (e_data == NULL)
8843 {
8844 error (_("Out of memory\n"));
8845 return NULL;
8846 }
8847
66543521 8848 if (fread (e_data, ent_size, number, file) != number)
252b5132
RH		 8849 {
8850 error (_("Unable to read in dynamic data\n"));
8851 return NULL;
8852 }
8853
3f5e193b 8854 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
252b5132
RH		 8855
8856 if (i_data == NULL)
8857 {
8858 error (_("Out of memory\n"));
8859 free (e_data);
8860 return NULL;
8861 }
8862
8863 while (number--)
66543521 8864 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 8865
8866 free (e_data);
8867
8868 return i_data;
8869}
8870
6bd1a22c
L		 8871static void
8872print_dynamic_symbol (bfd_vma si, unsigned long hn)
8873{
2cf0635d 8874 Elf_Internal_Sym * psym;
6bd1a22c
L		 8875 int n;
8876
8877 psym = dynamic_symbols + si;
8878
8879 n = print_vma (si, DEC_5);
8880 if (n < 5)
8881 fputs (" " + n, stdout);
8882 printf (" %3lu: ", hn);
8883 print_vma (psym->st_value, LONG_HEX);
8884 putchar (' ');
8885 print_vma (psym->st_size, DEC_5);
8886
f4be36b3
AM		 8887 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
8888 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
8889 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 8890 /* Check to see if any other bits in the st_other field are set.
8891 Note - displaying this information disrupts the layout of the
8892 table being generated, but for the moment this case is very
8893 rare. */
8894 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
8895 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
8896 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
8897 if (VALID_DYNAMIC_NAME (psym->st_name))
8898 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
8899 else
2b692964 8900 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 8901 putchar ('\n');
8902}
8903
e3c8793a 8904/* Dump the symbol table. */
252b5132 8905static int
2cf0635d 8906process_symbol_table (FILE * file)
252b5132 8907{
2cf0635d 8908 Elf_Internal_Shdr * section;
66543521
AM		 8909 bfd_vma nbuckets = 0;
8910 bfd_vma nchains = 0;
2cf0635d
NC		 8911 bfd_vma * buckets = NULL;
8912 bfd_vma * chains = NULL;
fdc90cb4 8913 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 8914 bfd_vma * gnubuckets = NULL;
8915 bfd_vma * gnuchains = NULL;
6bd1a22c 8916 bfd_vma gnusymidx = 0;
252b5132 8917
2c610e4b 8918 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 8919 return 1;
8920
6bd1a22c
L		 8921 if (dynamic_info[DT_HASH]
8922 && (do_histogram
2c610e4b
L		 8923 || (do_using_dynamic
8924 && !do_dyn_syms
8925 && dynamic_strings != NULL)))
252b5132 8926 {
66543521
AM		 8927 unsigned char nb[8];
8928 unsigned char nc[8];
8929 int hash_ent_size = 4;
8930
8931 if ((elf_header.e_machine == EM_ALPHA
8932 || elf_header.e_machine == EM_S390
8933 || elf_header.e_machine == EM_S390_OLD)
8934 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
8935 hash_ent_size = 8;
8936
fb52b2f4
NC		 8937 if (fseek (file,
8938 (archive_file_offset
8939 + offset_from_vma (file, dynamic_info[DT_HASH],
8940 sizeof nb + sizeof nc)),
d93f0186 8941 SEEK_SET))
252b5132 8942 {
591a748a 8943 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 8944 goto no_hash;
252b5132
RH		 8945 }
8946
66543521 8947 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 8948 {
8949 error (_("Failed to read in number of buckets\n"));
d3a44ec6 8950 goto no_hash;
252b5132
RH		 8951 }
8952
66543521 8953 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 8954 {
8955 error (_("Failed to read in number of chains\n"));
d3a44ec6 8956 goto no_hash;
252b5132
RH		 8957 }
8958
66543521
AM		 8959 nbuckets = byte_get (nb, hash_ent_size);
8960 nchains = byte_get (nc, hash_ent_size);
252b5132 8961
66543521
AM		 8962 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
8963 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 8964
d3a44ec6 8965 no_hash:
252b5132 8966 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 8967 {
8968 if (do_using_dynamic)
8969 return 0;
8970 free (buckets);
8971 free (chains);
8972 buckets = NULL;
8973 chains = NULL;
8974 nbuckets = 0;
8975 nchains = 0;
8976 }
252b5132
RH		 8977 }
8978
6bd1a22c
L		 8979 if (dynamic_info_DT_GNU_HASH
8980 && (do_histogram
2c610e4b
L		 8981 || (do_using_dynamic
8982 && !do_dyn_syms
8983 && dynamic_strings != NULL)))
252b5132 8984 {
6bd1a22c
L		 8985 unsigned char nb[16];
8986 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
8987 bfd_vma buckets_vma;
8988
8989 if (fseek (file,
8990 (archive_file_offset
8991 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
8992 sizeof nb)),
8993 SEEK_SET))
8994 {
8995 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 8996 goto no_gnu_hash;
6bd1a22c 8997 }
252b5132 8998
6bd1a22c
L		 8999 if (fread (nb, 16, 1, file) != 1)
9000 {
9001 error (_("Failed to read in number of buckets\n"));
d3a44ec6 9002 goto no_gnu_hash;
6bd1a22c
L		 9003 }
9004
9005 ngnubuckets = byte_get (nb, 4);
9006 gnusymidx = byte_get (nb + 4, 4);
9007 bitmaskwords = byte_get (nb + 8, 4);
9008 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 9009 if (is_32bit_elf)
6bd1a22c 9010 buckets_vma += bitmaskwords * 4;
f7a99963 9011 else
6bd1a22c 9012 buckets_vma += bitmaskwords * 8;
252b5132 9013
6bd1a22c
L		 9014 if (fseek (file,
9015 (archive_file_offset
9016 + offset_from_vma (file, buckets_vma, 4)),
9017 SEEK_SET))
252b5132 9018 {
6bd1a22c 9019 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9020 goto no_gnu_hash;
6bd1a22c
L		 9021 }
9022
9023 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 9024
6bd1a22c 9025 if (gnubuckets == NULL)
d3a44ec6 9026 goto no_gnu_hash;
6bd1a22c
L		 9027
9028 for (i = 0; i < ngnubuckets; i++)
9029 if (gnubuckets[i] != 0)
9030 {
9031 if (gnubuckets[i] < gnusymidx)
9032 return 0;
9033
9034 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9035 maxchain = gnubuckets[i];
9036 }
9037
9038 if (maxchain == 0xffffffff)
d3a44ec6 9039 goto no_gnu_hash;
6bd1a22c
L		 9040
9041 maxchain -= gnusymidx;
9042
9043 if (fseek (file,
9044 (archive_file_offset
9045 + offset_from_vma (file, buckets_vma
9046 + 4 * (ngnubuckets + maxchain), 4)),
9047 SEEK_SET))
9048 {
9049 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9050 goto no_gnu_hash;
6bd1a22c
L		 9051 }
9052
9053 do
9054 {
9055 if (fread (nb, 4, 1, file) != 1)
252b5132 9056 {
6bd1a22c 9057 error (_("Failed to determine last chain length\n"));
d3a44ec6 9058 goto no_gnu_hash;
6bd1a22c 9059 }
252b5132 9060
6bd1a22c 9061 if (maxchain + 1 == 0)
d3a44ec6 9062 goto no_gnu_hash;
252b5132 9063
6bd1a22c
L		 9064 ++maxchain;
9065 }
9066 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 9067
6bd1a22c
L		 9068 if (fseek (file,
9069 (archive_file_offset
9070 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9071 SEEK_SET))
9072 {
9073 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9074 goto no_gnu_hash;
6bd1a22c
L		 9075 }
9076
9077 gnuchains = get_dynamic_data (file, maxchain, 4);
9078
d3a44ec6 9079 no_gnu_hash:
6bd1a22c 9080 if (gnuchains == NULL)
d3a44ec6
JJ		 9081 {
9082 free (gnubuckets);
d3a44ec6
JJ		 9083 gnubuckets = NULL;
9084 ngnubuckets = 0;
f64fddf1
NC		 9085 if (do_using_dynamic)
9086 return 0;
d3a44ec6 9087 }
6bd1a22c
L		 9088 }
9089
9090 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9091 && do_syms
9092 && do_using_dynamic
9093 && dynamic_strings != NULL)
9094 {
9095 unsigned long hn;
9096
9097 if (dynamic_info[DT_HASH])
9098 {
9099 bfd_vma si;
9100
9101 printf (_("\nSymbol table for image:\n"));
9102 if (is_32bit_elf)
9103 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9104 else
9105 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9106
9107 for (hn = 0; hn < nbuckets; hn++)
9108 {
9109 if (! buckets[hn])
9110 continue;
9111
9112 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9113 print_dynamic_symbol (si, hn);
252b5132
RH		 9114 }
9115 }
6bd1a22c
L		 9116
9117 if (dynamic_info_DT_GNU_HASH)
9118 {
9119 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9120 if (is_32bit_elf)
9121 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9122 else
9123 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9124
9125 for (hn = 0; hn < ngnubuckets; ++hn)
9126 if (gnubuckets[hn] != 0)
9127 {
9128 bfd_vma si = gnubuckets[hn];
9129 bfd_vma off = si - gnusymidx;
9130
9131 do
9132 {
9133 print_dynamic_symbol (si, hn);
9134 si++;
9135 }
9136 while ((gnuchains[off++] & 1) == 0);
9137 }
9138 }
252b5132 9139 }
2c610e4b 9140 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
252b5132 9141 {
b34976b6 9142 unsigned int i;
252b5132
RH		 9143
9144 for (i = 0, section = section_headers;
9145 i < elf_header.e_shnum;
9146 i++, section++)
9147 {
b34976b6 9148 unsigned int si;
2cf0635d 9149 char * strtab = NULL;
c256ffe7 9150 unsigned long int strtab_size = 0;
2cf0635d
NC		 9151 Elf_Internal_Sym * symtab;
9152 Elf_Internal_Sym * psym;
252b5132 9153
2c610e4b
L		 9154 if ((section->sh_type != SHT_SYMTAB
9155 && section->sh_type != SHT_DYNSYM)
9156 || (!do_syms
9157 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 9158 continue;
9159
dd24e3da
NC		 9160 if (section->sh_entsize == 0)
9161 {
9162 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9163 SECTION_NAME (section));
9164 continue;
9165 }
9166
252b5132
RH		 9167 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9168 SECTION_NAME (section),
9169 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 9170
f7a99963 9171 if (is_32bit_elf)
ca47b30c 9172 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 9173 else
ca47b30c 9174 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 9175
9ad5cbcf 9176 symtab = GET_ELF_SYMBOLS (file, section);
252b5132
RH		 9177 if (symtab == NULL)
9178 continue;
9179
9180 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 9181 {
9182 strtab = string_table;
9183 strtab_size = string_table_length;
9184 }
4fbb74a6 9185 else if (section->sh_link < elf_header.e_shnum)
252b5132 9186 {
2cf0635d 9187 Elf_Internal_Shdr * string_sec;
252b5132 9188
4fbb74a6 9189 string_sec = section_headers + section->sh_link;
252b5132 9190
3f5e193b
NC		 9191 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9192 1, string_sec->sh_size,
9193 _("string table"));
c256ffe7 9194 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 9195 }
9196
9197 for (si = 0, psym = symtab;
9198 si < section->sh_size / section->sh_entsize;
b34976b6 9199 si++, psym++)
252b5132 9200 {
5e220199 9201 printf ("%6d: ", si);
f7a99963
NC		 9202 print_vma (psym->st_value, LONG_HEX);
9203 putchar (' ');
9204 print_vma (psym->st_size, DEC_5);
d1133906
NC		 9205 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9206 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 9207 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 9208 /* Check to see if any other bits in the st_other field are set.
9209 Note - displaying this information disrupts the layout of the
9210 table being generated, but for the moment this case is very rare. */
9211 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9212 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 9213 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 9214 print_symbol (25, psym->st_name < strtab_size
2b692964 9215 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 9216
59245841
NC		 9217 if (section->sh_type == SHT_DYNSYM
9218 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
252b5132 9219 {
b34976b6
AM		 9220 unsigned char data[2];
9221 unsigned short vers_data;
9222 unsigned long offset;
9223 int is_nobits;
9224 int check_def;
252b5132 9225
d93f0186
NC		 9226 offset = offset_from_vma
9227 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9228 sizeof data + si * sizeof (vers_data));
252b5132 9229
59245841
NC		 9230 if (get_data (&data, file, offset + si * sizeof (vers_data),
9231 sizeof (data), 1, _("version data")) == NULL)
9232 break;
252b5132
RH		 9233
9234 vers_data = byte_get (data, 2);
9235
4fbb74a6
AM		 9236 is_nobits = (psym->st_shndx < elf_header.e_shnum
9237 && section_headers[psym->st_shndx].sh_type
c256ffe7 9238 == SHT_NOBITS);
252b5132
RH		 9239
9240 check_def = (psym->st_shndx != SHN_UNDEF);
9241
c244d050 9242 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
252b5132 9243 {
b34976b6 9244 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
00d93f34 9245 && (is_nobits || ! check_def))
252b5132 9246 {
b34976b6
AM		 9247 Elf_External_Verneed evn;
9248 Elf_Internal_Verneed ivn;
9249 Elf_Internal_Vernaux ivna;
252b5132
RH		 9250
9251 /* We must test both. */
d93f0186
NC		 9252 offset = offset_from_vma
9253 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9254 sizeof evn);
252b5132 9255
252b5132
RH		 9256 do
9257 {
b34976b6 9258 unsigned long vna_off;
252b5132 9259
59245841
NC		 9260 if (get_data (&evn, file, offset, sizeof (evn), 1,
9261 _("version need")) == NULL)
9262 {
9263 ivna.vna_next = 0;
9264 ivna.vna_other = 0;
9265 ivna.vna_name = 0;
9266 break;
9267 }
dd27201e
L		 9268
9269 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9270 ivn.vn_next = BYTE_GET (evn.vn_next);
9271
252b5132
RH		 9272 vna_off = offset + ivn.vn_aux;
9273
9274 do
9275 {
b34976b6 9276 Elf_External_Vernaux evna;
252b5132 9277
59245841
NC		 9278 if (get_data (&evna, file, vna_off,
9279 sizeof (evna), 1,
9280 _("version need aux (3)")) == NULL)
9281 {
9282 ivna.vna_next = 0;
9283 ivna.vna_other = 0;
9284 ivna.vna_name = 0;
9285 }
9286 else
9287 {
9288 ivna.vna_other = BYTE_GET (evna.vna_other);
9289 ivna.vna_next = BYTE_GET (evna.vna_next);
9290 ivna.vna_name = BYTE_GET (evna.vna_name);
9291 }
252b5132
RH		 9292
9293 vna_off += ivna.vna_next;
9294 }
9295 while (ivna.vna_other != vers_data
9296 && ivna.vna_next != 0);
9297
9298 if (ivna.vna_other == vers_data)
9299 break;
9300
9301 offset += ivn.vn_next;
9302 }
9303 while (ivn.vn_next != 0);
9304
9305 if (ivna.vna_other == vers_data)
9306 {
9307 printf ("@%s (%d)",
c256ffe7 9308 ivna.vna_name < strtab_size
2b692964 9309 ? strtab + ivna.vna_name : _("<corrupt>"),
c256ffe7 9310 ivna.vna_other);
252b5132
RH		 9311 check_def = 0;
9312 }
9313 else if (! is_nobits)
591a748a 9314 error (_("bad dynamic symbol\n"));
252b5132
RH		 9315 else
9316 check_def = 1;
9317 }
9318
9319 if (check_def)
9320 {
00d93f34 9321 if (vers_data != 0x8001
b34976b6 9322 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9323 {
b34976b6
AM		 9324 Elf_Internal_Verdef ivd;
9325 Elf_Internal_Verdaux ivda;
9326 Elf_External_Verdaux evda;
91d6fa6a 9327 unsigned long off;
252b5132 9328
91d6fa6a 9329 off = offset_from_vma
d93f0186
NC		 9330 (file,
9331 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9332 sizeof (Elf_External_Verdef));
252b5132
RH		 9333
9334 do
9335 {
b34976b6 9336 Elf_External_Verdef evd;
252b5132 9337
59245841
NC		 9338 if (get_data (&evd, file, off, sizeof (evd),
9339 1, _("version def")) == NULL)
9340 {
9341 ivd.vd_ndx = 0;
9342 ivd.vd_aux = 0;
9343 ivd.vd_next = 0;
9344 }
9345 else
9346 {
9347 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9348 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9349 ivd.vd_next = BYTE_GET (evd.vd_next);
9350 }
252b5132 9351
91d6fa6a 9352 off += ivd.vd_next;
252b5132 9353 }
c244d050 9354 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
252b5132
RH		 9355 && ivd.vd_next != 0);
9356
91d6fa6a
NC		 9357 off -= ivd.vd_next;
9358 off += ivd.vd_aux;
252b5132 9359
59245841
NC		 9360 if (get_data (&evda, file, off, sizeof (evda),
9361 1, _("version def aux")) == NULL)
9362 break;
252b5132
RH		 9363
9364 ivda.vda_name = BYTE_GET (evda.vda_name);
9365
9366 if (psym->st_name != ivda.vda_name)
c244d050 9367 printf ((vers_data & VERSYM_HIDDEN)
252b5132 9368 ? "@%s" : "@@%s",
c256ffe7 9369 ivda.vda_name < strtab_size
2b692964 9370 ? strtab + ivda.vda_name : _("<corrupt>"));
252b5132
RH		 9371 }
9372 }
9373 }
9374 }
9375
9376 putchar ('\n');
9377 }
9378
9379 free (symtab);
9380 if (strtab != string_table)
9381 free (strtab);
9382 }
9383 }
9384 else if (do_syms)
9385 printf
9386 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9387
9388 if (do_histogram && buckets != NULL)
9389 {
2cf0635d
NC		 9390 unsigned long * lengths;
9391 unsigned long * counts;
66543521
AM		 9392 unsigned long hn;
9393 bfd_vma si;
9394 unsigned long maxlength = 0;
9395 unsigned long nzero_counts = 0;
9396 unsigned long nsyms = 0;
252b5132 9397
66543521
AM		 9398 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9399 (unsigned long) nbuckets);
252b5132
RH		 9400 printf (_(" Length Number %% of total Coverage\n"));
9401
3f5e193b 9402 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 9403 if (lengths == NULL)
9404 {
591a748a 9405 error (_("Out of memory\n"));
252b5132
RH		 9406 return 0;
9407 }
9408 for (hn = 0; hn < nbuckets; ++hn)
9409 {
f7a99963 9410 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
252b5132 9411 {
b34976b6 9412 ++nsyms;
252b5132 9413 if (maxlength < ++lengths[hn])
b34976b6 9414 ++maxlength;
252b5132
RH		 9415 }
9416 }
9417
3f5e193b 9418 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 9419 if (counts == NULL)
9420 {
591a748a 9421 error (_("Out of memory\n"));
252b5132
RH		 9422 return 0;
9423 }
9424
9425 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 9426 ++counts[lengths[hn]];
252b5132 9427
103f02d3 9428 if (nbuckets > 0)
252b5132 9429 {
66543521
AM		 9430 unsigned long i;
9431 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 9432 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 9433 for (i = 1; i <= maxlength; ++i)
103f02d3 9434 {
66543521
AM		 9435 nzero_counts += counts[i] * i;
9436 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9437 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 9438 (nzero_counts * 100.0) / nsyms);
9439 }
252b5132
RH		 9440 }
9441
9442 free (counts);
9443 free (lengths);
9444 }
9445
9446 if (buckets != NULL)
9447 {
9448 free (buckets);
9449 free (chains);
9450 }
9451
d3a44ec6 9452 if (do_histogram && gnubuckets != NULL)
fdc90cb4 9453 {
2cf0635d
NC		 9454 unsigned long * lengths;
9455 unsigned long * counts;
fdc90cb4
JJ		 9456 unsigned long hn;
9457 unsigned long maxlength = 0;
9458 unsigned long nzero_counts = 0;
9459 unsigned long nsyms = 0;
fdc90cb4 9460
3f5e193b 9461 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 9462 if (lengths == NULL)
9463 {
591a748a 9464 error (_("Out of memory\n"));
fdc90cb4
JJ		 9465 return 0;
9466 }
9467
9468 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9469 (unsigned long) ngnubuckets);
9470 printf (_(" Length Number %% of total Coverage\n"));
9471
9472 for (hn = 0; hn < ngnubuckets; ++hn)
9473 if (gnubuckets[hn] != 0)
9474 {
9475 bfd_vma off, length = 1;
9476
6bd1a22c 9477 for (off = gnubuckets[hn] - gnusymidx;
fdc90cb4
JJ		 9478 (gnuchains[off] & 1) == 0; ++off)
9479 ++length;
9480 lengths[hn] = length;
9481 if (length > maxlength)
9482 maxlength = length;
9483 nsyms += length;
9484 }
9485
3f5e193b 9486 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 9487 if (counts == NULL)
9488 {
591a748a 9489 error (_("Out of memory\n"));
fdc90cb4
JJ		 9490 return 0;
9491 }
9492
9493 for (hn = 0; hn < ngnubuckets; ++hn)
9494 ++counts[lengths[hn]];
9495
9496 if (ngnubuckets > 0)
9497 {
9498 unsigned long j;
9499 printf (" 0 %-10lu (%5.1f%%)\n",
9500 counts[0], (counts[0] * 100.0) / ngnubuckets);
9501 for (j = 1; j <= maxlength; ++j)
9502 {
9503 nzero_counts += counts[j] * j;
9504 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9505 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9506 (nzero_counts * 100.0) / nsyms);
9507 }
9508 }
9509
9510 free (counts);
9511 free (lengths);
9512 free (gnubuckets);
9513 free (gnuchains);
9514 }
9515
252b5132
RH		 9516 return 1;
9517}
9518
9519static int
2cf0635d 9520process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 9521{
b4c96d0d 9522 unsigned int i;
252b5132
RH		 9523
9524 if (dynamic_syminfo == NULL
9525 || !do_dynamic)
9526 /* No syminfo, this is ok. */
9527 return 1;
9528
9529 /* There better should be a dynamic symbol section. */
9530 if (dynamic_symbols == NULL || dynamic_strings == NULL)
9531 return 0;
9532
9533 if (dynamic_addr)
9534 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9535 dynamic_syminfo_offset, dynamic_syminfo_nent);
9536
9537 printf (_(" Num: Name BoundTo Flags\n"));
9538 for (i = 0; i < dynamic_syminfo_nent; ++i)
9539 {
9540 unsigned short int flags = dynamic_syminfo[i].si_flags;
9541
31104126 9542 printf ("%4d: ", i);
d79b3d50
NC		 9543 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9544 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9545 else
2b692964 9546 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 9547 putchar (' ');
252b5132
RH		 9548
9549 switch (dynamic_syminfo[i].si_boundto)
9550 {
9551 case SYMINFO_BT_SELF:
9552 fputs ("SELF ", stdout);
9553 break;
9554 case SYMINFO_BT_PARENT:
9555 fputs ("PARENT ", stdout);
9556 break;
9557 default:
9558 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 9559 && dynamic_syminfo[i].si_boundto < dynamic_nent
9560 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 9561 {
d79b3d50 9562 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 9563 putchar (' ' );
9564 }
252b5132
RH		 9565 else
9566 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
9567 break;
9568 }
9569
9570 if (flags & SYMINFO_FLG_DIRECT)
9571 printf (" DIRECT");
9572 if (flags & SYMINFO_FLG_PASSTHRU)
9573 printf (" PASSTHRU");
9574 if (flags & SYMINFO_FLG_COPY)
9575 printf (" COPY");
9576 if (flags & SYMINFO_FLG_LAZYLOAD)
9577 printf (" LAZYLOAD");
9578
9579 puts ("");
9580 }
9581
9582 return 1;
9583}
9584
cf13d699
NC		 9585/* Check to see if the given reloc needs to be handled in a target specific
9586 manner. If so then process the reloc and return TRUE otherwise return
9587 FALSE. */
09c11c86 9588
cf13d699
NC		 9589static bfd_boolean
9590target_specific_reloc_handling (Elf_Internal_Rela * reloc,
9591 unsigned char * start,
9592 Elf_Internal_Sym * symtab)
252b5132 9593{
cf13d699 9594 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 9595
cf13d699 9596 switch (elf_header.e_machine)
252b5132 9597 {
cf13d699
NC		 9598 case EM_MN10300:
9599 case EM_CYGNUS_MN10300:
9600 {
9601 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 9602
cf13d699
NC		 9603 switch (reloc_type)
9604 {
9605 case 34: /* R_MN10300_ALIGN */
9606 return TRUE;
9607 case 33: /* R_MN10300_SYM_DIFF */
9608 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
9609 return TRUE;
9610 case 1: /* R_MN10300_32 */
9611 case 2: /* R_MN10300_16 */
9612 if (saved_sym != NULL)
9613 {
9614 bfd_vma value;
252b5132 9615
cf13d699
NC		 9616 value = reloc->r_addend
9617 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
9618 - saved_sym->st_value);
252b5132 9619
cf13d699 9620 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 9621
cf13d699
NC		 9622 saved_sym = NULL;
9623 return TRUE;
9624 }
9625 break;
9626 default:
9627 if (saved_sym != NULL)
9628 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9629 break;
9630 }
9631 break;
9632 }
252b5132
RH		 9633 }
9634
cf13d699 9635 return FALSE;
252b5132
RH		 9636}
9637
aca88567
NC		 9638/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9639 DWARF debug sections. This is a target specific test. Note - we do not
9640 go through the whole including-target-headers-multiple-times route, (as
9641 we have already done with <elf/h8.h>) because this would become very
9642 messy and even then this function would have to contain target specific
9643 information (the names of the relocs instead of their numeric values).
9644 FIXME: This is not the correct way to solve this problem. The proper way
9645 is to have target specific reloc sizing and typing functions created by
9646 the reloc-macros.h header, in the same way that it already creates the
9647 reloc naming functions. */
9648
9649static bfd_boolean
9650is_32bit_abs_reloc (unsigned int reloc_type)
9651{
9652 switch (elf_header.e_machine)
9653 {
41e92641
NC		 9654 case EM_386:
9655 case EM_486:
9656 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 9657 case EM_68K:
9658 return reloc_type == 1; /* R_68K_32. */
9659 case EM_860:
9660 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 9661 case EM_960:
9662 return reloc_type == 2; /* R_960_32. */
aca88567 9663 case EM_ALPHA:
137b6b5f 9664 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 9665 case EM_ARC:
9666 return reloc_type == 1; /* R_ARC_32. */
9667 case EM_ARM:
9668 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 9669 case EM_AVR_OLD:
aca88567
NC		 9670 case EM_AVR:
9671 return reloc_type == 1;
9672 case EM_BLACKFIN:
9673 return reloc_type == 0x12; /* R_byte4_data. */
9674 case EM_CRIS:
9675 return reloc_type == 3; /* R_CRIS_32. */
9676 case EM_CR16:
6c03b1ed 9677 case EM_CR16_OLD:
aca88567
NC		 9678 return reloc_type == 3; /* R_CR16_NUM32. */
9679 case EM_CRX:
9680 return reloc_type == 15; /* R_CRX_NUM32. */
9681 case EM_CYGNUS_FRV:
9682 return reloc_type == 1;
41e92641
NC		 9683 case EM_CYGNUS_D10V:
9684 case EM_D10V:
9685 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 9686 case EM_CYGNUS_D30V:
9687 case EM_D30V:
9688 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 9689 case EM_DLX:
9690 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 9691 case EM_CYGNUS_FR30:
9692 case EM_FR30:
9693 return reloc_type == 3; /* R_FR30_32. */
9694 case EM_H8S:
9695 case EM_H8_300:
9696 case EM_H8_300H:
9697 return reloc_type == 1; /* R_H8_DIR32. */
3730236a
NC		 9698 case EM_IA_64:
9699 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
aca88567
NC		 9700 case EM_IP2K_OLD:
9701 case EM_IP2K:
9702 return reloc_type == 2; /* R_IP2K_32. */
9703 case EM_IQ2000:
9704 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 9705 case EM_LATTICEMICO32:
9706 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 9707 case EM_M32C_OLD:
aca88567
NC		 9708 case EM_M32C:
9709 return reloc_type == 3; /* R_M32C_32. */
9710 case EM_M32R:
9711 return reloc_type == 34; /* R_M32R_32_RELA. */
9712 case EM_MCORE:
9713 return reloc_type == 1; /* R_MCORE_ADDR32. */
9714 case EM_CYGNUS_MEP:
9715 return reloc_type == 4; /* R_MEP_32. */
137b6b5f
AM		 9716 case EM_MICROBLAZE:
9717 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 9718 case EM_MIPS:
9719 return reloc_type == 2; /* R_MIPS_32. */
9720 case EM_MMIX:
9721 return reloc_type == 4; /* R_MMIX_32. */
9722 case EM_CYGNUS_MN10200:
9723 case EM_MN10200:
9724 return reloc_type == 1; /* R_MN10200_32. */
9725 case EM_CYGNUS_MN10300:
9726 case EM_MN10300:
9727 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 9728 case EM_MOXIE:
9729 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 9730 case EM_MSP430_OLD:
9731 case EM_MSP430:
9732 return reloc_type == 1; /* R_MSP43_32. */
9733 case EM_MT:
9734 return reloc_type == 2; /* R_MT_32. */
3e0873ac
NC		 9735 case EM_ALTERA_NIOS2:
9736 case EM_NIOS32:
9737 return reloc_type == 1; /* R_NIOS_32. */
41e92641
NC		 9738 case EM_OPENRISC:
9739 case EM_OR32:
9740 return reloc_type == 1; /* R_OR32_32. */
aca88567 9741 case EM_PARISC:
5fda8eca
NC		 9742 return (reloc_type == 1 /* R_PARISC_DIR32. */
9743 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 9744 case EM_PJ:
9745 case EM_PJ_OLD:
9746 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
9747 case EM_PPC64:
9748 return reloc_type == 1; /* R_PPC64_ADDR32. */
9749 case EM_PPC:
9750 return reloc_type == 1; /* R_PPC_ADDR32. */
c7927a3c
NC		 9751 case EM_RX:
9752 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 9753 case EM_S370:
9754 return reloc_type == 1; /* R_I370_ADDR31. */
9755 case EM_S390_OLD:
9756 case EM_S390:
9757 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 9758 case EM_SCORE:
9759 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 9760 case EM_SH:
9761 return reloc_type == 1; /* R_SH_DIR32. */
9762 case EM_SPARC32PLUS:
9763 case EM_SPARCV9:
9764 case EM_SPARC:
9765 return reloc_type == 3 /* R_SPARC_32. */
9766 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 9767 case EM_SPU:
9768 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 9769 case EM_TI_C6000:
9770 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 9771 case EM_TILEGX:
9772 return reloc_type == 2; /* R_TILEGX_32. */
9773 case EM_TILEPRO:
9774 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 9775 case EM_CYGNUS_V850:
9776 case EM_V850:
9777 return reloc_type == 6; /* R_V850_ABS32. */
9778 case EM_VAX:
9779 return reloc_type == 1; /* R_VAX_32. */
9780 case EM_X86_64:
8a9036a4 9781 case EM_L1OM:
7a9068fe 9782 case EM_K1OM:
aca88567 9783 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 9784 case EM_XC16X:
9785 case EM_C166:
9786 return reloc_type == 3; /* R_XC16C_ABS_32. */
aca88567
NC		 9787 case EM_XSTORMY16:
9788 return reloc_type == 1; /* R_XSTROMY16_32. */
9789 case EM_XTENSA_OLD:
9790 case EM_XTENSA:
9791 return reloc_type == 1; /* R_XTENSA_32. */
aca88567
NC		 9792 default:
9793 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
9794 elf_header.e_machine);
9795 abort ();
9796 }
9797}
9798
9799/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9800 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
9801
9802static bfd_boolean
9803is_32bit_pcrel_reloc (unsigned int reloc_type)
9804{
9805 switch (elf_header.e_machine)
9806 {
41e92641
NC		 9807 case EM_386:
9808 case EM_486:
3e0873ac 9809 return reloc_type == 2; /* R_386_PC32. */
aca88567 9810 case EM_68K:
3e0873ac 9811 return reloc_type == 4; /* R_68K_PC32. */
aca88567
NC		 9812 case EM_ALPHA:
9813 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 9814 case EM_ARM:
3e0873ac 9815 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 9816 case EM_MICROBLAZE:
9817 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
aca88567 9818 case EM_PARISC:
85acf597 9819 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 9820 case EM_PPC:
9821 return reloc_type == 26; /* R_PPC_REL32. */
9822 case EM_PPC64:
3e0873ac 9823 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 9824 case EM_S390_OLD:
9825 case EM_S390:
3e0873ac 9826 return reloc_type == 5; /* R_390_PC32. */
aca88567 9827 case EM_SH:
3e0873ac 9828 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 9829 case EM_SPARC32PLUS:
9830 case EM_SPARCV9:
9831 case EM_SPARC:
3e0873ac 9832 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 9833 case EM_SPU:
9834 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 9835 case EM_TILEGX:
9836 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
9837 case EM_TILEPRO:
9838 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
aca88567 9839 case EM_X86_64:
8a9036a4 9840 case EM_L1OM:
7a9068fe 9841 case EM_K1OM:
3e0873ac 9842 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 9843 case EM_XTENSA_OLD:
9844 case EM_XTENSA:
9845 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 9846 default:
9847 /* Do not abort or issue an error message here. Not all targets use
9848 pc-relative 32-bit relocs in their DWARF debug information and we
9849 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 9850 more helpful warning message will be generated by apply_relocations
9851 anyway, so just return. */
aca88567
NC		 9852 return FALSE;
9853 }
9854}
9855
9856/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9857 a 64-bit absolute RELA relocation used in DWARF debug sections. */
9858
9859static bfd_boolean
9860is_64bit_abs_reloc (unsigned int reloc_type)
9861{
9862 switch (elf_header.e_machine)
9863 {
9864 case EM_ALPHA:
9865 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 9866 case EM_IA_64:
9867 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 9868 case EM_PARISC:
9869 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 9870 case EM_PPC64:
9871 return reloc_type == 38; /* R_PPC64_ADDR64. */
9872 case EM_SPARC32PLUS:
9873 case EM_SPARCV9:
9874 case EM_SPARC:
9875 return reloc_type == 54; /* R_SPARC_UA64. */
9876 case EM_X86_64:
8a9036a4 9877 case EM_L1OM:
7a9068fe 9878 case EM_K1OM:
aca88567 9879 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 9880 case EM_S390_OLD:
9881 case EM_S390:
aa137e4d
NC		 9882 return reloc_type == 22; /* R_S390_64. */
9883 case EM_TILEGX:
9884 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 9885 case EM_MIPS:
aa137e4d 9886 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 9887 default:
9888 return FALSE;
9889 }
9890}
9891
85acf597
RH		 9892/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
9893 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
9894
9895static bfd_boolean
9896is_64bit_pcrel_reloc (unsigned int reloc_type)
9897{
9898 switch (elf_header.e_machine)
9899 {
9900 case EM_ALPHA:
aa137e4d 9901 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 9902 case EM_IA_64:
aa137e4d 9903 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 9904 case EM_PARISC:
aa137e4d 9905 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 9906 case EM_PPC64:
aa137e4d 9907 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 9908 case EM_SPARC32PLUS:
9909 case EM_SPARCV9:
9910 case EM_SPARC:
aa137e4d 9911 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 9912 case EM_X86_64:
8a9036a4 9913 case EM_L1OM:
7a9068fe 9914 case EM_K1OM:
aa137e4d 9915 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 9916 case EM_S390_OLD:
9917 case EM_S390:
aa137e4d
NC		 9918 return reloc_type == 23; /* R_S390_PC64. */
9919 case EM_TILEGX:
9920 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 9921 default:
9922 return FALSE;
9923 }
9924}
9925
4dc3c23d
AM		 9926/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9927 a 24-bit absolute RELA relocation used in DWARF debug sections. */
9928
9929static bfd_boolean
9930is_24bit_abs_reloc (unsigned int reloc_type)
9931{
9932 switch (elf_header.e_machine)
9933 {
9934 case EM_CYGNUS_MN10200:
9935 case EM_MN10200:
9936 return reloc_type == 4; /* R_MN10200_24. */
9937 default:
9938 return FALSE;
9939 }
9940}
9941
aca88567
NC		 9942/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9943 a 16-bit absolute RELA relocation used in DWARF debug sections. */
9944
9945static bfd_boolean
9946is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 9947{
9948 switch (elf_header.e_machine)
9949 {
aca88567
NC		 9950 case EM_AVR_OLD:
9951 case EM_AVR:
9952 return reloc_type == 4; /* R_AVR_16. */
41e92641
NC		 9953 case EM_CYGNUS_D10V:
9954 case EM_D10V:
9955 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 9956 case EM_H8S:
9957 case EM_H8_300:
9958 case EM_H8_300H:
aca88567
NC		 9959 return reloc_type == R_H8_DIR16;
9960 case EM_IP2K_OLD:
9961 case EM_IP2K:
9962 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 9963 case EM_M32C_OLD:
f4236fe4
DD		 9964 case EM_M32C:
9965 return reloc_type == 1; /* R_M32C_16 */
aca88567
NC		 9966 case EM_MSP430_OLD:
9967 case EM_MSP430:
9968 return reloc_type == 5; /* R_MSP430_16_BYTE. */
3e0873ac
NC		 9969 case EM_ALTERA_NIOS2:
9970 case EM_NIOS32:
9971 return reloc_type == 9; /* R_NIOS_16. */
40b36596
JM		 9972 case EM_TI_C6000:
9973 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 9974 case EM_XC16X:
9975 case EM_C166:
9976 return reloc_type == 2; /* R_XC16C_ABS_16. */
4b78141a 9977 default:
aca88567 9978 return FALSE;
4b78141a
NC		 9979 }
9980}
9981
2a7b2e88
JK		 9982/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
9983 relocation entries (possibly formerly used for SHT_GROUP sections). */
9984
9985static bfd_boolean
9986is_none_reloc (unsigned int reloc_type)
9987{
9988 switch (elf_header.e_machine)
9989 {
cb8f3167
NC		 9990 case EM_68K: /* R_68K_NONE. */
9991 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 9992 case EM_SPARC32PLUS:
9993 case EM_SPARCV9:
cb8f3167
NC		 9994 case EM_SPARC: /* R_SPARC_NONE. */
9995 case EM_MIPS: /* R_MIPS_NONE. */
9996 case EM_PARISC: /* R_PARISC_NONE. */
9997 case EM_ALPHA: /* R_ALPHA_NONE. */
9998 case EM_PPC: /* R_PPC_NONE. */
9999 case EM_PPC64: /* R_PPC64_NONE. */
10000 case EM_ARM: /* R_ARM_NONE. */
10001 case EM_IA_64: /* R_IA64_NONE. */
10002 case EM_SH: /* R_SH_NONE. */
2a7b2e88 10003 case EM_S390_OLD:
cb8f3167
NC		 10004 case EM_S390: /* R_390_NONE. */
10005 case EM_CRIS: /* R_CRIS_NONE. */
10006 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 10007 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 10008 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 10009 case EM_MN10300: /* R_MN10300_NONE. */
5506d11a 10010 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 10011 case EM_M32R: /* R_M32R_NONE. */
40b36596 10012 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 10013 case EM_TILEGX: /* R_TILEGX_NONE. */
10014 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 10015 case EM_XC16X:
10016 case EM_C166: /* R_XC16X_NONE. */
cb8f3167 10017 return reloc_type == 0;
58332dda
JK		 10018 case EM_XTENSA_OLD:
10019 case EM_XTENSA:
4dc3c23d
AM		 10020 return (reloc_type == 0 /* R_XTENSA_NONE. */
10021 || reloc_type == 17 /* R_XTENSA_DIFF8. */
10022 || reloc_type == 18 /* R_XTENSA_DIFF16. */
10023 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
2a7b2e88
JK		 10024 }
10025 return FALSE;
10026}
10027
cf13d699
NC		 10028/* Apply relocations to a section.
10029 Note: So far support has been added only for those relocations
10030 which can be found in debug sections.
10031 FIXME: Add support for more relocations ? */
1b315056 10032
cf13d699
NC		 10033static void
10034apply_relocations (void * file,
10035 Elf_Internal_Shdr * section,
10036 unsigned char * start)
1b315056 10037{
cf13d699
NC		 10038 Elf_Internal_Shdr * relsec;
10039 unsigned char * end = start + section->sh_size;
cb8f3167 10040
cf13d699
NC		 10041 if (elf_header.e_type != ET_REL)
10042 return;
1b315056 10043
cf13d699 10044 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 10045 for (relsec = section_headers;
10046 relsec < section_headers + elf_header.e_shnum;
10047 ++relsec)
252b5132 10048 {
41e92641
NC		 10049 bfd_boolean is_rela;
10050 unsigned long num_relocs;
2cf0635d
NC		 10051 Elf_Internal_Rela * relocs;
10052 Elf_Internal_Rela * rp;
10053 Elf_Internal_Shdr * symsec;
10054 Elf_Internal_Sym * symtab;
10055 Elf_Internal_Sym * sym;
252b5132 10056
41e92641 10057 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 10058 || relsec->sh_info >= elf_header.e_shnum
10059 || section_headers + relsec->sh_info != section
c256ffe7 10060 || relsec->sh_size == 0
4fbb74a6 10061 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 10062 continue;
428409d5 10063
41e92641
NC		 10064 is_rela = relsec->sh_type == SHT_RELA;
10065
10066 if (is_rela)
10067 {
3f5e193b
NC		 10068 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10069 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10070 return;
10071 }
10072 else
10073 {
3f5e193b
NC		 10074 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10075 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10076 return;
10077 }
10078
10079 /* SH uses RELA but uses in place value instead of the addend field. */
10080 if (elf_header.e_machine == EM_SH)
10081 is_rela = FALSE;
428409d5 10082
4fbb74a6 10083 symsec = section_headers + relsec->sh_link;
3f5e193b 10084 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec);
103f02d3 10085
41e92641 10086 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 10087 {
41e92641
NC		 10088 bfd_vma addend;
10089 unsigned int reloc_type;
10090 unsigned int reloc_size;
91d6fa6a 10091 unsigned char * rloc;
4b78141a 10092
aca88567 10093 reloc_type = get_reloc_type (rp->r_info);
41e92641 10094
98fb390a 10095 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 10096 continue;
98fb390a
NC		 10097 else if (is_none_reloc (reloc_type))
10098 continue;
10099 else if (is_32bit_abs_reloc (reloc_type)
10100 || is_32bit_pcrel_reloc (reloc_type))
aca88567 10101 reloc_size = 4;
85acf597
RH		 10102 else if (is_64bit_abs_reloc (reloc_type)
10103 || is_64bit_pcrel_reloc (reloc_type))
aca88567 10104 reloc_size = 8;
4dc3c23d
AM		 10105 else if (is_24bit_abs_reloc (reloc_type))
10106 reloc_size = 3;
aca88567
NC		 10107 else if (is_16bit_abs_reloc (reloc_type))
10108 reloc_size = 2;
10109 else
4b78141a 10110 {
41e92641 10111 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
aca88567 10112 reloc_type, SECTION_NAME (section));
4b78141a
NC		 10113 continue;
10114 }
103f02d3 10115
91d6fa6a
NC		 10116 rloc = start + rp->r_offset;
10117 if ((rloc + reloc_size) > end)
700dd8b7
L		 10118 {
10119 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10120 (unsigned long) rp->r_offset,
10121 SECTION_NAME (section));
10122 continue;
10123 }
103f02d3 10124
41e92641
NC		 10125 sym = symtab + get_reloc_symindex (rp->r_info);
10126
10127 /* If the reloc has a symbol associated with it,
55f25fc3
L		 10128 make sure that it is of an appropriate type.
10129
10130 Relocations against symbols without type can happen.
10131 Gcc -feliminate-dwarf2-dups may generate symbols
10132 without type for debug info.
10133
10134 Icc generates relocations against function symbols
10135 instead of local labels.
10136
10137 Relocations against object symbols can happen, eg when
10138 referencing a global array. For an example of this see
10139 the _clz.o binary in libgcc.a. */
aca88567 10140 if (sym != symtab
55f25fc3 10141 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 10142 {
41e92641 10143 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 10144 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 10145 (long int)(rp - relocs),
41e92641 10146 SECTION_NAME (relsec));
aca88567 10147 continue;
5b18a4bc 10148 }
252b5132 10149
4dc3c23d
AM		 10150 addend = 0;
10151 if (is_rela)
10152 addend += rp->r_addend;
c47320c3
AM		 10153 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10154 partial_inplace. */
4dc3c23d
AM		 10155 if (!is_rela
10156 || (elf_header.e_machine == EM_XTENSA
10157 && reloc_type == 1)
10158 || ((elf_header.e_machine == EM_PJ
10159 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 10160 && reloc_type == 1)
10161 || ((elf_header.e_machine == EM_D30V
10162 || elf_header.e_machine == EM_CYGNUS_D30V)
10163 && reloc_type == 12))
91d6fa6a 10164 addend += byte_get (rloc, reloc_size);
cb8f3167 10165
85acf597
RH		 10166 if (is_32bit_pcrel_reloc (reloc_type)
10167 || is_64bit_pcrel_reloc (reloc_type))
10168 {
10169 /* On HPPA, all pc-relative relocations are biased by 8. */
10170 if (elf_header.e_machine == EM_PARISC)
10171 addend -= 8;
91d6fa6a 10172 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 10173 reloc_size);
10174 }
41e92641 10175 else
91d6fa6a 10176 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 10177 }
252b5132 10178
5b18a4bc 10179 free (symtab);
41e92641 10180 free (relocs);
5b18a4bc
NC		 10181 break;
10182 }
5b18a4bc 10183}
103f02d3 10184
cf13d699
NC		 10185#ifdef SUPPORT_DISASSEMBLY
10186static int
10187disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10188{
10189 printf (_("\nAssembly dump of section %s\n"),
10190 SECTION_NAME (section));
10191
10192 /* XXX -- to be done --- XXX */
10193
10194 return 1;
10195}
10196#endif
10197
10198/* Reads in the contents of SECTION from FILE, returning a pointer
10199 to a malloc'ed buffer or NULL if something went wrong. */
10200
10201static char *
10202get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10203{
10204 bfd_size_type num_bytes;
10205
10206 num_bytes = section->sh_size;
10207
10208 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
10209 {
10210 printf (_("\nSection '%s' has no data to dump.\n"),
10211 SECTION_NAME (section));
10212 return NULL;
10213 }
10214
3f5e193b
NC		 10215 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
10216 _("section contents"));
cf13d699
NC		 10217}
10218
dd24e3da 10219
cf13d699
NC		 10220static void
10221dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
10222{
10223 Elf_Internal_Shdr * relsec;
10224 bfd_size_type num_bytes;
cf13d699
NC		 10225 char * data;
10226 char * end;
10227 char * start;
10228 char * name = SECTION_NAME (section);
10229 bfd_boolean some_strings_shown;
10230
10231 start = get_section_contents (section, file);
10232 if (start == NULL)
10233 return;
10234
10235 printf (_("\nString dump of section '%s':\n"), name);
10236
10237 /* If the section being dumped has relocations against it the user might
10238 be expecting these relocations to have been applied. Check for this
10239 case and issue a warning message in order to avoid confusion.
10240 FIXME: Maybe we ought to have an option that dumps a section with
10241 relocs applied ? */
10242 for (relsec = section_headers;
10243 relsec < section_headers + elf_header.e_shnum;
10244 ++relsec)
10245 {
10246 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10247 || relsec->sh_info >= elf_header.e_shnum
10248 || section_headers + relsec->sh_info != section
10249 || relsec->sh_size == 0
10250 || relsec->sh_link >= elf_header.e_shnum)
10251 continue;
10252
10253 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10254 break;
10255 }
10256
10257 num_bytes = section->sh_size;
cf13d699
NC		 10258 data = start;
10259 end = start + num_bytes;
10260 some_strings_shown = FALSE;
10261
10262 while (data < end)
10263 {
10264 while (!ISPRINT (* data))
10265 if (++ data >= end)
10266 break;
10267
10268 if (data < end)
10269 {
10270#ifndef __MSVCRT__
c975cc98
NC		 10271 /* PR 11128: Use two separate invocations in order to work
10272 around bugs in the Solaris 8 implementation of printf. */
10273 printf (" [%6tx] ", data - start);
10274 printf ("%s\n", data);
cf13d699
NC		 10275#else
10276 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
10277#endif
10278 data += strlen (data);
10279 some_strings_shown = TRUE;
10280 }
10281 }
10282
10283 if (! some_strings_shown)
10284 printf (_(" No strings found in this section."));
10285
10286 free (start);
10287
10288 putchar ('\n');
10289}
10290
10291static void
10292dump_section_as_bytes (Elf_Internal_Shdr * section,
10293 FILE * file,
10294 bfd_boolean relocate)
10295{
10296 Elf_Internal_Shdr * relsec;
10297 bfd_size_type bytes;
10298 bfd_vma addr;
10299 unsigned char * data;
10300 unsigned char * start;
10301
10302 start = (unsigned char *) get_section_contents (section, file);
10303 if (start == NULL)
10304 return;
10305
10306 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
10307
10308 if (relocate)
10309 {
10310 apply_relocations (file, section, start);
10311 }
10312 else
10313 {
10314 /* If the section being dumped has relocations against it the user might
10315 be expecting these relocations to have been applied. Check for this
10316 case and issue a warning message in order to avoid confusion.
10317 FIXME: Maybe we ought to have an option that dumps a section with
10318 relocs applied ? */
10319 for (relsec = section_headers;
10320 relsec < section_headers + elf_header.e_shnum;
10321 ++relsec)
10322 {
10323 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10324 || relsec->sh_info >= elf_header.e_shnum
10325 || section_headers + relsec->sh_info != section
10326 || relsec->sh_size == 0
10327 || relsec->sh_link >= elf_header.e_shnum)
10328 continue;
10329
10330 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10331 break;
10332 }
10333 }
10334
10335 addr = section->sh_addr;
10336 bytes = section->sh_size;
10337 data = start;
10338
10339 while (bytes)
10340 {
10341 int j;
10342 int k;
10343 int lbytes;
10344
10345 lbytes = (bytes > 16 ? 16 : bytes);
10346
10347 printf (" 0x%8.8lx ", (unsigned long) addr);
10348
10349 for (j = 0; j < 16; j++)
10350 {
10351 if (j < lbytes)
10352 printf ("%2.2x", data[j]);
10353 else
10354 printf (" ");
10355
10356 if ((j & 3) == 3)
10357 printf (" ");
10358 }
10359
10360 for (j = 0; j < lbytes; j++)
10361 {
10362 k = data[j];
10363 if (k >= ' ' && k < 0x7f)
10364 printf ("%c", k);
10365 else
10366 printf (".");
10367 }
10368
10369 putchar ('\n');
10370
10371 data += lbytes;
10372 addr += lbytes;
10373 bytes -= lbytes;
10374 }
10375
10376 free (start);
10377
10378 putchar ('\n');
10379}
10380
4a114e3e 10381/* Uncompresses a section that was compressed using zlib, in place. */
cf13d699
NC		 10382
10383static int
d3dbc530
AM		 10384uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10385 dwarf_size_type *size ATTRIBUTE_UNUSED)
cf13d699
NC		 10386{
10387#ifndef HAVE_ZLIB_H
cf13d699
NC		 10388 return FALSE;
10389#else
10390 dwarf_size_type compressed_size = *size;
10391 unsigned char * compressed_buffer = *buffer;
10392 dwarf_size_type uncompressed_size;
10393 unsigned char * uncompressed_buffer;
10394 z_stream strm;
10395 int rc;
10396 dwarf_size_type header_size = 12;
10397
10398 /* Read the zlib header. In this case, it should be "ZLIB" followed
10399 by the uncompressed section size, 8 bytes in big-endian order. */
10400 if (compressed_size < header_size
10401 || ! streq ((char *) compressed_buffer, "ZLIB"))
10402 return 0;
10403
10404 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10405 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10406 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10407 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10408 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10409 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10410 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10411 uncompressed_size += compressed_buffer[11];
10412
10413 /* It is possible the section consists of several compressed
10414 buffers concatenated together, so we uncompress in a loop. */
10415 strm.zalloc = NULL;
10416 strm.zfree = NULL;
10417 strm.opaque = NULL;
10418 strm.avail_in = compressed_size - header_size;
10419 strm.next_in = (Bytef *) compressed_buffer + header_size;
10420 strm.avail_out = uncompressed_size;
3f5e193b 10421 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
cf13d699
NC		 10422
10423 rc = inflateInit (& strm);
10424 while (strm.avail_in > 0)
10425 {
10426 if (rc != Z_OK)
10427 goto fail;
10428 strm.next_out = ((Bytef *) uncompressed_buffer
10429 + (uncompressed_size - strm.avail_out));
10430 rc = inflate (&strm, Z_FINISH);
10431 if (rc != Z_STREAM_END)
10432 goto fail;
10433 rc = inflateReset (& strm);
10434 }
10435 rc = inflateEnd (& strm);
10436 if (rc != Z_OK
10437 || strm.avail_out != 0)
10438 goto fail;
10439
10440 free (compressed_buffer);
10441 *buffer = uncompressed_buffer;
10442 *size = uncompressed_size;
10443 return 1;
10444
10445 fail:
10446 free (uncompressed_buffer);
4a114e3e
L		 10447 /* Indicate decompression failure. */
10448 *buffer = NULL;
cf13d699
NC		 10449 return 0;
10450#endif /* HAVE_ZLIB_H */
10451}
10452
d966045b
DJ		 10453static int
10454load_specific_debug_section (enum dwarf_section_display_enum debug,
2cf0635d 10455 Elf_Internal_Shdr * sec, void * file)
1007acb3 10456{
2cf0635d 10457 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 10458 char buf [64];
1007acb3 10459
19e6b90e
L		 10460 /* If it is already loaded, do nothing. */
10461 if (section->start != NULL)
10462 return 1;
1007acb3 10463
19e6b90e
L		 10464 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
10465 section->address = sec->sh_addr;
3f5e193b
NC		 10466 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
10467 sec->sh_offset, 1,
10468 sec->sh_size, buf);
59245841
NC		 10469 if (section->start == NULL)
10470 section->size = 0;
10471 else
10472 {
10473 section->size = sec->sh_size;
10474 if (uncompress_section_contents (&section->start, &section->size))
10475 sec->sh_size = section->size;
10476 }
4a114e3e 10477
1b315056
CS		 10478 if (section->start == NULL)
10479 return 0;
10480
19e6b90e 10481 if (debug_displays [debug].relocate)
3f5e193b 10482 apply_relocations ((FILE *) file, sec, section->start);
1007acb3 10483
1b315056 10484 return 1;
1007acb3
L		 10485}
10486
d966045b 10487int
2cf0635d 10488load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 10489{
2cf0635d
NC		 10490 struct dwarf_section * section = &debug_displays [debug].section;
10491 Elf_Internal_Shdr * sec;
d966045b
DJ		 10492
10493 /* Locate the debug section. */
10494 sec = find_section (section->uncompressed_name);
10495 if (sec != NULL)
10496 section->name = section->uncompressed_name;
10497 else
10498 {
10499 sec = find_section (section->compressed_name);
10500 if (sec != NULL)
10501 section->name = section->compressed_name;
10502 }
10503 if (sec == NULL)
10504 return 0;
10505
3f5e193b 10506 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 10507}
10508
19e6b90e
L		 10509void
10510free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 10511{
2cf0635d 10512 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 10513
19e6b90e
L		 10514 if (section->start == NULL)
10515 return;
1007acb3 10516
19e6b90e
L		 10517 free ((char *) section->start);
10518 section->start = NULL;
10519 section->address = 0;
10520 section->size = 0;
1007acb3
L		 10521}
10522
1007acb3 10523static int
2cf0635d 10524display_debug_section (Elf_Internal_Shdr * section, FILE * file)
1007acb3 10525{
2cf0635d 10526 char * name = SECTION_NAME (section);
19e6b90e
L		 10527 bfd_size_type length;
10528 int result = 1;
3f5e193b 10529 int i;
1007acb3 10530
19e6b90e
L		 10531 length = section->sh_size;
10532 if (length == 0)
1007acb3 10533 {
19e6b90e
L		 10534 printf (_("\nSection '%s' has no debugging data.\n"), name);
10535 return 0;
1007acb3 10536 }
5dff79d8
NC		 10537 if (section->sh_type == SHT_NOBITS)
10538 {
10539 /* There is no point in dumping the contents of a debugging section
10540 which has the NOBITS type - the bits in the file will be random.
10541 This can happen when a file containing a .eh_frame section is
10542 stripped with the --only-keep-debug command line option. */
10543 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
10544 return 0;
10545 }
1007acb3 10546
0112cd26 10547 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 10548 name = ".debug_info";
1007acb3 10549
19e6b90e
L		 10550 /* See if we know how to display the contents of this section. */
10551 for (i = 0; i < max; i++)
1b315056
CS		 10552 if (streq (debug_displays[i].section.uncompressed_name, name)
10553 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 10554 {
2cf0635d 10555 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 10556 int secondary = (section != find_section (name));
10557
10558 if (secondary)
3f5e193b 10559 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 10560
2b6f5997 10561 if (streq (sec->uncompressed_name, name))
d966045b
DJ		 10562 sec->name = sec->uncompressed_name;
10563 else
10564 sec->name = sec->compressed_name;
3f5e193b
NC		 10565 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
10566 section, file))
19e6b90e
L		 10567 {
10568 result &= debug_displays[i].display (sec, file);
1007acb3 10569
d966045b 10570 if (secondary || (i != info && i != abbrev))
3f5e193b 10571 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 10572 }
1007acb3 10573
19e6b90e
L		 10574 break;
10575 }
1007acb3 10576
19e6b90e 10577 if (i == max)
1007acb3 10578 {
19e6b90e
L		 10579 printf (_("Unrecognized debug section: %s\n"), name);
10580 result = 0;
1007acb3
L		 10581 }
10582
19e6b90e 10583 return result;
5b18a4bc 10584}
103f02d3 10585
aef1f6d0
DJ		 10586/* Set DUMP_SECTS for all sections where dumps were requested
10587 based on section name. */
10588
10589static void
10590initialise_dumps_byname (void)
10591{
2cf0635d 10592 struct dump_list_entry * cur;
aef1f6d0
DJ		 10593
10594 for (cur = dump_sects_byname; cur; cur = cur->next)
10595 {
10596 unsigned int i;
10597 int any;
10598
10599 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
10600 if (streq (SECTION_NAME (section_headers + i), cur->name))
10601 {
09c11c86 10602 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 10603 any = 1;
10604 }
10605
10606 if (!any)
10607 warn (_("Section '%s' was not dumped because it does not exist!\n"),
10608 cur->name);
10609 }
10610}
10611
5b18a4bc 10612static void
2cf0635d 10613process_section_contents (FILE * file)
5b18a4bc 10614{
2cf0635d 10615 Elf_Internal_Shdr * section;
19e6b90e 10616 unsigned int i;
103f02d3 10617
19e6b90e
L		 10618 if (! do_dump)
10619 return;
103f02d3 10620
aef1f6d0
DJ		 10621 initialise_dumps_byname ();
10622
19e6b90e
L		 10623 for (i = 0, section = section_headers;
10624 i < elf_header.e_shnum && i < num_dump_sects;
10625 i++, section++)
10626 {
10627#ifdef SUPPORT_DISASSEMBLY
10628 if (dump_sects[i] & DISASS_DUMP)
10629 disassemble_section (section, file);
10630#endif
10631 if (dump_sects[i] & HEX_DUMP)
cf13d699 10632 dump_section_as_bytes (section, file, FALSE);
103f02d3 10633
cf13d699
NC		 10634 if (dump_sects[i] & RELOC_DUMP)
10635 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 10636
10637 if (dump_sects[i] & STRING_DUMP)
10638 dump_section_as_strings (section, file);
cf13d699
NC		 10639
10640 if (dump_sects[i] & DEBUG_DUMP)
10641 display_debug_section (section, file);
5b18a4bc 10642 }
103f02d3 10643
19e6b90e
L		 10644 /* Check to see if the user requested a
10645 dump of a section that does not exist. */
10646 while (i++ < num_dump_sects)
10647 if (dump_sects[i])
10648 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 10649}
103f02d3 10650
5b18a4bc 10651static void
19e6b90e 10652process_mips_fpe_exception (int mask)
5b18a4bc 10653{
19e6b90e
L		 10654 if (mask)
10655 {
10656 int first = 1;
10657 if (mask & OEX_FPU_INEX)
10658 fputs ("INEX", stdout), first = 0;
10659 if (mask & OEX_FPU_UFLO)
10660 printf ("%sUFLO", first ? "" : "|"), first = 0;
10661 if (mask & OEX_FPU_OFLO)
10662 printf ("%sOFLO", first ? "" : "|"), first = 0;
10663 if (mask & OEX_FPU_DIV0)
10664 printf ("%sDIV0", first ? "" : "|"), first = 0;
10665 if (mask & OEX_FPU_INVAL)
10666 printf ("%sINVAL", first ? "" : "|");
10667 }
5b18a4bc 10668 else
19e6b90e 10669 fputs ("0", stdout);
5b18a4bc 10670}
103f02d3 10671
11c1ff18
PB		 10672/* ARM EABI attributes section. */
10673typedef struct
10674{
10675 int tag;
2cf0635d 10676 const char * name;
11c1ff18
PB		 10677 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
10678 int type;
2cf0635d 10679 const char ** table;
11c1ff18
PB		 10680} arm_attr_public_tag;
10681
2cf0635d 10682static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 10683 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
9e3c6df6 10684 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
2cf0635d
NC		 10685static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
10686static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 10687 {"No", "Thumb-1", "Thumb-2"};
75375b3e 10688static const char * arm_attr_tag_FP_arch[] =
62f3b8c8 10689 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
2cf0635d 10690static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 10691static const char * arm_attr_tag_Advanced_SIMD_arch[] =
cd21e546 10692 {"No", "NEONv1", "NEONv1 with Fused-MAC"};
2cf0635d 10693static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 10694 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
10695 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 10696static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 10697 {"V6", "SB", "TLS", "Unused"};
2cf0635d 10698static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 10699 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 10700static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 10701 {"Absolute", "PC-relative", "None"};
2cf0635d 10702static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 10703 {"None", "direct", "GOT-indirect"};
2cf0635d 10704static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 10705 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 10706static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
10707static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 10708 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 10709static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
10710static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
10711static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 10712 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 10713static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 10714 {"Unused", "small", "int", "forced to int"};
2cf0635d 10715static const char * arm_attr_tag_ABI_HardFP_use[] =
75375b3e 10716 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
2cf0635d 10717static const char * arm_attr_tag_ABI_VFP_args[] =
11c1ff18 10718 {"AAPCS", "VFP registers", "custom"};
2cf0635d 10719static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 10720 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 10721static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 10722 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10723 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 10724static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 10725 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10726 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 10727static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 10728static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 10729 {"Not Allowed", "Allowed"};
2cf0635d 10730static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 10731 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 10732static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 10733 {"Not Allowed", "Allowed"};
10734static const char * arm_attr_tag_DIV_use[] =
dd24e3da 10735 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 10736 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 10737static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
10738static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 10739 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 10740 "TrustZone and Virtualization Extensions"};
dd24e3da 10741static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 10742 {"Not Allowed", "Allowed"};
11c1ff18
PB		 10743
10744#define LOOKUP(id, name) \
10745 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 10746static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 10747{
10748 {4, "CPU_raw_name", 1, NULL},
10749 {5, "CPU_name", 1, NULL},
10750 LOOKUP(6, CPU_arch),
10751 {7, "CPU_arch_profile", 0, NULL},
10752 LOOKUP(8, ARM_ISA_use),
10753 LOOKUP(9, THUMB_ISA_use),
75375b3e 10754 LOOKUP(10, FP_arch),
11c1ff18 10755 LOOKUP(11, WMMX_arch),
f5f53991
AS		 10756 LOOKUP(12, Advanced_SIMD_arch),
10757 LOOKUP(13, PCS_config),
11c1ff18
PB		 10758 LOOKUP(14, ABI_PCS_R9_use),
10759 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 10760 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 10761 LOOKUP(17, ABI_PCS_GOT_use),
10762 LOOKUP(18, ABI_PCS_wchar_t),
10763 LOOKUP(19, ABI_FP_rounding),
10764 LOOKUP(20, ABI_FP_denormal),
10765 LOOKUP(21, ABI_FP_exceptions),
10766 LOOKUP(22, ABI_FP_user_exceptions),
10767 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 10768 {24, "ABI_align_needed", 0, NULL},
10769 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 10770 LOOKUP(26, ABI_enum_size),
10771 LOOKUP(27, ABI_HardFP_use),
10772 LOOKUP(28, ABI_VFP_args),
10773 LOOKUP(29, ABI_WMMX_args),
10774 LOOKUP(30, ABI_optimization_goals),
10775 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 10776 {32, "compatibility", 0, NULL},
f5f53991 10777 LOOKUP(34, CPU_unaligned_access),
75375b3e 10778 LOOKUP(36, FP_HP_extension),
8e79c3df 10779 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 10780 LOOKUP(42, MPextension_use),
10781 LOOKUP(44, DIV_use),
f5f53991
AS		 10782 {64, "nodefaults", 0, NULL},
10783 {65, "also_compatible_with", 0, NULL},
10784 LOOKUP(66, T2EE_use),
10785 {67, "conformance", 1, NULL},
10786 LOOKUP(68, Virtualization_use),
cd21e546 10787 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 10788};
10789#undef LOOKUP
10790
11c1ff18 10791static unsigned char *
2cf0635d 10792display_arm_attribute (unsigned char * p)
11c1ff18
PB		 10793{
10794 int tag;
10795 unsigned int len;
10796 int val;
2cf0635d 10797 arm_attr_public_tag * attr;
11c1ff18
PB		 10798 unsigned i;
10799 int type;
10800
10801 tag = read_uleb128 (p, &len);
10802 p += len;
10803 attr = NULL;
2cf0635d 10804 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 10805 {
10806 if (arm_attr_public_tags[i].tag == tag)
10807 {
10808 attr = &arm_attr_public_tags[i];
10809 break;
10810 }
10811 }
10812
10813 if (attr)
10814 {
10815 printf (" Tag_%s: ", attr->name);
10816 switch (attr->type)
10817 {
10818 case 0:
10819 switch (tag)
10820 {
10821 case 7: /* Tag_CPU_arch_profile. */
10822 val = read_uleb128 (p, &len);
10823 p += len;
10824 switch (val)
10825 {
2b692964
NC		 10826 case 0: printf (_("None\n")); break;
10827 case 'A': printf (_("Application\n")); break;
10828 case 'R': printf (_("Realtime\n")); break;
10829 case 'M': printf (_("Microcontroller\n")); break;
10830 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 10831 default: printf ("??? (%d)\n", val); break;
10832 }
10833 break;
10834
75375b3e
MGD		 10835 case 24: /* Tag_align_needed. */
10836 val = read_uleb128 (p, &len);
10837 p += len;
10838 switch (val)
10839 {
2b692964
NC		 10840 case 0: printf (_("None\n")); break;
10841 case 1: printf (_("8-byte\n")); break;
10842 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 10843 case 3: printf ("??? 3\n"); break;
10844 default:
10845 if (val <= 12)
dd24e3da 10846 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 10847 1 << val);
10848 else
10849 printf ("??? (%d)\n", val);
10850 break;
10851 }
10852 break;
10853
10854 case 25: /* Tag_align_preserved. */
10855 val = read_uleb128 (p, &len);
10856 p += len;
10857 switch (val)
10858 {
2b692964
NC		 10859 case 0: printf (_("None\n")); break;
10860 case 1: printf (_("8-byte, except leaf SP\n")); break;
10861 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 10862 case 3: printf ("??? 3\n"); break;
10863 default:
10864 if (val <= 12)
dd24e3da 10865 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 10866 1 << val);
10867 else
10868 printf ("??? (%d)\n", val);
10869 break;
10870 }
10871 break;
10872
11c1ff18
PB		 10873 case 32: /* Tag_compatibility. */
10874 val = read_uleb128 (p, &len);
10875 p += len;
2b692964 10876 printf (_("flag = %d, vendor = %s\n"), val, p);
2cf0635d 10877 p += strlen ((char *) p) + 1;
11c1ff18
PB		 10878 break;
10879
f5f53991
AS		 10880 case 64: /* Tag_nodefaults. */
10881 p++;
2b692964 10882 printf (_("True\n"));
f5f53991
AS		 10883 break;
10884
10885 case 65: /* Tag_also_compatible_with. */
10886 val = read_uleb128 (p, &len);
10887 p += len;
10888 if (val == 6 /* Tag_CPU_arch. */)
10889 {
10890 val = read_uleb128 (p, &len);
10891 p += len;
2cf0635d 10892 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 10893 printf ("??? (%d)\n", val);
10894 else
10895 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
10896 }
10897 else
10898 printf ("???\n");
10899 while (*(p++) != '\0' /* NUL terminator. */);
10900 break;
10901
11c1ff18 10902 default:
2cf0635d 10903 abort ();
11c1ff18
PB		 10904 }
10905 return p;
10906
10907 case 1:
10908 case 2:
10909 type = attr->type;
10910 break;
10911
10912 default:
10913 assert (attr->type & 0x80);
10914 val = read_uleb128 (p, &len);
10915 p += len;
10916 type = attr->type & 0x7f;
10917 if (val >= type)
10918 printf ("??? (%d)\n", val);
10919 else
10920 printf ("%s\n", attr->table[val]);
10921 return p;
10922 }
10923 }
10924 else
10925 {
10926 if (tag & 1)
10927 type = 1; /* String. */
10928 else
10929 type = 2; /* uleb128. */
10930 printf (" Tag_unknown_%d: ", tag);
10931 }
10932
10933 if (type == 1)
10934 {
10935 printf ("\"%s\"\n", p);
2cf0635d 10936 p += strlen ((char *) p) + 1;
11c1ff18
PB		 10937 }
10938 else
10939 {
10940 val = read_uleb128 (p, &len);
10941 p += len;
10942 printf ("%d (0x%x)\n", val, val);
10943 }
10944
10945 return p;
10946}
10947
104d59d1 10948static unsigned char *
60bca95a
NC		 10949display_gnu_attribute (unsigned char * p,
10950 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
104d59d1
JM		 10951{
10952 int tag;
10953 unsigned int len;
10954 int val;
10955 int type;
10956
10957 tag = read_uleb128 (p, &len);
10958 p += len;
10959
10960 /* Tag_compatibility is the only generic GNU attribute defined at
10961 present. */
10962 if (tag == 32)
10963 {
10964 val = read_uleb128 (p, &len);
10965 p += len;
2b692964 10966 printf (_("flag = %d, vendor = %s\n"), val, p);
60bca95a 10967 p += strlen ((char *) p) + 1;
104d59d1
JM		 10968 return p;
10969 }
10970
10971 if ((tag & 2) == 0 && display_proc_gnu_attribute)
10972 return display_proc_gnu_attribute (p, tag);
10973
10974 if (tag & 1)
10975 type = 1; /* String. */
10976 else
10977 type = 2; /* uleb128. */
10978 printf (" Tag_unknown_%d: ", tag);
10979
10980 if (type == 1)
10981 {
10982 printf ("\"%s\"\n", p);
60bca95a 10983 p += strlen ((char *) p) + 1;
104d59d1
JM		 10984 }
10985 else
10986 {
10987 val = read_uleb128 (p, &len);
10988 p += len;
10989 printf ("%d (0x%x)\n", val, val);
10990 }
10991
10992 return p;
10993}
10994
34c8bcba 10995static unsigned char *
2cf0635d 10996display_power_gnu_attribute (unsigned char * p, int tag)
34c8bcba
JM		 10997{
10998 int type;
10999 unsigned int len;
11000 int val;
11001
11002 if (tag == Tag_GNU_Power_ABI_FP)
11003 {
11004 val = read_uleb128 (p, &len);
11005 p += len;
11006 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 11007
34c8bcba
JM		 11008 switch (val)
11009 {
11010 case 0:
2b692964 11011 printf (_("Hard or soft float\n"));
34c8bcba
JM		 11012 break;
11013 case 1:
2b692964 11014 printf (_("Hard float\n"));
34c8bcba
JM		 11015 break;
11016 case 2:
2b692964 11017 printf (_("Soft float\n"));
34c8bcba 11018 break;
3c7b9897 11019 case 3:
2b692964 11020 printf (_("Single-precision hard float\n"));
3c7b9897 11021 break;
34c8bcba
JM		 11022 default:
11023 printf ("??? (%d)\n", val);
11024 break;
11025 }
11026 return p;
11027 }
11028
c6e65352
DJ		 11029 if (tag == Tag_GNU_Power_ABI_Vector)
11030 {
11031 val = read_uleb128 (p, &len);
11032 p += len;
11033 printf (" Tag_GNU_Power_ABI_Vector: ");
11034 switch (val)
11035 {
11036 case 0:
2b692964 11037 printf (_("Any\n"));
c6e65352
DJ		 11038 break;
11039 case 1:
2b692964 11040 printf (_("Generic\n"));
c6e65352
DJ		 11041 break;
11042 case 2:
11043 printf ("AltiVec\n");
11044 break;
11045 case 3:
11046 printf ("SPE\n");
11047 break;
11048 default:
11049 printf ("??? (%d)\n", val);
11050 break;
11051 }
11052 return p;
11053 }
11054
f82e0623
NF		 11055 if (tag == Tag_GNU_Power_ABI_Struct_Return)
11056 {
11057 val = read_uleb128 (p, &len);
11058 p += len;
11059 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11060 switch (val)
11061 {
11062 case 0:
2b692964 11063 printf (_("Any\n"));
f82e0623
NF		 11064 break;
11065 case 1:
11066 printf ("r3/r4\n");
11067 break;
11068 case 2:
2b692964 11069 printf (_("Memory\n"));
f82e0623
NF		 11070 break;
11071 default:
11072 printf ("??? (%d)\n", val);
11073 break;
11074 }
11075 return p;
11076 }
11077
34c8bcba
JM		 11078 if (tag & 1)
11079 type = 1; /* String. */
11080 else
11081 type = 2; /* uleb128. */
11082 printf (" Tag_unknown_%d: ", tag);
11083
11084 if (type == 1)
11085 {
11086 printf ("\"%s\"\n", p);
60bca95a 11087 p += strlen ((char *) p) + 1;
34c8bcba
JM		 11088 }
11089 else
11090 {
11091 val = read_uleb128 (p, &len);
11092 p += len;
11093 printf ("%d (0x%x)\n", val, val);
11094 }
11095
11096 return p;
11097}
11098
9e8c70f9
DM		 11099static void
11100display_sparc_hwcaps (int mask)
11101{
11102 if (mask)
11103 {
11104 int first = 1;
11105 if (mask & ELF_SPARC_HWCAP_MUL32)
11106 fputs ("mul32", stdout), first = 0;
11107 if (mask & ELF_SPARC_HWCAP_DIV32)
11108 printf ("%sdiv32", first ? "" : "|"), first = 0;
11109 if (mask & ELF_SPARC_HWCAP_FSMULD)
11110 printf ("%sfsmuld", first ? "" : "|"), first = 0;
11111 if (mask & ELF_SPARC_HWCAP_V8PLUS)
11112 printf ("%sv8plus", first ? "" : "|"), first = 0;
11113 if (mask & ELF_SPARC_HWCAP_POPC)
11114 printf ("%spopc", first ? "" : "|"), first = 0;
11115 if (mask & ELF_SPARC_HWCAP_VIS)
11116 printf ("%svis", first ? "" : "|"), first = 0;
11117 if (mask & ELF_SPARC_HWCAP_VIS2)
11118 printf ("%svis2", first ? "" : "|"), first = 0;
11119 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
11120 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
11121 if (mask & ELF_SPARC_HWCAP_FMAF)
11122 printf ("%sfmaf", first ? "" : "|"), first = 0;
11123 if (mask & ELF_SPARC_HWCAP_VIS3)
11124 printf ("%svis3", first ? "" : "|"), first = 0;
11125 if (mask & ELF_SPARC_HWCAP_HPC)
11126 printf ("%shpc", first ? "" : "|"), first = 0;
11127 if (mask & ELF_SPARC_HWCAP_RANDOM)
11128 printf ("%srandom", first ? "" : "|"), first = 0;
11129 if (mask & ELF_SPARC_HWCAP_TRANS)
11130 printf ("%strans", first ? "" : "|"), first = 0;
11131 if (mask & ELF_SPARC_HWCAP_FJFMAU)
11132 printf ("%sfjfmau", first ? "" : "|"), first = 0;
11133 if (mask & ELF_SPARC_HWCAP_IMA)
11134 printf ("%sima", first ? "" : "|"), first = 0;
11135 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
11136 printf ("%scspare", first ? "" : "|"), first = 0;
11137 }
11138 else
11139 fputc('0', stdout);
11140 fputc('\n', stdout);
11141}
11142
11143static unsigned char *
11144display_sparc_gnu_attribute (unsigned char * p, int tag)
11145{
11146 int type;
11147 unsigned int len;
11148 int val;
11149
11150 if (tag == Tag_GNU_Sparc_HWCAPS)
11151 {
11152 val = read_uleb128 (p, &len);
11153 p += len;
11154 printf (" Tag_GNU_Sparc_HWCAPS: ");
11155
11156 display_sparc_hwcaps (val);
11157 return p;
11158 }
11159
11160 if (tag & 1)
11161 type = 1; /* String. */
11162 else
11163 type = 2; /* uleb128. */
11164 printf (" Tag_unknown_%d: ", tag);
11165
11166 if (type == 1)
11167 {
11168 printf ("\"%s\"\n", p);
11169 p += strlen ((char *) p) + 1;
11170 }
11171 else
11172 {
11173 val = read_uleb128 (p, &len);
11174 p += len;
11175 printf ("%d (0x%x)\n", val, val);
11176 }
11177
11178 return p;
11179}
11180
2cf19d5c 11181static unsigned char *
2cf0635d 11182display_mips_gnu_attribute (unsigned char * p, int tag)
2cf19d5c
JM		 11183{
11184 int type;
11185 unsigned int len;
11186 int val;
11187
11188 if (tag == Tag_GNU_MIPS_ABI_FP)
11189 {
11190 val = read_uleb128 (p, &len);
11191 p += len;
11192 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 11193
2cf19d5c
JM		 11194 switch (val)
11195 {
11196 case 0:
2b692964 11197 printf (_("Hard or soft float\n"));
2cf19d5c
JM		 11198 break;
11199 case 1:
2b692964 11200 printf (_("Hard float (double precision)\n"));
2cf19d5c
JM		 11201 break;
11202 case 2:
2b692964 11203 printf (_("Hard float (single precision)\n"));
2cf19d5c
JM		 11204 break;
11205 case 3:
2b692964 11206 printf (_("Soft float\n"));
2cf19d5c 11207 break;
42554f6a 11208 case 4:
9eeefea8 11209 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
42554f6a 11210 break;
2cf19d5c
JM		 11211 default:
11212 printf ("??? (%d)\n", val);
11213 break;
11214 }
11215 return p;
11216 }
11217
11218 if (tag & 1)
11219 type = 1; /* String. */
11220 else
11221 type = 2; /* uleb128. */
11222 printf (" Tag_unknown_%d: ", tag);
11223
11224 if (type == 1)
11225 {
11226 printf ("\"%s\"\n", p);
60bca95a 11227 p += strlen ((char *) p) + 1;
2cf19d5c
JM		 11228 }
11229 else
11230 {
11231 val = read_uleb128 (p, &len);
11232 p += len;
11233 printf ("%d (0x%x)\n", val, val);
11234 }
11235
11236 return p;
11237}
11238
59e6276b
JM		 11239static unsigned char *
11240display_tic6x_attribute (unsigned char * p)
11241{
11242 int tag;
11243 unsigned int len;
11244 int val;
11245
11246 tag = read_uleb128 (p, &len);
11247 p += len;
11248
11249 switch (tag)
11250 {
75fa6dc1 11251 case Tag_ISA:
59e6276b
JM		 11252 val = read_uleb128 (p, &len);
11253 p += len;
75fa6dc1 11254 printf (" Tag_ISA: ");
59e6276b
JM		 11255
11256 switch (val)
11257 {
75fa6dc1 11258 case C6XABI_Tag_ISA_none:
59e6276b
JM		 11259 printf (_("None\n"));
11260 break;
75fa6dc1 11261 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 11262 printf ("C62x\n");
11263 break;
75fa6dc1 11264 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 11265 printf ("C67x\n");
11266 break;
75fa6dc1 11267 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 11268 printf ("C67x+\n");
11269 break;
75fa6dc1 11270 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 11271 printf ("C64x\n");
11272 break;
75fa6dc1 11273 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 11274 printf ("C64x+\n");
11275 break;
75fa6dc1 11276 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 11277 printf ("C674x\n");
11278 break;
11279 default:
11280 printf ("??? (%d)\n", val);
11281 break;
11282 }
11283 return p;
11284
87779176
JM		 11285 case Tag_ABI_wchar_t:
11286 val = read_uleb128 (p, &len);
11287 p += len;
11288 printf (" Tag_ABI_wchar_t: ");
11289 switch (val)
11290 {
11291 case 0:
11292 printf (_("Not used\n"));
11293 break;
11294 case 1:
11295 printf (_("2 bytes\n"));
11296 break;
11297 case 2:
11298 printf (_("4 bytes\n"));
11299 break;
11300 default:
11301 printf ("??? (%d)\n", val);
11302 break;
11303 }
11304 return p;
11305
11306 case Tag_ABI_stack_align_needed:
11307 val = read_uleb128 (p, &len);
11308 p += len;
11309 printf (" Tag_ABI_stack_align_needed: ");
11310 switch (val)
11311 {
11312 case 0:
11313 printf (_("8-byte\n"));
11314 break;
11315 case 1:
11316 printf (_("16-byte\n"));
11317 break;
11318 default:
11319 printf ("??? (%d)\n", val);
11320 break;
11321 }
11322 return p;
11323
11324 case Tag_ABI_stack_align_preserved:
11325 val = read_uleb128 (p, &len);
11326 p += len;
11327 printf (" Tag_ABI_stack_align_preserved: ");
11328 switch (val)
11329 {
11330 case 0:
11331 printf (_("8-byte\n"));
11332 break;
11333 case 1:
11334 printf (_("16-byte\n"));
11335 break;
11336 default:
11337 printf ("??? (%d)\n", val);
11338 break;
11339 }
11340 return p;
11341
b5593623
JM		 11342 case Tag_ABI_DSBT:
11343 val = read_uleb128 (p, &len);
11344 p += len;
11345 printf (" Tag_ABI_DSBT: ");
11346 switch (val)
11347 {
11348 case 0:
11349 printf (_("DSBT addressing not used\n"));
11350 break;
11351 case 1:
11352 printf (_("DSBT addressing used\n"));
11353 break;
11354 default:
11355 printf ("??? (%d)\n", val);
11356 break;
11357 }
11358 return p;
11359
87779176
JM		 11360 case Tag_ABI_PID:
11361 val = read_uleb128 (p, &len);
11362 p += len;
11363 printf (" Tag_ABI_PID: ");
11364 switch (val)
11365 {
11366 case 0:
11367 printf (_("Data addressing position-dependent\n"));
11368 break;
11369 case 1:
11370 printf (_("Data addressing position-independent, GOT near DP\n"));
11371 break;
11372 case 2:
11373 printf (_("Data addressing position-independent, GOT far from DP\n"));
11374 break;
11375 default:
11376 printf ("??? (%d)\n", val);
11377 break;
11378 }
11379 return p;
11380
11381 case Tag_ABI_PIC:
11382 val = read_uleb128 (p, &len);
11383 p += len;
11384 printf (" Tag_ABI_PIC: ");
11385 switch (val)
11386 {
11387 case 0:
11388 printf (_("Code addressing position-dependent\n"));
11389 break;
11390 case 1:
11391 printf (_("Code addressing position-independent\n"));
11392 break;
11393 default:
11394 printf ("??? (%d)\n", val);
11395 break;
11396 }
11397 return p;
11398
11399 case Tag_ABI_array_object_alignment:
11400 val = read_uleb128 (p, &len);
11401 p += len;
11402 printf (" Tag_ABI_array_object_alignment: ");
11403 switch (val)
11404 {
11405 case 0:
11406 printf (_("8-byte\n"));
11407 break;
11408 case 1:
11409 printf (_("4-byte\n"));
11410 break;
11411 case 2:
11412 printf (_("16-byte\n"));
11413 break;
11414 default:
11415 printf ("??? (%d)\n", val);
11416 break;
11417 }
11418 return p;
11419
11420 case Tag_ABI_array_object_align_expected:
11421 val = read_uleb128 (p, &len);
11422 p += len;
11423 printf (" Tag_ABI_array_object_align_expected: ");
11424 switch (val)
11425 {
11426 case 0:
11427 printf (_("8-byte\n"));
11428 break;
11429 case 1:
11430 printf (_("4-byte\n"));
11431 break;
11432 case 2:
11433 printf (_("16-byte\n"));
11434 break;
11435 default:
11436 printf ("??? (%d)\n", val);
11437 break;
11438 }
11439 return p;
11440
3cbd1c06 11441 case Tag_ABI_compatibility:
59e6276b
JM		 11442 val = read_uleb128 (p, &len);
11443 p += len;
3cbd1c06 11444 printf (" Tag_ABI_compatibility: ");
59e6276b
JM		 11445 printf (_("flag = %d, vendor = %s\n"), val, p);
11446 p += strlen ((char *) p) + 1;
11447 return p;
87779176
JM		 11448
11449 case Tag_ABI_conformance:
11450 printf (" Tag_ABI_conformance: ");
11451 printf ("\"%s\"\n", p);
11452 p += strlen ((char *) p) + 1;
11453 return p;
59e6276b
JM		 11454 }
11455
11456 printf (" Tag_unknown_%d: ", tag);
11457
87779176
JM		 11458 if (tag & 1)
11459 {
11460 printf ("\"%s\"\n", p);
11461 p += strlen ((char *) p) + 1;
11462 }
11463 else
11464 {
11465 val = read_uleb128 (p, &len);
11466 p += len;
11467 printf ("%d (0x%x)\n", val, val);
11468 }
59e6276b
JM		 11469
11470 return p;
11471}
11472
11c1ff18 11473static int
60bca95a
NC		 11474process_attributes (FILE * file,
11475 const char * public_name,
104d59d1 11476 unsigned int proc_type,
60bca95a
NC		 11477 unsigned char * (* display_pub_attribute) (unsigned char *),
11478 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11c1ff18 11479{
2cf0635d
NC		 11480 Elf_Internal_Shdr * sect;
11481 unsigned char * contents;
11482 unsigned char * p;
11483 unsigned char * end;
11c1ff18
PB		 11484 bfd_vma section_len;
11485 bfd_vma len;
11486 unsigned i;
11487
11488 /* Find the section header so that we get the size. */
11489 for (i = 0, sect = section_headers;
11490 i < elf_header.e_shnum;
11491 i++, sect++)
11492 {
104d59d1 11493 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 11494 continue;
11495
3f5e193b
NC		 11496 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
11497 sect->sh_size, _("attributes"));
60bca95a 11498 if (contents == NULL)
11c1ff18 11499 continue;
60bca95a 11500
11c1ff18
PB		 11501 p = contents;
11502 if (*p == 'A')
11503 {
11504 len = sect->sh_size - 1;
11505 p++;
60bca95a 11506
11c1ff18
PB		 11507 while (len > 0)
11508 {
11509 int namelen;
11510 bfd_boolean public_section;
104d59d1 11511 bfd_boolean gnu_section;
11c1ff18
PB		 11512
11513 section_len = byte_get (p, 4);
11514 p += 4;
60bca95a 11515
11c1ff18
PB		 11516 if (section_len > len)
11517 {
11518 printf (_("ERROR: Bad section length (%d > %d)\n"),
60bca95a 11519 (int) section_len, (int) len);
11c1ff18
PB		 11520 section_len = len;
11521 }
60bca95a 11522
11c1ff18 11523 len -= section_len;
2b692964 11524 printf (_("Attribute Section: %s\n"), p);
60bca95a
NC		 11525
11526 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 11527 public_section = TRUE;
11528 else
11529 public_section = FALSE;
60bca95a
NC		 11530
11531 if (streq ((char *) p, "gnu"))
104d59d1
JM		 11532 gnu_section = TRUE;
11533 else
11534 gnu_section = FALSE;
60bca95a
NC		 11535
11536 namelen = strlen ((char *) p) + 1;
11c1ff18
PB		 11537 p += namelen;
11538 section_len -= namelen + 4;
60bca95a 11539
11c1ff18
PB		 11540 while (section_len > 0)
11541 {
11542 int tag = *(p++);
11543 int val;
11544 bfd_vma size;
60bca95a 11545
11c1ff18
PB		 11546 size = byte_get (p, 4);
11547 if (size > section_len)
11548 {
11549 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
60bca95a 11550 (int) size, (int) section_len);
11c1ff18
PB		 11551 size = section_len;
11552 }
60bca95a 11553
11c1ff18
PB		 11554 section_len -= size;
11555 end = p + size - 1;
11556 p += 4;
60bca95a 11557
11c1ff18
PB		 11558 switch (tag)
11559 {
11560 case 1:
2b692964 11561 printf (_("File Attributes\n"));
11c1ff18
PB		 11562 break;
11563 case 2:
2b692964 11564 printf (_("Section Attributes:"));
11c1ff18
PB		 11565 goto do_numlist;
11566 case 3:
2b692964 11567 printf (_("Symbol Attributes:"));
11c1ff18
PB		 11568 do_numlist:
11569 for (;;)
11570 {
91d6fa6a 11571 unsigned int j;
60bca95a 11572
91d6fa6a
NC		 11573 val = read_uleb128 (p, &j);
11574 p += j;
11c1ff18
PB		 11575 if (val == 0)
11576 break;
11577 printf (" %d", val);
11578 }
11579 printf ("\n");
11580 break;
11581 default:
2b692964 11582 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 11583 public_section = FALSE;
11584 break;
11585 }
60bca95a 11586
11c1ff18
PB		 11587 if (public_section)
11588 {
11589 while (p < end)
104d59d1
JM		 11590 p = display_pub_attribute (p);
11591 }
11592 else if (gnu_section)
11593 {
11594 while (p < end)
11595 p = display_gnu_attribute (p,
11596 display_proc_gnu_attribute);
11c1ff18
PB		 11597 }
11598 else
11599 {
11600 /* ??? Do something sensible, like dump hex. */
2b692964 11601 printf (_(" Unknown section contexts\n"));
11c1ff18
PB		 11602 p = end;
11603 }
11604 }
11605 }
11606 }
11607 else
60bca95a 11608 printf (_("Unknown format '%c'\n"), *p);
d70c5fc7 11609
60bca95a 11610 free (contents);
11c1ff18
PB		 11611 }
11612 return 1;
11613}
11614
104d59d1 11615static int
2cf0635d 11616process_arm_specific (FILE * file)
104d59d1
JM		 11617{
11618 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
11619 display_arm_attribute, NULL);
11620}
11621
34c8bcba 11622static int
2cf0635d 11623process_power_specific (FILE * file)
34c8bcba
JM		 11624{
11625 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11626 display_power_gnu_attribute);
11627}
11628
9e8c70f9
DM		 11629static int
11630process_sparc_specific (FILE * file)
11631{
11632 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11633 display_sparc_gnu_attribute);
11634}
11635
59e6276b
JM		 11636static int
11637process_tic6x_specific (FILE * file)
11638{
11639 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
11640 display_tic6x_attribute, NULL);
11641}
11642
ccb4c951
RS		 11643/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
11644 Print the Address, Access and Initial fields of an entry at VMA ADDR
11645 and return the VMA of the next entry. */
11646
11647static bfd_vma
2cf0635d 11648print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
ccb4c951
RS		 11649{
11650 printf (" ");
11651 print_vma (addr, LONG_HEX);
11652 printf (" ");
11653 if (addr < pltgot + 0xfff0)
11654 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
11655 else
11656 printf ("%10s", "");
11657 printf (" ");
11658 if (data == NULL)
2b692964 11659 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 11660 else
11661 {
11662 bfd_vma entry;
11663
11664 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11665 print_vma (entry, LONG_HEX);
11666 }
11667 return addr + (is_32bit_elf ? 4 : 8);
11668}
11669
861fb55a
DJ		 11670/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
11671 PLTGOT. Print the Address and Initial fields of an entry at VMA
11672 ADDR and return the VMA of the next entry. */
11673
11674static bfd_vma
2cf0635d 11675print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 11676{
11677 printf (" ");
11678 print_vma (addr, LONG_HEX);
11679 printf (" ");
11680 if (data == NULL)
2b692964 11681 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 11682 else
11683 {
11684 bfd_vma entry;
11685
11686 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11687 print_vma (entry, LONG_HEX);
11688 }
11689 return addr + (is_32bit_elf ? 4 : 8);
11690}
11691
19e6b90e 11692static int
2cf0635d 11693process_mips_specific (FILE * file)
5b18a4bc 11694{
2cf0635d 11695 Elf_Internal_Dyn * entry;
19e6b90e
L		 11696 size_t liblist_offset = 0;
11697 size_t liblistno = 0;
11698 size_t conflictsno = 0;
11699 size_t options_offset = 0;
11700 size_t conflicts_offset = 0;
861fb55a
DJ		 11701 size_t pltrelsz = 0;
11702 size_t pltrel = 0;
ccb4c951 11703 bfd_vma pltgot = 0;
861fb55a
DJ		 11704 bfd_vma mips_pltgot = 0;
11705 bfd_vma jmprel = 0;
ccb4c951
RS		 11706 bfd_vma local_gotno = 0;
11707 bfd_vma gotsym = 0;
11708 bfd_vma symtabno = 0;
103f02d3 11709
2cf19d5c
JM		 11710 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11711 display_mips_gnu_attribute);
11712
19e6b90e
L		 11713 /* We have a lot of special sections. Thanks SGI! */
11714 if (dynamic_section == NULL)
11715 /* No information available. */
11716 return 0;
252b5132 11717
b2d38a17 11718 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
252b5132
RH		 11719 switch (entry->d_tag)
11720 {
11721 case DT_MIPS_LIBLIST:
d93f0186
NC		 11722 liblist_offset
11723 = offset_from_vma (file, entry->d_un.d_val,
11724 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 11725 break;
11726 case DT_MIPS_LIBLISTNO:
11727 liblistno = entry->d_un.d_val;
11728 break;
11729 case DT_MIPS_OPTIONS:
d93f0186 11730 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 11731 break;
11732 case DT_MIPS_CONFLICT:
d93f0186
NC		 11733 conflicts_offset
11734 = offset_from_vma (file, entry->d_un.d_val,
11735 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 11736 break;
11737 case DT_MIPS_CONFLICTNO:
11738 conflictsno = entry->d_un.d_val;
11739 break;
ccb4c951 11740 case DT_PLTGOT:
861fb55a
DJ		 11741 pltgot = entry->d_un.d_ptr;
11742 break;
ccb4c951
RS		 11743 case DT_MIPS_LOCAL_GOTNO:
11744 local_gotno = entry->d_un.d_val;
11745 break;
11746 case DT_MIPS_GOTSYM:
11747 gotsym = entry->d_un.d_val;
11748 break;
11749 case DT_MIPS_SYMTABNO:
11750 symtabno = entry->d_un.d_val;
11751 break;
861fb55a
DJ		 11752 case DT_MIPS_PLTGOT:
11753 mips_pltgot = entry->d_un.d_ptr;
11754 break;
11755 case DT_PLTREL:
11756 pltrel = entry->d_un.d_val;
11757 break;
11758 case DT_PLTRELSZ:
11759 pltrelsz = entry->d_un.d_val;
11760 break;
11761 case DT_JMPREL:
11762 jmprel = entry->d_un.d_ptr;
11763 break;
252b5132
RH		 11764 default:
11765 break;
11766 }
11767
11768 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
11769 {
2cf0635d 11770 Elf32_External_Lib * elib;
252b5132
RH		 11771 size_t cnt;
11772
3f5e193b
NC		 11773 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
11774 liblistno,
11775 sizeof (Elf32_External_Lib),
11776 _("liblist"));
a6e9f9df 11777 if (elib)
252b5132 11778 {
2b692964 11779 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 11780 (unsigned long) liblistno);
2b692964 11781 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 11782 stdout);
11783
11784 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 11785 {
a6e9f9df 11786 Elf32_Lib liblist;
91d6fa6a 11787 time_t atime;
a6e9f9df 11788 char timebuf[20];
2cf0635d 11789 struct tm * tmp;
a6e9f9df
AM		 11790
11791 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 11792 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 11793 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
11794 liblist.l_version = BYTE_GET (elib[cnt].l_version);
11795 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
11796
91d6fa6a 11797 tmp = gmtime (&atime);
e9e44622
JJ		 11798 snprintf (timebuf, sizeof (timebuf),
11799 "%04u-%02u-%02uT%02u:%02u:%02u",
11800 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
11801 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 11802
31104126 11803 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 11804 if (VALID_DYNAMIC_NAME (liblist.l_name))
11805 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
11806 else
2b692964 11807 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 11808 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
11809 liblist.l_version);
a6e9f9df
AM		 11810
11811 if (liblist.l_flags == 0)
2b692964 11812 puts (_(" NONE"));
a6e9f9df
AM		 11813 else
11814 {
11815 static const struct
252b5132 11816 {
2cf0635d 11817 const char * name;
a6e9f9df 11818 int bit;
252b5132 11819 }
a6e9f9df
AM		 11820 l_flags_vals[] =
11821 {
11822 { " EXACT_MATCH", LL_EXACT_MATCH },
11823 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
11824 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
11825 { " EXPORTS", LL_EXPORTS },
11826 { " DELAY_LOAD", LL_DELAY_LOAD },
11827 { " DELTA", LL_DELTA }
11828 };
11829 int flags = liblist.l_flags;
11830 size_t fcnt;
11831
60bca95a 11832 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 11833 if ((flags & l_flags_vals[fcnt].bit) != 0)
11834 {
11835 fputs (l_flags_vals[fcnt].name, stdout);
11836 flags ^= l_flags_vals[fcnt].bit;
11837 }
11838 if (flags != 0)
11839 printf (" %#x", (unsigned int) flags);
252b5132 11840
a6e9f9df
AM		 11841 puts ("");
11842 }
252b5132 11843 }
252b5132 11844
a6e9f9df
AM		 11845 free (elib);
11846 }
252b5132
RH		 11847 }
11848
11849 if (options_offset != 0)
11850 {
2cf0635d
NC		 11851 Elf_External_Options * eopt;
11852 Elf_Internal_Shdr * sect = section_headers;
11853 Elf_Internal_Options * iopt;
11854 Elf_Internal_Options * option;
252b5132
RH		 11855 size_t offset;
11856 int cnt;
11857
11858 /* Find the section header so that we get the size. */
11859 while (sect->sh_type != SHT_MIPS_OPTIONS)
b34976b6 11860 ++sect;
252b5132 11861
3f5e193b
NC		 11862 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
11863 sect->sh_size, _("options"));
a6e9f9df 11864 if (eopt)
252b5132 11865 {
3f5e193b
NC		 11866 iopt = (Elf_Internal_Options *)
11867 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 11868 if (iopt == NULL)
11869 {
591a748a 11870 error (_("Out of memory\n"));
a6e9f9df
AM		 11871 return 0;
11872 }
76da6bbe 11873
a6e9f9df
AM		 11874 offset = cnt = 0;
11875 option = iopt;
252b5132 11876
a6e9f9df
AM		 11877 while (offset < sect->sh_size)
11878 {
2cf0635d 11879 Elf_External_Options * eoption;
252b5132 11880
a6e9f9df 11881 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 11882
a6e9f9df
AM		 11883 option->kind = BYTE_GET (eoption->kind);
11884 option->size = BYTE_GET (eoption->size);
11885 option->section = BYTE_GET (eoption->section);
11886 option->info = BYTE_GET (eoption->info);
76da6bbe 11887
a6e9f9df 11888 offset += option->size;
252b5132 11889
a6e9f9df
AM		 11890 ++option;
11891 ++cnt;
11892 }
252b5132 11893
a6e9f9df
AM		 11894 printf (_("\nSection '%s' contains %d entries:\n"),
11895 SECTION_NAME (sect), cnt);
76da6bbe 11896
a6e9f9df 11897 option = iopt;
252b5132 11898
a6e9f9df 11899 while (cnt-- > 0)
252b5132 11900 {
a6e9f9df
AM		 11901 size_t len;
11902
11903 switch (option->kind)
252b5132 11904 {
a6e9f9df
AM		 11905 case ODK_NULL:
11906 /* This shouldn't happen. */
11907 printf (" NULL %d %lx", option->section, option->info);
11908 break;
11909 case ODK_REGINFO:
11910 printf (" REGINFO ");
11911 if (elf_header.e_machine == EM_MIPS)
11912 {
11913 /* 32bit form. */
2cf0635d 11914 Elf32_External_RegInfo * ereg;
b34976b6 11915 Elf32_RegInfo reginfo;
a6e9f9df
AM		 11916
11917 ereg = (Elf32_External_RegInfo *) (option + 1);
11918 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
11919 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11920 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11921 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11922 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
11923 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
11924
11925 printf ("GPR %08lx GP 0x%lx\n",
11926 reginfo.ri_gprmask,
11927 (unsigned long) reginfo.ri_gp_value);
11928 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11929 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11930 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11931 }
11932 else
11933 {
11934 /* 64 bit form. */
2cf0635d 11935 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 11936 Elf64_Internal_RegInfo reginfo;
11937
11938 ereg = (Elf64_External_RegInfo *) (option + 1);
11939 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
11940 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11941 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11942 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11943 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 11944 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 11945
11946 printf ("GPR %08lx GP 0x",
11947 reginfo.ri_gprmask);
11948 printf_vma (reginfo.ri_gp_value);
11949 printf ("\n");
11950
11951 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11952 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11953 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11954 }
11955 ++option;
11956 continue;
11957 case ODK_EXCEPTIONS:
11958 fputs (" EXCEPTIONS fpe_min(", stdout);
11959 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
11960 fputs (") fpe_max(", stdout);
11961 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
11962 fputs (")", stdout);
11963
11964 if (option->info & OEX_PAGE0)
11965 fputs (" PAGE0", stdout);
11966 if (option->info & OEX_SMM)
11967 fputs (" SMM", stdout);
11968 if (option->info & OEX_FPDBUG)
11969 fputs (" FPDBUG", stdout);
11970 if (option->info & OEX_DISMISS)
11971 fputs (" DISMISS", stdout);
11972 break;
11973 case ODK_PAD:
11974 fputs (" PAD ", stdout);
11975 if (option->info & OPAD_PREFIX)
11976 fputs (" PREFIX", stdout);
11977 if (option->info & OPAD_POSTFIX)
11978 fputs (" POSTFIX", stdout);
11979 if (option->info & OPAD_SYMBOL)
11980 fputs (" SYMBOL", stdout);
11981 break;
11982 case ODK_HWPATCH:
11983 fputs (" HWPATCH ", stdout);
11984 if (option->info & OHW_R4KEOP)
11985 fputs (" R4KEOP", stdout);
11986 if (option->info & OHW_R8KPFETCH)
11987 fputs (" R8KPFETCH", stdout);
11988 if (option->info & OHW_R5KEOP)
11989 fputs (" R5KEOP", stdout);
11990 if (option->info & OHW_R5KCVTL)
11991 fputs (" R5KCVTL", stdout);
11992 break;
11993 case ODK_FILL:
11994 fputs (" FILL ", stdout);
11995 /* XXX Print content of info word? */
11996 break;
11997 case ODK_TAGS:
11998 fputs (" TAGS ", stdout);
11999 /* XXX Print content of info word? */
12000 break;
12001 case ODK_HWAND:
12002 fputs (" HWAND ", stdout);
12003 if (option->info & OHWA0_R4KEOP_CHECKED)
12004 fputs (" R4KEOP_CHECKED", stdout);
12005 if (option->info & OHWA0_R4KEOP_CLEAN)
12006 fputs (" R4KEOP_CLEAN", stdout);
12007 break;
12008 case ODK_HWOR:
12009 fputs (" HWOR ", stdout);
12010 if (option->info & OHWA0_R4KEOP_CHECKED)
12011 fputs (" R4KEOP_CHECKED", stdout);
12012 if (option->info & OHWA0_R4KEOP_CLEAN)
12013 fputs (" R4KEOP_CLEAN", stdout);
12014 break;
12015 case ODK_GP_GROUP:
12016 printf (" GP_GROUP %#06lx self-contained %#06lx",
12017 option->info & OGP_GROUP,
12018 (option->info & OGP_SELF) >> 16);
12019 break;
12020 case ODK_IDENT:
12021 printf (" IDENT %#06lx self-contained %#06lx",
12022 option->info & OGP_GROUP,
12023 (option->info & OGP_SELF) >> 16);
12024 break;
12025 default:
12026 /* This shouldn't happen. */
12027 printf (" %3d ??? %d %lx",
12028 option->kind, option->section, option->info);
12029 break;
252b5132 12030 }
a6e9f9df 12031
2cf0635d 12032 len = sizeof (* eopt);
a6e9f9df
AM		 12033 while (len < option->size)
12034 if (((char *) option)[len] >= ' '
12035 && ((char *) option)[len] < 0x7f)
12036 printf ("%c", ((char *) option)[len++]);
12037 else
12038 printf ("\\%03o", ((char *) option)[len++]);
12039
12040 fputs ("\n", stdout);
252b5132 12041 ++option;
252b5132
RH		 12042 }
12043
a6e9f9df 12044 free (eopt);
252b5132 12045 }
252b5132
RH		 12046 }
12047
12048 if (conflicts_offset != 0 && conflictsno != 0)
12049 {
2cf0635d 12050 Elf32_Conflict * iconf;
252b5132
RH		 12051 size_t cnt;
12052
12053 if (dynamic_symbols == NULL)
12054 {
591a748a 12055 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 12056 return 0;
12057 }
12058
3f5e193b 12059 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 12060 if (iconf == NULL)
12061 {
591a748a 12062 error (_("Out of memory\n"));
252b5132
RH		 12063 return 0;
12064 }
12065
9ea033b2 12066 if (is_32bit_elf)
252b5132 12067 {
2cf0635d 12068 Elf32_External_Conflict * econf32;
a6e9f9df 12069
3f5e193b
NC		 12070 econf32 = (Elf32_External_Conflict *)
12071 get_data (NULL, file, conflicts_offset, conflictsno,
12072 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 12073 if (!econf32)
12074 return 0;
252b5132
RH		 12075
12076 for (cnt = 0; cnt < conflictsno; ++cnt)
12077 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 12078
12079 free (econf32);
252b5132
RH		 12080 }
12081 else
12082 {
2cf0635d 12083 Elf64_External_Conflict * econf64;
a6e9f9df 12084
3f5e193b
NC		 12085 econf64 = (Elf64_External_Conflict *)
12086 get_data (NULL, file, conflicts_offset, conflictsno,
12087 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 12088 if (!econf64)
12089 return 0;
252b5132
RH		 12090
12091 for (cnt = 0; cnt < conflictsno; ++cnt)
12092 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 12093
12094 free (econf64);
252b5132
RH		 12095 }
12096
c7e7ca54
NC		 12097 printf (_("\nSection '.conflict' contains %lu entries:\n"),
12098 (unsigned long) conflictsno);
252b5132
RH		 12099 puts (_(" Num: Index Value Name"));
12100
12101 for (cnt = 0; cnt < conflictsno; ++cnt)
12102 {
2cf0635d 12103 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
252b5132 12104
b34976b6 12105 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
f7a99963 12106 print_vma (psym->st_value, FULL_HEX);
31104126 12107 putchar (' ');
d79b3d50
NC		 12108 if (VALID_DYNAMIC_NAME (psym->st_name))
12109 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
12110 else
2b692964 12111 printf (_("<corrupt: %14ld>"), psym->st_name);
31104126 12112 putchar ('\n');
252b5132
RH		 12113 }
12114
252b5132
RH		 12115 free (iconf);
12116 }
12117
ccb4c951
RS		 12118 if (pltgot != 0 && local_gotno != 0)
12119 {
91d6fa6a 12120 bfd_vma ent, local_end, global_end;
bbeee7ea 12121 size_t i, offset;
2cf0635d 12122 unsigned char * data;
bbeee7ea 12123 int addr_size;
ccb4c951 12124
91d6fa6a 12125 ent = pltgot;
ccb4c951
RS		 12126 addr_size = (is_32bit_elf ? 4 : 8);
12127 local_end = pltgot + local_gotno * addr_size;
12128 global_end = local_end + (symtabno - gotsym) * addr_size;
12129
12130 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b
NC		 12131 data = (unsigned char *) get_data (NULL, file, offset,
12132 global_end - pltgot, 1, _("GOT"));
59245841
NC		 12133 if (data == NULL)
12134 return 0;
12135
ccb4c951
RS		 12136 printf (_("\nPrimary GOT:\n"));
12137 printf (_(" Canonical gp value: "));
12138 print_vma (pltgot + 0x7ff0, LONG_HEX);
12139 printf ("\n\n");
12140
12141 printf (_(" Reserved entries:\n"));
12142 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 12143 addr_size * 2, _("Address"), _("Access"),
12144 addr_size * 2, _("Initial"));
91d6fa6a 12145 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 12146 printf (_(" Lazy resolver\n"));
ccb4c951 12147 if (data
91d6fa6a 12148 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 12149 >> (addr_size * 8 - 1)) != 0)
12150 {
91d6fa6a 12151 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 12152 printf (_(" Module pointer (GNU extension)\n"));
ccb4c951
RS		 12153 }
12154 printf ("\n");
12155
91d6fa6a 12156 if (ent < local_end)
ccb4c951
RS		 12157 {
12158 printf (_(" Local entries:\n"));
cc5914eb 12159 printf (" %*s %10s %*s\n",
2b692964
NC		 12160 addr_size * 2, _("Address"), _("Access"),
12161 addr_size * 2, _("Initial"));
91d6fa6a 12162 while (ent < local_end)
ccb4c951 12163 {
91d6fa6a 12164 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 12165 printf ("\n");
12166 }
12167 printf ("\n");
12168 }
12169
12170 if (gotsym < symtabno)
12171 {
12172 int sym_width;
12173
12174 printf (_(" Global entries:\n"));
cc5914eb 12175 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
2b692964
NC		 12176 addr_size * 2, _("Address"), _("Access"),
12177 addr_size * 2, _("Initial"),
12178 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
ccb4c951
RS		 12179 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
12180 for (i = gotsym; i < symtabno; i++)
12181 {
2cf0635d 12182 Elf_Internal_Sym * psym;
ccb4c951
RS		 12183
12184 psym = dynamic_symbols + i;
91d6fa6a 12185 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 12186 printf (" ");
12187 print_vma (psym->st_value, LONG_HEX);
12188 printf (" %-7s %3s ",
12189 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12190 get_symbol_index_type (psym->st_shndx));
12191 if (VALID_DYNAMIC_NAME (psym->st_name))
12192 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12193 else
2b692964 12194 printf (_("<corrupt: %14ld>"), psym->st_name);
ccb4c951
RS		 12195 printf ("\n");
12196 }
12197 printf ("\n");
12198 }
12199
12200 if (data)
12201 free (data);
12202 }
12203
861fb55a
DJ		 12204 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
12205 {
91d6fa6a 12206 bfd_vma ent, end;
861fb55a
DJ		 12207 size_t offset, rel_offset;
12208 unsigned long count, i;
2cf0635d 12209 unsigned char * data;
861fb55a 12210 int addr_size, sym_width;
2cf0635d 12211 Elf_Internal_Rela * rels;
861fb55a
DJ		 12212
12213 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
12214 if (pltrel == DT_RELA)
12215 {
12216 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
12217 return 0;
12218 }
12219 else
12220 {
12221 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
12222 return 0;
12223 }
12224
91d6fa6a 12225 ent = mips_pltgot;
861fb55a
DJ		 12226 addr_size = (is_32bit_elf ? 4 : 8);
12227 end = mips_pltgot + (2 + count) * addr_size;
12228
12229 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b
NC		 12230 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
12231 1, _("PLT GOT"));
59245841
NC		 12232 if (data == NULL)
12233 return 0;
12234
861fb55a
DJ		 12235 printf (_("\nPLT GOT:\n\n"));
12236 printf (_(" Reserved entries:\n"));
12237 printf (_(" %*s %*s Purpose\n"),
2b692964 12238 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 12239 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 12240 printf (_(" PLT lazy resolver\n"));
91d6fa6a 12241 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 12242 printf (_(" Module pointer\n"));
861fb55a
DJ		 12243 printf ("\n");
12244
12245 printf (_(" Entries:\n"));
cc5914eb 12246 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 12247 addr_size * 2, _("Address"),
12248 addr_size * 2, _("Initial"),
12249 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 12250 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
12251 for (i = 0; i < count; i++)
12252 {
2cf0635d 12253 Elf_Internal_Sym * psym;
861fb55a
DJ		 12254
12255 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
91d6fa6a 12256 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a
DJ		 12257 printf (" ");
12258 print_vma (psym->st_value, LONG_HEX);
12259 printf (" %-7s %3s ",
12260 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12261 get_symbol_index_type (psym->st_shndx));
12262 if (VALID_DYNAMIC_NAME (psym->st_name))
12263 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12264 else
2b692964 12265 printf (_("<corrupt: %14ld>"), psym->st_name);
861fb55a
DJ		 12266 printf ("\n");
12267 }
12268 printf ("\n");
12269
12270 if (data)
12271 free (data);
12272 free (rels);
12273 }
12274
252b5132
RH		 12275 return 1;
12276}
12277
047b2264 12278static int
2cf0635d 12279process_gnu_liblist (FILE * file)
047b2264 12280{
2cf0635d
NC		 12281 Elf_Internal_Shdr * section;
12282 Elf_Internal_Shdr * string_sec;
12283 Elf32_External_Lib * elib;
12284 char * strtab;
c256ffe7 12285 size_t strtab_size;
047b2264
JJ		 12286 size_t cnt;
12287 unsigned i;
12288
12289 if (! do_arch)
12290 return 0;
12291
12292 for (i = 0, section = section_headers;
12293 i < elf_header.e_shnum;
b34976b6 12294 i++, section++)
047b2264
JJ		 12295 {
12296 switch (section->sh_type)
12297 {
12298 case SHT_GNU_LIBLIST:
4fbb74a6 12299 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 12300 break;
12301
3f5e193b
NC		 12302 elib = (Elf32_External_Lib *)
12303 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
12304 _("liblist"));
047b2264
JJ		 12305
12306 if (elib == NULL)
12307 break;
4fbb74a6 12308 string_sec = section_headers + section->sh_link;
047b2264 12309
3f5e193b
NC		 12310 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
12311 string_sec->sh_size,
12312 _("liblist string table"));
047b2264
JJ		 12313 if (strtab == NULL
12314 || section->sh_entsize != sizeof (Elf32_External_Lib))
12315 {
12316 free (elib);
2842702f 12317 free (strtab);
047b2264
JJ		 12318 break;
12319 }
59245841 12320 strtab_size = string_sec->sh_size;
047b2264
JJ		 12321
12322 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12323 SECTION_NAME (section),
0af1713e 12324 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 12325
2b692964 12326 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 12327
12328 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
12329 ++cnt)
12330 {
12331 Elf32_Lib liblist;
91d6fa6a 12332 time_t atime;
047b2264 12333 char timebuf[20];
2cf0635d 12334 struct tm * tmp;
047b2264
JJ		 12335
12336 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 12337 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 12338 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12339 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12340 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12341
91d6fa6a 12342 tmp = gmtime (&atime);
e9e44622
JJ		 12343 snprintf (timebuf, sizeof (timebuf),
12344 "%04u-%02u-%02uT%02u:%02u:%02u",
12345 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12346 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 12347
12348 printf ("%3lu: ", (unsigned long) cnt);
12349 if (do_wide)
c256ffe7 12350 printf ("%-20s", liblist.l_name < strtab_size
2b692964 12351 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 12352 else
c256ffe7 12353 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 12354 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 12355 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
12356 liblist.l_version, liblist.l_flags);
12357 }
12358
12359 free (elib);
2842702f 12360 free (strtab);
047b2264
JJ		 12361 }
12362 }
12363
12364 return 1;
12365}
12366
9437c45b 12367static const char *
d3ba0551 12368get_note_type (unsigned e_type)
779fe533
NC		 12369{
12370 static char buff[64];
103f02d3 12371
1ec5cd37
NC		 12372 if (elf_header.e_type == ET_CORE)
12373 switch (e_type)
12374 {
57346661 12375 case NT_AUXV:
1ec5cd37 12376 return _("NT_AUXV (auxiliary vector)");
57346661 12377 case NT_PRSTATUS:
1ec5cd37 12378 return _("NT_PRSTATUS (prstatus structure)");
57346661 12379 case NT_FPREGSET:
1ec5cd37 12380 return _("NT_FPREGSET (floating point registers)");
57346661 12381 case NT_PRPSINFO:
1ec5cd37 12382 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 12383 case NT_TASKSTRUCT:
1ec5cd37 12384 return _("NT_TASKSTRUCT (task structure)");
57346661 12385 case NT_PRXFPREG:
1ec5cd37 12386 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 12387 case NT_PPC_VMX:
12388 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 12389 case NT_PPC_VSX:
12390 return _("NT_PPC_VSX (ppc VSX registers)");
4339cae0
L		 12391 case NT_X86_XSTATE:
12392 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 12393 case NT_S390_HIGH_GPRS:
12394 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 12395 case NT_S390_TIMER:
12396 return _("NT_S390_TIMER (s390 timer register)");
12397 case NT_S390_TODCMP:
12398 return _("NT_S390_TODCMP (s390 TOD comparator register)");
12399 case NT_S390_TODPREG:
12400 return _("NT_S390_TODPREG (s390 TOD programmable register)");
12401 case NT_S390_CTRS:
12402 return _("NT_S390_CTRS (s390 control registers)");
12403 case NT_S390_PREFIX:
12404 return _("NT_S390_PREFIX (s390 prefix register)");
faa9a424
UW		 12405 case NT_ARM_VFP:
12406 return _("NT_ARM_VFP (arm VFP registers)");
57346661 12407 case NT_PSTATUS:
1ec5cd37 12408 return _("NT_PSTATUS (pstatus structure)");
57346661 12409 case NT_FPREGS:
1ec5cd37 12410 return _("NT_FPREGS (floating point registers)");
57346661 12411 case NT_PSINFO:
1ec5cd37 12412 return _("NT_PSINFO (psinfo structure)");
57346661 12413 case NT_LWPSTATUS:
1ec5cd37 12414 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 12415 case NT_LWPSINFO:
1ec5cd37 12416 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 12417 case NT_WIN32PSTATUS:
1ec5cd37
NC		 12418 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
12419 default:
12420 break;
12421 }
12422 else
12423 switch (e_type)
12424 {
12425 case NT_VERSION:
12426 return _("NT_VERSION (version)");
12427 case NT_ARCH:
12428 return _("NT_ARCH (architecture)");
12429 default:
12430 break;
12431 }
12432
e9e44622 12433 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 12434 return buff;
779fe533
NC		 12435}
12436
1118d252
RM		 12437static const char *
12438get_gnu_elf_note_type (unsigned e_type)
12439{
12440 static char buff[64];
12441
12442 switch (e_type)
12443 {
12444 case NT_GNU_ABI_TAG:
12445 return _("NT_GNU_ABI_TAG (ABI version tag)");
12446 case NT_GNU_HWCAP:
12447 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
12448 case NT_GNU_BUILD_ID:
12449 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 12450 case NT_GNU_GOLD_VERSION:
12451 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 12452 default:
12453 break;
12454 }
12455
12456 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12457 return buff;
12458}
12459
664f90a3
TT		 12460static int
12461print_gnu_note (Elf_Internal_Note *pnote)
12462{
12463 switch (pnote->type)
12464 {
12465 case NT_GNU_BUILD_ID:
12466 {
12467 unsigned long i;
12468
12469 printf (_(" Build ID: "));
12470 for (i = 0; i < pnote->descsz; ++i)
12471 printf ("%02x", pnote->descdata[i] & 0xff);
12472 printf (_("\n"));
12473 }
12474 break;
12475
12476 case NT_GNU_ABI_TAG:
12477 {
12478 unsigned long os, major, minor, subminor;
12479 const char *osname;
12480
12481 os = byte_get ((unsigned char *) pnote->descdata, 4);
12482 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
12483 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
12484 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
12485
12486 switch (os)
12487 {
12488 case GNU_ABI_TAG_LINUX:
12489 osname = "Linux";
12490 break;
12491 case GNU_ABI_TAG_HURD:
12492 osname = "Hurd";
12493 break;
12494 case GNU_ABI_TAG_SOLARIS:
12495 osname = "Solaris";
12496 break;
12497 case GNU_ABI_TAG_FREEBSD:
12498 osname = "FreeBSD";
12499 break;
12500 case GNU_ABI_TAG_NETBSD:
12501 osname = "NetBSD";
12502 break;
12503 default:
12504 osname = "Unknown";
12505 break;
12506 }
12507
12508 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
12509 major, minor, subminor);
12510 }
12511 break;
12512 }
12513
12514 return 1;
12515}
12516
9437c45b 12517static const char *
d3ba0551 12518get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 12519{
12520 static char buff[64];
12521
b4db1224 12522 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 12523 {
12524 /* NetBSD core "procinfo" structure. */
12525 return _("NetBSD procinfo structure");
12526 }
12527
12528 /* As of Jan 2002 there are no other machine-independent notes
12529 defined for NetBSD core files. If the note type is less
12530 than the start of the machine-dependent note types, we don't
12531 understand it. */
12532
b4db1224 12533 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 12534 {
e9e44622 12535 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 12536 return buff;
12537 }
12538
12539 switch (elf_header.e_machine)
12540 {
12541 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
12542 and PT_GETFPREGS == mach+2. */
12543
12544 case EM_OLD_ALPHA:
12545 case EM_ALPHA:
12546 case EM_SPARC:
12547 case EM_SPARC32PLUS:
12548 case EM_SPARCV9:
12549 switch (e_type)
12550 {
2b692964 12551 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 12552 return _("PT_GETREGS (reg structure)");
2b692964 12553 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 12554 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 12555 default:
12556 break;
12557 }
12558 break;
12559
12560 /* On all other arch's, PT_GETREGS == mach+1 and
12561 PT_GETFPREGS == mach+3. */
12562 default:
12563 switch (e_type)
12564 {
2b692964 12565 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 12566 return _("PT_GETREGS (reg structure)");
2b692964 12567 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 12568 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 12569 default:
12570 break;
12571 }
12572 }
12573
e9e44622
JJ		 12574 snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
12575 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 12576 return buff;
12577}
12578
70616151
TT		 12579static const char *
12580get_stapsdt_note_type (unsigned e_type)
12581{
12582 static char buff[64];
12583
12584 switch (e_type)
12585 {
12586 case NT_STAPSDT:
12587 return _("NT_STAPSDT (SystemTap probe descriptors)");
12588
12589 default:
12590 break;
12591 }
12592
12593 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12594 return buff;
12595}
12596
c6a9fc58
TT		 12597static int
12598print_stapsdt_note (Elf_Internal_Note *pnote)
12599{
12600 int addr_size = is_32bit_elf ? 4 : 8;
12601 char *data = pnote->descdata;
12602 char *data_end = pnote->descdata + pnote->descsz;
12603 bfd_vma pc, base_addr, semaphore;
12604 char *provider, *probe, *arg_fmt;
12605
12606 pc = byte_get ((unsigned char *) data, addr_size);
12607 data += addr_size;
12608 base_addr = byte_get ((unsigned char *) data, addr_size);
12609 data += addr_size;
12610 semaphore = byte_get ((unsigned char *) data, addr_size);
12611 data += addr_size;
12612
12613 provider = data;
12614 data += strlen (data) + 1;
12615 probe = data;
12616 data += strlen (data) + 1;
12617 arg_fmt = data;
12618 data += strlen (data) + 1;
12619
12620 printf (_(" Provider: %s\n"), provider);
12621 printf (_(" Name: %s\n"), probe);
12622 printf (_(" Location: "));
12623 print_vma (pc, FULL_HEX);
12624 printf (_(", Base: "));
12625 print_vma (base_addr, FULL_HEX);
12626 printf (_(", Semaphore: "));
12627 print_vma (semaphore, FULL_HEX);
12628 printf (_("\n"));
12629 printf (_(" Arguments: %s\n"), arg_fmt);
12630
12631 return data == data_end;
12632}
12633
00e98fc7
TG		 12634static const char *
12635get_ia64_vms_note_type (unsigned e_type)
12636{
12637 static char buff[64];
12638
12639 switch (e_type)
12640 {
12641 case NT_VMS_MHD:
12642 return _("NT_VMS_MHD (module header)");
12643 case NT_VMS_LNM:
12644 return _("NT_VMS_LNM (language name)");
12645 case NT_VMS_SRC:
12646 return _("NT_VMS_SRC (source files)");
12647 case NT_VMS_TITLE:
12648 return _("NT_VMS_TITLE");
12649 case NT_VMS_EIDC:
12650 return _("NT_VMS_EIDC (consistency check)");
12651 case NT_VMS_FPMODE:
12652 return _("NT_VMS_FPMODE (FP mode)");
12653 case NT_VMS_LINKTIME:
12654 return _("NT_VMS_LINKTIME");
12655 case NT_VMS_IMGNAM:
12656 return _("NT_VMS_IMGNAM (image name)");
12657 case NT_VMS_IMGID:
12658 return _("NT_VMS_IMGID (image id)");
12659 case NT_VMS_LINKID:
12660 return _("NT_VMS_LINKID (link id)");
12661 case NT_VMS_IMGBID:
12662 return _("NT_VMS_IMGBID (build id)");
12663 case NT_VMS_GSTNAM:
12664 return _("NT_VMS_GSTNAM (sym table name)");
12665 case NT_VMS_ORIG_DYN:
12666 return _("NT_VMS_ORIG_DYN");
12667 case NT_VMS_PATCHTIME:
12668 return _("NT_VMS_PATCHTIME");
12669 default:
12670 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12671 return buff;
12672 }
12673}
12674
12675static int
12676print_ia64_vms_note (Elf_Internal_Note * pnote)
12677{
12678 switch (pnote->type)
12679 {
12680 case NT_VMS_MHD:
12681 if (pnote->descsz > 36)
12682 {
12683 size_t l = strlen (pnote->descdata + 34);
12684 printf (_(" Creation date : %.17s\n"), pnote->descdata);
12685 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
12686 printf (_(" Module name : %s\n"), pnote->descdata + 34);
12687 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
12688 }
12689 else
12690 printf (_(" Invalid size\n"));
12691 break;
12692 case NT_VMS_LNM:
12693 printf (_(" Language: %s\n"), pnote->descdata);
12694 break;
12695#ifdef BFD64
12696 case NT_VMS_FPMODE:
12697 printf (_(" FP mode: 0x%016" BFD_VMA_FMT "x\n"),
12698 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
12699 break;
12700 case NT_VMS_LINKTIME:
12701 printf (_(" Link time: "));
12702 print_vms_time
12703 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
12704 printf ("\n");
12705 break;
12706 case NT_VMS_PATCHTIME:
12707 printf (_(" Patch time: "));
12708 print_vms_time
12709 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
12710 printf ("\n");
12711 break;
12712 case NT_VMS_ORIG_DYN:
12713 printf (_(" Major id: %u, minor id: %u\n"),
12714 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
12715 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
12716 printf (_(" Manip date : "));
12717 print_vms_time
12718 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
12719 printf (_("\n"
12720 " Link flags : 0x%016" BFD_VMA_FMT "x\n"),
12721 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
12722 printf (_(" Header flags: 0x%08x\n"),
12723 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
12724 printf (_(" Image id : %s\n"), pnote->descdata + 32);
12725 break;
12726#endif
12727 case NT_VMS_IMGNAM:
12728 printf (_(" Image name: %s\n"), pnote->descdata);
12729 break;
12730 case NT_VMS_GSTNAM:
12731 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
12732 break;
12733 case NT_VMS_IMGID:
12734 printf (_(" Image id: %s\n"), pnote->descdata);
12735 break;
12736 case NT_VMS_LINKID:
12737 printf (_(" Linker id: %s\n"), pnote->descdata);
12738 break;
12739 default:
12740 break;
12741 }
12742 return 1;
12743}
12744
6d118b09
NC		 12745/* Note that by the ELF standard, the name field is already null byte
12746 terminated, and namesz includes the terminating null byte.
12747 I.E. the value of namesz for the name "FSF" is 4.
12748
e3c8793a 12749 If the value of namesz is zero, there is no name present. */
779fe533 12750static int
2cf0635d 12751process_note (Elf_Internal_Note * pnote)
779fe533 12752{
2cf0635d
NC		 12753 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
12754 const char * nt;
9437c45b
JT		 12755
12756 if (pnote->namesz == 0)
1ec5cd37
NC		 12757 /* If there is no note name, then use the default set of
12758 note type strings. */
12759 nt = get_note_type (pnote->type);
12760
1118d252
RM		 12761 else if (const_strneq (pnote->namedata, "GNU"))
12762 /* GNU-specific object file notes. */
12763 nt = get_gnu_elf_note_type (pnote->type);
12764
0112cd26 12765 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 12766 /* NetBSD-specific core file notes. */
12767 nt = get_netbsd_elfcore_note_type (pnote->type);
12768
b15fa79e
AM		 12769 else if (strneq (pnote->namedata, "SPU/", 4))
12770 {
12771 /* SPU-specific core file notes. */
12772 nt = pnote->namedata + 4;
12773 name = "SPU";
12774 }
12775
00e98fc7
TG		 12776 else if (const_strneq (pnote->namedata, "IPF/VMS"))
12777 /* VMS/ia64-specific file notes. */
12778 nt = get_ia64_vms_note_type (pnote->type);
12779
70616151
TT		 12780 else if (const_strneq (pnote->namedata, "stapsdt"))
12781 nt = get_stapsdt_note_type (pnote->type);
12782
9437c45b 12783 else
1ec5cd37
NC		 12784 /* Don't recognize this note name; just use the default set of
12785 note type strings. */
00e98fc7 12786 nt = get_note_type (pnote->type);
9437c45b 12787
2aee03ae 12788 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 12789
12790 if (const_strneq (pnote->namedata, "IPF/VMS"))
12791 return print_ia64_vms_note (pnote);
664f90a3
TT		 12792 else if (const_strneq (pnote->namedata, "GNU"))
12793 return print_gnu_note (pnote);
c6a9fc58
TT		 12794 else if (const_strneq (pnote->namedata, "stapsdt"))
12795 return print_stapsdt_note (pnote);
00e98fc7
TG		 12796 else
12797 return 1;
779fe533
NC		 12798}
12799
6d118b09 12800
779fe533 12801static int
2cf0635d 12802process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 12803{
2cf0635d
NC		 12804 Elf_External_Note * pnotes;
12805 Elf_External_Note * external;
b34976b6 12806 int res = 1;
103f02d3 12807
779fe533
NC		 12808 if (length <= 0)
12809 return 0;
103f02d3 12810
3f5e193b
NC		 12811 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
12812 _("notes"));
dd24e3da 12813 if (pnotes == NULL)
a6e9f9df 12814 return 0;
779fe533 12815
103f02d3 12816 external = pnotes;
103f02d3 12817
305c7206 12818 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 12819 (unsigned long) offset, (unsigned long) length);
2aee03ae 12820 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 12821
2cf0635d 12822 while (external < (Elf_External_Note *) ((char *) pnotes + length))
779fe533 12823 {
2cf0635d 12824 Elf_External_Note * next;
b34976b6 12825 Elf_Internal_Note inote;
2cf0635d 12826 char * temp = NULL;
6d118b09 12827
00e98fc7
TG		 12828 if (!is_ia64_vms ())
12829 {
12830 inote.type = BYTE_GET (external->type);
12831 inote.namesz = BYTE_GET (external->namesz);
12832 inote.namedata = external->name;
12833 inote.descsz = BYTE_GET (external->descsz);
12834 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
12835 inote.descpos = offset + (inote.descdata - (char *) pnotes);
12836
12837 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
12838 }
12839 else
12840 {
12841 Elf64_External_VMS_Note *vms_external;
12842
12843 vms_external = (Elf64_External_VMS_Note *)external;
12844 inote.type = BYTE_GET (vms_external->type);
12845 inote.namesz = BYTE_GET (vms_external->namesz);
12846 inote.namedata = vms_external->name;
12847 inote.descsz = BYTE_GET (vms_external->descsz);
12848 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
12849 inote.descpos = offset + (inote.descdata - (char *) pnotes);
12850
12851 next = (Elf_External_Note *)
12852 (inote.descdata + align_power (inote.descsz, 3));
12853 }
3e55a963 12854
dd24e3da
NC		 12855 if ( ((char *) next > ((char *) pnotes) + length)
12856 || ((char *) next < (char *) pnotes))
3e55a963 12857 {
0fd3a477 12858 warn (_("corrupt note found at offset %lx into core notes\n"),
0af1713e 12859 (unsigned long) ((char *) external - (char *) pnotes));
0fd3a477 12860 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
3e55a963
NC		 12861 inote.type, inote.namesz, inote.descsz);
12862 break;
12863 }
12864
12865 external = next;
6d118b09 12866
dd24e3da
NC		 12867 /* Prevent out-of-bounds indexing. */
12868 if (inote.namedata + inote.namesz >= (char *) pnotes + length
12869 || inote.namedata + inote.namesz < inote.namedata)
12870 {
12871 warn (_("corrupt note found at offset %lx into core notes\n"),
12872 (unsigned long) ((char *) external - (char *) pnotes));
12873 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
12874 inote.type, inote.namesz, inote.descsz);
12875 break;
12876 }
12877
6d118b09
NC		 12878 /* Verify that name is null terminated. It appears that at least
12879 one version of Linux (RedHat 6.0) generates corefiles that don't
12880 comply with the ELF spec by failing to include the null byte in
12881 namesz. */
12882 if (inote.namedata[inote.namesz] != '\0')
12883 {
3f5e193b 12884 temp = (char *) malloc (inote.namesz + 1);
76da6bbe 12885
6d118b09
NC		 12886 if (temp == NULL)
12887 {
12888 error (_("Out of memory\n"));
12889 res = 0;
12890 break;
12891 }
76da6bbe 12892
6d118b09
NC		 12893 strncpy (temp, inote.namedata, inote.namesz);
12894 temp[inote.namesz] = 0;
76da6bbe 12895
6d118b09
NC		 12896 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
12897 inote.namedata = temp;
12898 }
12899
12900 res &= process_note (& inote);
103f02d3 12901
6d118b09
NC		 12902 if (temp != NULL)
12903 {
12904 free (temp);
12905 temp = NULL;
12906 }
779fe533
NC		 12907 }
12908
12909 free (pnotes);
103f02d3 12910
779fe533
NC		 12911 return res;
12912}
12913
12914static int
2cf0635d 12915process_corefile_note_segments (FILE * file)
779fe533 12916{
2cf0635d 12917 Elf_Internal_Phdr * segment;
b34976b6
AM		 12918 unsigned int i;
12919 int res = 1;
103f02d3 12920
d93f0186 12921 if (! get_program_headers (file))
779fe533 12922 return 0;
103f02d3 12923
779fe533
NC		 12924 for (i = 0, segment = program_headers;
12925 i < elf_header.e_phnum;
b34976b6 12926 i++, segment++)
779fe533
NC		 12927 {
12928 if (segment->p_type == PT_NOTE)
103f02d3 12929 res &= process_corefile_note_segment (file,
30800947
NC		 12930 (bfd_vma) segment->p_offset,
12931 (bfd_vma) segment->p_filesz);
779fe533 12932 }
103f02d3 12933
779fe533
NC		 12934 return res;
12935}
12936
12937static int
2cf0635d 12938process_note_sections (FILE * file)
1ec5cd37 12939{
2cf0635d 12940 Elf_Internal_Shdr * section;
1ec5cd37
NC		 12941 unsigned long i;
12942 int res = 1;
12943
12944 for (i = 0, section = section_headers;
12945 i < elf_header.e_shnum;
12946 i++, section++)
12947 if (section->sh_type == SHT_NOTE)
12948 res &= process_corefile_note_segment (file,
12949 (bfd_vma) section->sh_offset,
12950 (bfd_vma) section->sh_size);
12951
12952 return res;
12953}
12954
12955static int
2cf0635d 12956process_notes (FILE * file)
779fe533
NC		 12957{
12958 /* If we have not been asked to display the notes then do nothing. */
12959 if (! do_notes)
12960 return 1;
103f02d3 12961
779fe533 12962 if (elf_header.e_type != ET_CORE)
1ec5cd37 12963 return process_note_sections (file);
103f02d3 12964
779fe533 12965 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 12966 if (elf_header.e_phnum > 0)
12967 return process_corefile_note_segments (file);
779fe533 12968
1ec5cd37
NC		 12969 printf (_("No note segments present in the core file.\n"));
12970 return 1;
779fe533
NC		 12971}
12972
252b5132 12973static int
2cf0635d 12974process_arch_specific (FILE * file)
252b5132 12975{
a952a375
NC		 12976 if (! do_arch)
12977 return 1;
12978
252b5132
RH		 12979 switch (elf_header.e_machine)
12980 {
11c1ff18
PB		 12981 case EM_ARM:
12982 return process_arm_specific (file);
252b5132 12983 case EM_MIPS:
4fe85591 12984 case EM_MIPS_RS3_LE:
252b5132
RH		 12985 return process_mips_specific (file);
12986 break;
34c8bcba
JM		 12987 case EM_PPC:
12988 return process_power_specific (file);
12989 break;
9e8c70f9
DM		 12990 case EM_SPARC:
12991 case EM_SPARC32PLUS:
12992 case EM_SPARCV9:
12993 return process_sparc_specific (file);
12994 break;
59e6276b
JM		 12995 case EM_TI_C6000:
12996 return process_tic6x_specific (file);
12997 break;
252b5132
RH		 12998 default:
12999 break;
13000 }
13001 return 1;
13002}
13003
13004static int
2cf0635d 13005get_file_header (FILE * file)
252b5132 13006{
9ea033b2
NC		 13007 /* Read in the identity array. */
13008 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 13009 return 0;
13010
9ea033b2 13011 /* Determine how to read the rest of the header. */
b34976b6 13012 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 13013 {
13014 default: /* fall through */
13015 case ELFDATANONE: /* fall through */
adab8cdc
AO		 13016 case ELFDATA2LSB:
13017 byte_get = byte_get_little_endian;
13018 byte_put = byte_put_little_endian;
13019 break;
13020 case ELFDATA2MSB:
13021 byte_get = byte_get_big_endian;
13022 byte_put = byte_put_big_endian;
13023 break;
9ea033b2
NC		 13024 }
13025
13026 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 13027 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 13028
13029 /* Read in the rest of the header. */
13030 if (is_32bit_elf)
13031 {
13032 Elf32_External_Ehdr ehdr32;
252b5132 13033
9ea033b2
NC		 13034 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
13035 return 0;
103f02d3 13036
9ea033b2
NC		 13037 elf_header.e_type = BYTE_GET (ehdr32.e_type);
13038 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
13039 elf_header.e_version = BYTE_GET (ehdr32.e_version);
13040 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
13041 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
13042 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
13043 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
13044 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
13045 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
13046 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
13047 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
13048 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
13049 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
13050 }
252b5132 13051 else
9ea033b2
NC		 13052 {
13053 Elf64_External_Ehdr ehdr64;
a952a375
NC		 13054
13055 /* If we have been compiled with sizeof (bfd_vma) == 4, then
13056 we will not be able to cope with the 64bit data found in
13057 64 ELF files. Detect this now and abort before we start
50c2245b 13058 overwriting things. */
a952a375
NC		 13059 if (sizeof (bfd_vma) < 8)
13060 {
e3c8793a
NC		 13061 error (_("This instance of readelf has been built without support for a\n\
1306264 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 13063 return 0;
13064 }
103f02d3 13065
9ea033b2
NC		 13066 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
13067 return 0;
103f02d3 13068
9ea033b2
NC		 13069 elf_header.e_type = BYTE_GET (ehdr64.e_type);
13070 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
13071 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 13072 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
13073 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
13074 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 13075 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
13076 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
13077 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
13078 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
13079 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
13080 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
13081 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
13082 }
252b5132 13083
7ece0d85
JJ		 13084 if (elf_header.e_shoff)
13085 {
13086 /* There may be some extensions in the first section header. Don't
13087 bomb if we can't read it. */
13088 if (is_32bit_elf)
13089 get_32bit_section_headers (file, 1);
13090 else
13091 get_64bit_section_headers (file, 1);
13092 }
560f3c1c 13093
252b5132
RH		 13094 return 1;
13095}
13096
fb52b2f4
NC		 13097/* Process one ELF object file according to the command line options.
13098 This file may actually be stored in an archive. The file is
13099 positioned at the start of the ELF object. */
13100
ff78d6d6 13101static int
2cf0635d 13102process_object (char * file_name, FILE * file)
252b5132 13103{
252b5132
RH		 13104 unsigned int i;
13105
252b5132
RH		 13106 if (! get_file_header (file))
13107 {
13108 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 13109 return 1;
252b5132
RH		 13110 }
13111
13112 /* Initialise per file variables. */
60bca95a 13113 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 13114 version_info[i] = 0;
13115
60bca95a 13116 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 13117 dynamic_info[i] = 0;
5115b233 13118 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 13119
13120 /* Process the file. */
13121 if (show_name)
13122 printf (_("\nFile: %s\n"), file_name);
13123
18bd398b
NC		 13124 /* Initialise the dump_sects array from the cmdline_dump_sects array.
13125 Note we do this even if cmdline_dump_sects is empty because we
13126 must make sure that the dump_sets array is zeroed out before each
13127 object file is processed. */
13128 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 13129 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 13130
13131 if (num_cmdline_dump_sects > 0)
13132 {
13133 if (num_dump_sects == 0)
13134 /* A sneaky way of allocating the dump_sects array. */
09c11c86 13135 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 13136
13137 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 13138 memcpy (dump_sects, cmdline_dump_sects,
13139 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 13140 }
d70c5fc7 13141
252b5132 13142 if (! process_file_header ())
fb52b2f4 13143 return 1;
252b5132 13144
d1f5c6e3 13145 if (! process_section_headers (file))
2f62977e 13146 {
d1f5c6e3
L		 13147 /* Without loaded section headers we cannot process lots of
13148 things. */
2f62977e 13149 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 13150
2f62977e 13151 if (! do_using_dynamic)
2c610e4b 13152 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 13153 }
252b5132 13154
d1f5c6e3
L		 13155 if (! process_section_groups (file))
13156 {
13157 /* Without loaded section groups we cannot process unwind. */
13158 do_unwind = 0;
13159 }
13160
2f62977e 13161 if (process_program_headers (file))
b2d38a17 13162 process_dynamic_section (file);
252b5132
RH		 13163
13164 process_relocs (file);
13165
4d6ed7c8
NC		 13166 process_unwind (file);
13167
252b5132
RH		 13168 process_symbol_table (file);
13169
13170 process_syminfo (file);
13171
13172 process_version_sections (file);
13173
13174 process_section_contents (file);
f5842774 13175
1ec5cd37 13176 process_notes (file);
103f02d3 13177
047b2264
JJ		 13178 process_gnu_liblist (file);
13179
252b5132
RH		 13180 process_arch_specific (file);
13181
d93f0186
NC		 13182 if (program_headers)
13183 {
13184 free (program_headers);
13185 program_headers = NULL;
13186 }
13187
252b5132
RH		 13188 if (section_headers)
13189 {
13190 free (section_headers);
13191 section_headers = NULL;
13192 }
13193
13194 if (string_table)
13195 {
13196 free (string_table);
13197 string_table = NULL;
d40ac9bd 13198 string_table_length = 0;
252b5132
RH		 13199 }
13200
13201 if (dynamic_strings)
13202 {
13203 free (dynamic_strings);
13204 dynamic_strings = NULL;
d79b3d50 13205 dynamic_strings_length = 0;
252b5132
RH		 13206 }
13207
13208 if (dynamic_symbols)
13209 {
13210 free (dynamic_symbols);
13211 dynamic_symbols = NULL;
19936277 13212 num_dynamic_syms = 0;
252b5132
RH		 13213 }
13214
13215 if (dynamic_syminfo)
13216 {
13217 free (dynamic_syminfo);
13218 dynamic_syminfo = NULL;
13219 }
ff78d6d6 13220
293c573e
MR		 13221 if (dynamic_section)
13222 {
13223 free (dynamic_section);
13224 dynamic_section = NULL;
13225 }
13226
e4b17d5c
L		 13227 if (section_headers_groups)
13228 {
13229 free (section_headers_groups);
13230 section_headers_groups = NULL;
13231 }
13232
13233 if (section_groups)
13234 {
2cf0635d
NC		 13235 struct group_list * g;
13236 struct group_list * next;
e4b17d5c
L		 13237
13238 for (i = 0; i < group_count; i++)
13239 {
13240 for (g = section_groups [i].root; g != NULL; g = next)
13241 {
13242 next = g->next;
13243 free (g);
13244 }
13245 }
13246
13247 free (section_groups);
13248 section_groups = NULL;
13249 }
13250
19e6b90e 13251 free_debug_memory ();
18bd398b 13252
ff78d6d6 13253 return 0;
252b5132
RH		 13254}
13255
2cf0635d
NC		 13256/* Process an ELF archive.
13257 On entry the file is positioned just after the ARMAG string. */
13258
13259static int
13260process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
13261{
13262 struct archive_info arch;
13263 struct archive_info nested_arch;
13264 size_t got;
2cf0635d
NC		 13265 int ret;
13266
13267 show_name = 1;
13268
13269 /* The ARCH structure is used to hold information about this archive. */
13270 arch.file_name = NULL;
13271 arch.file = NULL;
13272 arch.index_array = NULL;
13273 arch.sym_table = NULL;
13274 arch.longnames = NULL;
13275
13276 /* The NESTED_ARCH structure is used as a single-item cache of information
13277 about a nested archive (when members of a thin archive reside within
13278 another regular archive file). */
13279 nested_arch.file_name = NULL;
13280 nested_arch.file = NULL;
13281 nested_arch.index_array = NULL;
13282 nested_arch.sym_table = NULL;
13283 nested_arch.longnames = NULL;
13284
13285 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
13286 {
13287 ret = 1;
13288 goto out;
4145f1d5 13289 }
fb52b2f4 13290
4145f1d5
NC		 13291 if (do_archive_index)
13292 {
2cf0635d 13293 if (arch.sym_table == NULL)
4145f1d5
NC		 13294 error (_("%s: unable to dump the index as none was found\n"), file_name);
13295 else
13296 {
2cf0635d 13297 unsigned int i, l;
4145f1d5
NC		 13298 unsigned long current_pos;
13299
13300 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
2cf0635d 13301 file_name, arch.index_num, arch.sym_size);
4145f1d5
NC		 13302 current_pos = ftell (file);
13303
2cf0635d 13304 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 13305 {
2cf0635d
NC		 13306 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
13307 {
13308 char * member_name;
4145f1d5 13309
2cf0635d
NC		 13310 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
13311
13312 if (member_name != NULL)
13313 {
13314 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
13315
13316 if (qualified_name != NULL)
13317 {
13318 printf (_("Binary %s contains:\n"), qualified_name);
13319 free (qualified_name);
13320 }
4145f1d5
NC		 13321 }
13322 }
2cf0635d
NC		 13323
13324 if (l >= arch.sym_size)
4145f1d5
NC		 13325 {
13326 error (_("%s: end of the symbol table reached before the end of the index\n"),
13327 file_name);
cb8f3167 13328 break;
4145f1d5 13329 }
2cf0635d
NC		 13330 printf ("\t%s\n", arch.sym_table + l);
13331 l += strlen (arch.sym_table + l) + 1;
4145f1d5
NC		 13332 }
13333
2cf0635d
NC		 13334 if (l & 01)
13335 ++l;
13336 if (l < arch.sym_size)
4145f1d5
NC		 13337 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
13338 file_name);
13339
4145f1d5
NC		 13340 if (fseek (file, current_pos, SEEK_SET) != 0)
13341 {
13342 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 13343 ret = 1;
13344 goto out;
4145f1d5 13345 }
fb52b2f4 13346 }
4145f1d5
NC		 13347
13348 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
13349 && !do_segments && !do_header && !do_dump && !do_version
13350 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 13351 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 13352 {
13353 ret = 0; /* Archive index only. */
13354 goto out;
13355 }
fb52b2f4
NC		 13356 }
13357
d989285c 13358 ret = 0;
fb52b2f4
NC		 13359
13360 while (1)
13361 {
2cf0635d
NC		 13362 char * name;
13363 size_t namelen;
13364 char * qualified_name;
13365
13366 /* Read the next archive header. */
13367 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
13368 {
13369 error (_("%s: failed to seek to next archive header\n"), file_name);
13370 return 1;
13371 }
13372 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
13373 if (got != sizeof arch.arhdr)
13374 {
13375 if (got == 0)
13376 break;
13377 error (_("%s: failed to read archive header\n"), file_name);
13378 ret = 1;
13379 break;
13380 }
13381 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
13382 {
13383 error (_("%s: did not find a valid archive header\n"), arch.file_name);
13384 ret = 1;
13385 break;
13386 }
13387
13388 arch.next_arhdr_offset += sizeof arch.arhdr;
13389
13390 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
13391 if (archive_file_size & 01)
13392 ++archive_file_size;
13393
13394 name = get_archive_member_name (&arch, &nested_arch);
13395 if (name == NULL)
fb52b2f4 13396 {
0fd3a477 13397 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 13398 ret = 1;
13399 break;
fb52b2f4 13400 }
2cf0635d 13401 namelen = strlen (name);
fb52b2f4 13402
2cf0635d
NC		 13403 qualified_name = make_qualified_name (&arch, &nested_arch, name);
13404 if (qualified_name == NULL)
fb52b2f4 13405 {
2cf0635d 13406 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 13407 ret = 1;
13408 break;
fb52b2f4
NC		 13409 }
13410
2cf0635d
NC		 13411 if (is_thin_archive && arch.nested_member_origin == 0)
13412 {
13413 /* This is a proxy for an external member of a thin archive. */
13414 FILE * member_file;
13415 char * member_file_name = adjust_relative_path (file_name, name, namelen);
13416 if (member_file_name == NULL)
13417 {
13418 ret = 1;
13419 break;
13420 }
13421
13422 member_file = fopen (member_file_name, "rb");
13423 if (member_file == NULL)
13424 {
13425 error (_("Input file '%s' is not readable.\n"), member_file_name);
13426 free (member_file_name);
13427 ret = 1;
13428 break;
13429 }
13430
13431 archive_file_offset = arch.nested_member_origin;
13432
13433 ret |= process_object (qualified_name, member_file);
13434
13435 fclose (member_file);
13436 free (member_file_name);
13437 }
13438 else if (is_thin_archive)
13439 {
13440 /* This is a proxy for a member of a nested archive. */
13441 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
13442
13443 /* The nested archive file will have been opened and setup by
13444 get_archive_member_name. */
13445 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
13446 {
13447 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
13448 ret = 1;
13449 break;
13450 }
13451
13452 ret |= process_object (qualified_name, nested_arch.file);
13453 }
13454 else
13455 {
13456 archive_file_offset = arch.next_arhdr_offset;
13457 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 13458
2cf0635d
NC		 13459 ret |= process_object (qualified_name, file);
13460 }
fb52b2f4 13461
2b52916e
L		 13462 if (dump_sects != NULL)
13463 {
13464 free (dump_sects);
13465 dump_sects = NULL;
13466 num_dump_sects = 0;
13467 }
13468
2cf0635d 13469 free (qualified_name);
fb52b2f4
NC		 13470 }
13471
4145f1d5 13472 out:
2cf0635d
NC		 13473 if (nested_arch.file != NULL)
13474 fclose (nested_arch.file);
13475 release_archive (&nested_arch);
13476 release_archive (&arch);
fb52b2f4 13477
d989285c 13478 return ret;
fb52b2f4
NC		 13479}
13480
13481static int
2cf0635d 13482process_file (char * file_name)
fb52b2f4 13483{
2cf0635d 13484 FILE * file;
fb52b2f4
NC		 13485 struct stat statbuf;
13486 char armag[SARMAG];
13487 int ret;
13488
13489 if (stat (file_name, &statbuf) < 0)
13490 {
f24ddbdd
NC		 13491 if (errno == ENOENT)
13492 error (_("'%s': No such file\n"), file_name);
13493 else
13494 error (_("Could not locate '%s'. System error message: %s\n"),
13495 file_name, strerror (errno));
13496 return 1;
13497 }
13498
13499 if (! S_ISREG (statbuf.st_mode))
13500 {
13501 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 13502 return 1;
13503 }
13504
13505 file = fopen (file_name, "rb");
13506 if (file == NULL)
13507 {
f24ddbdd 13508 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 13509 return 1;
13510 }
13511
13512 if (fread (armag, SARMAG, 1, file) != 1)
13513 {
4145f1d5 13514 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 13515 fclose (file);
13516 return 1;
13517 }
13518
13519 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 13520 ret = process_archive (file_name, file, FALSE);
13521 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
13522 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 13523 else
13524 {
4145f1d5
NC		 13525 if (do_archive_index)
13526 error (_("File %s is not an archive so its index cannot be displayed.\n"),
13527 file_name);
13528
fb52b2f4
NC		 13529 rewind (file);
13530 archive_file_size = archive_file_offset = 0;
13531 ret = process_object (file_name, file);
13532 }
13533
13534 fclose (file);
13535
13536 return ret;
13537}
13538
252b5132
RH		 13539#ifdef SUPPORT_DISASSEMBLY
13540/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 13541 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 13542 symbols. */
252b5132
RH		 13543
13544void
2cf0635d 13545print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 13546{
13547 fprintf (outfile,"0x%8.8x", addr);
13548}
13549
e3c8793a 13550/* Needed by the i386 disassembler. */
252b5132
RH		 13551void
13552db_task_printsym (unsigned int addr)
13553{
13554 print_address (addr, stderr);
13555}
13556#endif
13557
13558int
2cf0635d 13559main (int argc, char ** argv)
252b5132 13560{
ff78d6d6
L		 13561 int err;
13562
252b5132
RH		 13563#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
13564 setlocale (LC_MESSAGES, "");
3882b010
L		 13565#endif
13566#if defined (HAVE_SETLOCALE)
13567 setlocale (LC_CTYPE, "");
252b5132
RH		 13568#endif
13569 bindtextdomain (PACKAGE, LOCALEDIR);
13570 textdomain (PACKAGE);
13571
869b9d07
MM		 13572 expandargv (&argc, &argv);
13573
252b5132
RH		 13574 parse_args (argc, argv);
13575
18bd398b 13576 if (num_dump_sects > 0)
59f14fc0 13577 {
18bd398b 13578 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 13579 cmdline_dump_sects = (dump_type *)
13580 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 13581 if (cmdline_dump_sects == NULL)
591a748a 13582 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 13583 else
13584 {
09c11c86
NC		 13585 memcpy (cmdline_dump_sects, dump_sects,
13586 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 13587 num_cmdline_dump_sects = num_dump_sects;
13588 }
13589 }
13590
18bd398b
NC		 13591 if (optind < (argc - 1))
13592 show_name = 1;
13593
ff78d6d6 13594 err = 0;
252b5132 13595 while (optind < argc)
18bd398b 13596 err |= process_file (argv[optind++]);
252b5132
RH		 13597
13598 if (dump_sects != NULL)
13599 free (dump_sects);
59f14fc0
AS		 13600 if (cmdline_dump_sects != NULL)
13601 free (cmdline_dump_sects);
252b5132 13602
ff78d6d6 13603 return err;
252b5132 13604}
A mirror of the official binutils-gdb repository